addon/doxmlparser/src/dochandler.h

   1 /******************************************************************************
   2  *
   3  * $Id$
   4  *
   5  *
   6  * Copyright (C) 1997-2015 by Dimitri van Heesch.
   7  *
   8  * Permission to use, copy, modify, and distribute this software and its
   9  * documentation under the terms of the GNU General Public License is hereby
  10  * granted. No representations are made about the suitability of this software
  11  * for any purpose. It is provided "as is" without express or implied warranty.
  12  * See the GNU General Public License for more details.
  13  *
  14  */
  15
  16 #ifndef _DOCHANDLER_H
  17 #define _DOCHANDLER_H
  18
  19 #include <qstring.h>
  20 #include <qlist.h>
  21 #include <qxml.h>
  22
  23 #include <doxmlintf.h>
  24 #include "stringimpl.h"
  25 #include "basehandler.h"
  26 #include "baseiterator.h"
  27
  28 class ParagraphHandler;
  29 class DocInternalHandler;
  30 class LinkedTextImpl;
  31 class LinkedTextHandler;
  32
  33 //-----------------------------------------------------------------------------
  34
  35 class DocImpl : public IDoc { public: virtual ~DocImpl() {} };
  36
  37 #define DEFINE_CLS_IMPL(cls) \
  38   class cls##Impl : public I##cls, public DocImpl { public: virtual ~cls##Impl() {} }
  39
  40 DEFINE_CLS_IMPL(DocMarkup);
  41 DEFINE_CLS_IMPL(DocPara);
  42 DEFINE_CLS_IMPL(DocText);
  43 DEFINE_CLS_IMPL(DocMarkupModifier);
  44 DEFINE_CLS_IMPL(DocItemizedList);
  45 DEFINE_CLS_IMPL(DocOrderedList);
  46 DEFINE_CLS_IMPL(DocListItem);
  47 DEFINE_CLS_IMPL(DocParameterList);
  48 DEFINE_CLS_IMPL(DocParameterItem);
  49 DEFINE_CLS_IMPL(DocParameter);
  50 DEFINE_CLS_IMPL(DocTitle);
  51 DEFINE_CLS_IMPL(DocSimpleSect);
  52 DEFINE_CLS_IMPL(DocRef);
  53 DEFINE_CLS_IMPL(DocVariableList);
  54 DEFINE_CLS_IMPL(DocVariableListEntry);
  55 DEFINE_CLS_IMPL(DocHRuler);
  56 DEFINE_CLS_IMPL(DocLineBreak);
  57 DEFINE_CLS_IMPL(DocULink);
  58 DEFINE_CLS_IMPL(DocEMail);
  59 DEFINE_CLS_IMPL(DocLink);
  60 DEFINE_CLS_IMPL(DocProgramListing);
  61 DEFINE_CLS_IMPL(DocCodeLine);
  62 DEFINE_CLS_IMPL(DocHighlight);
  63 DEFINE_CLS_IMPL(DocFormula);
  64 DEFINE_CLS_IMPL(DocImage);
  65 DEFINE_CLS_IMPL(DocDotFile);
  66 DEFINE_CLS_IMPL(DocIndexEntry);
  67 DEFINE_CLS_IMPL(DocTable);
  68 DEFINE_CLS_IMPL(DocRow);
  69 DEFINE_CLS_IMPL(DocEntry);
  70 DEFINE_CLS_IMPL(DocSection);
  71 DEFINE_CLS_IMPL(DocVerbatim);
  72 DEFINE_CLS_IMPL(DocCopy);
  73 DEFINE_CLS_IMPL(DocTocList);
  74 DEFINE_CLS_IMPL(DocTocItem);
  75 DEFINE_CLS_IMPL(DocAnchor);
  76 DEFINE_CLS_IMPL(DocSymbol);
  77 DEFINE_CLS_IMPL(DocInternal);
  78 DEFINE_CLS_IMPL(DocRoot);
  79
  80 //-----------------------------------------------------------------------------
  81
  82
  83 /*! \brief Node representing a piece of text.
  84  *
  85  */
  86 class TextNode : public DocTextImpl
  87 {
  88   public:
  89     TextNode(const QString &t,int markup,int level)
  90       : m_text(t), m_markup(markup), m_headingLevel(level) {}
  91     virtual ~TextNode() {}
  92
  93     // IDocText
  94     virtual Kind kind() const { return DocImpl::Text; }
  95     virtual const IString *text() const { return &m_text; }
  96     virtual int markup() const { return m_markup; }
  97     virtual int headingLevel() const { return m_headingLevel; }
  98
  99   private:
 100     StringImpl m_text;
 101     int m_markup;
 102     int m_headingLevel;
 103 };
 104
 105 //-----------------------------------------------------------------------------
 106
 107 /*! \brief Node representing a change in the markup style.
 108  *
 109  */
 110 class MarkupModifierNode : public DocMarkupModifierImpl
 111 {
 112   public:
 113     MarkupModifierNode(int markup,bool enabled,int level=0)
 114       : m_markup(markup), m_enabled(enabled), m_headingLevel(level) {}
 115     virtual ~MarkupModifierNode() {}
 116
 117     // IDocMarkupModifier
 118     virtual Kind kind() const { return DocImpl::MarkupModifier; }
 119     virtual bool enabled() const { return m_enabled; }
 120     virtual int markup() const { return m_markup; }
 121     virtual int headingLevel() const { return m_headingLevel; }
 122
 123   private:
 124     int m_markup;
 125     bool m_enabled;
 126     int m_headingLevel;
 127 };
 128
 129
 130 //-----------------------------------------------------------------------------
 131
 132 /*! \brief Handles markup commands in the XML input.
 133  *
 134  */
 135 class MarkupHandler : public BaseFallBackHandler<MarkupHandler>
 136 {
 137   public:
 138     MarkupHandler(QList<DocImpl> &children,QString &curString);
 139     virtual ~MarkupHandler();
 140     int markup() const { return m_curMarkup; }
 141     int headingLevel() const { return m_headingLevel; }
 142
 143     virtual void startBold(const QXmlAttributes &attrib);
 144     virtual void endBold();
 145     virtual void startEmphasis(const QXmlAttributes &attrib);
 146     virtual void endEmphasis();
 147     virtual void startComputerOutput(const QXmlAttributes &attrib);
 148     virtual void endComputerOutput();
 149     virtual void startCenter(const QXmlAttributes &attrib);
 150     virtual void endCenter();
 151     virtual void startSmallFont(const QXmlAttributes &attrib);
 152     virtual void endSmallFont();
 153     virtual void startSubscript(const QXmlAttributes &attrib);
 154     virtual void endSubscript();
 155     virtual void startSuperscript(const QXmlAttributes &attrib);
 156     virtual void endSuperscript();
 157     virtual void startPreformatted(const QXmlAttributes &attrib);
 158     virtual void endPreformatted();
 159     virtual void startHeading1(const QXmlAttributes &attrib);
 160     virtual void endHeading1();
 161     virtual void startHeading2(const QXmlAttributes &attrib);
 162     virtual void endHeading2();
 163     virtual void startHeading3(const QXmlAttributes &attrib);
 164     virtual void endHeading3();
 165     virtual void startHeading4(const QXmlAttributes &attrib);
 166     virtual void endHeading4();
 167     virtual void startHeading5(const QXmlAttributes &attrib);
 168     virtual void endHeading5();
 169     virtual void startHeading6(const QXmlAttributes &attrib);
 170     virtual void endHeading6();
 171
 172
 173   private:
 174     void addTextNode();
 175
 176     QList<DocImpl>  &m_children;
 177     QString         &m_curString;
 178     int             m_curMarkup;
 179     int             m_headingLevel;
 180 };
 181
 182 //-----------------------------------------------------------------------------
 183
 184 /*! \brief Node representing a paragraph of text and commands.
 185  *
 186  */
 187 // children: itemizedlist, orderedlist, parameterlist, simplesect, ref,
 188 //           variablelist, hruler, linebreak, ulink, email, link
 189 //           programlisting, formula, image, dotfile, indexentry,
 190 //           table
 191 //
 192 // children handled by MarkupHandler:
 193 //           bold, computeroutput, emphasis, center,
 194 //           small, subscript, superscript.
 195 //
 196 class ParagraphHandler : public DocParaImpl,
 197                          public BaseHandler<ParagraphHandler>
 198 {
 199     friend class ParagraphIterator;
 200
 201   public:
 202     virtual void startParagraph(const QXmlAttributes& attrib);
 203     virtual void endParagraph();
 204     virtual void startItemizedList(const QXmlAttributes& attrib);
 205     virtual void startOrderedList(const QXmlAttributes& attrib);
 206     virtual void startParameterList(const QXmlAttributes& attrib);
 207     virtual void startSimpleSect(const QXmlAttributes& attrib);
 208     virtual void startRef(const QXmlAttributes& attrib);
 209     virtual void startVariableList(const QXmlAttributes& attrib);
 210     virtual void startHRuler(const QXmlAttributes& attrib);
 211     virtual void startLineBreak(const QXmlAttributes& attrib);
 212     virtual void startULink(const QXmlAttributes& attrib);
 213     virtual void startEMail(const QXmlAttributes& attrib);
 214     virtual void startLink(const QXmlAttributes& attrib);
 215     virtual void startProgramListing(const QXmlAttributes& attrib);
 216     virtual void startFormula(const QXmlAttributes& attrib);
 217     virtual void startImage(const QXmlAttributes& attrib);
 218     virtual void startDotFile(const QXmlAttributes& attrib);
 219     virtual void startIndexEntry(const QXmlAttributes& attrib);
 220     virtual void startTable(const QXmlAttributes& attrib);
 221     virtual void startVerbatim(const QXmlAttributes& attrib);
 222     virtual void startHtmlOnly(const QXmlAttributes& attrib);
 223     virtual void startLatexOnly(const QXmlAttributes& attrib);
 224     virtual void startUmlaut(const QXmlAttributes& attrib);
 225     virtual void startAcute(const QXmlAttributes& attrib);
 226     virtual void startGrave(const QXmlAttributes& attrib);
 227     virtual void startCirc(const QXmlAttributes& attrib);
 228     virtual void startTilde(const QXmlAttributes& attrib);
 229     virtual void startSzlig(const QXmlAttributes& attrib);
 230     virtual void startCedil(const QXmlAttributes& attrib);
 231     virtual void startRing(const QXmlAttributes& attrib);
 232     virtual void startNbsp(const QXmlAttributes& attrib);
 233     virtual void startCopy(const QXmlAttributes& attrib);
 234     virtual void startAnchor(const QXmlAttributes& attrib);
 235     virtual void startCopyDoc(const QXmlAttributes& attrib);
 236     virtual void startTocList(const QXmlAttributes& attrib);
 237
 238     ParagraphHandler(IBaseHandler *parent);
 239     virtual ~ParagraphHandler();
 240
 241     // IDocPara
 242     virtual Kind kind() const { return DocImpl::Para; }
 243     virtual IDocIterator *contents() const;
 244
 245   private:
 246     void addTextNode();
 247     IBaseHandler   *m_parent;
 248     QList<DocImpl>  m_children;
 249     MarkupHandler  *m_markupHandler;
 250 };
 251
 252 class ParagraphIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
 253 {
 254   public:
 255     ParagraphIterator(const ParagraphHandler &handler) :
 256       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
 257 };
 258
 259 //-----------------------------------------------------------------------------
 260
 261 /*! \brief Node representing a list item.
 262  *
 263  */
 264 class ListItemHandler : public DocListItemImpl, public BaseHandler<ListItemHandler>
 265 {
 266     friend class ListItemIterator;
 267   public:
 268     ListItemHandler(IBaseHandler *parent);
 269     virtual ~ListItemHandler();
 270     virtual void startListItem(const QXmlAttributes& attrib);
 271     virtual void endListItem();
 272     virtual void startParagraph(const QXmlAttributes& attrib);
 273
 274     // IDocItem
 275     virtual Kind kind() const { return DocImpl::ListItem; }
 276     virtual IDocIterator *contents() const;
 277
 278   private:
 279     IBaseHandler   *m_parent;
 280     QList<DocImpl>  m_children;
 281 };
 282
 283 class ListItemIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
 284 {
 285   public:
 286     ListItemIterator(const ListItemHandler &handler) :
 287       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
 288 };
 289
 290
 291 //-----------------------------------------------------------------------------
 292
 293 /*! \brief Node representing list of items.
 294  *
 295  */
 296 class OrderedListHandler : public DocOrderedListImpl, public BaseHandler<OrderedListHandler>
 297 {
 298     friend class OrderedListIterator;
 299   public:
 300     OrderedListHandler(IBaseHandler *parent);
 301     virtual ~OrderedListHandler();
 302     virtual void startOrderedList(const QXmlAttributes& attrib);
 303     virtual void endOrderedList();
 304     virtual void startOrderedListItem(const QXmlAttributes& attrib);
 305
 306     // IDocOrderedList
 307     virtual Kind kind() const { return DocImpl::OrderedList; }
 308     virtual IDocIterator *elements() const;
 309
 310   private:
 311     IBaseHandler   *m_parent;
 312     QList<DocImpl>  m_children;
 313 };
 314
 315 class OrderedListIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
 316 {
 317   public:
 318     OrderedListIterator(const OrderedListHandler &handler) :
 319       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
 320 };
 321
 322 //-----------------------------------------------------------------------------
 323
 324 /*! \brief Node representing table of contents list.
 325  *
 326  */
 327 class TocListHandler : public DocTocListImpl, public BaseHandler<TocListHandler>
 328 {
 329     friend class TocListIterator;
 330   public:
 331     TocListHandler(IBaseHandler *parent);
 332     virtual ~TocListHandler();
 333     virtual void startTocList(const QXmlAttributes& attrib);
 334     virtual void endTocList();
 335     virtual void startTocItem(const QXmlAttributes& attrib);
 336
 337     // IDocTocList
 338     virtual Kind kind() const { return DocImpl::TocList; }
 339     virtual IDocIterator *elements() const;
 340
 341   private:
 342     IBaseHandler   *m_parent;
 343     QList<DocImpl>  m_children;
 344 };
 345
 346 class TocListIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
 347 {
 348   public:
 349     TocListIterator(const TocListHandler &handler) :
 350       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
 351 };
 352
 353 //-----------------------------------------------------------------------------
 354
 355 /*! \brief Node representing a table of contents item.
 356  *
 357  */
 358 class TocItemHandler : public DocTocItemImpl, public BaseHandler<TocItemHandler>
 359 {
 360     friend class TocItemIterator;
 361   public:
 362     TocItemHandler(IBaseHandler *parent);
 363     virtual ~TocItemHandler();
 364     virtual void startTocItem(const QXmlAttributes& attrib);
 365     virtual void endTocItem();
 366
 367     // IDocItem
 368     virtual Kind kind() const { return DocImpl::TocItem; }
 369     virtual const IString *id() const { return &m_id; }
 370     virtual const IString *title() const { return &m_title; }
 371
 372   private:
 373     IBaseHandler   *m_parent;
 374     StringImpl      m_id;
 375     StringImpl      m_title;
 376 };
 377
 378 //-----------------------------------------------------------------------------
 379
 380 /*! \brief Node representing list of items.
 381  *
 382  */
 383 class ItemizedListHandler : public DocItemizedListImpl, public BaseHandler<ItemizedListHandler>
 384 {
 385     friend class ItemizedListIterator;
 386   public:
 387     ItemizedListHandler(IBaseHandler *parent);
 388     virtual ~ItemizedListHandler();
 389     virtual void startItemizedList(const QXmlAttributes& attrib);
 390     virtual void endItemizedList();
 391     virtual void startItemizedListItem(const QXmlAttributes& attrib);
 392
 393     // IDocItemizedList
 394     virtual Kind kind() const { return DocImpl::ItemizedList; }
 395     virtual IDocIterator *elements() const;
 396
 397   private:
 398     IBaseHandler   *m_parent;
 399     QList<DocImpl>  m_children;
 400 };
 401
 402 class ItemizedListIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
 403 {
 404   public:
 405     ItemizedListIterator(const ItemizedListHandler &handler) :
 406       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
 407 };
 408
 409
 410 //-----------------------------------------------------------------------------
 411 /*! \brief Node representing a parameter.
 412  *
 413  */
 414 class ParameterHandler : public DocParameterImpl,
 415                          public BaseHandler<ParameterHandler>
 416 {
 417   public:
 418     ParameterHandler(IBaseHandler *parent);
 419     virtual ~ParameterHandler();
 420     virtual void startParameterName(const QXmlAttributes& attrib);
 421     virtual void endParameterName();
 422
 423     // IDocParameter
 424     virtual Kind kind() const { return DocImpl::Parameter; }
 425     virtual const IString *name() const { return &m_name; }
 426
 427   private:
 428     IBaseHandler     *m_parent;
 429     StringImpl        m_name;
 430 };
 431
 432 //-----------------------------------------------------------------------------
 433
 434 /* \brief Node representing a list of param names with a single description.
 435  *
 436  */
 437 class ParameterItemHandler : public DocParameterItemImpl,
 438                              public BaseHandler<ParameterItemHandler>
 439 {
 440     friend class ParameterItemIterator;
 441   public:
 442     ParameterItemHandler(IBaseHandler *parent);
 443     virtual ~ParameterItemHandler();
 444     virtual void startParameterItem(const QXmlAttributes& attrib);
 445     virtual void endParameterItem();
 446     virtual void startParameterName(const QXmlAttributes& attrib);
 447     virtual void startParagraph(const QXmlAttributes& attrib);
 448
 449     // IDocParameterItem
 450     virtual Kind kind() const { return DocImpl::ParameterItem; }
 451     virtual IDocIterator *paramNames() const;
 452     virtual IDocPara *description() const { return m_description; }
 453
 454   private:
 455     IBaseHandler            *m_parent;
 456     QList<ParameterHandler>  m_parameters;
 457     ParagraphHandler *m_description;
 458 };
 459
 460 class ParameterItemIterator : public BaseIteratorVia<IDocIterator,IDoc,ParameterHandler,DocImpl>
 461 {
 462   public:
 463     ParameterItemIterator(const ParameterItemHandler &handler) :
 464       BaseIteratorVia<IDocIterator,IDoc,ParameterHandler,DocImpl>(handler.m_parameters) {}
 465 };
 466
 467 //-----------------------------------------------------------------------------
 468
 469 /* \brief Node representing a parameter section.
 470  *
 471  */
 472 class ParameterListHandler : public DocParameterListImpl,
 473                              public BaseHandler<ParameterListHandler>
 474 {
 475     friend class ParameterListIterator;
 476   public:
 477     ParameterListHandler(IBaseHandler *parent);
 478     virtual ~ParameterListHandler();
 479     virtual void startParameterList(const QXmlAttributes& attrib);
 480     virtual void endParameterList();
 481     virtual void startParameterItem(const QXmlAttributes& attrib);
 482
 483     // IDocParameterList
 484     virtual Kind kind() const { return DocImpl::ParameterList; }
 485     virtual Types sectType() const { return m_type; }
 486     virtual IDocIterator *params() const;
 487
 488   private:
 489     IBaseHandler            *m_parent;
 490     QList<ParameterItemHandler>  m_paramItems;
 491     Types                    m_type;
 492 };
 493
 494 class ParameterListIterator : public BaseIteratorVia<IDocIterator,IDoc,ParameterItemHandler,DocImpl>
 495 {
 496   public:
 497     ParameterListIterator(const ParameterListHandler &handler) :
 498       BaseIteratorVia<IDocIterator,IDoc,ParameterItemHandler,DocImpl>(handler.m_paramItems) {}
 499 };
 500
 501 //-----------------------------------------------------------------------------
 502
 503 /* \brief Node representing a horizontal ruler
 504  *
 505  */
 506 class LineBreakHandler : public DocLineBreakImpl, public BaseHandler<LineBreakHandler>
 507 {
 508   public:
 509     LineBreakHandler(IBaseHandler *parent);
 510     virtual ~LineBreakHandler();
 511
 512     void startLineBreak(const QXmlAttributes& attrib);
 513     void endLineBreak();
 514
 515     // IDocLineBreak
 516     virtual Kind kind() const { return DocImpl::LineBreak; }
 517
 518   private:
 519     IBaseHandler   *m_parent;
 520 };
 521
 522 //-----------------------------------------------------------------------------
 523
 524 /* \brief Node representing a link to section
 525  *
 526  */
 527 class LinkHandler : public DocLinkImpl, public BaseHandler<LinkHandler>
 528 {
 529   public:
 530     LinkHandler(IBaseHandler *parent);
 531     virtual ~LinkHandler();
 532
 533     void startLink(const QXmlAttributes& attrib);
 534     void endLink();
 535
 536     // IDocLink
 537     virtual Kind kind() const { return DocImpl::Link; }
 538     virtual const IString *refId() const { return &m_ref; }
 539     virtual const IString *text() const { return &m_text; }
 540
 541   private:
 542     IBaseHandler   *m_parent;
 543     StringImpl      m_ref;
 544     StringImpl      m_text;
 545 };
 546
 547
 548 //-----------------------------------------------------------------------------
 549
 550 /* \brief Node representing a link to an email address
 551  *
 552  */
 553 class EMailHandler : public DocEMailImpl, public BaseHandler<EMailHandler>
 554 {
 555   public:
 556     EMailHandler(IBaseHandler *parent);
 557     virtual ~EMailHandler();
 558
 559     void startEMail(const QXmlAttributes& attrib);
 560     void endEMail();
 561
 562     // IDocEMail
 563     virtual Kind kind() const { return DocImpl::EMail; }
 564     virtual const IString *address() const { return &m_address; }
 565
 566   private:
 567     IBaseHandler   *m_parent;
 568     StringImpl      m_address;
 569 };
 570
 571
 572 //-----------------------------------------------------------------------------
 573
 574 /* \brief Node representing a link to an URL
 575  *
 576  */
 577 class ULinkHandler : public DocULinkImpl, public BaseHandler<ULinkHandler>
 578 {
 579   public:
 580     ULinkHandler(IBaseHandler *parent);
 581     virtual ~ULinkHandler();
 582
 583     void startULink(const QXmlAttributes& attrib);
 584     void endULink();
 585
 586     // IDocULink
 587     virtual Kind kind() const { return DocImpl::ULink; }
 588     virtual const IString * url() const { return &m_url; }
 589     virtual const IString * text() const { return &m_text; }
 590
 591   private:
 592     IBaseHandler   *m_parent;
 593     StringImpl      m_url;
 594     StringImpl      m_text;
 595 };
 596
 597 //-----------------------------------------------------------------------------
 598
 599 /* \brief Node representing a horizontal ruler
 600  *
 601  */
 602 class HRulerHandler : public DocHRulerImpl, public BaseHandler<HRulerHandler>
 603 {
 604   public:
 605     HRulerHandler(IBaseHandler *parent);
 606     virtual ~HRulerHandler();
 607
 608     void startHRuler(const QXmlAttributes& attrib);
 609     void endHRuler();
 610
 611     // IDocHRuler
 612     virtual Kind kind() const { return DocImpl::HRuler; }
 613
 614   private:
 615     IBaseHandler   *m_parent;
 616 };
 617
 618 //-----------------------------------------------------------------------------
 619
 620 /* \brief Node representing a reference to another item
 621  *
 622  */
 623 class RefHandler : public DocRefImpl, public BaseHandler<RefHandler>
 624 {
 625   public:
 626     RefHandler(IBaseHandler *parent);
 627     virtual ~RefHandler();
 628     void startRef(const QXmlAttributes& attrib);
 629     void endRef();
 630
 631     // IDocRef
 632     virtual Kind kind() const { return DocImpl::Ref; }
 633     virtual const IString *refId() const { return &m_refId; }
 634     virtual TargetKind targetKind() const { return m_targetKind; }
 635     virtual const IString *external() const { return &m_extId; }
 636     virtual const IString *text() const { return &m_linkText; }
 637
 638   private:
 639     IBaseHandler   *m_parent;
 640     StringImpl      m_refId;
 641     StringImpl      m_extId;
 642     StringImpl      m_linkText;
 643     TargetKind      m_targetKind;
 644 };
 645
 646 //-----------------------------------------------------------------------------
 647
 648 /* \brief Node representing the title of a section
 649  *
 650  */
 651 // children: text, ref
 652 // children handled by MarkupHandler:
 653 //           bold, computeroutput, emphasis, center,
 654 //           small, subscript, superscript.
 655 class TitleHandler : public DocTitleImpl, public BaseHandler<TitleHandler>
 656 {
 657     friend class TitleIterator;
 658   public:
 659     TitleHandler(IBaseHandler *parent);
 660     virtual ~TitleHandler();
 661     virtual void startTitle(const QXmlAttributes& attrib);
 662     virtual void endTitle();
 663     virtual void startRef(const QXmlAttributes& attrib);
 664     void addTextNode();
 665
 666     // IDocTitle
 667     virtual Kind kind() const { return DocImpl::Title; }
 668     virtual IDocIterator *title() const;
 669
 670   private:
 671     IBaseHandler   *m_parent;
 672     QList<DocImpl>  m_children;
 673     MarkupHandler  *m_markupHandler;
 674 };
 675
 676 class TitleIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
 677 {
 678   public:
 679     TitleIterator(const TitleHandler &handler) :
 680       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
 681 };
 682
 683 //-----------------------------------------------------------------------------
 684
 685 /* \brief Node representing a simple section with an unnumbered header.
 686  *
 687  */
 688 // children: title, para
 689 class SimpleSectHandler : public DocSimpleSectImpl,
 690                           public BaseHandler<SimpleSectHandler>
 691 {
 692   public:
 693     SimpleSectHandler(IBaseHandler *parent);
 694     virtual ~SimpleSectHandler();
 695     virtual void startSimpleSect(const QXmlAttributes& attrib);
 696     virtual void endSimpleSect();
 697     virtual void startTitle(const QXmlAttributes& attrib);
 698     virtual void startParagraph(const QXmlAttributes& attrib);
 699
 700     // IDocSimpleSect
 701     virtual Kind kind() const { return DocImpl::SimpleSect; }
 702     virtual Types type() const { return m_type; }
 703     virtual const IString *typeString() const { return &m_typeString; }
 704     virtual IDocTitle *title() const { return m_title; }
 705     virtual IDocPara *description() const { return m_paragraph; }
 706
 707   private:
 708     IBaseHandler            *m_parent;
 709     ParagraphHandler        *m_paragraph;
 710     Types                    m_type;
 711     StringImpl               m_typeString;
 712     TitleHandler            *m_title;
 713 };
 714
 715 //-----------------------------------------------------------------------------
 716
 717 /* \brief Node representing an named item of a VariableList.
 718  *
 719  */
 720 class VariableListEntryHandler : public DocVariableListEntryImpl,
 721                                  public BaseHandler<VariableListEntryHandler>
 722 {
 723   public:
 724     virtual void startVarListEntry(const QXmlAttributes& attrib);
 725     virtual void endVarListEntry();
 726     virtual void startListItem(const QXmlAttributes& attrib);
 727     virtual void endListItem();
 728     virtual void startTerm(const QXmlAttributes& attrib);
 729     virtual void endTerm();
 730     virtual void startParagraph(const QXmlAttributes& attrib);
 731
 732     VariableListEntryHandler(IBaseHandler *parent);
 733     virtual ~VariableListEntryHandler();
 734
 735     // IDocVariableListEntry
 736     virtual Kind kind() const { return DocImpl::VariableListEntry; }
 737     virtual ILinkedTextIterator *term() const;
 738     virtual IDocPara *description() const { return m_description; }
 739
 740   private:
 741     IBaseHandler*         m_parent;
 742     QList<LinkedTextImpl> m_term;
 743     ParagraphHandler*     m_description;
 744     LinkedTextHandler*    m_linkedTextHandler;
 745 };
 746
 747 //-----------------------------------------------------------------------------
 748
 749 /*! \brief Node representing a list of named items.
 750  *
 751  */
 752 // children: varlistentry, listitem
 753 class VariableListHandler : public DocVariableListImpl,
 754                             public BaseHandler<VariableListHandler>
 755 {
 756     friend class VariableListIterator;
 757
 758   public:
 759     virtual void startVariableList(const QXmlAttributes& attrib);
 760     virtual void endVariableList();
 761     virtual void startVarListEntry(const QXmlAttributes& attrib);
 762     virtual void startListItem(const QXmlAttributes& attrib);
 763
 764     VariableListHandler(IBaseHandler *parent);
 765     virtual ~VariableListHandler();
 766
 767     // IDocVariableList
 768     virtual Kind kind() const { return DocImpl::VariableList; }
 769     virtual IDocIterator *entries() const;
 770
 771   private:
 772     IBaseHandler   *m_parent;
 773     QList<VariableListEntryHandler> m_entries;
 774     VariableListEntryHandler *m_curEntry;
 775 };
 776
 777 class VariableListIterator : public BaseIteratorVia<IDocIterator,IDoc,VariableListEntryHandler,DocImpl>
 778 {
 779   public:
 780     VariableListIterator(const VariableListHandler &handler) :
 781       BaseIteratorVia<IDocIterator,IDoc,VariableListEntryHandler,DocImpl>(handler.m_entries) {}
 782 };
 783
 784 //-----------------------------------------------------------------------------
 785
 786 /*! \brief Node representing a highlighted text fragment.
 787  *
 788  */
 789 // children: ref
 790 class HighlightHandler : public DocHighlightImpl, public BaseHandler<HighlightHandler>
 791 {
 792     friend class HighlightIterator;
 793   public:
 794     HighlightHandler(IBaseHandler *parent);
 795     virtual ~HighlightHandler();
 796     void startHighlight(const QXmlAttributes& attrib);
 797     void endHighlight();
 798     virtual void startRef(const QXmlAttributes&);
 799     virtual void startSpace(const QXmlAttributes&);
 800
 801     // IDocHighlight
 802     virtual Kind kind() const { return DocImpl::Highlight; }
 803     virtual HighlightKind highlightKind() const { return m_hl; }
 804     virtual IDocIterator *codeElements() const;
 805
 806   private:
 807     void addTextNode();
 808
 809     IBaseHandler   *m_parent;
 810     HighlightKind  m_hl;
 811     QString        m_hlString;
 812     QList<DocImpl> m_children;
 813 };
 814
 815 class HighlightIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
 816 {
 817   public:
 818     HighlightIterator(const HighlightHandler &handler) :
 819       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
 820 };
 821
 822 //-----------------------------------------------------------------------------
 823
 824 /*! \brief Node representing a line of code.
 825  *
 826  */
 827 // children: linenumber, highlight, anchor, ref
 828 class CodeLineHandler : public DocCodeLineImpl, public BaseHandler<CodeLineHandler>
 829 {
 830     friend class CodeLineIterator;
 831   public:
 832
 833     virtual void startCodeLine(const QXmlAttributes&);
 834     virtual void endCodeLine();
 835     virtual void startLineNumber(const QXmlAttributes&);
 836     virtual void endLineNumber();
 837     virtual void startHighlight(const QXmlAttributes&);
 838     virtual void startRef(const QXmlAttributes&);
 839
 840     CodeLineHandler(IBaseHandler *parent);
 841     virtual ~CodeLineHandler();
 842
 843     // IDocCodeLine
 844     virtual Kind kind() const { return DocImpl::CodeLine; }
 845     virtual int lineNumber() const { return m_lineNumber; }
 846     virtual const IString *refId() const { return &m_refId; }
 847     virtual IDocIterator *codeElements() const;
 848
 849   private:
 850     void addTextNode();
 851
 852     IBaseHandler   *m_parent;
 853     int            m_lineNumber;
 854     StringImpl     m_refId;
 855     QList<DocImpl> m_children;
 856 };
 857
 858 class CodeLineIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
 859 {
 860   public:
 861     CodeLineIterator(const CodeLineHandler &handler) :
 862       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
 863 };
 864
 865 //-----------------------------------------------------------------------------
 866
 867 /*! \brief Node representing a program listing
 868  *
 869  */
 870 // children: codeline, linenumber
 871 class ProgramListingHandler : public DocProgramListingImpl, public BaseHandler<ProgramListingHandler>
 872 {
 873     friend class ProgramListingIterator;
 874   public:
 875     virtual void startProgramListing(const QXmlAttributes& attrib);
 876     virtual void endProgramListing();
 877     virtual void startCodeLine(const QXmlAttributes&);
 878     virtual void startLineNumber(const QXmlAttributes&);
 879
 880     ProgramListingHandler(IBaseHandler *parent);
 881     virtual ~ProgramListingHandler();
 882
 883     // IDocProgramListing
 884     virtual Kind kind() const { return DocImpl::ProgramListing; }
 885     virtual IDocIterator *codeLines() const;
 886
 887   private:
 888     IBaseHandler           *m_parent;
 889     QList<CodeLineHandler>  m_children;
 890     bool m_hasLineNumber;
 891 };
 892
 893 //-----------------------------------------------------------------------------
 894
 895 class ProgramListingIterator : public BaseIteratorVia<IDocIterator,IDoc,CodeLineHandler,DocImpl>
 896 {
 897   public:
 898     ProgramListingIterator(const ProgramListingHandler &handler) :
 899       BaseIteratorVia<IDocIterator,IDoc,CodeLineHandler,DocImpl>(handler.m_children) {}
 900 };
 901
 902 //-----------------------------------------------------------------------------
 903
 904 /*! \brief Node representing a formula.
 905  *
 906  */
 907 // children: -
 908 class FormulaHandler : public DocFormulaImpl, public BaseHandler<FormulaHandler>
 909 {
 910   public:
 911     FormulaHandler(IBaseHandler *parent);
 912     virtual ~FormulaHandler();
 913     void startFormula(const QXmlAttributes& attrib);
 914     void endFormula();
 915
 916     // IDocFormula
 917     virtual Kind kind() const { return DocImpl::Formula; }
 918     virtual const IString *id() const { return &m_id; }
 919     virtual const IString *text() const { return &m_text; }
 920
 921   private:
 922     IBaseHandler  *m_parent;
 923     StringImpl     m_id;
 924     StringImpl     m_text;
 925 };
 926
 927 //-----------------------------------------------------------------------------
 928
 929 /*! \brief Node representing an image.
 930  *
 931  */
 932 // children: -
 933 class ImageHandler : public DocImageImpl, public BaseHandler<ImageHandler>
 934 {
 935   public:
 936     ImageHandler(IBaseHandler *parent);
 937     virtual ~ImageHandler();
 938     void startImage(const QXmlAttributes& attrib);
 939     void endImage();
 940
 941     // IDocImage
 942     virtual Kind kind() const { return DocImpl::Image; }
 943     virtual const IString *name() const { return &m_name; }
 944     virtual const IString *caption() const { return &m_caption; }
 945
 946   private:
 947     IBaseHandler  *m_parent;
 948     StringImpl     m_name;
 949     StringImpl     m_caption;
 950 };
 951
 952
 953 //-----------------------------------------------------------------------------
 954 /*! \brief Node representing an anchor.
 955  *
 956  */
 957 // children: -
 958 class AnchorHandler : public DocAnchorImpl, public BaseHandler<AnchorHandler>
 959 {
 960   public:
 961     AnchorHandler(IBaseHandler *parent);
 962     virtual ~AnchorHandler();
 963     void startAnchor(const QXmlAttributes& attrib);
 964     void endAnchor();
 965
 966     // IDocAnchor
 967     virtual Kind kind() const { return DocImpl::Anchor; }
 968     virtual const IString *id() const { return &m_id; }
 969
 970   private:
 971     IBaseHandler  *m_parent;
 972     StringImpl     m_id;
 973 };
 974
 975 //-----------------------------------------------------------------------------
 976
 977 /*! \brief Node representing a dot file.
 978  *
 979  */
 980 // children: -
 981 class DotFileHandler : public DocDotFileImpl, public BaseHandler<DotFileHandler>
 982 {
 983   public:
 984     DotFileHandler(IBaseHandler *parent);
 985     virtual ~DotFileHandler();
 986     void startDotFile(const QXmlAttributes& attrib);
 987     void endDotFile();
 988
 989     // IDocDotFile
 990     virtual Kind kind() const { return DocImpl::DotFile; }
 991     virtual const IString *name() const { return &m_name; }
 992     virtual const IString *caption() const { return &m_caption; }
 993
 994   private:
 995     IBaseHandler  *m_parent;
 996     StringImpl     m_name;
 997     StringImpl     m_caption;
 998 };
 999
