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

 *

 * $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.

 *

 */

#include <qmap.h>

#include "dochandler.h"

#include "debug.h"

#include "linkedtexthandler.h"

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

class TypeNameMapper

{

  public:

    TypeNameMapper()

    {

      m_map.insert("see",       SimpleSectHandler::See);

      m_map.insert("return",    SimpleSectHandler::Return);

      m_map.insert("author",    SimpleSectHandler::Author);

      m_map.insert("version",   SimpleSectHandler::Version);

      m_map.insert("since",     SimpleSectHandler::Since);

      m_map.insert("date",      SimpleSectHandler::Date);

      m_map.insert("bug",       SimpleSectHandler::Bug);

      m_map.insert("note",      SimpleSectHandler::Note);

      m_map.insert("warning",   SimpleSectHandler::Warning);

      m_map.insert("par",       SimpleSectHandler::Par);

      m_map.insert("deprecated",SimpleSectHandler::Deprecated);

      m_map.insert("pre",       SimpleSectHandler::Pre);

      m_map.insert("post",      SimpleSectHandler::Post);

      m_map.insert("invariant", SimpleSectHandler::Invar);

      m_map.insert("remark",    SimpleSectHandler::Remark);

      m_map.insert("attention", SimpleSectHandler::Attention);

      m_map.insert("todo",      SimpleSectHandler::Todo);

      m_map.insert("test",      SimpleSectHandler::Test);

      m_map.insert("rcs",       SimpleSectHandler::RCS);

      m_map.insert("enumvalues",SimpleSectHandler::EnumValues);

      m_map.insert("examples",  SimpleSectHandler::Examples);

    }

    SimpleSectHandler::Types stringToType(const QString &typeStr)

    {

      return m_map[typeStr];

    }

  private:

    QMap<QString,SimpleSectHandler::Types> m_map;

};

class HighlightMapper

{

  public:

    HighlightMapper()

    {

      m_map.insert("comment",        HighlightHandler::Comment);

      m_map.insert("keyword",        HighlightHandler::Keyword);

      m_map.insert("keywordtype",    HighlightHandler::KeywordType);

      m_map.insert("keywordflow",    HighlightHandler::KeywordFlow);

      m_map.insert("charliteral",    HighlightHandler::CharLiteral);

      m_map.insert("stringliteral",  HighlightHandler::StringLiteral);

      m_map.insert("preprocessor",   HighlightHandler::Preprocessor);

    }

    HighlightHandler::HighlightKind stringToKind(const QString &kindStr)

    {

      return m_map[kindStr];

    }

  private:

    QMap<QString,HighlightHandler::HighlightKind> m_map;

};

static TypeNameMapper *s_typeMapper;

static HighlightMapper *s_highlightMapper;

void dochandler_init()

{

  s_typeMapper = new TypeNameMapper;

  s_highlightMapper = new HighlightMapper;

}

void dochandler_exit()

{

  delete s_typeMapper;

  delete s_highlightMapper;

}

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

// MarkupHandler

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

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

  : m_children(children), m_curString(curString), 

    m_curMarkup(IDocMarkup::Normal), m_headingLevel(0)

{

  addStartHandler("bold",this,&MarkupHandler::startBold);

  addEndHandler("bold",this,&MarkupHandler::endBold);

  addStartHandler("emphasis",this,&MarkupHandler::startEmphasis);

  addEndHandler("emphasis",this,&MarkupHandler::endEmphasis);

  addStartHandler("computeroutput",this,&MarkupHandler::startComputerOutput);

  addEndHandler("computeroutput",this,&MarkupHandler::endComputerOutput);

  addStartHandler("center",this,&MarkupHandler::startCenter);

  addEndHandler("center",this,&MarkupHandler::endCenter);

  addStartHandler("small",this,&MarkupHandler::startSmallFont);

  addEndHandler("small",this,&MarkupHandler::endSmallFont);

  addStartHandler("subscript",this,&MarkupHandler::startSubscript);

  addEndHandler("subscript",this,&MarkupHandler::endSubscript);

  addStartHandler("superscript",this,&MarkupHandler::startSuperscript);

  addEndHandler("superscript",this,&MarkupHandler::endSuperscript);

  addStartHandler("preformatted",this,&MarkupHandler::startPreformatted);

  addEndHandler("preformatted",this,&MarkupHandler::endPreformatted);

  addStartHandler("heading1",this,&MarkupHandler::startHeading1);

  addEndHandler("heading1",this,&MarkupHandler::endHeading1);

  addStartHandler("heading2",this,&MarkupHandler::startHeading2);

  addEndHandler("heading2",this,&MarkupHandler::endHeading2);

  addStartHandler("heading3",this,&MarkupHandler::startHeading3);

  addEndHandler("heading3",this,&MarkupHandler::endHeading3);

  addStartHandler("heading4",this,&MarkupHandler::startHeading4);

  addEndHandler("heading4",this,&MarkupHandler::endHeading4);

  addStartHandler("heading5",this,&MarkupHandler::startHeading5);

  addEndHandler("heading5",this,&MarkupHandler::endHeading5);

  addStartHandler("heading6",this,&MarkupHandler::startHeading6);

  addEndHandler("heading6",this,&MarkupHandler::endHeading6);

}

