1 /******************************************************************************
6 * Copyright (C) 1997-2015 by Dimitri van Heesch.
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.
23 #include <doxmlintf.h>
24 #include "stringimpl.h"
25 #include "basehandler.h"
26 #include "baseiterator.h"
28 class ParagraphHandler;
29 class DocInternalHandler;
31 class LinkedTextHandler;
33 //-----------------------------------------------------------------------------
35 class DocImpl : public IDoc { public: virtual ~DocImpl() {} };
37 #define DEFINE_CLS_IMPL(cls) \
38 class cls##Impl : public I##cls, public DocImpl { public: virtual ~cls##Impl() {} }
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);
80 //-----------------------------------------------------------------------------
83 /*! \brief Node representing a piece of text.
86 class TextNode : public DocTextImpl
89 TextNode(const QString &t,int markup,int level)
90 : m_text(t), m_markup(markup), m_headingLevel(level) {}
91 virtual ~TextNode() {}
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; }
105 //-----------------------------------------------------------------------------
107 /*! \brief Node representing a change in the markup style.
110 class MarkupModifierNode : public DocMarkupModifierImpl
113 MarkupModifierNode(int markup,bool enabled,int level=0)
114 : m_markup(markup), m_enabled(enabled), m_headingLevel(level) {}
115 virtual ~MarkupModifierNode() {}
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; }
130 //-----------------------------------------------------------------------------
132 /*! \brief Handles markup commands in the XML input.
135 class MarkupHandler : public BaseFallBackHandler<MarkupHandler>
138 MarkupHandler(QList<DocImpl> &children,QString &curString);
139 virtual ~MarkupHandler();
140 int markup() const { return m_curMarkup; }
141 int headingLevel() const { return m_headingLevel; }
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();
176 QList<DocImpl> &m_children;
177 QString &m_curString;
182 //-----------------------------------------------------------------------------
184 /*! \brief Node representing a paragraph of text and commands.
187 // children: itemizedlist, orderedlist, parameterlist, simplesect, ref,
188 // variablelist, hruler, linebreak, ulink, email, link
189 // programlisting, formula, image, dotfile, indexentry,
192 // children handled by MarkupHandler:
193 // bold, computeroutput, emphasis, center,
194 // small, subscript, superscript.
196 class ParagraphHandler : public DocParaImpl,
197 public BaseHandler<ParagraphHandler>
199 friend class ParagraphIterator;
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);
238 ParagraphHandler(IBaseHandler *parent);
239 virtual ~ParagraphHandler();
242 virtual Kind kind() const { return DocImpl::Para; }
243 virtual IDocIterator *contents() const;
247 IBaseHandler *m_parent;
248 QList<DocImpl> m_children;
249 MarkupHandler *m_markupHandler;
252 class ParagraphIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
255 ParagraphIterator(const ParagraphHandler &handler) :
256 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
259 //-----------------------------------------------------------------------------
261 /*! \brief Node representing a list item.
264 class ListItemHandler : public DocListItemImpl, public BaseHandler<ListItemHandler>
266 friend class ListItemIterator;
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);
275 virtual Kind kind() const { return DocImpl::ListItem; }
276 virtual IDocIterator *contents() const;
279 IBaseHandler *m_parent;
280 QList<DocImpl> m_children;
283 class ListItemIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
286 ListItemIterator(const ListItemHandler &handler) :
287 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
291 //-----------------------------------------------------------------------------
293 /*! \brief Node representing list of items.
296 class OrderedListHandler : public DocOrderedListImpl, public BaseHandler<OrderedListHandler>
298 friend class OrderedListIterator;
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);
307 virtual Kind kind() const { return DocImpl::OrderedList; }
308 virtual IDocIterator *elements() const;
311 IBaseHandler *m_parent;
312 QList<DocImpl> m_children;
315 class OrderedListIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
318 OrderedListIterator(const OrderedListHandler &handler) :
319 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
322 //-----------------------------------------------------------------------------
324 /*! \brief Node representing table of contents list.
327 class TocListHandler : public DocTocListImpl, public BaseHandler<TocListHandler>
329 friend class TocListIterator;
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);
338 virtual Kind kind() const { return DocImpl::TocList; }
339 virtual IDocIterator *elements() const;
342 IBaseHandler *m_parent;
343 QList<DocImpl> m_children;
346 class TocListIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
349 TocListIterator(const TocListHandler &handler) :
350 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
353 //-----------------------------------------------------------------------------
355 /*! \brief Node representing a table of contents item.
358 class TocItemHandler : public DocTocItemImpl, public BaseHandler<TocItemHandler>
360 friend class TocItemIterator;
362 TocItemHandler(IBaseHandler *parent);
363 virtual ~TocItemHandler();
364 virtual void startTocItem(const QXmlAttributes& attrib);
365 virtual void endTocItem();
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; }
373 IBaseHandler *m_parent;
378 //-----------------------------------------------------------------------------
380 /*! \brief Node representing list of items.
383 class ItemizedListHandler : public DocItemizedListImpl, public BaseHandler<ItemizedListHandler>
385 friend class ItemizedListIterator;
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);
394 virtual Kind kind() const { return DocImpl::ItemizedList; }
395 virtual IDocIterator *elements() const;
398 IBaseHandler *m_parent;
399 QList<DocImpl> m_children;
402 class ItemizedListIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
405 ItemizedListIterator(const ItemizedListHandler &handler) :
406 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
410 //-----------------------------------------------------------------------------
411 /*! \brief Node representing a parameter.
414 class ParameterHandler : public DocParameterImpl,
415 public BaseHandler<ParameterHandler>
418 ParameterHandler(IBaseHandler *parent);
419 virtual ~ParameterHandler();
420 virtual void startParameterName(const QXmlAttributes& attrib);
421 virtual void endParameterName();
424 virtual Kind kind() const { return DocImpl::Parameter; }
425 virtual const IString *name() const { return &m_name; }
428 IBaseHandler *m_parent;
432 //-----------------------------------------------------------------------------
434 /* \brief Node representing a list of param names with a single description.
437 class ParameterItemHandler : public DocParameterItemImpl,
438 public BaseHandler<ParameterItemHandler>
440 friend class ParameterItemIterator;
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);
450 virtual Kind kind() const { return DocImpl::ParameterItem; }
451 virtual IDocIterator *paramNames() const;
452 virtual IDocPara *description() const { return m_description; }
455 IBaseHandler *m_parent;
456 QList<ParameterHandler> m_parameters;
457 ParagraphHandler *m_description;
460 class ParameterItemIterator : public BaseIteratorVia<IDocIterator,IDoc,ParameterHandler,DocImpl>
463 ParameterItemIterator(const ParameterItemHandler &handler) :
464 BaseIteratorVia<IDocIterator,IDoc,ParameterHandler,DocImpl>(handler.m_parameters) {}
467 //-----------------------------------------------------------------------------
469 /* \brief Node representing a parameter section.
472 class ParameterListHandler : public DocParameterListImpl,
473 public BaseHandler<ParameterListHandler>
475 friend class ParameterListIterator;
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);
484 virtual Kind kind() const { return DocImpl::ParameterList; }
485 virtual Types sectType() const { return m_type; }
486 virtual IDocIterator *params() const;
489 IBaseHandler *m_parent;
490 QList<ParameterItemHandler> m_paramItems;
494 class ParameterListIterator : public BaseIteratorVia<IDocIterator,IDoc,ParameterItemHandler,DocImpl>
497 ParameterListIterator(const ParameterListHandler &handler) :
498 BaseIteratorVia<IDocIterator,IDoc,ParameterItemHandler,DocImpl>(handler.m_paramItems) {}
501 //-----------------------------------------------------------------------------
503 /* \brief Node representing a horizontal ruler
506 class LineBreakHandler : public DocLineBreakImpl, public BaseHandler<LineBreakHandler>
509 LineBreakHandler(IBaseHandler *parent);
510 virtual ~LineBreakHandler();
512 void startLineBreak(const QXmlAttributes& attrib);
516 virtual Kind kind() const { return DocImpl::LineBreak; }
519 IBaseHandler *m_parent;
522 //-----------------------------------------------------------------------------
524 /* \brief Node representing a link to section
527 class LinkHandler : public DocLinkImpl, public BaseHandler<LinkHandler>
530 LinkHandler(IBaseHandler *parent);
531 virtual ~LinkHandler();
533 void startLink(const QXmlAttributes& attrib);
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; }
542 IBaseHandler *m_parent;
548 //-----------------------------------------------------------------------------
550 /* \brief Node representing a link to an email address
553 class EMailHandler : public DocEMailImpl, public BaseHandler<EMailHandler>
556 EMailHandler(IBaseHandler *parent);
557 virtual ~EMailHandler();
559 void startEMail(const QXmlAttributes& attrib);
563 virtual Kind kind() const { return DocImpl::EMail; }
564 virtual const IString *address() const { return &m_address; }
567 IBaseHandler *m_parent;
568 StringImpl m_address;
572 //-----------------------------------------------------------------------------
574 /* \brief Node representing a link to a URL
577 class ULinkHandler : public DocULinkImpl, public BaseHandler<ULinkHandler>
580 ULinkHandler(IBaseHandler *parent);
581 virtual ~ULinkHandler();
583 void startULink(const QXmlAttributes& attrib);
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; }
592 IBaseHandler *m_parent;
597 //-----------------------------------------------------------------------------
599 /* \brief Node representing a horizontal ruler
602 class HRulerHandler : public DocHRulerImpl, public BaseHandler<HRulerHandler>
605 HRulerHandler(IBaseHandler *parent);
606 virtual ~HRulerHandler();
608 void startHRuler(const QXmlAttributes& attrib);
612 virtual Kind kind() const { return DocImpl::HRuler; }
615 IBaseHandler *m_parent;
618 //-----------------------------------------------------------------------------
620 /* \brief Node representing a reference to another item
623 class RefHandler : public DocRefImpl, public BaseHandler<RefHandler>
626 RefHandler(IBaseHandler *parent);
627 virtual ~RefHandler();
628 void startRef(const QXmlAttributes& attrib);
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; }
639 IBaseHandler *m_parent;
642 StringImpl m_linkText;
643 TargetKind m_targetKind;
646 //-----------------------------------------------------------------------------
648 /* \brief Node representing the title of a section
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>
657 friend class TitleIterator;
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);
667 virtual Kind kind() const { return DocImpl::Title; }
668 virtual IDocIterator *title() const;
671 IBaseHandler *m_parent;
672 QList<DocImpl> m_children;
673 MarkupHandler *m_markupHandler;
676 class TitleIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
679 TitleIterator(const TitleHandler &handler) :
680 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
683 //-----------------------------------------------------------------------------
685 /* \brief Node representing a simple section with an unnumbered header.
688 // children: title, para
689 class SimpleSectHandler : public DocSimpleSectImpl,
690 public BaseHandler<SimpleSectHandler>
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);
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; }
708 IBaseHandler *m_parent;
709 ParagraphHandler *m_paragraph;
711 StringImpl m_typeString;
712 TitleHandler *m_title;
715 //-----------------------------------------------------------------------------
717 /* \brief Node representing an named item of a VariableList.
720 class VariableListEntryHandler : public DocVariableListEntryImpl,
721 public BaseHandler<VariableListEntryHandler>
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);
732 VariableListEntryHandler(IBaseHandler *parent);
733 virtual ~VariableListEntryHandler();
735 // IDocVariableListEntry
736 virtual Kind kind() const { return DocImpl::VariableListEntry; }
737 virtual ILinkedTextIterator *term() const;
738 virtual IDocPara *description() const { return m_description; }
741 IBaseHandler* m_parent;
742 QList<LinkedTextImpl> m_term;
743 ParagraphHandler* m_description;
744 LinkedTextHandler* m_linkedTextHandler;
747 //-----------------------------------------------------------------------------
749 /*! \brief Node representing a list of named items.
752 // children: varlistentry, listitem
753 class VariableListHandler : public DocVariableListImpl,
754 public BaseHandler<VariableListHandler>
756 friend class VariableListIterator;
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);
764 VariableListHandler(IBaseHandler *parent);
765 virtual ~VariableListHandler();
768 virtual Kind kind() const { return DocImpl::VariableList; }
769 virtual IDocIterator *entries() const;
772 IBaseHandler *m_parent;
773 QList<VariableListEntryHandler> m_entries;
774 VariableListEntryHandler *m_curEntry;
777 class VariableListIterator : public BaseIteratorVia<IDocIterator,IDoc,VariableListEntryHandler,DocImpl>
780 VariableListIterator(const VariableListHandler &handler) :
781 BaseIteratorVia<IDocIterator,IDoc,VariableListEntryHandler,DocImpl>(handler.m_entries) {}
784 //-----------------------------------------------------------------------------
786 /*! \brief Node representing a highlighted text fragment.
790 class HighlightHandler : public DocHighlightImpl, public BaseHandler<HighlightHandler>
792 friend class HighlightIterator;
794 HighlightHandler(IBaseHandler *parent);
795 virtual ~HighlightHandler();
796 void startHighlight(const QXmlAttributes& attrib);
798 virtual void startRef(const QXmlAttributes&);
799 virtual void startSpace(const QXmlAttributes&);
802 virtual Kind kind() const { return DocImpl::Highlight; }
803 virtual HighlightKind highlightKind() const { return m_hl; }
804 virtual IDocIterator *codeElements() const;
809 IBaseHandler *m_parent;
812 QList<DocImpl> m_children;
815 class HighlightIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
818 HighlightIterator(const HighlightHandler &handler) :
819 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
822 //-----------------------------------------------------------------------------
824 /*! \brief Node representing a line of code.
827 // children: linenumber, highlight, anchor, ref
828 class CodeLineHandler : public DocCodeLineImpl, public BaseHandler<CodeLineHandler>
830 friend class CodeLineIterator;
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&);
840 CodeLineHandler(IBaseHandler *parent);
841 virtual ~CodeLineHandler();
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;
852 IBaseHandler *m_parent;
855 QList<DocImpl> m_children;
858 class CodeLineIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
861 CodeLineIterator(const CodeLineHandler &handler) :
862 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
865 //-----------------------------------------------------------------------------
867 /*! \brief Node representing a program listing
870 // children: codeline, linenumber
871 class ProgramListingHandler : public DocProgramListingImpl, public BaseHandler<ProgramListingHandler>
873 friend class ProgramListingIterator;
875 virtual void startProgramListing(const QXmlAttributes& attrib);
876 virtual void endProgramListing();
877 virtual void startCodeLine(const QXmlAttributes&);
878 virtual void startLineNumber(const QXmlAttributes&);
880 ProgramListingHandler(IBaseHandler *parent);
881 virtual ~ProgramListingHandler();
883 // IDocProgramListing
884 virtual Kind kind() const { return DocImpl::ProgramListing; }
885 virtual IDocIterator *codeLines() const;
888 IBaseHandler *m_parent;
889 QList<CodeLineHandler> m_children;
890 bool m_hasLineNumber;
893 //-----------------------------------------------------------------------------
895 class ProgramListingIterator : public BaseIteratorVia<IDocIterator,IDoc,CodeLineHandler,DocImpl>
898 ProgramListingIterator(const ProgramListingHandler &handler) :
899 BaseIteratorVia<IDocIterator,IDoc,CodeLineHandler,DocImpl>(handler.m_children) {}
902 //-----------------------------------------------------------------------------
904 /*! \brief Node representing a formula.
908 class FormulaHandler : public DocFormulaImpl, public BaseHandler<FormulaHandler>
911 FormulaHandler(IBaseHandler *parent);
912 virtual ~FormulaHandler();
913 void startFormula(const QXmlAttributes& attrib);
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; }
922 IBaseHandler *m_parent;
927 //-----------------------------------------------------------------------------
929 /*! \brief Node representing an image.
933 class ImageHandler : public DocImageImpl, public BaseHandler<ImageHandler>
936 ImageHandler(IBaseHandler *parent);
937 virtual ~ImageHandler();
938 void startImage(const QXmlAttributes& attrib);
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; }
947 IBaseHandler *m_parent;
949 StringImpl m_caption;
953 //-----------------------------------------------------------------------------
954 /*! \brief Node representing an anchor.
958 class AnchorHandler : public DocAnchorImpl, public BaseHandler<AnchorHandler>
961 AnchorHandler(IBaseHandler *parent);
962 virtual ~AnchorHandler();
963 void startAnchor(const QXmlAttributes& attrib);
967 virtual Kind kind() const { return DocImpl::Anchor; }
968 virtual const IString *id() const { return &m_id; }
971 IBaseHandler *m_parent;
975 //-----------------------------------------------------------------------------
977 /*! \brief Node representing a dot file.
981 class DotFileHandler : public DocDotFileImpl, public BaseHandler<DotFileHandler>
984 DotFileHandler(IBaseHandler *parent);
985 virtual ~DotFileHandler();
986 void startDotFile(const QXmlAttributes& attrib);
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; }
995 IBaseHandler *m_parent;
997 StringImpl m_caption;
1000 //-----------------------------------------------------------------------------
1002 /*! \brief Node representing an entry in the index.
1006 class IndexEntryHandler : public DocIndexEntryImpl, public BaseHandler<IndexEntryHandler>
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();
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; }
1024 IBaseHandler *m_parent;
1025 StringImpl m_primary;
1026 StringImpl m_secondary;
1029 //-----------------------------------------------------------------------------
1031 /*! \brief Node representing an entry in the table entry.
1035 class EntryHandler : public DocEntryImpl, public BaseHandler<EntryHandler>
1037 friend class EntryIterator;
1039 EntryHandler(IBaseHandler *parent);
1040 virtual ~EntryHandler();
1041 void startEntry(const QXmlAttributes& attrib);
1043 void startParagraph(const QXmlAttributes& attrib);
1046 virtual Kind kind() const { return DocImpl::Entry; }
1047 virtual IDocIterator *contents() const;
1050 IBaseHandler *m_parent;
1051 QList<DocImpl> m_children;
1054 class EntryIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1057 EntryIterator(const EntryHandler &handler) :
1058 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
1061 //-----------------------------------------------------------------------------
1063 /*! \brief Node representing an entry in the table row.
1067 class RowHandler : public DocRowImpl, public BaseHandler<RowHandler>
1069 friend class RowIterator;
1071 RowHandler(IBaseHandler *parent);
1072 virtual ~RowHandler();
1073 void startRow(const QXmlAttributes& attrib);
1075 void startEntry(const QXmlAttributes& attrib);
1078 virtual Kind kind() const { return DocImpl::Row; }
1079 virtual IDocIterator *entries() const;
1082 IBaseHandler *m_parent;
1083 QList<EntryHandler> m_children;
1086 class RowIterator : public BaseIteratorVia<IDocIterator,IDoc,EntryHandler,DocImpl>
1089 RowIterator(const RowHandler &handler) :
1090 BaseIteratorVia<IDocIterator,IDoc,EntryHandler,DocImpl>(handler.m_children) {}
1093 //-----------------------------------------------------------------------------
1095 /*! \brief Node representing an entry in the table.
1098 // children: row, caption
1099 class TableHandler : public DocTableImpl, public BaseHandler<TableHandler>
1101 friend class TableIterator;
1103 TableHandler(IBaseHandler *parent);
1104 virtual ~TableHandler();
1105 void startTable(const QXmlAttributes& attrib);
1107 void startRow(const QXmlAttributes& attrib);
1108 void startCaption(const QXmlAttributes& attrib);
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; }
1118 IBaseHandler *m_parent;
1119 QList<RowHandler> m_children;
1121 StringImpl m_caption;
1124 class TableIterator : public BaseIteratorVia<IDocIterator,IDoc,RowHandler,DocImpl>
1127 TableIterator(const TableHandler &handler) :
1128 BaseIteratorVia<IDocIterator,IDoc,RowHandler,DocImpl>(handler.m_children) {}
1131 //-----------------------------------------------------------------------------
1133 /*! \brief Node representing a copied piece of documentation.
1136 class CopyHandler : public DocCopyImpl, public BaseHandler<CopyHandler>
1138 friend class CopyIterator;
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);
1147 virtual Kind kind() const { return DocImpl::Copy; }
1148 virtual IDocIterator *contents() const;
1151 IBaseHandler *m_parent;
1152 QList<DocImpl> m_children;
1155 class CopyIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1158 CopyIterator(const CopyHandler &handler) :
1159 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
1162 //-----------------------------------------------------------------------------
1164 /*! \brief Node representing an preformatted section
1166 class VerbatimHandler : public DocVerbatimImpl,
1167 public BaseHandler<VerbatimHandler>
1170 VerbatimHandler(IBaseHandler *parent);
1171 virtual ~VerbatimHandler();
1172 void startVerbatim(const QXmlAttributes& attrib,Types type);
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; }
1181 IBaseHandler *m_parent;
1187 //-----------------------------------------------------------------------------
1189 /*! \brief Node representing an special symbol.
1193 class SymbolHandler : public DocSymbolImpl, public BaseHandler<SymbolHandler>
1196 SymbolHandler(IBaseHandler *parent,Types type);
1197 virtual ~SymbolHandler();
1198 void startSymbol(const QXmlAttributes& attrib);
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; }
1208 IBaseHandler *m_parent;
1211 StringImpl m_typeString;
1215 //-----------------------------------------------------------------------------
1217 /*! \brief Node representing a section.
1220 // children: title, para, sect(n+1)
1221 class DocSectionHandler : public DocSectionImpl, public BaseHandler<DocSectionHandler>
1223 friend class DocSectionParaIterator;
1224 friend class DocSectionSubIterator;
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);
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;
1245 IBaseHandler *m_parent;
1246 QList<DocImpl> m_paragraphs;
1247 QList<DocImpl> m_subsections;
1248 DocInternalHandler *m_internal;
1251 TitleHandler *m_title;
1254 class DocSectionParaIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1257 DocSectionParaIterator(const DocSectionHandler &handler) :
1258 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_paragraphs) {}
1261 class DocSectionSubIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1264 DocSectionSubIterator(const DocSectionHandler &handler) :
1265 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_subsections) {}
1268 //-----------------------------------------------------------------------------
1270 class DocInternalHandler : public DocInternalImpl, public BaseHandler<DocInternalHandler>
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);
1283 virtual Kind kind() const { return DocImpl::Internal; }
1284 virtual IDocIterator *paragraphs() const;
1285 virtual IDocIterator *subSections() const;
1288 IBaseHandler *m_parent;
1289 QList<DocImpl> m_paragraphs;
1290 QList<DocImpl> m_subsections;
1294 class DocInternalParaIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1297 DocInternalParaIterator(const DocInternalHandler &handler) :
1298 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_paragraphs) {}
1301 class DocInternalSubIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1304 DocInternalSubIterator(const DocInternalHandler &handler) :
1305 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_subsections) {}
1309 //-----------------------------------------------------------------------------
1311 /*! \brief Node representing a documentation block.
1314 // children: para, title, sect1, internal
1315 class DocHandler : public DocRootImpl, public BaseHandler<DocHandler>
1317 friend class DocIterator;
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);
1326 DocHandler(IBaseHandler *parent);
1327 virtual ~DocHandler();
1330 virtual Kind kind() const { return DocImpl::Root; }
1331 virtual IDocIterator *contents() const;
1332 virtual IDocInternal *internal() const;
1335 IBaseHandler *m_parent;
1336 QList<DocImpl> m_children;
1337 DocInternalHandler *m_internal;
1340 class DocIterator : public BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>
1343 DocIterator(const DocHandler &handler) :
1344 BaseIteratorVia<IDocIterator,IDoc,DocImpl,DocImpl>(handler.m_children) {}
1347 //-----------------------------------------------------------------------------
1349 void dochandler_init();
1350 void dochandler_exit();