/******************************************************************************

 *

 * $Id$

 *

 *

 * Copyright (C) 1997-2015 by Dimitri van Heesch.

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation under the terms of the GNU General Public License is hereby 

 * granted. No representations are made about the suitability of this software 

 * for any purpose. It is provided "as is" without express or implied warranty.

 * See the GNU General Public License for more details.

 *

 */

#ifndef _DOCHANDLER_H

#define _DOCHANDLER_H

#include <qstring.h>

#include <qlist.h>

#include <qxml.h>

#include <doxmlintf.h>

#include "stringimpl.h"

#include "basehandler.h"

#include "baseiterator.h"

class ParagraphHandler;

class DocInternalHandler;

class LinkedTextImpl;

class LinkedTextHandler;

//-----------------------------------------------------------------------------

class DocImpl : public IDoc { public: virtual ~DocImpl() {} };

#define DEFINE_CLS_IMPL(cls) \

  class cls##Impl : public I##cls, public DocImpl { public: virtual ~cls##Impl() {} }

DEFINE_CLS_IMPL(DocMarkup);

DEFINE_CLS_IMPL(DocPara);

DEFINE_CLS_IMPL(DocText);

DEFINE_CLS_IMPL(DocMarkupModifier);

DEFINE_CLS_IMPL(DocItemizedList);

DEFINE_CLS_IMPL(DocOrderedList);

DEFINE_CLS_IMPL(DocListItem);

DEFINE_CLS_IMPL(DocParameterList);

DEFINE_CLS_IMPL(DocParameterItem);

DEFINE_CLS_IMPL(DocParameter);

DEFINE_CLS_IMPL(DocTitle);

DEFINE_CLS_IMPL(DocSimpleSect);

DEFINE_CLS_IMPL(DocRef);

DEFINE_CLS_IMPL(DocVariableList);

DEFINE_CLS_IMPL(DocVariableListEntry);

DEFINE_CLS_IMPL(DocHRuler);

DEFINE_CLS_IMPL(DocLineBreak);

DEFINE_CLS_IMPL(DocULink);

DEFINE_CLS_IMPL(DocEMail);

DEFINE_CLS_IMPL(DocLink);

DEFINE_CLS_IMPL(DocProgramListing);

DEFINE_CLS_IMPL(DocCodeLine);

DEFINE_CLS_IMPL(DocHighlight);

DEFINE_CLS_IMPL(DocFormula);

DEFINE_CLS_IMPL(DocImage);

DEFINE_CLS_IMPL(DocDotFile);

DEFINE_CLS_IMPL(DocIndexEntry);

DEFINE_CLS_IMPL(DocTable);

DEFINE_CLS_IMPL(DocRow);

DEFINE_CLS_IMPL(DocEntry);

DEFINE_CLS_IMPL(DocSection);

DEFINE_CLS_IMPL(DocVerbatim);

DEFINE_CLS_IMPL(DocCopy);

DEFINE_CLS_IMPL(DocTocList);

DEFINE_CLS_IMPL(DocTocItem);

DEFINE_CLS_IMPL(DocAnchor);

DEFINE_CLS_IMPL(DocSymbol);

DEFINE_CLS_IMPL(DocInternal);

DEFINE_CLS_IMPL(DocRoot);

//-----------------------------------------------------------------------------

/*! \brief Node representing a piece of text.

 *

 */

class TextNode : public DocTextImpl

{

  public:

    TextNode(const QString &t,int markup,int level) 

      : m_text(t), m_markup(markup), m_headingLevel(level) {}

    virtual ~TextNode() {}

    // IDocText

    virtual Kind kind() const { return DocImpl::Text; }

    virtual const IString *text() const { return &m_text; }

    virtual int markup() const { return m_markup; }

    virtual int headingLevel() const { return m_headingLevel; }

  private:  

    StringImpl m_text;

    int m_markup;

    int m_headingLevel;

};

//-----------------------------------------------------------------------------

/*! \brief Node representing a change in the markup style.

 *

 */