MarkupHandler::~MarkupHandler()

{

}

void MarkupHandler::addTextNode()

{

  if (!m_curString.isEmpty())

  {

    m_children.append(new TextNode(m_curString,m_curMarkup,m_headingLevel));

    debug(2,"addTextNode() text=%s markup=%x\n",m_curString.data(),m_curMarkup);

    m_curString="";

  }

}

void MarkupHandler::startBold(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Bold,TRUE));

  m_curMarkup |= IDocMarkup::Bold;

}

void MarkupHandler::endBold()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Bold,FALSE));

  m_curMarkup &= ~IDocMarkup::Bold;

}

void MarkupHandler::startEmphasis(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Emphasis,TRUE));

  m_curMarkup |= IDocMarkup::Emphasis;

}

void MarkupHandler::endEmphasis()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Emphasis,FALSE));

  m_curMarkup &= ~IDocMarkup::Emphasis;

}

void MarkupHandler::startComputerOutput(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::ComputerOutput,TRUE));

  m_curMarkup |= IDocMarkup::ComputerOutput;

}

void MarkupHandler::endComputerOutput()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::ComputerOutput,FALSE));

  m_curMarkup &= ~IDocMarkup::ComputerOutput;

}

void MarkupHandler::startCenter(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Center,TRUE));

  m_curMarkup |= IDocMarkup::Center;

}

void MarkupHandler::endCenter()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Center,FALSE));

  m_curMarkup &= ~IDocMarkup::Center;

}

void MarkupHandler::startSmallFont(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::SmallFont,TRUE));

  m_curMarkup |= IDocMarkup::SmallFont;

}

void MarkupHandler::endSmallFont()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::SmallFont,FALSE));

  m_curMarkup &= ~IDocMarkup::SmallFont;

}

void MarkupHandler::startSubscript(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Subscript,TRUE));

  m_curMarkup |= IDocMarkup::Subscript;

}

void MarkupHandler::endSubscript()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Subscript,FALSE));

  m_curMarkup &= ~IDocMarkup::Subscript;

}

void MarkupHandler::startSuperscript(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Superscript,TRUE));

  m_curMarkup |= IDocMarkup::Superscript;

}

void MarkupHandler::endSuperscript()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Superscript,FALSE));

  m_curMarkup &= ~IDocMarkup::Superscript;

}

void MarkupHandler::startPreformatted(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Preformatted,TRUE));

  m_curMarkup |= IDocMarkup::Preformatted;

}

void MarkupHandler::endPreformatted()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Preformatted,FALSE));

  m_curMarkup &= ~IDocMarkup::Preformatted;

}

void MarkupHandler::startHeading1(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,TRUE,1));

  m_curMarkup |= IDocMarkup::Heading;

  m_headingLevel=1;

}

void MarkupHandler::endHeading1()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,FALSE,1));

  m_curMarkup &= ~IDocMarkup::Heading;

  m_headingLevel=0;

}

void MarkupHandler::startHeading2(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,TRUE,2));

  m_curMarkup |= IDocMarkup::Heading;

  m_headingLevel=2;

}

void MarkupHandler::endHeading2()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,FALSE,2));

  m_curMarkup &= ~IDocMarkup::Heading;

  m_headingLevel=0;

}

void MarkupHandler::startHeading3(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,TRUE,3));

  m_curMarkup |= IDocMarkup::Heading;

  m_headingLevel=3;

}

void MarkupHandler::endHeading3()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,FALSE,3));

  m_curMarkup &= ~IDocMarkup::Heading;

  m_headingLevel=0;

}

void MarkupHandler::startHeading4(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,TRUE,4));

  m_curMarkup |= IDocMarkup::Heading;

  m_headingLevel=4;

}

