开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
html.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：65k
源码类别：

生物技术

开发平台：

C/C++

html.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: html.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:15:26  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.103
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: html.cpp,v 1000.4 2004/06/01 19:15:26 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Lewis Geer
  36.  *
  37.  */
  40. #include <ncbi_pch.hpp>
  41. #include <html/html.hpp>
  42. #include <html/htmlhelper.hpp>
  43. #include <html/indentstream.hpp>
  44. #include <html/html_exception.hpp>
  45. #include <errno.h>
  46. #include <string.h>
  49. BEGIN_NCBI_SCOPE
  52. /// Tag delimiters
  53. const char* kTagStart    = "<@";   ///< Tag start.
  54. const char* kTagEnd      = "@>";   ///< Tag end.
  55. const char* kTagStartEnd = "</@";  ///< Tag start in the end of
  56.                                    ///< block definition.
  58. #define CHECK_STREAM_WRITE(out)                                               
  59.     if ( !out ) {                                                             
  60.         int x_errno = errno;                                                  
  61.         string x_err("write to stream failed");                               
  62.         if (x_errno != 0) {                                                   
  63.             const char* x_strerror = strerror(x_errno);                       
  64.             if ( !x_strerror ) {                                              
  65.                 x_strerror = "Error code is out of range";                    
  66.             }                                                                 
  67.             string x_strerrno = NStr::IntToString(x_errno);                   
  68.             x_err += " {errno=" + x_strerrno + ',' + x_strerror + '}';        
  69.         }                                                                     
  70.         NCBI_THROW(CHTMLException, eWrite, x_err);                            
  71.     }
  74. static string s_GenerateNodeInternalName(const string& basename,
  75.                                          const string& v1,
  76.                                          const string& v2 = kEmptyStr)
  77. {
  78.     string name(basename);
  79.     if ( !v1.empty() ) {
  80.         name += "("" + v1.substr(0,10) + """;
  81.         if ( !v2.empty() ) {
  82.             name += "|"" + v2.substr(0,10) + """;
  83.         }
  84.         name += ")";
  85.     }
  86.     return name;
  87. }
  90. // CHTMLNode
  92. CHTMLNode::~CHTMLNode(void)
  93. {
  94.     return;
  95. }
  97. CHTMLNode* CHTMLNode::SetClass(const string& class_name)
  98. {
  99.     SetOptionalAttribute("class", class_name);
  100.     return this;
  101. }
  103. CHTMLNode* CHTMLNode::SetId(const string& class_name)
  104. {
  105.     SetOptionalAttribute("id", class_name);
  106.     return this;
  107. }
  109. CHTMLNode* CHTMLNode::SetWidth(int width)
  110. {
  111.     SetAttribute("width", width);
  112.     return this;
  113. }
  115. CHTMLNode* CHTMLNode::SetHeight(int height)
  116. {
  117.     SetAttribute("height", height);
  118.     return this;
  119. }
  121. CHTMLNode* CHTMLNode::SetWidth(const string& width)
  122. {
  123.     SetOptionalAttribute("width", width);
  124.     return this;
  125. }
  127. CHTMLNode* CHTMLNode::SetHeight(const string& height)
  128. {
  129.     SetOptionalAttribute("height", height);
  130.     return this;
  131. }
  133. CHTMLNode* CHTMLNode::SetSize(int size)
  134. {
  135.     SetAttribute("size", size);
  136.     return this;
  137. }
  139. CHTMLNode* CHTMLNode::SetAlign(const string& align)
  140. {
  141.     SetOptionalAttribute("align", align);
  142.     return this;
  143. }
  145. CHTMLNode* CHTMLNode::SetVAlign(const string& align)
  146. {
  147.     SetOptionalAttribute("valign", align);
  148.     return this;
  149. }
  151. CHTMLNode* CHTMLNode::SetColor(const string& color)
  152. {
  153.     SetOptionalAttribute("color", color);
  154.     return this;
  155. }
  157. CHTMLNode* CHTMLNode::SetBgColor(const string& color)
  158. {
  159.     SetOptionalAttribute("bgcolor", color);
  160.     return this;
  161. }
  163. CHTMLNode* CHTMLNode::SetNameAttribute(const string& name)
  164. {
  165.     SetAttribute("name", name);
  166.     return this;
  167. }
  169. const string& CHTMLNode::GetNameAttribute(void) const
  170. {
  171.     return GetAttribute("name");
  172. }
  174. CHTMLNode* CHTMLNode::SetAccessKey(char key)
  175. {
  176.     SetAttribute("accesskey", string(1, key));
  177.     return this;
  178. }
  180. CHTMLNode* CHTMLNode::SetTitle(const string& title)
  181. {
  182.     SetAttribute("title", title);
  183.     return this;
  184. }
  186. CHTMLNode* CHTMLNode::SetStyle(const string& style)
  187. {
  188.     SetAttribute("style", style);
  189.     return this;
  190. }
  192. void CHTMLNode::AppendPlainText(const string& appendstring, bool noEncode)
  193. {
  194.     if ( !appendstring.empty() ) {
  195.         AppendChild(new CHTMLPlainText(appendstring, noEncode));
  196.     }
  197. }
  199. void CHTMLNode::AppendPlainText(const char* appendstring, bool noEncode)
  200. {
  201.     if ( appendstring && *appendstring ) {
  202.         AppendChild(new CHTMLPlainText(appendstring, noEncode));
  203.     }
  204. }
  206. void CHTMLNode::AppendHTMLText(const string& appendstring)
  207. {
  208.     if ( !appendstring.empty() ) {
  209.         AppendChild(new CHTMLText(appendstring));
  210.     }
  211. }
  213. void CHTMLNode::AppendHTMLText(const char* appendstring)
  214. {
  215.     if ( appendstring && *appendstring ) {
  216.         AppendChild(new CHTMLText(appendstring));
  217.     }
  218. }
  220. string CHTMLNode::GetEventHandlerName(const EHTML_EH_Attribute name) const
  221. {
  222.     switch (name) {
  224.     case eHTML_EH_Blur:
  225.         return "onBlur";
  226.     case eHTML_EH_Change:
  227.         return "onChange";
  228.     case eHTML_EH_Click:
  229.         return "onClick";
  230.     case eHTML_EH_DblClick:
  231.         return "onDblClick";
  232.     case eHTML_EH_Focus:
  233.         return "onFocus";
  234.     case eHTML_EH_Load:
  235.         return "onLoad";
  236.     case eHTML_EH_Unload:
  237.         return "onUnload";
  238.     case eHTML_EH_MouseDown:
  239.         return "onMouseDown";
  240.     case eHTML_EH_MouseUp:
  241.         return "onMouseUp";
  242.     case eHTML_EH_MouseMove:
  243.         return "onMouseMove";
  244.     case eHTML_EH_MouseOver:
  245.         return "onMouseOver";
  246.     case eHTML_EH_MouseOut:
  247.         return "onMouseOut";
  248.     case eHTML_EH_Select:
  249.         return "onSelect";
  250.     case eHTML_EH_Submit:
  251.         return "onSubmit";
  252.     case eHTML_EH_KeyDown:
  253.         return "onKeyDown";
  254.     case eHTML_EH_KeyPress:
  255.         return "onKeyPress";
  256.     case eHTML_EH_KeyUp:
  257.         return "onKeyUp";
  258.     }
  259.     _TROUBLE;
  260.     return kEmptyStr;
  261. }
  264. void CHTMLNode::SetEventHandler(const EHTML_EH_Attribute event,
  265.                                 const string& value)
  266. {
  267.     if ( value.empty() ) {
  268.         return;
  269.     }
  270.     SetAttribute(GetEventHandlerName(event), value);
  271. }
  274. void CHTMLNode::AttachPopupMenu(const CHTMLPopupMenu* menu,
  275.                                 EHTML_EH_Attribute    event)
  276. {
  277.     if ( !menu ) {
  278.         return;
  279.     }
  280.     const string kStopEvent = " return false;";
  282.     switch (menu->GetType()) {
  283.     case CHTMLPopupMenu::eSmith: 
  284.         SetEventHandler(event, menu->ShowMenu() + kStopEvent);
  285.         return;
  286.     case CHTMLPopupMenu::eKurdin: 
  287.     case CHTMLPopupMenu::eKurdinConf: 
  288.         SetEventHandler(event, menu->ShowMenu() + kStopEvent);
  289.         SetEventHandler(eHTML_EH_MouseOut, menu->HideMenu());
  290.         return;
  291.     case CHTMLPopupMenu::eKurdinSide:
  292.         AppendHTMLText(menu->ShowMenu());
  293.         return;
  294.     }
  295.     _TROUBLE;
  296. }
  299. // <@XXX@> mapping tag node
  301. CHTMLTagNode::CHTMLTagNode(const char* name)
  302.     : CParent(name)
  303. {
  304.     return;
  305. }
  307. CHTMLTagNode::CHTMLTagNode(const string& name)
  308.     : CParent(name)
  309. {
  310.     return;
  311. }
  313. CHTMLTagNode::~CHTMLTagNode(void)
  314. {
  315.     return;
  316. }
  318. CNcbiOstream& CHTMLTagNode::PrintChildren(CNcbiOstream& out, TMode mode)
  319. {
  320.     CNodeRef node = MapTagAll(GetName(), mode);
  321.     if ( node ) {
  322.         node->Print(out, mode);
  323.     }
  324.     return out;
  325. }
  328. // Dual text node.
  330. CHTMLDualNode::CHTMLDualNode(const char* html, const char* plain)
  331.     : CParent(s_GenerateNodeInternalName("dualnode", html, plain))
  332. {
  333.     AppendChild(new CHTMLText(html));
  334.     m_Plain = plain;
  335. }
  337. CHTMLDualNode::CHTMLDualNode(CNCBINode* child, const char* plain)
  338.     : CParent(s_GenerateNodeInternalName("dualnode", "[node]", plain))
  339. {
  340.     AppendChild(child);
  341.     m_Plain = plain;
  342. }
  344. CHTMLDualNode::~CHTMLDualNode(void)
  345. {
  346.     return;
  347. }
  349. CNcbiOstream& CHTMLDualNode::PrintChildren(CNcbiOstream& out, TMode mode)
  350. {
  351.     if ( mode == ePlainText ) {
  352.         out << m_Plain;
  353.         CHECK_STREAM_WRITE(out);
  354.         return out;
  355.     } else {
  356.         return CParent::PrintChildren(out, mode);
  357.     }
  358. }
  361. // plain text node
  363. CHTMLPlainText::CHTMLPlainText(const char* text, bool noEncode)
  364.     : CNCBINode(s_GenerateNodeInternalName("plaintext", text)),
  365.       m_NoEncode(noEncode), m_Text(text)
  366. {
  367.     return;
  368. }
  370. CHTMLPlainText::CHTMLPlainText(const string& text, bool noEncode)
  371.     : CNCBINode(s_GenerateNodeInternalName("plaintext", text)),
  372.       m_NoEncode(noEncode), m_Text(text)
  373. {
  374.     return;
  375. }
  377. CHTMLPlainText::~CHTMLPlainText(void)
  378. {
  379.     return;
  380. }
  383. CNcbiOstream& CHTMLPlainText::PrintBegin(CNcbiOstream& out, TMode mode)
  384. {
  385.     if (mode == ePlainText  ||  NoEncode()) {
  386.         out << GetText();
  387.     }
  388.     else {
  389.         out << CHTMLHelper::HTMLEncode(GetText());
  390.     }
  391.     CHECK_STREAM_WRITE(out);
  392.     return out;
  393. }
  396. // text node
  398. CHTMLText::CHTMLText(const string& text)
  399.     : CParent(s_GenerateNodeInternalName("htmltext", text)),
  400.       m_Text(text)
  401. {
  402.     return;
  403. }
  405. CHTMLText::CHTMLText(const char* text)
  406.     : CParent(s_GenerateNodeInternalName("htmltext", text)),
  407.       m_Text(text)
  408. {
  409.     return;
  410. }
  412. CHTMLText::~CHTMLText(void)
  413. {
  414.     return;
  415. }
  418. static SIZE_TYPE s_Find(const string& s, const char* target,
  419.                         SIZE_TYPE start = 0)
  420. {
  421.     // Return s.find(target);
  422.     // Some implementations of string::find call memcmp at every
  423.     // possible position, which is way too slow.
  424.     if ( start >= s.size() ) {
  425.         return NPOS;
  426.     }
  427.     const char* cstr = s.c_str();
  428.     const char* p    = strstr(cstr + start, target);
  429.     return p ? p - cstr : NPOS;
  430. }
  433. CNcbiOstream& CHTMLText::x_PrintBegin(CNcbiOstream& out, TMode mode,
  434.                                       const string& s) const
  435. {
  436.     if ( mode == ePlainText ) {
  437.         out << CHTMLHelper::StripHTML(s);
  438.     } else {
  439.         out << s;
  440.     }
  441.     CHECK_STREAM_WRITE(out);
  442.     return out;
  443. }
  446. CNcbiOstream& CHTMLText::PrintBegin(CNcbiOstream& out, TMode mode)
  447. {
  448.     const string& text = GetText();
  449.     SIZE_TYPE tagStart = s_Find(text, kTagStart);
  450.     if ( tagStart == NPOS ) {
  451.         return x_PrintBegin(out, mode, text);
  452.     }
  454.     SIZE_TYPE tag_start_size = strlen(kTagStart);
  455.     SIZE_TYPE tag_end_size   = strlen(kTagEnd);
  457.     x_PrintBegin(out, mode, text.substr(0, tagStart));
  458.     SIZE_TYPE last = tagStart;
  459.     do {
  460.         SIZE_TYPE tagNameStart = tagStart + tag_start_size;
  461.         SIZE_TYPE tagNameEnd = s_Find(text, kTagEnd, tagNameStart);
  462.         if ( tagNameEnd == NPOS ) {
  463.             // tag not closed
  464.             NCBI_THROW(CHTMLException, eTextUnclosedTag, "tag not closed");
  465.         }
  466.         else {
  467.             // tag found
  468.             if ( last != tagStart ) {
  469.                 x_PrintBegin(out, mode, text.substr(last, tagStart - last));
  470.             }
  472.             string name = text.substr(tagNameStart,tagNameEnd-tagNameStart);
  473.             // Resolve and repeat tag
  474.             for (;;) {
  475.                 CNodeRef tag = MapTagAll(name, mode);
  476.                 if ( tag ) {
  477.                     tag->Print(out, mode);
  478.                     if ( tag->NeedRepeatTag() ) {
  479.                         RepeatTag(false);
  480.                         continue;
  481.                     }
  482.                 }
  483.                 break;
  484.             }
  485.             last = tagNameEnd + tag_end_size;
  486.             tagStart = s_Find(text, kTagStart, last);
  487.         }
  488.     } while ( tagStart != NPOS );
  490.     if ( last != text.size() ) {
  491.         x_PrintBegin(out, mode, text.substr(last));
  492.     }
  493.     return out;
  494. }
  497. CHTMLOpenElement::~CHTMLOpenElement(void)
  498. {
  499.     return;
  500. }
  503. CNcbiOstream& CHTMLOpenElement::PrintBegin(CNcbiOstream& out, TMode mode)
  504. {
  505.     if ( mode != ePlainText ) {
  506.         out << '<' << m_Name;
  507.         if ( HaveAttributes() ) {
  508.             for ( TAttributes::const_iterator i = Attributes().begin();
  509.                   i != Attributes().end(); ++i ) {
  510.                 out << ' ' << i->first;
  511.                 CHECK_STREAM_WRITE(out);
  512.                 if ( !i->second.IsOptional() ||
  513.                      !i->second.GetValue().empty() ) {
  514.                     out << "="" << i->second.GetValue() << '"';
  515.                 }
  516.             }
  517.         }
  518.         if ( m_NoWrap ) {
  519.             out << " nowrap";
  520.         }
  521.         out << '>';
  522.         CHECK_STREAM_WRITE(out);
  523.     }
  524.     return out;
  525. }
  528. CHTMLInlineElement::~CHTMLInlineElement(void)
  529. {
  530.     return;
  531. }
  534. CNcbiOstream& CHTMLInlineElement::PrintEnd(CNcbiOstream& out, TMode mode)
  535. {
  536.     if ( mode != ePlainText ) {
  537.         out << "</" << m_Name << '>';
  538.         CHECK_STREAM_WRITE(out);
  539.     }
  540.     return out;
  541. }
  544. CHTMLElement::~CHTMLElement(void)
  545. {
  546.     return;
  547. }
  550. CNcbiOstream& CHTMLElement::PrintEnd(CNcbiOstream& out, TMode mode)
  551. {
  552.     CParent::PrintEnd(out, mode);
  554.     if ( mode != ePlainText ) {
  555.         const TMode* previous = mode.GetPreviousContext();
  556.         if ( previous ) {
  557.             CNCBINode* parent = previous->GetNode();
  558.             if ( parent && parent->HaveChildren() &&
  559.                  parent->Children().size() > 1 )
  560.                 out << 'n'; // separate child nodes by newline
  561.         } else {
  562.             out << 'n';
  563.         }
  564.     }
  565.     CHECK_STREAM_WRITE(out);
  566.     return out;
  567. }
  570. CHTMLBlockElement::~CHTMLBlockElement(void)
  571. {
  572.     return;
  573. }
  576. CNcbiOstream& CHTMLBlockElement::PrintEnd(CNcbiOstream& out, TMode mode)
  577. {
  578.     CParent::PrintEnd(out, mode);
  579.     if ( mode == ePlainText ) {
  580.         // Add a newline iff no node on the path to the last descendant
  581.         // is also a block element. We only need one break.
  582.         CNCBINode* node = this;
  583.         while (node->HaveChildren()) {
  584.             node = node->Children().back();
  585.             if (dynamic_cast<CHTMLBlockElement*>(node)) {
  586.                 return out;
  587.             }
  588.         }
  589.         out << 'n';
  590.         CHECK_STREAM_WRITE(out);
  591.     }
  592.     return out;
  593. }
  596. // HTML comment.
  598. const char CHTMLComment::sm_TagName[] = "comment";
  600. CHTMLComment::~CHTMLComment(void)
  601. {
  602.     return;
  603. }
  605. CNcbiOstream& CHTMLComment::Print(CNcbiOstream& out, TMode mode)
  606. {
  607.     if (mode == ePlainText) {
  608.         return out;
  609.     }
  610.     return CParent::Print(out, mode);
  611. }
  613. CNcbiOstream& CHTMLComment::PrintBegin(CNcbiOstream& out, TMode mode)
  614. {
  615.     if (mode == eHTML) {
  616.         out << "<!--";
  617.         CHECK_STREAM_WRITE(out);
  618.     }
  619.     return out;
  620. }
  622. CNcbiOstream& CHTMLComment::PrintEnd(CNcbiOstream& out, TMode mode)
  623. {
  624.     if (mode == eHTML) {
  625.         return out << "-->";
  626.     }
  627.     CHECK_STREAM_WRITE(out);
  628.     return out;
  629. }
  631. CHTMLListElement::~CHTMLListElement(void)
  632. {
  633.     return;
  634. }
  636. CHTMLListElement* CHTMLListElement::SetType(const char* type)
  637. {
  638.     SetAttribute("type", type);
  639.     return this;
  640. }
  642. CHTMLListElement* CHTMLListElement::SetType(const string& type)
  643. {
  644.     SetAttribute("type", type);
  645.     return this;
  646. }
  648. CHTMLListElement* CHTMLListElement::SetCompact(void)
  649. {
  650.     SetOptionalAttribute("compact", true);
  651.     return this;
  652. }
  654. CNcbiOstream& CHTMLListElement::PrintChildren(CNcbiOstream& out, TMode mode)
  655. {
  656.     if (mode == ePlainText) {
  657.         CIndentingOstream out2(out);
  658.         CHTMLElement::PrintChildren(out2, mode);
  659.     } else {
  660.         CHTMLElement::PrintChildren(out, mode);
  661.     }
  662.     return out;
  663. }
  666. // Special char.
  668. CHTMLSpecialChar::CHTMLSpecialChar(const char* html, const char* plain,
  669.                                    int count)
  670.     : CParent("", plain)
  671. {
  672.     m_Name  = s_GenerateNodeInternalName("specialchar", html);
  673.     m_Html  = html;
  674.     m_Count = count;
  675. }
  678. CHTMLSpecialChar::~CHTMLSpecialChar(void)
  679. {
  680.     return;
  681. }
  684. CNcbiOstream& CHTMLSpecialChar::PrintChildren(CNcbiOstream& out, TMode mode)
  685. {
  686.     if ( mode == ePlainText ) {
  687.         for ( int i = 0; i < m_Count; i++ ) {
  688.             out << m_Plain;
  689.             CHECK_STREAM_WRITE(out);
  690.         }
  691.     } else {
  692.         for ( int i = 0; i < m_Count; i++ ) {
  693.             out << "&" << m_Html << ";";
  694.             CHECK_STREAM_WRITE(out);
  695.         }
  696.     }
  697.     return out;
  698. }
  701. // <html> tag.
  703. const char CHTML_html::sm_TagName[] = "html";
  705. CHTML_html::~CHTML_html(void)
  706. {
  707.     return;
  708. }
  710. void CHTML_html::Init(void)
  711. {
  712.     return;
  713. }
  715. void CHTML_html::EnablePopupMenu(CHTMLPopupMenu::EType type,
  716.                                  const string& menu_script_url,
  717.                                  bool use_dynamic_menu)
  718. {
  719.     SPopupMenuInfo info(menu_script_url, use_dynamic_menu);
  720.     m_PopupMenus[type] = info;
  721. }
  723. static bool s_CheckUsePopupMenus(const CNCBINode* node, 
  724.                                  CHTMLPopupMenu::EType type)
  725. {
  726.     if ( !node  ||  !node->HaveChildren() ) {
  727.         return false;
  728.     }
  729.     ITERATE ( CNCBINode::TChildren, i, node->Children() ) {
  730.         const CNCBINode* cnode = node->Node(i);
  731.         if ( dynamic_cast<const CHTMLPopupMenu*>(cnode) ) {
  732.             const CHTMLPopupMenu* menu = 
  733.                 dynamic_cast<const CHTMLPopupMenu*>(cnode);
  734.             if ( menu->GetType() == type )
  735.                 return true;
  736.         }
  737.         if ( cnode->HaveChildren()  &&  s_CheckUsePopupMenus(cnode, type)) {
  738.             return true;
  739.         }
  740.     }
  741.     return false;
  742. }
  744. CNcbiOstream& CHTML_html::PrintChildren(CNcbiOstream& out, TMode mode)
  745. {
  746.     // Check mode
  747.     if ( mode != eHTML ) {
  748.         return CParent::PrintChildren(out, mode);
  749.     }
  750.     
  751.     // Check for use popup menus
  752.     bool use_popup_menus = false;
  753.     for (int t = CHTMLPopupMenu::ePMFirst; t <= CHTMLPopupMenu::ePMLast; t++ )    {
  754.         CHTMLPopupMenu::EType type = (CHTMLPopupMenu::EType)t;
  755.         if ( m_PopupMenus.find(type) == m_PopupMenus.end() ) {
  756.             if ( s_CheckUsePopupMenus(this, type) ) {
  757.                 EnablePopupMenu(type);
  758.                 use_popup_menus = true;
  759.             }
  760.         } else {
  761.             use_popup_menus = true;
  762.         }
  763.     }
  765.     if ( !use_popup_menus  ||  !HaveChildren() ) {
  766.         return CParent::PrintChildren(out, mode);
  767.     }
  769.     NON_CONST_ITERATE ( TChildren, i, Children() ) {
  770.         if ( dynamic_cast<CHTML_head*>(Node(i)) ) {
  771.             for (int t = CHTMLPopupMenu::ePMFirst;
  772.                  t <= CHTMLPopupMenu::ePMLast; t++ ) {
  773.                 CHTMLPopupMenu::EType type = (CHTMLPopupMenu::EType)t;
  774.                 TPopupMenus::const_iterator info = m_PopupMenus.find(type);
  775.                 if ( info != m_PopupMenus.end() ) {
  776.                     Node(i)->AppendChild(new CHTMLText(
  777.                         CHTMLPopupMenu::GetCodeHead(type,info->second.m_Url)));
  778.                 }
  779.             }
  780.         } else if ( dynamic_cast<CHTML_body*>(Node(i)) ) {
  781.             for (int t = CHTMLPopupMenu::ePMFirst;
  782.                  t <= CHTMLPopupMenu::ePMLast; t++ ) {
  783.                 CHTMLPopupMenu::EType type = (CHTMLPopupMenu::EType)t;
  784.                 TPopupMenus::const_iterator info = m_PopupMenus.find(type);
  785.                 if ( info != m_PopupMenus.end() ) {
  786.                     Node(i)->AppendChild(new CHTMLText(
  787.                         CHTMLPopupMenu::GetCodeBody(type, info->second.m_UseDynamicMenu)));
  788.                 }
  789.             }
  790.         }
  791.     }
  792.     return CParent::PrintChildren(out, mode);
  793. }
  797. // Table element.
  799. class CHTML_tc_Cache
  800. {
  801. public:
  802.     CHTML_tc_Cache(void)
  803.         : m_Used(false), m_Node(0)
  804.     {
  805.         return;
  806.     }
  808.     bool IsUsed(void) const
  809.     {
  810.         return m_Used;
  811.     }
  813.     bool IsNode(void) const
  814.     {
  815.         return m_Node != 0;
  816.     }
  817.     CHTML_tc* GetCellNode(void) const
  818.     {
  819.         return m_Node;
  820.     }
  822.     void SetUsed(void);
  823.     void SetCellNode(CHTML_tc* node);
  825. private:
  826.     bool m_Used;
  827.     CHTML_tc* m_Node;
  828. };
  831. class CHTML_tr_Cache
  832. {
  833. public:
  834.     typedef CHTML_table::TIndex TIndex;
  836.     CHTML_tr_Cache(void)
  837.         : m_Node(0),
  838.           m_CellCount(0), m_CellsSize(0), m_Cells(0), m_FilledCellCount(0)
  839.     {
  840.         return;
  841.     }
  843.     ~CHTML_tr_Cache(void)
  844.     {
  845.         delete[] m_Cells;
  846.     }
  848.     CHTML_tr* GetRowNode(void) const
  849.     {
  850.         return m_Node;
  851.     }
  853.     void SetRowNode(CHTML_tr* rowNode)
  854.     {
  855.         _ASSERT(!m_Node && rowNode);
  856.         m_Node = rowNode;
  857.     }
  859.     TIndex GetCellCount(void) const
  860.     {
  861.         return m_CellCount;
  862.     }
  864.     CHTML_tc_Cache& GetCellCache(TIndex col);
  866.     void AppendCell(CHTML_tr* rowNode, TIndex col,
  867.                     CHTML_tc* cellNode, TIndex colSpan);
  868.     void SetUsedCells(TIndex colBegin, TIndex colEnd);
  869.     void SetUsedCells(CHTML_tc* cellNode, TIndex colBegin, TIndex colEnd);
  871. private:
  872.     CHTML_tr_Cache(const CHTML_tr_Cache&);
  873.     CHTML_tr_Cache& operator=(const CHTML_tr_Cache&);
  875.     CHTML_tr* m_Node;
  876.     TIndex m_CellCount;
  877.     TIndex m_CellsSize;
  878.     CHTML_tc_Cache* m_Cells;
  879.     TIndex m_FilledCellCount;
  880. };
  883. class CHTML_table_Cache
  884. {
  885. public:
  886.     typedef CHTML_table::TIndex TIndex;
  888.     CHTML_table_Cache(CHTML_table* table);
  889.     ~CHTML_table_Cache(void);
  891.     TIndex GetRowCount(void) const
  892.     {
  893.         return m_RowCount;
  894.     }
  896.     CHTML_tr_Cache& GetRowCache(TIndex row);
  897.     CHTML_tr* GetRowNode(TIndex row);
  898.     CHTML_tc* GetCellNode(TIndex row, TIndex col,
  899.                           CHTML_table::ECellType type);
  900.     CHTML_tc* GetCellNode(TIndex row, TIndex col,
  901.                           CHTML_table::ECellType type,
  902.                           TIndex rowSpan, TIndex colSpan);
  904.     void InitRow(TIndex row, CHTML_tr* rowNode);
  905.     void SetUsedCells(TIndex rowBegin, TIndex rowEnd,
  906.                       TIndex colBegin, TIndex colEnd);
  907. private:
  908.     CHTML_table* m_Node;
  909.     TIndex m_RowCount;
  910.     TIndex m_RowsSize;
  911.     CHTML_tr_Cache** m_Rows;
  912.     TIndex m_FilledRowCount;
  914.     CHTML_table_Cache(const CHTML_table_Cache&);
  915.     CHTML_table_Cache& operator=(const CHTML_table_Cache&);
  916. };
  919. CHTML_tr::CHTML_tr(void)
  920.     : CParent("tr"), m_Parent(0)
  921. {
  922.     return;
  923. }
  925. CHTML_tr::CHTML_tr(CNCBINode* node)
  926.     : CParent("tr", node), m_Parent(0)
  927. {
  928.     return;
  929. }
  931. CHTML_tr::CHTML_tr(const string& text)
  932.     : CParent("tr", text), m_Parent(0)
  933. {
  934.     return;
  935. }
  937. void CHTML_tr::DoAppendChild(CNCBINode* node)
  938. {
  939.     CHTML_tc* cell = dynamic_cast<CHTML_tc*>(node);
  940.     if ( cell ) {
  941.         // Adding new cell
  942.         _ASSERT(!cell->m_Parent);
  943.         ResetTableCache();
  944.         cell->m_Parent = this;
  945.     }
  946.     CParent::DoAppendChild(node);
  947. }
  949. void CHTML_tr::AppendCell(CHTML_tc* cell)
  950. {
  951.     _ASSERT(!cell->m_Parent);
  952.     cell->m_Parent = this;
  953.     CParent::DoAppendChild(cell);
  954. }
  956. void CHTML_tr::ResetTableCache(void)
  957. {
  958.     if ( m_Parent )
  959.         m_Parent->ResetTableCache();
  960. }
  962. CNcbiOstream& CHTML_tr::PrintEnd(CNcbiOstream& out, TMode mode)
  963. {
  964.     CParent::PrintEnd(out, mode);
  965.     if ( mode == ePlainText ) {
  966.         out << CHTMLHelper::GetNL();
  967.         if (m_Parent->m_IsRowSep == CHTML_table::ePrintRowSep) {
  968.             out << string(GetTextLength(mode), m_Parent->m_RowSepChar)
  969.                 << CHTMLHelper::GetNL();
  970.         }
  971.         CHECK_STREAM_WRITE(out);
  972.     }
  973.     return out;
  974. }
  976. CNcbiOstream& CHTML_tr::PrintChildren(CNcbiOstream& out, TMode mode)
  977. {
  978.     if ( !HaveChildren() ) {
  979.         return out;
  980.     }
  981.     if ( mode != ePlainText ) {
  982.         return CParent::PrintChildren(out, mode);
  983.     }
  984.     out << m_Parent->m_ColSepL;
  986.     NON_CONST_ITERATE ( TChildren, i, Children() ) {
  987.         if ( i != Children().begin() ) {
  988.             out << m_Parent->m_ColSepM;
  989.             CHECK_STREAM_WRITE(out);
  990.         }
  991.         Node(i)->Print(out, mode);
  992.     }
  994.     out << m_Parent->m_ColSepR;
  995.     CHECK_STREAM_WRITE(out);
  997.     return out;
  998. }
  1000. SIZE_TYPE CHTML_tr::GetTextLength(TMode mode)
  1001. {
  1002.     if ( !HaveChildren() ) {
  1003.         return 0;
  1004.     }
  1006.     CNcbiOstrstream sout;
  1007.     SIZE_TYPE cols = 0;
  1009.     NON_CONST_ITERATE ( TChildren, i, Children() ) {
  1010.         Node(i)->Print(sout, mode);
  1011.         cols++;
  1012.     }
  1013.     sout.put('');
  1015.     SIZE_TYPE textlen = strlen(sout.str());
  1016.     if ( mode == ePlainText ) {
  1017.         textlen += m_Parent->m_ColSepL.length() +
  1018.             m_Parent->m_ColSepR.length();
  1019.         if ( cols ) {
  1020.             textlen += m_Parent->m_ColSepM.length() * (cols - 1);
  1021.         }
  1022.     }
  1023.     return textlen;
  1024. }
  1026. CHTML_tc::~CHTML_tc(void)
  1027. {
  1028.     return;
  1029. }
  1031. CHTML_tc* CHTML_tc::SetRowSpan(TIndex span)
  1032. {
  1033.     SetAttribute("rowspan", span);
  1034.     return this;
  1035. }
  1037. CHTML_tc* CHTML_tc::SetColSpan(TIndex span)
  1038. {
  1039.     SetAttribute("colspan", span);
  1040.     return this;
  1041. }
  1043. static 
  1044. CHTML_table::TIndex x_GetSpan(const CHTML_tc* node,
  1045.                               const string& attributeName)
  1046. {
  1047.     if ( !node->HaveAttribute(attributeName) ) {
  1048.         return 1;
  1049.     }
  1050.     const string& value = node->GetAttribute(attributeName);
  1052.     try {
  1053.         CHTML_table::TIndex span = NStr::StringToUInt(value);
  1054.         if ( span > 0 ) {
  1055.             return span;
  1056.         }
  1057.     }
  1058.     catch ( exception& ) {
  1059.         // Error will be posted later
  1060.     }
  1061.     ERR_POST("Bad attribute: " << attributeName << "="" << value << """);
  1062.     return 1;
  1063. }
  1065. void CHTML_tc::DoSetAttribute(const string& name,
  1066.                               const string& value, bool optional)
  1067. {
  1068.     if (name == "rowspan"  ||  name == "colspan") {
  1069.         // Changing cell size
  1070.         ResetTableCache();
  1071.     }
  1072.     CParent::DoSetAttribute(name, value, optional);
  1073. }
  1075. void CHTML_tc::ResetTableCache(void)
  1076. {
  1077.     if ( m_Parent ) {
  1078.         m_Parent->ResetTableCache();
  1079.     }
  1080. }
  1082. void CHTML_tc_Cache::SetUsed()
  1083. {
  1084.     if ( IsUsed() ) {
  1085.         NCBI_THROW(CHTMLException, eTableCellUse, "overlapped table cells");
  1086.     }
  1087.     m_Used = true;
  1088. }
  1090. void CHTML_tc_Cache::SetCellNode(CHTML_tc* cellNode)
  1091. {
  1092.     SetUsed();
  1093.     m_Node = cellNode;
  1094. }
  1096. static
  1097. CHTML_table::TIndex x_NextSize(CHTML_table::TIndex size,
  1098.                                CHTML_table::TIndex limit)
  1099. {
  1100.     do {
  1101.         if ( size == 0 )
  1102.             size = 2;
  1103.         else
  1104.             size *= 2;
  1105.     } while ( size < limit );
  1106.     return size;
  1107. }
  1109. CHTML_tc_Cache& CHTML_tr_Cache::GetCellCache(TIndex col)
  1110. {
  1111.     TIndex count = GetCellCount();
  1112.     if ( col >= count ) {
  1113.         TIndex newCount = col + 1;
  1114.         TIndex size = m_CellsSize;
  1115.         if ( newCount > size ) {
  1116.             TIndex newSize = x_NextSize(size, newCount);
  1117.             CHTML_tc_Cache* newCells = new CHTML_tc_Cache[newSize];
  1118.             for ( TIndex i = 0; i < count; ++i )
  1119.                 newCells[i] = m_Cells[i];
  1120.             delete[] m_Cells;
  1121.             m_Cells = newCells;
  1122.             m_CellsSize = newSize;
  1123.         }
  1124.         m_CellCount = newCount;
  1125.     }
  1126.     return m_Cells[col];
  1127. }
  1129. void CHTML_tr_Cache::SetUsedCells(TIndex colBegin, TIndex colEnd)
  1130. {
  1131.     for ( TIndex col = colBegin; col < colEnd; ++col ) {
  1132.         GetCellCache(col).SetUsed();
  1133.     }
  1134. }
  1136. void CHTML_tr_Cache::AppendCell(CHTML_tr* rowNode, TIndex col,
  1137.                                 CHTML_tc* cellNode, TIndex colSpan)
  1138. {
  1139.     _ASSERT(m_FilledCellCount <= col);
  1140.     for ( TIndex i = m_FilledCellCount; i < col; ++i ) {
  1141.         CHTML_tc_Cache& cellCache = GetCellCache(i);
  1142.         if ( !cellCache.IsUsed() ) {
  1143.             CHTML_tc* cell;
  1144.             cell = new CHTML_td;
  1145.             rowNode->AppendCell(cell);
  1146.             cellCache.SetCellNode(cell);
  1147.         }
  1148.     }
  1149.     CHTML_tc_Cache& cellCache = GetCellCache(col);
  1150.     _ASSERT(!cellCache.IsUsed());
  1151.     _ASSERT(x_GetSpan(cellNode, "colspan") == colSpan);
  1152.     rowNode->AppendCell(cellNode);
  1153.     cellCache.SetCellNode(cellNode);
  1154.     if ( colSpan != 1 ) {
  1155.         SetUsedCells(col + 1, col + colSpan);
  1156.     }
  1157.     m_FilledCellCount = col + colSpan;
  1158. }
  1160. void CHTML_tr_Cache::SetUsedCells(CHTML_tc* cellNode,
  1161.                                   TIndex colBegin, TIndex colEnd)
  1162. {
  1163.     GetCellCache(colBegin).SetCellNode(cellNode);
  1164.     SetUsedCells(colBegin + 1, colEnd);
  1165.     m_FilledCellCount = colEnd;
  1166. }
  1169. CHTML_table_Cache::~CHTML_table_Cache(void)
  1170. {
  1171.     for ( TIndex i = 0; i < GetRowCount(); ++i ) {
  1172.         delete m_Rows[i];
  1173.     }
  1174.     delete[] m_Rows;
  1175. }
  1178. CHTML_tr_Cache& CHTML_table_Cache::GetRowCache(TIndex row)
  1179. {
  1180.     TIndex count = GetRowCount();
  1181.     if ( row >= count ) {
  1182.         TIndex newCount = row + 1;
  1183.         TIndex size = m_RowsSize;
  1184.         if ( newCount > size ) {
  1185.             TIndex newSize = x_NextSize(size, newCount);
  1186.             CHTML_tr_Cache** newRows = new CHTML_tr_Cache*[newSize];
  1187.             for ( TIndex i = 0; i < count; ++i )
  1188.                 newRows[i] = m_Rows[i];
  1189.             delete[] m_Rows;
  1190.             m_Rows = newRows;
  1191.             m_RowsSize = newSize;
  1192.         }
  1193.         for ( TIndex i = count; i < newCount; ++i )
  1194.             m_Rows[i] = new CHTML_tr_Cache;
  1195.         m_RowCount = newCount;
  1196.     }
  1197.     return *m_Rows[row];
  1198. }
  1200. void CHTML_table_Cache::InitRow(TIndex row, CHTML_tr* rowNode)
  1201. {
  1202.     CHTML_tr_Cache& rowCache = GetRowCache(row);
  1203.     m_Rows[row]->SetRowNode(rowNode);
  1204.     m_FilledRowCount = row + 1;
  1206.     // Scan all children (which should be <TH> or <TD> tags)
  1207.     if ( rowNode->HaveChildren() ) {
  1208.         // Beginning with column 0
  1209.         TIndex col = 0;
  1210.         for ( CNCBINode::TChildren::iterator iCol = rowNode->ChildBegin(),
  1211.               iColEnd = rowNode->ChildEnd();
  1212.               iCol != iColEnd; ++iCol ) {
  1213.             CHTML_tc* cellNode =
  1214.                 dynamic_cast<CHTML_tc*>(rowNode->Node(iCol));
  1216.             if ( !cellNode ) {
  1217.                 continue;
  1218.             }
  1220.             // Skip all used cells
  1221.             while ( rowCache.GetCellCache(col).IsUsed() ) {
  1222.                 ++col;
  1223.             }
  1225.             // Determine current cell size
  1226.             TIndex rowSpan = x_GetSpan(cellNode, "rowspan");
  1227.             TIndex colSpan = x_GetSpan(cellNode, "colspan");
  1229.             // End of new cell in columns
  1230.             rowCache.SetUsedCells(cellNode, col, col + colSpan);
  1231.             if ( rowSpan > 1 ) {
  1232.                 SetUsedCells(row + 1, row + rowSpan, col, col + colSpan);
  1233.             }
  1235.             // Skip this cell's columns
  1236.             col += colSpan;
  1237.         }
  1238.     }
  1239. }
  1241. CHTML_table_Cache::CHTML_table_Cache(CHTML_table* table)
  1242.     : m_Node(table),
  1243.       m_RowCount(0), m_RowsSize(0), m_Rows(0), m_FilledRowCount(0)
  1244. {
  1245.     // Scan all children (which should be <TR> tags)
  1246.     if ( table->HaveChildren() ) {
  1247.         // Beginning with row 0
  1248.         TIndex row = 0;
  1249.         for ( CNCBINode::TChildren::iterator iRow = table->ChildBegin(),
  1250.               iRowEnd = table->ChildEnd(); iRow != iRowEnd; ++iRow ) {
  1251.             CHTML_tr* rowNode = dynamic_cast<CHTML_tr*>(table->Node(iRow));
  1252.             if ( !rowNode ) {
  1253.                 continue;
  1254.             }
  1255.             InitRow(row, rowNode);
  1256.             ++row;
  1257.         }
  1258.     }
  1259. }
  1261. CHTML_tr* CHTML_table_Cache::GetRowNode(TIndex row)
  1262. {
  1263.     GetRowCache(row);
  1264.     while ( row >= m_FilledRowCount ) {
  1265.         CHTML_tr* rowNode = new CHTML_tr;
  1266.         m_Node->AppendRow(rowNode);
  1267.         m_Rows[m_FilledRowCount++]->SetRowNode(rowNode);
  1268.     }
  1269.     return m_Rows[row]->GetRowNode();
  1270. }
  1272. void CHTML_table_Cache::SetUsedCells(TIndex rowBegin, TIndex rowEnd,
  1273.                                      TIndex colBegin, TIndex colEnd)
  1274. {
  1275.     for ( TIndex row = rowBegin; row < rowEnd; ++row ) {
  1276.         GetRowCache(row).SetUsedCells(colBegin, colEnd);
  1277.     }
  1278. }
  1280. CHTML_tc* CHTML_table_Cache::GetCellNode(TIndex row, TIndex col,
  1281.                                          CHTML_table::ECellType type)
  1282. {
  1283.     CHTML_tr_Cache& rowCache = GetRowCache(row);
  1284.     if ( col < rowCache.GetCellCount() ) {
  1285.         CHTML_tc_Cache& cellCache = rowCache.GetCellCache(col);
  1286.         if ( cellCache.IsNode() ) {
  1287.             CHTML_tc* cell = cellCache.GetCellNode();
  1288.             switch ( type ) {
  1289.             case CHTML_table::eHeaderCell:
  1290.                 if ( !dynamic_cast<CHTML_th*>(cell) )
  1291.                     NCBI_THROW(CHTMLException, eTableCellType,
  1292.                                "wrong cell type: TH expected");
  1293.                 break;
  1294.             case CHTML_table::eDataCell:
  1295.                 if ( !dynamic_cast<CHTML_td*>(cell) )
  1296.                     NCBI_THROW(CHTMLException, eTableCellType,
  1297.                                "wrong cell type: TD expected");
  1298.                 break;
  1299.             default:
  1300.                 break;
  1301.             }
  1302.             return cell;
  1303.         }
  1304.         if ( cellCache.IsUsed() )
  1305.             NCBI_THROW(CHTMLException, eTableCellUse,
  1306.                        "invalid use of big table cell");
  1307.     }
  1308.     CHTML_tc* cell;
  1309.     if ( type == CHTML_table::eHeaderCell ) {
  1310.         cell = new CHTML_th;
  1311.     } else {
  1312.         cell = new CHTML_td;
  1313.     }
  1314.     rowCache.AppendCell(GetRowNode(row), col, cell, 1);
  1315.     return cell;
  1316. }
  1318. CHTML_tc* CHTML_table_Cache::GetCellNode(TIndex row, TIndex col,
  1319.                                          CHTML_table::ECellType type,
  1320.                                          TIndex rowSpan, TIndex colSpan)
  1321. {
  1322.     CHTML_tr_Cache& rowCache = GetRowCache(row);
  1323.     if ( col < rowCache.GetCellCount() ) {
  1324.         CHTML_tc_Cache& cellCache = rowCache.GetCellCache(col);
  1325.         if ( cellCache.IsNode() ) {
  1326.             CHTML_tc* cell = cellCache.GetCellNode();
  1327.             switch ( type ) {
  1328.             case CHTML_table::eHeaderCell:
  1329.                 if ( !dynamic_cast<CHTML_th*>(cell) )
  1330.                     NCBI_THROW(CHTMLException, eTableCellType,
  1331.                                "wrong cell type: TH expected");
  1332.                 break;
  1333.             case CHTML_table::eDataCell:
  1334.                 if ( !dynamic_cast<CHTML_td*>(cell) )
  1335.                     NCBI_THROW(CHTMLException, eTableCellType,
  1336.                                "wrong cell type: TD expected");
  1337.                 break;
  1338.             default:
  1339.                 break;
  1340.             }
  1341.             if ( x_GetSpan(cell, "rowspan") != rowSpan ||
  1342.                  x_GetSpan(cell, "colspan") != colSpan )
  1343.                 NCBI_THROW(CHTMLException, eTableCellUse,
  1344.                            "cannot change table cell size");
  1345.             return cell;
  1346.         }
  1347.         if ( cellCache.IsUsed() )
  1348.             NCBI_THROW(CHTMLException, eTableCellUse,
  1349.                        "invalid use of big table cell");
  1350.     }
  1352.     CHTML_tc* cell;
  1353.     if ( type == CHTML_table::eHeaderCell ) {
  1354.         cell = new CHTML_th;
  1355.     } else {
  1356.         cell = new CHTML_td;
  1357.     }
  1358.     if ( colSpan != 1 ) {
  1359.         cell->SetColSpan(colSpan);
  1360.     }
  1361.     if ( rowSpan != 1 ) {
  1362.         cell->SetRowSpan(rowSpan);
  1363.     }
  1364.     rowCache.AppendCell(GetRowNode(row), col, cell, colSpan);
  1365.     if ( rowSpan != 1 ) {
  1366.         SetUsedCells(row + 1, row + rowSpan, col, col + colSpan);
  1367.     }
  1368.     return cell;
  1369. }
  1371. CHTML_table::CHTML_table(void)
  1372.     : CParent("table"), m_CurrentRow(0), m_CurrentCol(TIndex(-1)),
  1373.       m_ColSepL(kEmptyStr), m_ColSepM(" "), m_ColSepR(kEmptyStr),
  1374.       m_RowSepChar('-'), m_IsRowSep(eSkipRowSep)
  1375. {
  1376.     return;
  1377. }
  1379. CHTML_table::~CHTML_table(void)
  1380. {
  1381.     return;
  1382. }
  1384. CHTML_table* CHTML_table::SetCellSpacing(int spacing)
  1385. {
  1386.     SetAttribute("cellspacing", spacing);
  1387.     return this;
  1388. }
  1390. CHTML_table* CHTML_table::SetCellPadding(int padding)
  1391. {
  1392.     SetAttribute("cellpadding", padding);
  1393.     return this;
  1394. }
  1396. void CHTML_table::ResetTableCache(void)
  1397. {
  1398.     m_Cache.reset(0);
  1399. }
  1401. CHTML_table_Cache& CHTML_table::GetCache(void) const
  1402. {
  1403.     CHTML_table_Cache* cache = m_Cache.get();
  1404.     if ( !cache ) {
  1405.         m_Cache.reset(cache =
  1406.                       new CHTML_table_Cache(const_cast<CHTML_table*>(this)));
  1407.     }
  1408.     return *cache;
  1409. }
  1411. void CHTML_table::DoAppendChild(CNCBINode* node)
  1412. {
  1413.     CHTML_tr* row = dynamic_cast<CHTML_tr*>(node);
  1414.     if ( row ) {
  1415.         // Adding new row
  1416.         _ASSERT(!row->m_Parent);
  1417.         ResetTableCache();
  1418.         row->m_Parent = this;
  1419.     }
  1420.     CParent::DoAppendChild(node);
  1421. }
  1423. void CHTML_table::AppendRow(CHTML_tr* row)
  1424. {
  1425.     _ASSERT(!row->m_Parent);
  1426.     row->m_Parent = this;
  1427.     CParent::DoAppendChild(row);
  1428. }
  1430. CHTML_tr* CHTML_table::Row(TIndex row)
  1431. {
  1432.     return GetCache().GetRowNode(row);
  1433. }
  1435. CHTML_tc* CHTML_table::Cell(TIndex row, TIndex col, ECellType type)
  1436. {
  1437.     return GetCache().GetCellNode(m_CurrentRow = row, m_CurrentCol = col,
  1438.                                   type);
  1439. }
  1441. CHTML_tc* CHTML_table::Cell(TIndex row, TIndex col, ECellType type,
  1442.                             TIndex rowSpan, TIndex colSpan)
  1443. {
  1444.     return GetCache().GetCellNode(m_CurrentRow = row, m_CurrentCol = col,
  1445.                                   type, rowSpan, colSpan);
  1446. }
  1448. void CHTML_table::CheckTable(void) const
  1449. {
  1450.     GetCache();
  1451. }
  1453. CHTML_table::TIndex CHTML_table::CalculateNumberOfColumns(void) const
  1454. {
  1455.     CHTML_table_Cache& cache = GetCache();
  1456.     TIndex columns = 0;
  1457.     for ( TIndex i = 0; i < cache.GetRowCount(); ++i ) {
  1458.         columns = max(columns, cache.GetRowCache(i).GetCellCount());
  1459.     }
  1460.     return columns;
  1461. }
  1463. CHTML_table::TIndex CHTML_table::CalculateNumberOfRows(void) const
  1464. {
  1465.     return GetCache().GetRowCount();
  1466. }
  1468. CNcbiOstream& CHTML_table::PrintBegin(CNcbiOstream& out, TMode mode)
  1469. {
  1470.     if ( mode == ePlainText ) {
  1471.         out << CHTMLHelper::GetNL();
  1472.         CHECK_STREAM_WRITE(out);
  1473.         if ( m_IsRowSep == ePrintRowSep ) {
  1474.             SIZE_TYPE seplen = 0;
  1475.             // Find length of first non-empty row
  1476.             NON_CONST_ITERATE ( TChildren, i, Children() ) {
  1477.                 if ( (seplen =
  1478.                       dynamic_cast<CHTML_tr*>(&**i)->GetTextLength(mode)) >0) {
  1479.                     break;
  1480.                 }
  1481.             }
  1482.             if ( !seplen ) {
  1483.                 seplen = 1;
  1484.             }
  1485.             out << string(seplen, m_RowSepChar) << CHTMLHelper::GetNL();
  1486.             CHECK_STREAM_WRITE(out);
  1487.         }
  1488.     }
  1489.     return CParent::PrintBegin(out, mode);
  1490. }
  1492. void CHTML_table::SetPlainSeparators(const string& col_left,
  1493.                                      const string& col_middle,
  1494.                                      const string& col_right,
  1495.                                      const char    row_sep_char,
  1496.                                      ERowPlainSep  is_row_sep)
  1497. {
  1498.     m_ColSepL    = col_left;
  1499.     m_ColSepM    = col_middle;
  1500.     m_ColSepR    = col_right;
  1501.     m_RowSepChar = row_sep_char;
  1502.     m_IsRowSep   = is_row_sep;
  1503. }
  1506. // <form> tag.
  1508. CHTML_form::CHTML_form(void)
  1509.     : CParent("form")
  1510. {
  1511.     return;
  1512. }
  1514. CHTML_form::CHTML_form(const string& url, EMethod method)
  1515.     : CParent("form")
  1516. {
  1517.     Init(url, method);
  1518. }
  1520. CHTML_form::CHTML_form(const string& url, CNCBINode* node, EMethod method)
  1521.     : CParent("form", node)
  1522. {
  1523.     Init(url, method);
  1524. }
  1526. CHTML_form::~CHTML_form(void)
  1527. {
  1528.     return;
  1529. }
  1531. void CHTML_form::Init(const string& url, EMethod method)
  1532. {
  1533.     SetOptionalAttribute("action", url);
  1534.     switch ( method ) {
  1535.     case eGet:
  1536.         SetAttribute("method", "GET");
  1537.         break;
  1538.     case ePost:
  1539.         SetAttribute("enctype",
  1540.                      "application/x-www-form-urlencoded");
  1541.         SetAttribute("method", "POST");
  1542.         break;
  1543.     case ePostData:
  1544.         SetAttribute("enctype",
  1545.                      "multipart/form-data");
  1546.         SetAttribute("method", "POST");
  1547.         break;
  1548.     }
  1549. }
  1551. void CHTML_form::AddHidden(const string& name, const string& value)
  1552. {
  1553.     AppendChild(new CHTML_hidden(name, value));
  1554. }
  1556. void CHTML_form::AddHidden(const string& name, int value)
  1557. {
  1558.     AppendChild(new CHTML_hidden(name, value));
  1559. }
  1562. // <legend> tag.
  1564. CHTML_legend::CHTML_legend(const string& legend)
  1565.     : CParent("legend", legend)
  1566. {
  1567.     return;
  1568. }
  1570. CHTML_legend::CHTML_legend(CHTMLNode* legend)
  1571.     : CParent("legend", legend)
  1572. {
  1573.     return;
  1574. }
  1576. CHTML_legend::~CHTML_legend(void)
  1577. {
  1578.     return;
  1579. }
  1581. // <fieldset> tag.
  1583. CHTML_fieldset::CHTML_fieldset(void)
  1584.     : CParent("fieldset")
  1585. {
  1586.     return;
  1587. }
  1589. CHTML_fieldset::CHTML_fieldset(const string& legend)
  1590.     : CParent("fieldset", new CHTML_legend(legend))
  1591. {
  1592.     return;
  1593. }
  1595. CHTML_fieldset::CHTML_fieldset(CHTML_legend* legend)
  1596.     : CParent("fieldset", legend)
  1597. {
  1598.     return;
  1599. }
  1601. CHTML_fieldset::~CHTML_fieldset(void)
  1602. {
  1603.     return;
  1604. }
  1607. // <label> tag.
  1609. CHTML_label::CHTML_label(const string& text)
  1610.     : CParent("label", text)
  1611. {
  1612.     return;
  1613. }
  1615. CHTML_label::CHTML_label(const string& text, const string& idRef)
  1616.     : CParent("label", text)
  1617. {
  1618.     SetFor(idRef);
  1619. }
  1621. CHTML_label::~CHTML_label(void)
  1622. {
  1623.     return;
  1624. }
  1626. void CHTML_label::SetFor(const string& idRef)
  1627. {
  1628.     SetAttribute("for", idRef);
  1629. }
  1632. // <textarea> tag.
  1634. CHTML_textarea::CHTML_textarea(const string& name, int cols, int rows)
  1635.     : CParent("textarea")
  1636. {
  1637.     SetNameAttribute(name);
  1638.     SetAttribute("cols", cols);
  1639.     SetAttribute("rows", rows);
  1640. }
  1642. CHTML_textarea::CHTML_textarea(const string& name, int cols, int rows,
  1643.                                const string& value)
  1644.     : CParent("textarea", value)
  1645. {
  1646.     SetNameAttribute(name);
  1647.     SetAttribute("cols", cols);
  1648.     SetAttribute("rows", rows);
  1649. }
  1651. CHTML_textarea::~CHTML_textarea(void)
  1652. {
  1653.     return;
  1654. }
  1657. // <input> tag.
  1659. CHTML_input::CHTML_input(const char* type, const string& name)
  1660.     : CParent("input")
  1661. {
  1662.     SetAttribute("type", type);
  1663.     SetNameAttribute(name);
  1664. }
  1666. CHTML_input::~CHTML_input(void)
  1667. {
  1668.     return;
  1669. }
  1672. // <checkbox> tag.
  1674. const char CHTML_checkbox::sm_InputType[] = "checkbox";
  1676. CHTML_checkbox::CHTML_checkbox(const string& name)
  1677.     : CParent(sm_InputType, name)
  1678. {
  1679.     return;
  1680. }
  1682. CHTML_checkbox::CHTML_checkbox(const string& name, const string& value)
  1683.     : CParent(sm_InputType, name)
  1684. {
  1685.     SetOptionalAttribute("value", value);
  1686. }
  1688. CHTML_checkbox::CHTML_checkbox(const string& name, bool checked,
  1689.                                const string& description)
  1690.     : CParent(sm_InputType, name)
  1691. {
  1692.     SetOptionalAttribute("checked", checked);
  1693.     // Add the description at the end
  1694.     AppendPlainText(description);
  1695. }
  1697. CHTML_checkbox::CHTML_checkbox(const string& name, const string& value,
  1698.                                bool checked, const string& description)
  1699.     : CParent(sm_InputType, name)
  1700. {
  1701.     SetOptionalAttribute("value", value);
  1702.     SetOptionalAttribute("checked", checked);
  1703.     // Add the description at the end
  1704.     AppendPlainText(description);  
  1705. }
  1707. CHTML_checkbox::~CHTML_checkbox(void)
  1708. {
  1709.     return;
  1710. }
  1713. // <image> tag.
  1715. const char CHTML_image::sm_InputType[] = "image";
  1717. CHTML_image::CHTML_image(const string& name, const string& src,
  1718.                          const string& alt)
  1719.     : CParent(sm_InputType, name)
  1720. {
  1721.     SetAttribute("src", src);
  1722.     SetOptionalAttribute("alt", alt);
  1723. }
  1725. CHTML_image::CHTML_image(const string& name, const string& src, int border,
  1726.                          const string& alt)
  1727.     : CParent(sm_InputType, name)
  1728. {
  1729.     SetAttribute("src", src);
  1730.     SetAttribute("border", border);
  1731.     SetOptionalAttribute("alt", alt);
  1732. }
  1734. CHTML_image::~CHTML_image(void)
  1735. {
  1736.     return;
  1737. }
  1740. // <radio> tag.
  1742. const char CHTML_radio::sm_InputType[] = "radio";
  1744. CHTML_radio::CHTML_radio(const string& name, const string& value)
  1745.     : CParent(sm_InputType, name)
  1746. {
  1747.     SetAttribute("value", value);
  1748. }
  1750. CHTML_radio::CHTML_radio(const string& name, const string& value,
  1751.                          bool checked, const string& description)
  1752.     : CParent(sm_InputType, name)
  1753. {
  1754.     SetAttribute("value", value);
  1755.     SetOptionalAttribute("checked", checked);
  1756.     AppendPlainText(description);  // adds the description at the end
  1757. }
  1759. CHTML_radio::~CHTML_radio(void)
  1760. {
  1761.     return;
  1762. }
  1765. // <hidden> tag.
  1767. const char CHTML_hidden::sm_InputType[] = "hidden";
  1769. CHTML_hidden::CHTML_hidden(const string& name, const string& value)
  1770.     : CParent(sm_InputType, name)
  1771. {
  1772.     SetAttribute("value", value);
  1773. }
  1775. CHTML_hidden::CHTML_hidden(const string& name, int value)
  1776.     : CParent(sm_InputType, name)
  1777. {
  1778.     SetAttribute("value", value);
  1779. }
  1781. CHTML_hidden::~CHTML_hidden(void)
  1782. {
  1783.     return;
  1784. }
  1787. // <submit> tag.
  1789. const char CHTML_submit::sm_InputType[] = "submit";
  1791. CHTML_submit::CHTML_submit(const string& name)
  1792.     : CParent(sm_InputType, NcbiEmptyString)
  1793. {
  1794.     SetOptionalAttribute("value", name);
  1795. }
  1797. CHTML_submit::CHTML_submit(const string& name, const string& label)
  1798.     : CParent(sm_InputType, name)
  1799. {
  1800.     SetOptionalAttribute("value", label);
  1801. }
  1803. CHTML_submit::~CHTML_submit(void)
  1804. {
  1805.     return;
  1806. }
  1809. // <reset> tag.
  1811. const char CHTML_reset::sm_InputType[] = "reset";
  1813. CHTML_reset::CHTML_reset(const string& label)
  1814.     : CParent(sm_InputType, NcbiEmptyString)
  1815. {
  1816.     SetOptionalAttribute("value", label);
  1817. }
  1819. CHTML_reset::~CHTML_reset(void)
  1820. {
  1821.     return;
  1822. }
  1825. // button tag
  1826. /*
  1827.   commented out because it's not supported in most browsers
  1828.   CHTML_button::CHTML_button(const string& text, EButtonType type)
  1829.   : CParent("button", text)
  1830.   {
  1831.   SetType(type);
  1832.   }
  1834.   CHTML_button::CHTML_button(CNCBINode* contents, EButtonType type)
  1835.   : CParent("button", contents)
  1836.   {
  1837.   SetType(type);
  1838.   }
  1840.   CHTML_button::CHTML_button(const string& text, const string& name,
  1841.   const string& value)
  1842.   : CParent("button", text)
  1843.   {
  1844.   SetSubmit(name, value);
  1845.   }
  1847.   CHTML_button::CHTML_button(CNCBINode* contents, const string& name,
  1848.   const string& value)
  1849.   : CParent("button", contents)
  1850.   {
  1851.   SetSubmit(name, value);
  1852.   }
  1854.   CHTML_button* CHTML_button::SetType(EButtonType type)
  1855.   {
  1856.   switch ( type ) {
  1857.   case eSubmit:
  1858.   SetAttribute("type", "submit");
  1859.   break;
  1860.   case eReset:
  1861.   SetAttribute("type", "reset");
  1862.   break;
  1863.   case eButton:
  1864.   SetAttribute("type", "button");
  1865.   break;
  1866.   }
  1867.   return this;
  1868.   }
  1870.   CHTML_button* CHTML_button::SetSubmit(const string& name,
  1871.   const string& value)
  1872.   {
  1873.   SetNameAttribute(name);
  1874.   SetOptionalAttribute("value", value);
  1875.   return this;
  1876.   }
  1878.   CHTML_button::~CHTML_button(void)
  1879.   {
  1880.   }
  1881. */
  1884. // <text> tag.
  1886. const char CHTML_text::sm_InputType[] = "text";
  1888. CHTML_text::CHTML_text(const string& name, const string& value)
  1889.     : CParent(sm_InputType, name)
  1890. {
  1891.     SetOptionalAttribute("value", value);
  1892. }
  1894. CHTML_text::CHTML_text(const string& name, int size, const string& value)
  1895.     : CParent(sm_InputType, name)
  1896. {
  1897.     SetSize(size);
  1898.     SetOptionalAttribute("value", value);
  1899. }
  1901. CHTML_text::CHTML_text(const string& name, int size, int maxlength,
  1902.                        const string& value)
  1903.     : CParent(sm_InputType, name)
  1904. {
  1905.     SetSize(size);
  1906.     SetAttribute("maxlength", maxlength);
  1907.     SetOptionalAttribute("value", value);
  1908. }
  1910. CHTML_text::~CHTML_text(void)
  1911. {
  1912.     return;
  1913. }
  1916. // <file> tag.
  1918. const char CHTML_file::sm_InputType[] = "file";
  1920. CHTML_file::CHTML_file(const string& name, const string& value)
  1921.     : CParent(sm_InputType, name)
  1922. {
  1923.     SetOptionalAttribute("value", value);
  1924. }
  1926. CHTML_file::~CHTML_file(void)
  1927. {
  1928.     return;
  1929. }
  1932. // <select> tag.
  1934. const char CHTML_select::sm_TagName[] = "select";
  1936. CHTML_select::~CHTML_select(void)
  1937. {
  1938.     return;
  1939. }
  1941. CHTML_select* CHTML_select::SetMultiple(void)
  1942. {
  1943.     SetAttribute("multiple");
  1944.     return this;
  1945. }
  1948. // <option> tag.
  1950. const char CHTML_option::sm_TagName[] = "option";
  1952. CHTML_option::~CHTML_option(void)
  1953. {
  1954.     return;
  1955. }
  1957. CHTML_option* CHTML_option::SetValue(const string& value)
  1958. {
  1959.     SetAttribute("value", value);
  1960.     return this;
  1961. }
  1963. CHTML_option* CHTML_option::SetSelected(void)
  1964. {
  1965.     SetAttribute("selected");
  1966.     return this;
  1967. }
  1970. // <a> tag.
  1972. const char CHTML_a::sm_TagName[] = "a";
  1974. CHTML_a::~CHTML_a(void)
  1975. {
  1976.     return;
  1977. }
  1979. CHTML_a* CHTML_a::SetHref(const string& href)
  1980. {
  1981.     SetAttribute("href", href);
  1982.     return this;
  1983. }
  1986. // <br> tag.
  1988. const char CHTML_br::sm_TagName[] = "br";
  1990. CHTML_br::CHTML_br(int count)
  1991.     : CParent(sm_TagName)
  1992. {
  1993.     for ( int i = 1; i < count; ++i ) {
  1994.         AppendChild(new CHTML_br());
  1995.     }
  1996. }
  1998. CHTML_br::~CHTML_br(void)
  1999. {
  2000.     return;
  2001. }
  2003. CNcbiOstream& CHTML_br::PrintBegin(CNcbiOstream& out, TMode mode)
  2004. {
  2005.     if ( mode == ePlainText ) {
  2006.         out << CHTMLHelper::GetNL();
  2007.         CHECK_STREAM_WRITE(out);
  2008.     }
  2009.     else {
  2010.         CParent::PrintBegin(out, mode);
  2011.     }
  2012.     return out;
  2014. }
  2017. // <img> tag.
  2019. CHTML_img::CHTML_img(const string& url, const string& alt)
  2020.     : CParent("img")
  2021. {
  2022.     SetAttribute("src", url);
  2023.     SetOptionalAttribute("alt", alt);
  2024. }
  2026. CHTML_img::CHTML_img(const string& url, int width, int height,
  2027.                      const string& alt)
  2028.     : CParent("img")
  2029. {
  2030.     SetAttribute("src", url);
  2031.     SetOptionalAttribute("alt", alt);
  2032.     SetWidth(width);
  2033.     SetHeight(height);
  2034. }
  2036. CHTML_img::~CHTML_img(void)
  2037. {
  2038.     return;
  2039. }
  2042. // <dl> tag.
  2044. const char CHTML_dl::sm_TagName[] = "dl";
  2046. CHTML_dl::~CHTML_dl(void)
  2047. {
  2048.     return;
  2049. }
  2051. CHTML_dl* CHTML_dl::AppendTerm(const string& term, const string& definition)
  2052. {
  2053.     AppendChild(new CHTML_dt(term));
  2054.     if ( !definition.empty() )
  2055.         AppendChild(new CHTML_dd(definition));
  2056.     return this;
  2057. }
  2059. CHTML_dl* CHTML_dl::AppendTerm(const string& term, CNCBINode* definition)
  2060. {
  2061.     AppendChild(new CHTML_dt(term));
  2062.     if ( definition )
  2063.         AppendChild(new CHTML_dd(definition));
  2064.     return this;
  2065. }
  2067. CHTML_dl* CHTML_dl::AppendTerm(CNCBINode* term, const string& definition)
  2068. {
  2069.     AppendChild(new CHTML_dt(term));
  2070.     if ( !definition.empty() ) {
  2071.         AppendChild(new CHTML_dd(definition));
  2072.     }
  2073.     return this;
  2074. }
  2076. CHTML_dl* CHTML_dl::AppendTerm(CNCBINode* term, CNCBINode* definition)
  2077. {
  2078.     AppendChild(new CHTML_dt(term));
  2079.     if ( definition )
  2080.         AppendChild(new CHTML_dd(definition));
  2081.     return this;
  2082. }
  2084. CHTML_dl* CHTML_dl::SetCompact(void)
  2085. {
  2086.     SetAttribute("compact");
  2087.     return this;
  2088. }
  2091. // <ol> tag.
  2093. const char CHTML_ol::sm_TagName[] = "ol";
  2095. CHTML_ol::~CHTML_ol(void)
  2096. {
  2097. }
  2099. CHTML_ol* CHTML_ol::SetStart(int start)
  2100. {
  2101.     SetAttribute("start", start);
  2102.     return this;
  2103. }
  2106. // <ul> tag.
  2108. const char CHTML_ul::sm_TagName[] = "ul";
  2110. CHTML_ul::~CHTML_ul(void)
  2111. {
  2112.     return;
  2113. }
  2116. // <dir> tag.
  2118. const char CHTML_dir::sm_TagName[] = "dir";
  2120. CHTML_dir::~CHTML_dir(void)
  2121. {
  2122.     return;
  2123. }
  2126. // <menu> tag.
  2128. const char CHTML_menu::sm_TagName[] = "menu";
  2130. CHTML_menu::~CHTML_menu(void)
  2131. {
  2132.     return;
  2133. }
  2135. const char CHTML_font::sm_TagName[] = "font";
  2137. CHTML_font::~CHTML_font(void)
  2138. {
  2139.     return;
  2140. }
  2143. // <font> tag.
  2145. CHTML_font* CHTML_font::SetTypeFace(const string& typeface)
  2146. {
  2147.     SetAttribute("face", typeface);
  2148.     return this;
  2149. }
  2151. CHTML_font* CHTML_font::SetRelativeSize(int size)
  2152. {
  2153.     if ( size != 0 )
  2154.         SetAttribute("size", NStr::IntToString(size, true));
  2155.     return this;
  2156. }
  2158. const char CHTML_basefont::sm_TagName[] = "basefont";
  2160. CHTML_basefont::~CHTML_basefont(void)
  2161. {
  2162.     return;
  2163. }
  2165. CHTML_basefont* CHTML_basefont::SetTypeFace(const string& typeface)
  2166. {
  2167.     SetAttribute("typeface", typeface);
  2168.     return this;
  2169. }
  2171. CHTML_color::~CHTML_color(void)
  2172. {
  2173.     return;
  2174. }
  2177. // <hr> tag.
  2179. const char CHTML_hr::sm_TagName[] = "hr";
  2181. CHTML_hr::~CHTML_hr(void)
  2182. {
  2183.     return;
  2184. }
  2186. CHTML_hr* CHTML_hr::SetNoShade(void)
  2187. {
  2188.     SetAttribute("noshade");
  2189.     return this;
  2190. }
  2192. CNcbiOstream& CHTML_hr::PrintBegin(CNcbiOstream& out, TMode mode)
  2193. {
  2194.     if ( mode == ePlainText ) {
  2195.         out << CHTMLHelper::GetNL() << CHTMLHelper::GetNL();
  2196.         CHECK_STREAM_WRITE(out);
  2197.     }
  2198.     else {
  2199.         CParent::PrintBegin(out, mode);
  2200.     }
  2201.     return out;
  2202. }
  2205. // <meta> tag.
  2207. const char CHTML_meta::sm_TagName[] = "meta";
  2209. CHTML_meta::CHTML_meta(EType mtype, const string& var, const string& content)
  2210.     : CParent(sm_TagName)
  2211. {
  2212.     SetAttribute(( mtype == eName ) ? "name" : "http-equiv", var);
  2213.     SetAttribute("content", content);
  2214. }
  2217. CHTML_meta::~CHTML_meta(void)
  2218. {
  2219.     return;
  2220. }
  2223. // <script> tag.
  2225. const char CHTML_script::sm_TagName[] = "script";
  2227. CHTML_script::CHTML_script(const string& stype)
  2228.     : CParent(sm_TagName)
  2229. {
  2230.     SetAttribute("type", stype);
  2231. }
  2234. CHTML_script::CHTML_script(const string& stype, const string& url)
  2235.     : CParent(sm_TagName)
  2236. {
  2237.     SetAttribute("type", stype);
  2238.     SetAttribute("src", url);
  2239. }
  2242. CHTML_script::~CHTML_script(void)
  2243. {
  2244.     return;
  2245. }
  2247. CHTML_script* CHTML_script::AppendScript(const string& script)
  2248. {
  2249.     AppendChild(new CHTMLPlainText("n<!--n" + script + "-->n", true));
  2250.     return this;
  2251. }
  2254. // Other tags.
  2256. #define DEFINE_HTML_ELEMENT(Tag) 
  2257. CHTML_NAME(Tag)::~CHTML_NAME(Tag)(void) 
  2258. { 
  2259. } 
  2260. const char CHTML_NAME(Tag)::sm_TagName[] = #Tag
  2263. DEFINE_HTML_ELEMENT(head);
  2264. DEFINE_HTML_ELEMENT(body);
  2265. DEFINE_HTML_ELEMENT(base);
  2266. DEFINE_HTML_ELEMENT(isindex);
  2267. DEFINE_HTML_ELEMENT(link);
  2268. DEFINE_HTML_ELEMENT(noscript);
  2269. DEFINE_HTML_ELEMENT(object);
  2270. DEFINE_HTML_ELEMENT(style);
  2271. DEFINE_HTML_ELEMENT(title);
  2272. DEFINE_HTML_ELEMENT(address);
  2273. DEFINE_HTML_ELEMENT(blockquote);
  2274. DEFINE_HTML_ELEMENT(center);
  2275. DEFINE_HTML_ELEMENT(div);
  2276. DEFINE_HTML_ELEMENT(h1);
  2277. DEFINE_HTML_ELEMENT(h2);
  2278. DEFINE_HTML_ELEMENT(h3);
  2279. DEFINE_HTML_ELEMENT(h4);
  2280. DEFINE_HTML_ELEMENT(h5);
  2281. DEFINE_HTML_ELEMENT(h6);
  2282. DEFINE_HTML_ELEMENT(p);
  2283. DEFINE_HTML_ELEMENT(pnop);
  2284. DEFINE_HTML_ELEMENT(pre);
  2285. DEFINE_HTML_ELEMENT(dt);
  2286. DEFINE_HTML_ELEMENT(dd);
  2287. DEFINE_HTML_ELEMENT(li);
  2288. DEFINE_HTML_ELEMENT(caption);
  2289. DEFINE_HTML_ELEMENT(col);
  2290. DEFINE_HTML_ELEMENT(colgroup);
  2291. DEFINE_HTML_ELEMENT(thead);
  2292. DEFINE_HTML_ELEMENT(tbody);
  2293. DEFINE_HTML_ELEMENT(tfoot);
  2294. DEFINE_HTML_ELEMENT(th);
  2295. DEFINE_HTML_ELEMENT(td);
  2296. DEFINE_HTML_ELEMENT(applet);
  2297. DEFINE_HTML_ELEMENT(param);
  2298. DEFINE_HTML_ELEMENT(cite);
  2299. DEFINE_HTML_ELEMENT(code);
  2300. DEFINE_HTML_ELEMENT(dfn);
  2301. DEFINE_HTML_ELEMENT(em);
  2302. DEFINE_HTML_ELEMENT(kbd);
  2303. DEFINE_HTML_ELEMENT(samp);
  2304. DEFINE_HTML_ELEMENT(strike);
  2305. DEFINE_HTML_ELEMENT(strong);
  2306. DEFINE_HTML_ELEMENT(var);
  2307. DEFINE_HTML_ELEMENT(b);
  2308. DEFINE_HTML_ELEMENT(big);
  2309. DEFINE_HTML_ELEMENT(i);
  2310. DEFINE_HTML_ELEMENT(s);
  2311. DEFINE_HTML_ELEMENT(small);
  2312. DEFINE_HTML_ELEMENT(sub);
  2313. DEFINE_HTML_ELEMENT(sup);
  2314. DEFINE_HTML_ELEMENT(tt);
  2315. DEFINE_HTML_ELEMENT(u);
  2316. DEFINE_HTML_ELEMENT(blink);
  2317. DEFINE_HTML_ELEMENT(span);
  2318. DEFINE_HTML_ELEMENT(map);
  2319. DEFINE_HTML_ELEMENT(area);
  2322. END_NCBI_SCOPE
  2325. /*
  2326.  * ===========================================================================
  2327.  * $Log: html.cpp,v $
  2328.  * Revision 1000.4  2004/06/01 19:15:26  gouriano
  2329.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.103
  2330.  *
  2331.  * Revision 1.103  2004/05/17 20:59:50  gorelenk
  2332.  * Added include of PCH ncbi_pch.hpp
  2333.  *
  2334.  * Revision 1.102  2004/04/05 16:19:57  ivanov
  2335.  * Added support for Sergey Kurdin's popup menu with configurations
  2336.  *
  2337.  * Revision 1.101  2004/03/10 20:11:35  ivanov
  2338.  * Changed message text
  2339.  *
  2340.  * Revision 1.100  2004/02/04 17:20:10  ivanov
  2341.  * Added s_GenerateNodeInternalName() function.
  2342.  * Use it insteed dummy names in the meta-tags node classes.
  2343.  *
  2344.  * Revision 1.99  2004/02/04 12:43:47  ivanov
  2345.  * Fixed CHTMLText::SetText() -- do not use m_Name for store HTML code.
  2346.  * Bind internal name for objects of the CHTMLSpecialChar class.
  2347.  *
  2348.  * Revision 1.98  2004/02/03 19:45:13  ivanov
  2349.  * Binded dummy names for the unnamed nodes
  2350.  *
  2351.  * Revision 1.97  2004/02/02 15:48:16  ivanov
  2352.  * CHTMLText::x_PrintBegin: using CHTMLHelper::StripHTML insteed StripTags
  2353.  *
  2354.  * Revision 1.96  2004/02/02 14:30:24  ivanov
  2355.  * CHTMLText::PrintBegin - added repeat tag support. Some cosmetic changes.
  2356.  *
  2357.  * Revision 1.95  2004/01/30 14:03:50  lavr
  2358.  * Print last errno along with "write failure" message
  2359.  *
  2360.  * Revision 1.94  2004/01/26 16:26:47  ivanov
  2361.  * Added NOWRAP attribute support
  2362.  *
  2363.  * Revision 1.93  2003/12/18 20:15:42  golikov
  2364.  * use HideMenu() call, CHTMLComment::PrintBegin fix
  2365.  *
  2366.  * Revision 1.92  2003/12/16 19:08:49  ivanov
  2367.  * CHTML_font::SetTypeFace: replaced attribute name "typeface" to "face".
  2368.  *
  2369.  * Revision 1.91  2003/12/10 19:15:14  ivanov
  2370.  * Move adding a string "return false;" to menues JS code call from ShowMenu()
  2371.  * to AttachPopupMenu()
  2372.  *
  2373.  * Revision 1.90  2003/12/02 14:25:58  ivanov
  2374.  * Removed obsolete functions GetCodeBodyTag[Handler|Action]().
  2375.  * AttachPopupMenu(): use event parameter for eKurdin menu also.
  2376.  *
  2377.  * Revision 1.89  2003/11/03 17:03:08  ivanov
  2378.  * Some formal code rearrangement. Move log to end.
  2379.  *
  2380.  * Revision 1.88  2003/11/03 14:49:16  ivanov
  2381.  * Always check if the write was successful, throw otherwise
  2382.  *
  2383.  * Revision 1.87  2003/10/01 15:57:13  ivanov
  2384.  * Added support for Sergey Kurdin's side menu
  2385.  *
  2386.  * Revision 1.86  2003/07/08 17:13:53  gouriano
  2387.  * changed thrown exceptions to CException-derived ones
  2388.  *
  2389.  * Revision 1.85  2003/05/30 18:39:33  lavr
  2390.  * Replace endl's with explicit 'n' to avoid premature flushing
  2391.  *
  2392.  * Revision 1.84  2003/05/15 12:33:54  ucko
  2393.  * s_Find: drop assertion, and just return NPOS at/past the end of s.
  2394.  *
  2395.  * Revision 1.83  2003/05/14 21:55:40  ucko
  2396.  * CHTMLText::PrintBegin: Use strstr() instead of string::find() when
  2397.  * looking for tags to replace, as the latter is much slower on some
  2398.  * systems.
  2399.  *
  2400.  * Revision 1.82  2003/04/22 15:04:05  ivanov
  2401.  * Removed HTMLEncode() for tags attributes in CHTMLOpenElement::PrintBegin()
  2402.  *
  2403.  * Revision 1.81  2003/03/11 15:28:57  kuznets
  2404.  * iterate -> ITERATE
  2405.  *
  2406.  * Revision 1.80  2003/02/14 16:19:32  ucko
  2407.  * Indent the children of CHTMLListElement in plain-text mode.
  2408.  * Avoid redundant newlines in CHTMLBlockElement::PrintEnd.
  2409.  *
  2410.  * Revision 1.79  2002/12/24 14:56:03  ivanov
  2411.  * Fix for R1.76:  HTML classes for tags <h1-6>, <p>, <div>. <pre>, <blockquote>
  2412.  * now inherits from CHTMLBlockElement (not CHTMElement as before)
  2413.  *
  2414.  * Revision 1.78  2002/12/20 19:20:19  ivanov
  2415.  * Added SPAN tag support
  2416.  *
  2417.  * Revision 1.77  2002/12/18 19:46:18  ivanov
  2418.  * Added line break after elements of the class CHTMLElement in plain text mode
  2419.  *
  2420.  * Revision 1.76  2002/12/09 22:11:33  ivanov
  2421.  * Added support for Sergey Kurdin's popup menu.
  2422.  * Added CHTMLNode::AttachPopupMenu().
  2423.  *
  2424.  * Revision 1.75  2002/09/25 01:24:56  dicuccio
  2425.  * Added CHTMLHelper::StripTags() - strips HTML comments and tags from any
  2426.  * string.  Implemented CHTMLText::PrintBegin() for mode = ePlainText
  2427.  *
  2428.  * Revision 1.74  2002/02/13 20:16:44  ivanov
  2429.  * Added support of dynamic popup menus. Changed EnablePopupMenu().
  2430.  *
  2431.  * Revision 1.73  2002/01/30 19:54:51  ivanov
  2432.  * CHTML_table::PrintBegin - determination length of prior table's separator
  2433.  * as length of first none empty table's row. Added new line at printing
  2434.  * table in plain text mode.
  2435.  *
  2436.  * Revision 1.72  2002/01/29 20:01:46  ivanov
  2437.  * (plain text) CHTML_table:: set def. medium sep. to " " instead of "t"
  2438.  *
  2439.  * Revision 1.71  2002/01/29 19:25:55  ivanov
  2440.  * Typo fixed
  2441.  *
  2442.  * Revision 1.70  2002/01/29 19:20:47  ivanov
  2443.  * (plain text) CHTML_table:: set def. medium sep. to "" instead of "t".
  2444.  * Restored functionality of CHTML_tr::PrintEnd().
  2445.  * Fixed CHTML_tr::GetTextLength() -- ".put('')" instead of "<< ''".
  2446.  *
  2447.  * Revision 1.69  2002/01/28 17:54:50  vakatov
  2448.  * (plain text) CHTML_table:: set def. medium sep. to "t" instead of "t|t"
  2449.  *
  2450.  * Revision 1.68  2002/01/17 23:40:01  ivanov
  2451.  * Added means to print HTML tables in plain text mode
  2452.  *
  2453.  * Revision 1.67  2001/08/14 16:51:05  ivanov
  2454.  * Change means for init JavaScript popup menu & add it to HTML document.
  2455.  * Remove early redefined classes for tags HEAD and BODY.
  2456.  *
  2457.  * Revision 1.66  2001/07/16 13:54:09  ivanov
  2458.  * Added support JavaScript popups menu (jsmenu.[ch]pp)
  2459.  *
  2460.  * Revision 1.65  2001/06/08 19:00:22  ivanov
  2461.  * Added base classes: CHTMLDualNode, CHTMLSpecialChar
  2462.  *     (and based on it: CHTML_nbsp, _gt, _lt, _quot, _amp, _copy, _reg)
  2463.  * Added realization for tags <meta> (CHTML_meta) and <script> (CHTML_script)
  2464.  * Changed base class for tags LINK, PARAM, ISINDEX -> CHTMLOpenElement
  2465.  * Added tags: OBJECT, NOSCRIPT
  2466.  * Added attribute "alt" for CHTML_img
  2467.  * Added CHTMLComment::Print() for disable print html-comments in plaintext mode
  2468.  *
  2469.  * Revision 1.64  2001/06/05 15:35:48  ivanov
  2470.  * Added attribute "alt" to CHTML_image
  2471.  *
  2472.  * Revision 1.63  2001/05/17 15:05:42  lavr
  2473.  * Typos corrected
  2474.  *
  2475.  * Revision 1.62  2000/10/13 19:55:15  vasilche
  2476.  * Fixed error with static html node object.
  2477.  *
  2478.  * Revision 1.61  2000/09/27 14:11:17  vasilche
  2479.  * Newline 'n' will not be generated after tags LABEL, A, FONT, CITE, CODE, EM,
  2480.  * KBD, STRIKE STRONG, VAR, B, BIG, I, S, SMALL, SUB, SUP, TT, U and BLINK.
  2481.  *
  2482.  * Revision 1.60  2000/08/15 19:40:48  vasilche
  2483.  * Added CHTML_label::SetFor() method for setting HTML attribute FOR.
  2484.  *
  2485.  * Revision 1.59  2000/08/01 20:05:11  golikov
  2486.  * Removed _TRACE
  2487.  *
  2488.  * Revision 1.58  2000/07/25 15:27:38  vasilche
  2489.  * Added newline symbols before table and after each table row in text mode.
  2490.  *
  2491.  * Revision 1.57  2000/07/20 20:37:19  vasilche
  2492.  * Fixed null pointer dereference.
  2493.  *
  2494.  * Revision 1.56  2000/07/18 19:08:55  vasilche
  2495.  * Fixed uninitialized members.
  2496.  * Fixed NextCell to advance to next cell.
  2497.  *
  2498.  * Revision 1.55  2000/07/18 17:21:39  vasilche
  2499.  * Added possibility to force output of empty attribute value.
  2500.  * Added caching to CHTML_table, now large tables work much faster.
  2501.  * Changed algorithm of emitting EOL symbols in html output.
  2502.  *
  2503.  * Revision 1.54  2000/07/12 16:37:42  vasilche
  2504.  * Added new HTML4 tags: LABEL, BUTTON, FIELDSET, LEGEND.
  2505.  * Added methods for setting common attributes: STYLE, ID, TITLE, ACCESSKEY.
  2506.  *
  2507.  * Revision 1.53  2000/03/07 15:26:12  vasilche
  2508.  * Removed second definition of CRef.
  2509.  *
  2510.  * Revision 1.52  1999/12/28 21:01:08  vasilche
  2511.  * Fixed conflict on MS VC between bool and const string& arguments by
  2512.  * adding const char* argument.
  2513.  *
  2514.  * Revision 1.51  1999/12/28 18:55:45  vasilche
  2515.  * Reduced size of compiled object files:
  2516.  * 1. avoid inline or implicit virtual methods (especially destructors).
  2517.  * 2. avoid std::string's methods usage in inline methods.
  2518.  * 3. avoid string literals ("xxx") in inline methods.
  2519.  *
  2520.  * Revision 1.50  1999/10/28 13:40:35  vasilche
  2521.  * Added reference counters to CNCBINode.
  2522.  *
  2523.  * Revision 1.49  1999/08/20 16:14:54  golikov
  2524.  * 'non-<TR> tag' bug fixed
  2525.  *
  2526.  * Revision 1.48  1999/08/09 16:20:07  golikov
  2527.  * Table output in plaintext fixed
  2528.  *
  2529.  * Revision 1.47  1999/07/08 18:05:15  vakatov
  2530.  * Fixed compilation warnings
  2531.  *
  2532.  * Revision 1.46  1999/06/18 20:42:50  vakatov
  2533.  * Fixed tiny compilation warnings
  2534.  *
  2535.  * Revision 1.45  1999/06/11 20:30:29  vasilche
  2536.  * We should catch exception by reference, because catching by value
  2537.  * doesn't preserve comment string.
  2538.  *
  2539.  * Revision 1.44  1999/06/09 20:57:58  golikov
  2540.  * RowSpan fixed by Vasilche
  2541.  *
  2542.  * Revision 1.43  1999/06/07 15:21:05  vasilche
  2543.  * Fixed some warnings.
  2544.  *
  2545.  * Revision 1.42  1999/05/28 18:03:51  vakatov
  2546.  * CHTMLNode::  added attribute "CLASS"
  2547.  *
  2548.  * Revision 1.41  1999/05/27 21:43:02  vakatov
  2549.  * Get rid of some minor compiler warnings
  2550.  *
  2551.  * Revision 1.40  1999/05/24 13:57:55  pubmed
  2552.  * Save Command; MEDLINE, FASTA format changes
  2553.  *
  2554.  * Revision 1.39  1999/05/20 16:52:31  pubmed
  2555.  * SaveAsText action for query; minor changes in filters,labels, tabletemplate
  2556.  *
  2557.  * Revision 1.38  1999/05/17 20:09:58  vasilche
  2558.  * Removed generation of implicit table cells.
  2559.  *
  2560.  * Revision 1.37  1999/04/16 17:45:35  vakatov
  2561.  * [MSVC++] Replace the <windef.h>'s min/max macros by the hand-made templates.
  2562.  *
  2563.  * Revision 1.36  1999/04/15 22:09:26  vakatov
  2564.  * "max" --> "NcbiMax"
  2565.  *
  2566.  * Revision 1.35  1999/04/15 19:56:24  vasilche
  2567.  * More warnings fixed
  2568.  *
  2569.  * Revision 1.34  1999/04/15 19:48:23  vasilche
  2570.  * Fixed several warnings detected by GCC
  2571.  *
  2572.  * Revision 1.33  1999/04/08 19:00:31  vasilche
  2573.  * Added current cell pointer to CHTML_table
  2574.  *
  2575.  * Revision 1.32  1999/03/26 22:00:01  sandomir
  2576.  * checked option in Radio button fixed; minor fixes in Selection
  2577.  *
  2578.  * Revision 1.31  1999/03/01 21:03:09  vasilche
  2579.  * Added CHTML_file input element.
  2580.  * Changed CHTML_form constructors.
  2581.  *
  2582.  * Revision 1.30  1999/02/26 21:03:33  vasilche
  2583.  * CAsnWriteNode made simple node. Use CHTML_pre explicitly.
  2584.  * Fixed bug in CHTML_table::Row.
  2585.  * Added CHTML_table::HeaderCell & DataCell methods.
  2586.  *
  2587.  * Revision 1.29  1999/02/02 17:57:49  vasilche
  2588.  * Added CHTML_table::Row(int row).
  2589.  * Linkbar now have equal image spacing.
  2590.  *
  2591.  * Revision 1.28  1999/01/28 21:58:08  vasilche
  2592.  * QueryBox now inherits from CHTML_table (not CHTML_form as before).
  2593.  * Use 'new CHTML_form("url", queryBox)' as replacement of old QueryBox.
  2594.  *
  2595.  * Revision 1.27  1999/01/28 16:59:01  vasilche
  2596.  * Added several constructors for CHTML_hr.
  2597.  * Added CHTMLNode::SetSize method.
  2598.  *
  2599.  * Revision 1.26  1999/01/25 19:34:18  vasilche
  2600.  * String arguments which are added as HTML text now treated as plain text.
  2601.  *
  2602.  * Revision 1.25  1999/01/21 21:12:59  vasilche
  2603.  * Added/used descriptions for HTML submit/select/text.
  2604.  * Fixed some bugs in paging.
  2605.  *
  2606.  * Revision 1.24  1999/01/21 16:18:05  sandomir
  2607.  * minor changes due to NStr namespace to contain string utility functions
  2608.  *
  2609.  * Revision 1.23  1999/01/14 21:25:20  vasilche
  2610.  * Changed CPageList to work via form image input elements.
  2611.  *
  2612.  * Revision 1.22  1999/01/11 22:05:52  vasilche
  2613.  * Fixed CHTML_font size.
  2614.  * Added CHTML_image input element.
  2615.  *
  2616.  * Revision 1.21  1999/01/11 15:13:35  vasilche
  2617.  * Fixed CHTML_font size.
  2618.  * CHTMLHelper extracted to separate file.
  2619.  *
  2620.  * Revision 1.20  1999/01/07 16:41:56  vasilche
  2621.  * CHTMLHelper moved to separate file.
  2622.  * TagNames of CHTML classes ara available via s_GetTagName() static
  2623.  * method.
  2624.  * Input tag types ara available via s_GetInputType() static method.
  2625.  * Initial selected database added to CQueryBox.
  2626.  * Background colors added to CPagerBax & CSmallPagerBox.
  2627.  *
  2628.  * Revision 1.19  1999/01/05 20:23:29  vasilche
  2629.  * Fixed HTMLEncode.
  2630.  *
  2631.  * Revision 1.18  1999/01/04 20:06:14  vasilche
  2632.  * Redesigned CHTML_table.
  2633.  * Added selection support to HTML forms (via hidden values).
  2634.  *
  2635.  * Revision 1.16  1998/12/28 21:48:16  vasilche
  2636.  * Made Lewis's 'tool' compilable
  2637.  *
  2638.  * Revision 1.15  1998/12/28 16:48:09  vasilche
  2639.  * Removed creation of QueryBox in CHTMLPage::CreateView()
  2640.  * CQueryBox extends from CHTML_form
  2641.  * CButtonList, CPageList, CPagerBox, CSmallPagerBox extend from CNCBINode.
  2642.  *
  2643.  * Revision 1.14  1998/12/24 16:15:41  vasilche
  2644.  * Added CHTMLComment class.
  2645.  * Added TagMappers from static functions.
  2646.  *
  2647.  * Revision 1.13  1998/12/23 21:51:44  vasilche
  2648.  * Added missing constructors to checkbox.
  2649.  *
  2650.  * Revision 1.12  1998/12/23 21:21:03  vasilche
  2651.  * Added more HTML tags (almost all).
  2652.  * Importent ones: all lists (OL, UL, DIR, MENU), fonts (FONT, BASEFONT).
  2653.  *
  2654.  * Revision 1.11  1998/12/23 14:28:10  vasilche
  2655.  * Most of closed HTML tags made via template.
  2656.  *
  2657.  * Revision 1.10  1998/12/21 22:25:03  vasilche
  2658.  * A lot of cleaning.
  2659.  *
  2660.  * Revision 1.9  1998/12/10 19:21:51  lewisg
  2661.  * correct error handling in InsertInTable
  2662.  *
  2663.  * Revision 1.8  1998/12/10 00:17:27  lewisg
  2664.  * fix index in InsertInTable
  2665.  *
  2666.  * Revision 1.7  1998/12/09 23:00:54  lewisg
  2667.  * use new cgiapp class
  2668.  *
  2669.  * Revision 1.6  1998/12/08 00:33:43  lewisg
  2670.  * cleanup
  2671.  *
  2672.  * Revision 1.5  1998/12/03 22:48:00  lewisg
  2673.  * added HTMLEncode() and CHTML_img
  2674.  *
  2675.  * Revision 1.4  1998/12/01 19:10:38  lewisg
  2676.  * uses CCgiApplication and new page factory
  2677.  *
  2678.  * Revision 1.3  1998/11/23 23:42:17  lewisg
  2679.  * *** empty log message ***
  2680.  *
  2681.  * Revision 1.2  1998/10/29 16:13:06  lewisg
  2682.  * version 2
  2683.  *
  2684.  * Revision 1.1  1998/10/06 20:36:05  lewisg
  2685.  * new html lib and test program
  2686.  *
  2687.  * ===========================================================================
  2688.  */