1000 //-----------------------------------------------------------------------------
1001
1002 /*! \brief Node representing an entry in the index.
1003  *
1004  */
1005 // children: -
1006 class IndexEntryHandler : public DocIndexEntryImpl, public BaseHandler<IndexEntryHandler>
1007 {
1008   public:
1009     IndexEntryHandler(IBaseHandler *parent);
1010     virtual ~IndexEntryHandler();
1011     void startIndexEntry(const QXmlAttributes& attrib);
1012     void endIndexEntry();
1013     void startPrimaryIE(const QXmlAttributes& attrib);
1014     void endPrimaryIE();
1015     void startSecondaryIE(const QXmlAttributes& attrib);
1016     void endSecondaryIE();
1017
1018     // IDocIndexEntry
1019     virtual Kind kind() const { return DocImpl::IndexEntry; }
1020     virtual const IString *primary() const { return &m_primary; }
1021     virtual const IString *secondary() const { return &m_secondary; }
1022
1023   private:
1024     IBaseHandler  *m_parent;
1025     StringImpl     m_primary;
1026     StringImpl     m_secondary;
1027 };
1028
1029 //-----------------------------------------------------------------------------
1030
1031 /*! \brief Node representing an entry in the table entry.
1032  *
1033  */
1034 // children: para
1035 class EntryHandler : public DocEntryImpl, public BaseHandler<EntryHandler>
1036 {
1037     friend class EntryIterator;
1038   public:
1039     EntryHandler(IBaseHandler *parent);
1040     virtual ~EntryHandler();
1041     void startEntry(const QXmlAttributes& attrib);
1042     void endEntry();
1043     void startParagraph(const QXmlAttributes& attrib);
1044
1045     // IDocEntry
1046     virtual Kind kind() const { return DocImpl::Entry; }
1047     virtual IDocIterator *contents() const;
1048
1049   private:
1050     IBaseHandler   *m_parent;
1051     QList<DocImpl>  m_children;
1052 };
1053
1054 class EntryIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1055 {
1056   public:
1057     EntryIterator(const EntryHandler &handler) :
1058       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
1059 };
1060
1061 //-----------------------------------------------------------------------------
1062
1063 /*! \brief Node representing an entry in the table row.
1064  *
1065  */
1066 // children: entry
1067 class RowHandler : public DocRowImpl, public BaseHandler<RowHandler>
1068 {
1069     friend class RowIterator;
1070   public:
1071     RowHandler(IBaseHandler *parent);
1072     virtual ~RowHandler();
1073     void startRow(const QXmlAttributes& attrib);
1074     void endRow();
1075     void startEntry(const QXmlAttributes& attrib);
1076
1077     // IDocRow
1078     virtual Kind kind() const { return DocImpl::Row; }
1079     virtual IDocIterator *entries() const;
1080
1081   private:
1082     IBaseHandler        *m_parent;
1083     QList<EntryHandler>  m_children;
1084 };
1085
1086 class RowIterator : public BaseIteratorVia<IDocIterator,IDoc,EntryHandler,DocImpl>
1087 {
1088   public:
1089     RowIterator(const RowHandler &handler) :
1090       BaseIteratorVia<IDocIterator,IDoc,EntryHandler,DocImpl>(handler.m_children) {}
1091 };
1092
1093 //-----------------------------------------------------------------------------
1094
1095 /*! \brief Node representing an entry in the table.
1096  *
1097  */
1098 // children: row, caption
1099 class TableHandler : public DocTableImpl, public BaseHandler<TableHandler>
1100 {
1101     friend class TableIterator;
1102   public:
1103     TableHandler(IBaseHandler *parent);
1104     virtual ~TableHandler();
1105     void startTable(const QXmlAttributes& attrib);
1106     void endTable();
1107     void startRow(const QXmlAttributes& attrib);
1108     void startCaption(const QXmlAttributes& attrib);
1109     void endCaption();
1110
1111     // IDocTable
1112     virtual Kind kind() const { return DocImpl::Table; }
1113     virtual IDocIterator *rows() const;
1114     virtual int numColumns() const { return m_numColumns; }
1115     virtual const IString *caption() const { return &m_caption; }
1116
1117   private:
1118     IBaseHandler      *m_parent;
1119     QList<RowHandler>  m_children;
1120     int                m_numColumns;
1121     StringImpl         m_caption;
1122 };
1123
1124 class TableIterator : public BaseIteratorVia<IDocIterator,IDoc,RowHandler,DocImpl>
1125 {
1126   public:
1127     TableIterator(const TableHandler &handler) :
1128       BaseIteratorVia<IDocIterator,IDoc,RowHandler,DocImpl>(handler.m_children) {}
1129 };
1130
1131 //-----------------------------------------------------------------------------
1132
1133 /*! \brief Node representing a copied piece of documentation.
1134  *
1135  */
1136 class CopyHandler : public DocCopyImpl, public BaseHandler<CopyHandler>
1137 {
1138     friend class CopyIterator;
1139   public:
1140     CopyHandler(IBaseHandler *parent);
1141     virtual ~CopyHandler();
1142     virtual void startCopy(const QXmlAttributes& attrib);
1143     virtual void endCopy();
1144     virtual void startParagraph(const QXmlAttributes& attrib);
1145
1146     // IDocCopy
1147     virtual Kind kind() const { return DocImpl::Copy; }
1148     virtual IDocIterator *contents() const;
1149
1150   private:
1151     IBaseHandler   *m_parent;
1152     QList<DocImpl>  m_children;
1153 };
1154
1155 class CopyIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1156 {
1157   public:
1158     CopyIterator(const CopyHandler &handler) :
1159       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
1160 };
1161
1162 //-----------------------------------------------------------------------------
1163
1164 /*! \brief Node representing an preformatted section
1165  */
1166 class VerbatimHandler : public DocVerbatimImpl,
1167                         public BaseHandler<VerbatimHandler>
1168 {
1169   public:
1170     VerbatimHandler(IBaseHandler *parent);
1171     virtual ~VerbatimHandler();
1172     void startVerbatim(const QXmlAttributes& attrib,Types type);
1173     void endVerbatim();
1174
1175     // IDocVerbatim
1176     virtual Kind kind() const { return DocImpl::Verbatim; }
1177     virtual const IString *text() const { return &m_text; }
1178     virtual Types type() const { return m_type; }
1179
1180   private:
1181     IBaseHandler *m_parent;
1182     StringImpl    m_text;
1183     Types         m_type;
1184 };
1185
1186
1187 //-----------------------------------------------------------------------------
1188
1189 /*! \brief Node representing an special symbol.
1190  *
1191  */
1192 // children: -
1193 class SymbolHandler : public DocSymbolImpl, public BaseHandler<SymbolHandler>
1194 {
1195   public:
1196     SymbolHandler(IBaseHandler *parent,Types type);
1197     virtual ~SymbolHandler();
1198     void startSymbol(const QXmlAttributes& attrib);
1199     void endSymbol();
1200
1201     // IDocSymbol
1202     virtual Kind kind() const   { return DocImpl::Symbol; }
1203     virtual Types type() const  { return m_type; }
1204     virtual const IString *typeString() const { return &m_typeString; }
1205     virtual char letter() const { return m_letter; }
1206
1207   private:
1208     IBaseHandler  *m_parent;
1209     char           m_letter;
1210     Types          m_type;
1211     StringImpl     m_typeString;
1212 };
1213
1214
1215 //-----------------------------------------------------------------------------
1216
1217 /*! \brief Node representing a section.
1218  *
1219  */
1220 // children: title, para, sect(n+1)
1221 class DocSectionHandler : public DocSectionImpl, public BaseHandler<DocSectionHandler>
1222 {
1223     friend class DocSectionParaIterator;
1224     friend class DocSectionSubIterator;
1225   public:
1226     DocSectionHandler(IBaseHandler *parent,int level);
1227     virtual ~DocSectionHandler();
1228     virtual void startDocSection(const QXmlAttributes& attrib);
1229     virtual void endDocSection();
1230     virtual void startTitle(const QXmlAttributes& attrib);
1231     virtual void startSubSection(const QXmlAttributes& attrib);
1232     virtual void startParagraph(const QXmlAttributes& attrib);
1233     virtual void startInternal(const QXmlAttributes& attrib);
1234
1235     // IDocSection
1236     virtual Kind kind() const { return DocImpl::Section; }
1237     virtual const IString *id() const { return &m_id; }
1238     virtual int level() const { return m_level; }
1239     virtual IDocTitle *title() const { return m_title; }
1240     virtual IDocIterator *paragraphs() const;
1241     virtual IDocIterator *subSections() const;
1242     virtual IDocInternal *internal() const;
1243
1244   private:
1245     IBaseHandler    *m_parent;
1246     QList<DocImpl>   m_paragraphs;
1247     QList<DocImpl>   m_subsections;
1248     DocInternalHandler *m_internal;
1249     StringImpl       m_id;
1250     int              m_level;
1251     TitleHandler    *m_title;
1252 };
1253
1254 class DocSectionParaIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1255 {
1256   public:
1257     DocSectionParaIterator(const DocSectionHandler &handler) :
1258       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_paragraphs) {}
1259 };
1260
1261 class DocSectionSubIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1262 {
1263   public:
1264     DocSectionSubIterator(const DocSectionHandler &handler) :
1265       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_subsections) {}
1266 };
1267
1268 //-----------------------------------------------------------------------------
1269
1270 class DocInternalHandler : public DocInternalImpl, public BaseHandler<DocInternalHandler>
1271 {
1272   public:
1273     friend class DocInternalParaIterator;
1274     friend class DocInternalSubIterator;
1275     DocInternalHandler(IBaseHandler *parent,int level);
1276     virtual ~DocInternalHandler();
1277     virtual void startInternal(const QXmlAttributes& attrib);
1278     virtual void endInternal();
1279     virtual void startSubSection(const QXmlAttributes& attrib);
1280     virtual void startParagraph(const QXmlAttributes& attrib);
1281
1282     // IDocInternal
1283     virtual Kind kind() const { return DocImpl::Internal; }
1284     virtual IDocIterator *paragraphs() const;
1285     virtual IDocIterator *subSections() const;
1286
1287   private:
1288     IBaseHandler    *m_parent;
1289     QList<DocImpl>   m_paragraphs;
1290     QList<DocImpl>   m_subsections;
1291     int              m_level;
1292 };
1293
1294 class DocInternalParaIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1295 {
1296   public:
1297     DocInternalParaIterator(const DocInternalHandler &handler) :
1298       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_paragraphs) {}
1299 };
1300
1301 class DocInternalSubIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1302 {
1303   public:
1304     DocInternalSubIterator(const DocInternalHandler &handler) :
1305       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_subsections) {}
1306 };
1307
1308
1309 //-----------------------------------------------------------------------------
1310
1311 /*! \brief Node representing a documentation block.
1312  *
1313  */
1314 // children: para, title, sect1, internal
1315 class DocHandler : public DocRootImpl, public BaseHandler<DocHandler>
1316 {
1317     friend class DocIterator;
1318   public:
1319     virtual void startDoc(const QXmlAttributes& attrib);
1320     virtual void endDoc();
1321     virtual void startParagraph(const QXmlAttributes& attrib);
1322     virtual void startSect1(const QXmlAttributes& attrib);
1323     virtual void startTitle(const QXmlAttributes& attrib);
1324     virtual void startInternal(const QXmlAttributes& attrib);
1325
1326     DocHandler(IBaseHandler *parent);
1327     virtual ~DocHandler();
1328
1329     // IDocRoot
1330     virtual Kind kind() const { return DocImpl::Root; }
1331     virtual IDocIterator *contents() const;
1332     virtual IDocInternal *internal() const;
1333
1334   private:
1335     IBaseHandler *m_parent;
1336     QList<DocImpl> m_children;
1337     DocInternalHandler *m_internal;
1338 };
1339
1340 class DocIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1341 {
1342   public:
1343     DocIterator(const DocHandler &handler) :
1344       BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
1345 };
1346
1347 //-----------------------------------------------------------------------------
1348
1349 void dochandler_init();
1350 void dochandler_exit();
1351
1352 #endif