void MarkupHandler::endHeading4()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,FALSE,4));

  m_curMarkup &= ~IDocMarkup::Heading;

  m_headingLevel=0;

}

void MarkupHandler::startHeading5(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,TRUE,5));

  m_curMarkup |= IDocMarkup::Heading;

  m_headingLevel=5;

}

void MarkupHandler::endHeading5()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,FALSE,5));

  m_curMarkup &= ~IDocMarkup::Heading;

  m_headingLevel=0;

}

void MarkupHandler::startHeading6(const QXmlAttributes & /*attrib*/)

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,TRUE,6));

  m_curMarkup |= IDocMarkup::Heading;

  m_headingLevel=6;

}

void MarkupHandler::endHeading6()

{

  addTextNode();

  m_children.append(new MarkupModifierNode(IDocMarkup::Heading,FALSE,6));

  m_curMarkup &= ~IDocMarkup::Heading;

  m_headingLevel=0;

}

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

// ListItemHandler

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

ListItemHandler::ListItemHandler(IBaseHandler *parent) 

  : m_parent(parent)

{

  m_children.setAutoDelete(TRUE);

  addEndHandler("listitem",this,&ListItemHandler::endListItem);

  addStartHandler("para",this,&ListItemHandler::startParagraph);

}

ListItemHandler::~ListItemHandler()

{

}

void ListItemHandler::startListItem(const QXmlAttributes& /*attrib*/)

{

  m_parent->setDelegate(this);

  debug(2,"start list item handler\n");

}

void ListItemHandler::endListItem()

{

  debug(2,"end list item handler\n");

  m_parent->setDelegate(0);

}

void ListItemHandler::startParagraph(const QXmlAttributes& attrib)

{

  ParagraphHandler *parHandler = new ParagraphHandler(this);

  parHandler->startParagraph(attrib);

  m_children.append(parHandler);

}

IDocIterator *ListItemHandler::contents() const

{

  return new ListItemIterator(*this);

}

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

// OrderedListHandler

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

OrderedListHandler::OrderedListHandler(IBaseHandler *parent) : m_parent(parent)

{

  m_children.setAutoDelete(TRUE);

  addEndHandler("orderedlist",this,&OrderedListHandler::endOrderedList);

  addStartHandler("listitem",this,&OrderedListHandler::startOrderedListItem);

}

OrderedListHandler::~OrderedListHandler()

{

}

void OrderedListHandler::startOrderedList(const QXmlAttributes& /*attrib*/)

{

  m_parent->setDelegate(this);

}

void OrderedListHandler::endOrderedList()

{

  m_parent->setDelegate(0);

}

void OrderedListHandler::startOrderedListItem(const QXmlAttributes& attrib)

{

  ListItemHandler *liHandler = new ListItemHandler(this);

  liHandler->startListItem(attrib);

  m_children.append(liHandler);

}

IDocIterator *OrderedListHandler::elements() const

{

  return new OrderedListIterator(*this);

}

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

// ItemizedListHandler

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

ItemizedListHandler::ItemizedListHandler(IBaseHandler *parent) : m_parent(parent)

{

  m_children.setAutoDelete(TRUE);

  addEndHandler("itemizedlist",this,&ItemizedListHandler::endItemizedList);

  addStartHandler("listitem",this,&ItemizedListHandler::startItemizedListItem);

}

ItemizedListHandler::~ItemizedListHandler()

{

}

void ItemizedListHandler::startItemizedList(const QXmlAttributes& /*attrib*/)

{

  m_parent->setDelegate(this);

}

void ItemizedListHandler::endItemizedList()

{

  m_parent->setDelegate(0);

}

void ItemizedListHandler::startItemizedListItem(const QXmlAttributes& attrib)

{

  ListItemHandler *liHandler = new ListItemHandler(this);

  liHandler->startListItem(attrib);

  m_children.append(liHandler);

}

IDocIterator *ItemizedListHandler::elements() const

{

  return new ItemizedListIterator(*this);

}

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

// TocListHandler

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

TocListHandler::TocListHandler(IBaseHandler *parent) : m_parent(parent)

{

  m_children.setAutoDelete(TRUE);

  addEndHandler("toclist",this,&TocListHandler::endTocList);

  addStartHandler("tocitem",this,&TocListHandler::startTocItem);

}

TocListHandler::~TocListHandler()

{

}

void TocListHandler::startTocList(const QXmlAttributes& /*attrib*/)

{

  m_parent->setDelegate(this);

}

void TocListHandler::endTocList()

{

  m_parent->setDelegate(0);

}