class MarkupModifierNode : public DocMarkupModifierImpl

{

  public:

    MarkupModifierNode(int markup,bool enabled,int level=0) 

      : m_markup(markup), m_enabled(enabled), m_headingLevel(level) {}

    virtual ~MarkupModifierNode() {}

    // IDocMarkupModifier

    virtual Kind kind() const { return DocImpl::MarkupModifier; }

    virtual bool enabled() const { return m_enabled; }

    virtual int markup() const { return m_markup; }

    virtual int headingLevel() const { return m_headingLevel; }

  private:

    int m_markup;

    bool m_enabled;

    int m_headingLevel;

};

//-----------------------------------------------------------------------------

/*! \brief Handles markup commands in the XML input. 

 *

 */

class MarkupHandler : public BaseFallBackHandler<MarkupHandler>

{

  public:

    MarkupHandler(QList<DocImpl> &children,QString &curString);

    virtual ~MarkupHandler();

    int markup() const { return m_curMarkup; }

    int headingLevel() const { return m_headingLevel; }

    virtual void startBold(const QXmlAttributes &attrib);

    virtual void endBold();

    virtual void startEmphasis(const QXmlAttributes &attrib);

    virtual void endEmphasis();

    virtual void startComputerOutput(const QXmlAttributes &attrib);

    virtual void endComputerOutput();

    virtual void startCenter(const QXmlAttributes &attrib);

    virtual void endCenter();

    virtual void startSmallFont(const QXmlAttributes &attrib);

    virtual void endSmallFont();

    virtual void startSubscript(const QXmlAttributes &attrib);

    virtual void endSubscript();

    virtual void startSuperscript(const QXmlAttributes &attrib);

    virtual void endSuperscript();

    virtual void startPreformatted(const QXmlAttributes &attrib);

    virtual void endPreformatted();

    virtual void startHeading1(const QXmlAttributes &attrib);

    virtual void endHeading1();

    virtual void startHeading2(const QXmlAttributes &attrib);

    virtual void endHeading2();

    virtual void startHeading3(const QXmlAttributes &attrib);

    virtual void endHeading3();

    virtual void startHeading4(const QXmlAttributes &attrib);

    virtual void endHeading4();

    virtual void startHeading5(const QXmlAttributes &attrib);

    virtual void endHeading5();

    virtual void startHeading6(const QXmlAttributes &attrib);

    virtual void endHeading6();

  private:

    void addTextNode();

    QList<DocImpl>  &m_children;

    QString         &m_curString;

    int             m_curMarkup;

    int             m_headingLevel;

};

//-----------------------------------------------------------------------------

/*! \brief Node representing a paragraph of text and commands.

 *

 */

// children: itemizedlist, orderedlist, parameterlist, simplesect, ref,

//           variablelist, hruler, linebreak, ulink, email, link

//           programlisting, formula, image, dotfile, indexentry,

//           table

//

// children handled by MarkupHandler: 

//           bold, computeroutput, emphasis, center,

//           small, subscript, superscript. 

//

class ParagraphHandler : public DocParaImpl, 

                         public BaseHandler<ParagraphHandler>

{

    friend class ParagraphIterator;

  public:

    virtual void startParagraph(const QXmlAttributes& attrib);

    virtual void endParagraph();

    virtual void startItemizedList(const QXmlAttributes& attrib);

    virtual void startOrderedList(const QXmlAttributes& attrib);

    virtual void startParameterList(const QXmlAttributes& attrib);

    virtual void startSimpleSect(const QXmlAttributes& attrib);

    virtual void startRef(const QXmlAttributes& attrib);

    virtual void startVariableList(const QXmlAttributes& attrib);

    virtual void startHRuler(const QXmlAttributes& attrib);

    virtual void startLineBreak(const QXmlAttributes& attrib);

    virtual void startULink(const QXmlAttributes& attrib);

    virtual void startEMail(const QXmlAttributes& attrib);

    virtual void startLink(const QXmlAttributes& attrib);

    virtual void startProgramListing(const QXmlAttributes& attrib);

    virtual void startFormula(const QXmlAttributes& attrib);

    virtual void startImage(const QXmlAttributes& attrib);

    virtual void startDotFile(const QXmlAttributes& attrib);

    virtual void startIndexEntry(const QXmlAttributes& attrib);

    virtual void startTable(const QXmlAttributes& attrib);

    virtual void startVerbatim(const QXmlAttributes& attrib);

    virtual void startHtmlOnly(const QXmlAttributes& attrib);

    virtual void startLatexOnly(const QXmlAttributes& attrib);

    virtual void startUmlaut(const QXmlAttributes& attrib);

    virtual void startAcute(const QXmlAttributes& attrib);

    virtual void startGrave(const QXmlAttributes& attrib);

    virtual void startCirc(const QXmlAttributes& attrib);

    virtual void startTilde(const QXmlAttributes& attrib);

    virtual void startSzlig(const QXmlAttributes& attrib);

    virtual void startCedil(const QXmlAttributes& attrib);

    virtual void startRing(const QXmlAttributes& attrib);

    virtual void startNbsp(const QXmlAttributes& attrib);

    virtual void startCopy(const QXmlAttributes& attrib);

    virtual void startAnchor(const QXmlAttributes& attrib);

    virtual void startCopyDoc(const QXmlAttributes& attrib);

    virtual void startTocList(const QXmlAttributes& attrib);

    ParagraphHandler(IBaseHandler *parent);

    virtual ~ParagraphHandler();

    // IDocPara

    virtual Kind kind() const { return DocImpl::Para; }

    virtual IDocIterator *contents() const;

  private:

    void addTextNode();

    IBaseHandler   *m_parent;

    QList<DocImpl>  m_children;

    MarkupHandler  *m_markupHandler;

};

class ParagraphIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>

{

  public:

    ParagraphIterator(const ParagraphHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}

};

//-----------------------------------------------------------------------------

/*! \brief Node representing a list item.

 *

 */

class ListItemHandler : public DocListItemImpl, public BaseHandler<ListItemHandler>

{

    friend class ListItemIterator;

  public:

    ListItemHandler(IBaseHandler *parent);

    virtual ~ListItemHandler();

    virtual void startListItem(const QXmlAttributes& attrib);

    virtual void endListItem();

    virtual void startParagraph(const QXmlAttributes& attrib);

    // IDocItem

    virtual Kind kind() const { return DocImpl::ListItem; }

    virtual IDocIterator *contents() const;

  private:

    IBaseHandler   *m_parent;

    QList<DocImpl>  m_children;

};

class ListItemIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>

{

  public:

    ListItemIterator(const ListItemHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}

};

//-----------------------------------------------------------------------------

/*! \brief Node representing list of items.

 *

 */

class OrderedListHandler : public DocOrderedListImpl, public BaseHandler<OrderedListHandler>

{

    friend class OrderedListIterator;

  public:

    OrderedListHandler(IBaseHandler *parent);

    virtual ~OrderedListHandler();

    virtual void startOrderedList(const QXmlAttributes& attrib);

    virtual void endOrderedList();

    virtual void startOrderedListItem(const QXmlAttributes& attrib);

    // IDocOrderedList

    virtual Kind kind() const { return DocImpl::OrderedList; }

    virtual IDocIterator *elements() const;

  private:

    IBaseHandler   *m_parent;

    QList<DocImpl>  m_children;

};

class OrderedListIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>

{

  public:

    OrderedListIterator(const OrderedListHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}

};

//-----------------------------------------------------------------------------

/*! \brief Node representing table of contents list.

 *

 */

class TocListHandler : public DocTocListImpl, public BaseHandler<TocListHandler>

{

    friend class TocListIterator;

  public:

    TocListHandler(IBaseHandler *parent);

    virtual ~TocListHandler();

    virtual void startTocList(const QXmlAttributes& attrib);