void TocListHandler::startTocItem(const QXmlAttributes& attrib)

{

  TocItemHandler *tiHandler = new TocItemHandler(this);

  tiHandler->startTocItem(attrib);

  m_children.append(tiHandler);

}

IDocIterator *TocListHandler::elements() const

{

  return new TocListIterator(*this);

}

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

// TocItemHandler

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

TocItemHandler::TocItemHandler(IBaseHandler *parent) : m_parent(parent)

{

  addEndHandler("tocitem",this,&TocItemHandler::endTocItem);

}

TocItemHandler::~TocItemHandler()

{

}

void TocItemHandler::startTocItem(const QXmlAttributes& attrib)

{

  m_parent->setDelegate(this);

  m_id = attrib.value("id");

  m_curString="";

}

void TocItemHandler::endTocItem()

{

  m_title = m_curString;

  m_parent->setDelegate(0);

}

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

// ParameterHandler

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

ParameterHandler::ParameterHandler(IBaseHandler *parent) : 

  m_parent(parent)

{

  addEndHandler("parametername",this,&ParameterHandler::endParameterName);

}

ParameterHandler::~ParameterHandler()

{

}

void ParameterHandler::startParameterName(const QXmlAttributes& /*attrib*/)

{

  m_parent->setDelegate(this);

}

void ParameterHandler::endParameterName()

{

  m_name = m_curString;

  debug(2,"parameter %s\n",m_name.data());

  m_curString="";

  m_parent->setDelegate(0);

}

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

// ParameterListHandler

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

ParameterItemHandler::ParameterItemHandler(IBaseHandler *parent) 

  : m_parent(parent)

{

  addEndHandler("parameteritem",this,&ParameterItemHandler::endParameterItem);

  addStartHandler("parameternamelist");

  addEndHandler("parameternamelist");

  addStartHandler("parametername",this,&ParameterItemHandler::startParameterName);

  addStartHandler("parameterdescription");

  addEndHandler("parameterdescription");

  addStartHandler("para",this,&ParameterItemHandler::startParagraph);

  m_parameters.setAutoDelete(TRUE);

  m_description = 0;

}

ParameterItemHandler::~ParameterItemHandler()

{

  delete m_description;

}

void ParameterItemHandler::startParameterItem(const QXmlAttributes&)

{

  m_parent->setDelegate(this);

}

void ParameterItemHandler::endParameterItem()

{

  m_parent->setDelegate(0);

}

void ParameterItemHandler::startParameterName(const QXmlAttributes& attrib)

{

  ParameterHandler *param = new ParameterHandler(this);

  m_parameters.append(param);

  param->startParameterName(attrib);

}

void ParameterItemHandler::startParagraph(const QXmlAttributes& attrib)

{

  m_description = new ParagraphHandler(this);

  m_description->startParagraph(attrib);

}

IDocIterator *ParameterItemHandler::paramNames() const

{

  return new ParameterItemIterator(*this);

}

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

// ParameterListHandler

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

ParameterListHandler::ParameterListHandler(IBaseHandler *parent) 

  : m_parent(parent)

{

  addEndHandler("parameterlist",this,&ParameterListHandler::endParameterList);

  addStartHandler("parameteritem",this,&ParameterListHandler::startParameterItem);

  m_paramItems.setAutoDelete(TRUE);

}

ParameterListHandler::~ParameterListHandler()

{

}

void ParameterListHandler::startParameterList(const QXmlAttributes& attrib)

{

  QString kind = attrib.value("kind");

  if (kind=="retval")         m_type=RetVal;

  else if (kind=="exception") m_type=Exception;

  else if (kind=="param")     m_type=Param;

  else

  {

    debug(1,"Error: invalid parameterlist type: %s\n",kind.data());

  }

  debug(2,"parameterlist kind=%s\n",kind.data());

  m_parent->setDelegate(this);

}

void ParameterListHandler::endParameterList()

{

  m_parent->setDelegate(0);

}

void ParameterListHandler::startParameterItem(const QXmlAttributes& attrib)

{

  ParameterItemHandler *paramItem = new ParameterItemHandler(this);

  m_paramItems.append(paramItem);

  paramItem->startParameterItem(attrib);

}

IDocIterator *ParameterListHandler::params() const

{

  return new ParameterListIterator(*this);

}

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

// LinkHandler

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

LinkHandler::LinkHandler(IBaseHandler *parent)

  : m_parent(parent)

{

  addEndHandler("link",this,&LinkHandler::endLink);

}

LinkHandler::~LinkHandler()