    virtual void endTocList();

    virtual void startTocItem(const QXmlAttributes& attrib);

    // IDocTocList

    virtual Kind kind() const { return DocImpl::TocList; }

    virtual IDocIterator *elements() const;

  private:

    IBaseHandler   *m_parent;

    QList<DocImpl>  m_children;

};

class TocListIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>

{

  public:

    TocListIterator(const TocListHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}

};

//-----------------------------------------------------------------------------

/*! \brief Node representing a table of contents item.

 *

 */

class TocItemHandler : public DocTocItemImpl, public BaseHandler<TocItemHandler>

{

    friend class TocItemIterator;

  public:

    TocItemHandler(IBaseHandler *parent);

    virtual ~TocItemHandler();

    virtual void startTocItem(const QXmlAttributes& attrib);

    virtual void endTocItem();

    // IDocItem

    virtual Kind kind() const { return DocImpl::TocItem; }

    virtual const IString *id() const { return &m_id; }

    virtual const IString *title() const { return &m_title; }

  private:

    IBaseHandler   *m_parent;

    StringImpl      m_id;

    StringImpl      m_title;

};

//-----------------------------------------------------------------------------

/*! \brief Node representing list of items.

 *

 */

class ItemizedListHandler : public DocItemizedListImpl, public BaseHandler<ItemizedListHandler>

{

    friend class ItemizedListIterator;

  public:

    ItemizedListHandler(IBaseHandler *parent);

    virtual ~ItemizedListHandler();

    virtual void startItemizedList(const QXmlAttributes& attrib);

    virtual void endItemizedList();

    virtual void startItemizedListItem(const QXmlAttributes& attrib);

    // IDocItemizedList

    virtual Kind kind() const { return DocImpl::ItemizedList; }

    virtual IDocIterator *elements() const;

  private:

    IBaseHandler   *m_parent;

    QList<DocImpl>  m_children;

};

class ItemizedListIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>

{

  public:

    ItemizedListIterator(const ItemizedListHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}

};

//-----------------------------------------------------------------------------

/*! \brief Node representing a parameter.

 *

 */

class ParameterHandler : public DocParameterImpl, 

                         public BaseHandler<ParameterHandler>

{

  public:

    ParameterHandler(IBaseHandler *parent);

    virtual ~ParameterHandler();

    virtual void startParameterName(const QXmlAttributes& attrib);

    virtual void endParameterName();

    // IDocParameter

    virtual Kind kind() const { return DocImpl::Parameter; }

    virtual const IString *name() const { return &m_name; }

  private:

    IBaseHandler     *m_parent;

    StringImpl        m_name;

};

//-----------------------------------------------------------------------------

/* \brief Node representing a list of param names with a single description.

 *

 */

class ParameterItemHandler : public DocParameterItemImpl, 

                             public BaseHandler<ParameterItemHandler>

{

    friend class ParameterItemIterator;

  public:

    ParameterItemHandler(IBaseHandler *parent);

    virtual ~ParameterItemHandler();

    virtual void startParameterItem(const QXmlAttributes& attrib);

    virtual void endParameterItem();

    virtual void startParameterName(const QXmlAttributes& attrib);

    virtual void startParagraph(const QXmlAttributes& attrib);

    // IDocParameterItem

    virtual Kind kind() const { return DocImpl::ParameterItem; }

    virtual IDocIterator *paramNames() const;

    virtual IDocPara *description() const { return m_description; }

  private:

    IBaseHandler            *m_parent;

    QList<ParameterHandler>  m_parameters;

    ParagraphHandler *m_description;

};

class ParameterItemIterator : public BaseIteratorVia<IDocIterator,IDoc,ParameterHandler,DocImpl>

{

  public:

    ParameterItemIterator(const ParameterItemHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,ParameterHandler,DocImpl>(handler.m_parameters) {}

};

//-----------------------------------------------------------------------------

/* \brief Node representing a parameter section.

 *

 */

class ParameterListHandler : public DocParameterListImpl, 

                             public BaseHandler<ParameterListHandler>

{

    friend class ParameterListIterator;

  public:

    ParameterListHandler(IBaseHandler *parent);

    virtual ~ParameterListHandler();

    virtual void startParameterList(const QXmlAttributes& attrib);

    virtual void endParameterList();

    virtual void startParameterItem(const QXmlAttributes& attrib);

    // IDocParameterList

    virtual Kind kind() const { return DocImpl::ParameterList; }

    virtual Types sectType() const { return m_type; }

    virtual IDocIterator *params() const;

  private:

    IBaseHandler            *m_parent;

    QList<ParameterItemHandler>  m_paramItems;

    Types                    m_type;

};

class ParameterListIterator : public BaseIteratorVia<IDocIterator,IDoc,ParameterItemHandler,DocImpl>

{

  public:

    ParameterListIterator(const ParameterListHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,ParameterItemHandler,DocImpl>(handler.m_paramItems) {}

};

//-----------------------------------------------------------------------------

/* \brief Node representing a horizontal ruler

 *

 */

class LineBreakHandler : public DocLineBreakImpl, public BaseHandler<LineBreakHandler>

{

  public:

    LineBreakHandler(IBaseHandler *parent);

    virtual ~LineBreakHandler();

    void startLineBreak(const QXmlAttributes& attrib);

    void endLineBreak();

    // IDocLineBreak

    virtual Kind kind() const { return DocImpl::LineBreak; }

  private:

    IBaseHandler   *m_parent;

};

//-----------------------------------------------------------------------------

/* \brief Node representing a link to section

 *

 */

class LinkHandler : public DocLinkImpl, public BaseHandler<LinkHandler>

{

  public:

    LinkHandler(IBaseHandler *parent);

    virtual ~LinkHandler();

    void startLink(const QXmlAttributes& attrib);

    void endLink();

    // IDocLink

    virtual Kind kind() const { return DocImpl::Link; }

    virtual const IString *refId() const { return &m_ref; }

    virtual const IString *text() const { return &m_text; }

  private:

    IBaseHandler   *m_parent;

    StringImpl      m_ref;

    StringImpl      m_text;

};

//-----------------------------------------------------------------------------

/* \brief Node representing a link to an email address

 *

 */

class EMailHandler : public DocEMailImpl, public BaseHandler<EMailHandler>

{

  public:

    EMailHandler(IBaseHandler *parent);

    virtual ~EMailHandler();

    void startEMail(const QXmlAttributes& attrib);

    void endEMail();

    // IDocEMail

    virtual Kind kind() const { return DocImpl::EMail; }

    virtual const IString *address() const { return &m_address; }

  private:

    IBaseHandler   *m_parent;

    StringImpl      m_address;

};

//-----------------------------------------------------------------------------

/* \brief Node representing a link to an URL

 *

 */

class ULinkHandler : public DocULinkImpl, public BaseHandler<ULinkHandler>

{

  public:

    ULinkHandler(IBaseHandler *parent);

    virtual ~ULinkHandler();

    void startULink(const QXmlAttributes& attrib);

    void endULink();

    // IDocULink

    virtual Kind kind() const { return DocImpl::ULink; }

    virtual const IString * url() const { return &m_url; }

    virtual const IString * text() const { return &m_text; }

  private:

    IBaseHandler   *m_parent;

    StringImpl      m_url;

    StringImpl      m_text;

};

//-----------------------------------------------------------------------------

/* \brief Node representing a horizontal ruler

 *

 */

class HRulerHandler : public DocHRulerImpl, public BaseHandler<HRulerHandler>

{

  public:

    HRulerHandler(IBaseHandler *parent);

    virtual ~HRulerHandler();

    void startHRuler(const QXmlAttributes& attrib);

    void endHRuler();

    // IDocHRuler

    virtual Kind kind() const { return DocImpl::HRuler; }

  private:

    IBaseHandler   *m_parent;

};

//-----------------------------------------------------------------------------

/* \brief Node representing a reference to another item

 *

 */

class RefHandler : public DocRefImpl, public BaseHandler<RefHandler>

{

  public:

    RefHandler(IBaseHandler *parent);

    virtual ~RefHandler();

    void startRef(const QXmlAttributes& attrib);

    void endRef();

    // IDocRef

    virtual Kind kind() const { return DocImpl::Ref; }

    virtual const IString *refId() const { return &m_refId; }

    virtual TargetKind targetKind() const { return m_targetKind; }

    virtual const IString *external() const { return &m_extId; }

    virtual const IString *text() const { return &m_linkText; }

  private:

    IBaseHandler   *m_parent;

    StringImpl      m_refId;

    StringImpl      m_extId;

    StringImpl      m_linkText;

    TargetKind      m_targetKind;

};

//-----------------------------------------------------------------------------

/* \brief Node representing the title of a section

 *

 */

// children: text, ref

// children handled by MarkupHandler: 

//           bold, computeroutput, emphasis, center,

//           small, subscript, superscript. 

class TitleHandler : public DocTitleImpl, public BaseHandler<TitleHandler>

{

    friend class TitleIterator;

  public:

    TitleHandler(IBaseHandler *parent);

    virtual ~TitleHandler();

    virtual void startTitle(const QXmlAttributes& attrib);

    virtual void endTitle();

    virtual void startRef(const QXmlAttributes& attrib);

    void addTextNode();

    // IDocTitle

    virtual Kind kind() const { return DocImpl::Title; }

    virtual IDocIterator *title() const;

  private:

    IBaseHandler   *m_parent;

    QList<DocImpl>  m_children;

    MarkupHandler  *m_markupHandler;

};

class TitleIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>

{

  public:

    TitleIterator(const TitleHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}

};

//-----------------------------------------------------------------------------

/* \brief Node representing a simple section with an unnumbered header.

 *

 */

// children: title, para

class SimpleSectHandler : public DocSimpleSectImpl, 

                          public BaseHandler<SimpleSectHandler>

{

  public:

    SimpleSectHandler(IBaseHandler *parent);

    virtual ~SimpleSectHandler();

    virtual void startSimpleSect(const QXmlAttributes& attrib);

    virtual void endSimpleSect();

    virtual void startTitle(const QXmlAttributes& attrib);

    virtual void startParagraph(const QXmlAttributes& attrib);

    // IDocSimpleSect

    virtual Kind kind() const { return DocImpl::SimpleSect; }

    virtual Types type() const { return m_type; }

    virtual const IString *typeString() const { return &m_typeString; }

    virtual IDocTitle *title() const { return m_title; }

    virtual IDocPara *description() const { return m_paragraph; }

  private:

    IBaseHandler            *m_parent;

    ParagraphHandler        *m_paragraph;

    Types                    m_type;

    StringImpl               m_typeString;

    TitleHandler            *m_title;

};

//-----------------------------------------------------------------------------

/* \brief Node representing an named item of a VariableList.

 *

 */

class VariableListEntryHandler : public DocVariableListEntryImpl, 

                                 public BaseHandler<VariableListEntryHandler>

{

  public:

    virtual void startVarListEntry(const QXmlAttributes& attrib);

    virtual void endVarListEntry();

    virtual void startListItem(const QXmlAttributes& attrib);

    virtual void endListItem();

    virtual void startTerm(const QXmlAttributes& attrib);

    virtual void endTerm();

    virtual void startParagraph(const QXmlAttributes& attrib);

    VariableListEntryHandler(IBaseHandler *parent);

    virtual ~VariableListEntryHandler();

    // IDocVariableListEntry

    virtual Kind kind() const { return DocImpl::VariableListEntry; }

    virtual ILinkedTextIterator *term() const;

    virtual IDocPara *description() const { return m_description; }

  private:

    IBaseHandler*         m_parent;

    QList<LinkedTextImpl> m_term;

    ParagraphHandler*     m_description;

    LinkedTextHandler*    m_linkedTextHandler;

};

//-----------------------------------------------------------------------------

/*! \brief Node representing a list of named items.

 *

 */

// children: varlistentry, listitem

class VariableListHandler : public DocVariableListImpl, 