{

}

void LinkHandler::startLink(const QXmlAttributes& attrib)

{

  m_parent->setDelegate(this);

  debug(2,"Start link\n");

  m_ref = attrib.value("linkend");

  m_curString="";

}

void LinkHandler::endLink()

{

  m_text = m_curString;

  m_curString="";

  m_parent->setDelegate(0);

  debug(2,"End link\n");

}

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

// EMailHandler

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

EMailHandler::EMailHandler(IBaseHandler *parent)

  : m_parent(parent)

{

  addEndHandler("email",this,&EMailHandler::endEMail);

}

EMailHandler::~EMailHandler()

{

}

void EMailHandler::startEMail(const QXmlAttributes& /*attrib*/)

{

  m_parent->setDelegate(this);

  debug(2,"Start email\n");

  m_curString="";

}

void EMailHandler::endEMail()

{

  m_address = m_curString;

  m_curString="";

  m_parent->setDelegate(0);

  debug(2,"End email\n");

}

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

// ULinkHandler

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

ULinkHandler::ULinkHandler(IBaseHandler *parent)

  :  m_parent(parent)

{

  addEndHandler("ulink",this,&ULinkHandler::endULink);

}

ULinkHandler::~ULinkHandler()

{

}

void ULinkHandler::startULink(const QXmlAttributes& attrib)

{

  m_parent->setDelegate(this);

  debug(2,"Start ulink\n");

  m_url = attrib.value("url");

  m_curString="";

}

void ULinkHandler::endULink()

{

  m_text = m_curString;

  m_curString="";

  m_parent->setDelegate(0);

  debug(2,"End ulink\n");

}

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

// LineBreakHandler

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

LineBreakHandler::LineBreakHandler(IBaseHandler *parent)

  : m_parent(parent)

{

  addEndHandler("linebreak",this,&LineBreakHandler::endLineBreak);

}

LineBreakHandler::~LineBreakHandler()

{

}

void LineBreakHandler::startLineBreak(const QXmlAttributes& /*attrib*/)

{

  m_parent->setDelegate(this);

  debug(2,"Start linebreak\n");

}

void LineBreakHandler::endLineBreak()

{

  m_parent->setDelegate(0);

  debug(2,"End linebreak\n");

}

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

// HRulerHandler

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

HRulerHandler::HRulerHandler(IBaseHandler *parent)

  : m_parent(parent)

{

  addEndHandler("hruler",this,&HRulerHandler::endHRuler);

}

HRulerHandler::~HRulerHandler()

{

}

void HRulerHandler::startHRuler(const QXmlAttributes& /*attrib*/)

{

  m_parent->setDelegate(this);

  debug(2,"Start hruler\n");

}

void HRulerHandler::endHRuler()

{

  m_parent->setDelegate(0);

  debug(2,"End hruler\n");

}

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

// RefHandler

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

RefHandler::RefHandler(IBaseHandler *parent)

  : m_parent(parent)

{

  addEndHandler("ref",this,&RefHandler::endRef);

}

RefHandler::~RefHandler()

{

}

void RefHandler::startRef(const QXmlAttributes& attrib)

{

  m_parent->setDelegate(this);

  m_refId = attrib.value("refid");

  m_extId = attrib.value("external");

  ASSERT(attrib.value("kindref")=="compound" || 

         attrib.value("kindref")=="member");

  m_targetKind = attrib.value("kindref")=="compound" ?  Compound : Member;

  debug(2,"Start ref refId=%s\n",m_refId.data());

  m_curString="";

}

void RefHandler::endRef()

{

  m_linkText = m_curString;

  m_parent->setDelegate(0);

  debug(2,"End ref: text=`%s'\n",m_linkText.data());

}

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

// TitleHandler

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

TitleHandler::TitleHandler(IBaseHandler *parent)

  : m_parent(parent)

{

  m_children.setAutoDelete(TRUE);

  m_markupHandler = new MarkupHandler(m_children,m_curString);

  setFallBackHandler(m_markupHandler);

  addStartHandler("ref",this,&TitleHandler::startRef);

  addEndHandler("title",this,&TitleHandler::endTitle);

}

TitleHandler::~TitleHandler()

{

  delete m_markupHandler;

}

void TitleHandler::startTitle(const QXmlAttributes& /*attrib*/)

{

  m_parent->setDelegate(this);

  debug(2,"Start title\n");

  m_curString="";

}

void TitleHandler::endTitle()

{

  addTextNode();

  m_parent->setDelegate(0);

  debug(2,"End title\n");