                            public BaseHandler<VariableListHandler>

{

    friend class VariableListIterator;

  public:

    virtual void startVariableList(const QXmlAttributes& attrib);

    virtual void endVariableList();

    virtual void startVarListEntry(const QXmlAttributes& attrib);

    virtual void startListItem(const QXmlAttributes& attrib);

    VariableListHandler(IBaseHandler *parent);

    virtual ~VariableListHandler();

    // IDocVariableList

    virtual Kind kind() const { return DocImpl::VariableList; }

    virtual IDocIterator *entries() const;

  private:

    IBaseHandler   *m_parent;

    QList<VariableListEntryHandler> m_entries;

    VariableListEntryHandler *m_curEntry;

};

class VariableListIterator : public BaseIteratorVia<IDocIterator,IDoc,VariableListEntryHandler,DocImpl>

{

  public:

    VariableListIterator(const VariableListHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,VariableListEntryHandler,DocImpl>(handler.m_entries) {}

};

//-----------------------------------------------------------------------------

/*! \brief Node representing a highlighted text fragment.

 *

 */

// children: ref

class HighlightHandler : public DocHighlightImpl, public BaseHandler<HighlightHandler>

{

    friend class HighlightIterator;

  public:

    HighlightHandler(IBaseHandler *parent);

    virtual ~HighlightHandler();

    void startHighlight(const QXmlAttributes& attrib);

    void endHighlight();

    virtual void startRef(const QXmlAttributes&);

    virtual void startSpace(const QXmlAttributes&);

    // IDocHighlight

    virtual Kind kind() const { return DocImpl::Highlight; }

    virtual HighlightKind highlightKind() const { return m_hl; }

    virtual IDocIterator *codeElements() const;

  private:

    void addTextNode();

    IBaseHandler   *m_parent;

    HighlightKind  m_hl;

    QString        m_hlString;

    QList<DocImpl> m_children;

};

class HighlightIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>

{

  public:

    HighlightIterator(const HighlightHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}

};

//-----------------------------------------------------------------------------

/*! \brief Node representing a line of code.

 *

 */

// children: linenumber, highlight, anchor, ref

class CodeLineHandler : public DocCodeLineImpl, public BaseHandler<CodeLineHandler>

{

    friend class CodeLineIterator;

  public:

    virtual void startCodeLine(const QXmlAttributes&);

    virtual void endCodeLine();

    virtual void startLineNumber(const QXmlAttributes&);

    virtual void endLineNumber();

    virtual void startHighlight(const QXmlAttributes&);

    virtual void startRef(const QXmlAttributes&);

    CodeLineHandler(IBaseHandler *parent);

    virtual ~CodeLineHandler();

    // IDocCodeLine

    virtual Kind kind() const { return DocImpl::CodeLine; }

    virtual int lineNumber() const { return m_lineNumber; }

    virtual const IString *refId() const { return &m_refId; }

    virtual IDocIterator *codeElements() const;

  private:

    void addTextNode();

    IBaseHandler   *m_parent;

    int            m_lineNumber;

    StringImpl     m_refId;

    QList<DocImpl> m_children;

};

class CodeLineIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>

{

  public:

    CodeLineIterator(const CodeLineHandler &handler) : 

      BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}

};

//-----------------------------------------------------------------------------

/*! \brief Node representing a program listing

 *

 */

// children: codeline, linenumber

class ProgramListingHandler : public DocProgramListingImpl, public BaseHandler<ProgramListingHandler>

{

    friend class ProgramListingIterator;

  public:

    virtual void startProgramListing(const QXmlAttributes& attrib);

    virtual void endProgramListing();

    virtual void startCodeLine(const QXmlAttributes&);

    virtual void startLineNumber(const QXmlAttributes&);