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

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

生物技术

开发平台：

C/C++

html.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: html.hpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 19:15:12  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.75
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef HTML___HTML__HPP
  11. #define HTML___HTML__HPP
  13. /*  $Id: html.hpp,v 1000.5 2004/06/01 19:15:12 gouriano Exp $
  14.  * ===========================================================================
  15.  *
  16.  *                            PUBLIC DOMAIN NOTICE
  17.  *               National Center for Biotechnology Information
  18.  *
  19.  *  This software/database is a "United States Government Work" under the
  20.  *  terms of the United States Copyright Act.  It was written as part of
  21.  *  the author's official duties as a United States Government employee and
  22.  *  thus cannot be copyrighted.  This software/database is freely available
  23.  *  to the public for use. The National Library of Medicine and the U.S.
  24.  *  Government have not placed any restriction on its use or reproduction.
  25.  *
  26.  *  Although all reasonable efforts have been taken to ensure the accuracy
  27.  *  and reliability of the software and data, the NLM and the U.S.
  28.  *  Government do not and cannot warrant the performance or results that
  29.  *  may be obtained by using this software or data. The NLM and the U.S.
  30.  *  Government disclaim all warranties, express or implied, including
  31.  *  warranties of performance, merchantability or fitness for any particular
  32.  *  purpose.
  33.  *
  34.  *  Please cite the author in any work or product based on this material.
  35.  *
  36.  * ===========================================================================
  37.  *
  38.  * Author:  Lewis Geer
  39.  *
  40.  */
  42. /// @file html.hpp 
  43. /// HTML classes.
  44. ///
  45. /// Defines classes to generate HTML code.
  48. #include <corelib/ncbiobj.hpp>
  49. #include <html/node.hpp>
  50. #include <html/jsmenu.hpp>
  51. #include <html/htmlhelper.hpp>
  54. /** @addtogroup HTMLcomp
  55.  *
  56.  * @{
  57.  */
  60. BEGIN_NCBI_SCOPE
  63. /// Macro for declare html elements.
  64. #define CHTML_NAME(Tag) NCBI_NAME2(CHTML_, Tag)
  67. #define DECLARE_HTML_ELEMENT_CONSTRUCTORS(Tag, Parent) 
  68.     CHTML_NAME(Tag)(void) 
  69.         : CParent(sm_TagName) 
  70.         { } 
  71.     CHTML_NAME(Tag)(const char* text) 
  72.         : CParent(sm_TagName, text) 
  73.         { } 
  74.     CHTML_NAME(Tag)(const string& text) 
  75.         : CParent(sm_TagName, text) 
  76.         { } 
  77.     CHTML_NAME(Tag)(CNCBINode* node) 
  78.         : CParent(sm_TagName, node) 
  79.         { } 
  80.     ~CHTML_NAME(Tag)(void)
  83. #define DECLARE_HTML_ELEMENT_CONSTRUCTORS_WITH_INIT(Tag, Parent) 
  84.     CHTML_NAME(Tag)(void) 
  85.         : CParent(sm_TagName) 
  86.         { Init(); } 
  87.     CHTML_NAME(Tag)(const char* text) 
  88.         : CParent(sm_TagName, text) 
  89.         { Init(); } 
  90.     CHTML_NAME(Tag)(const string& text) 
  91.         : CParent(sm_TagName, text) 
  92.         { Init(); } 
  93.     CHTML_NAME(Tag)(CNCBINode* node) 
  94.         : CParent(sm_TagName, node) 
  95.         { Init(); } 
  96.     ~CHTML_NAME(Tag)(void)
  99. #define DECLARE_HTML_ELEMENT_TYPES(Parent) 
  100.     typedef Parent CParent; 
  101.     static const char sm_TagName[]
  104. #define DECLARE_HTML_ELEMENT_COMMON(Tag, Parent) 
  105.     DECLARE_HTML_ELEMENT_TYPES(Parent); 
  106. public: 
  107.     DECLARE_HTML_ELEMENT_CONSTRUCTORS(Tag, Parent)
  110. #define DECLARE_HTML_ELEMENT_COMMON_WITH_INIT(Tag, Parent) 
  111.     DECLARE_HTML_ELEMENT_TYPES(Parent); 
  112. public: 
  113.     DECLARE_HTML_ELEMENT_CONSTRUCTORS_WITH_INIT(Tag, Parent)
  116. #define DECLARE_HTML_ELEMENT(Tag, Parent) 
  117. class NCBI_XHTML_EXPORT CHTML_NAME(Tag) : public Parent 
  118. { 
  119.     DECLARE_HTML_ELEMENT_COMMON(Tag, Parent); 
  120. }
  123. // Macro for declare special chars.
  125. #define DECLARE_HTML_SPECIAL_CHAR(Tag, plain) 
  126. class NCBI_XHTML_EXPORT CHTML_NAME(Tag) : public CHTMLSpecialChar 
  127. { 
  128.     typedef CHTMLSpecialChar CParent; 
  129. public: 
  130.     CHTML_NAME(Tag)(int count = 1) 
  131.         : CParent(#Tag, plain, count) 
  132.         { } 
  133.     ~CHTML_NAME(Tag)(void) { }; 
  134. }
  137. // Event tag handler type.
  138. //
  139. // NOTE: Availability of realization event-handlers for some tags
  140. //       stand on from browser's type! Set of event-handlers for tags can 
  141. //       fluctuate in different browsers.
  143. enum EHTML_EH_Attribute {
  144.     //                    work with next HTML-tags (tag's group):
  145.     eHTML_EH_Blur,        //   select, text, textarea
  146.     eHTML_EH_Change,      //   select, text, textarea 
  147.     eHTML_EH_Click,       //   button, checkbox, radio, link, reset, submit
  148.     eHTML_EH_DblClick,    //   
  149.     eHTML_EH_Focus,       //   select, text, textarea  
  150.     eHTML_EH_Load,        //   body, frameset
  151.     eHTML_EH_Unload,      //   body, frameset
  152.     eHTML_EH_MouseDown,   //
  153.     eHTML_EH_MouseUp,     //
  154.     eHTML_EH_MouseMove,   //
  155.     eHTML_EH_MouseOver,   //
  156.     eHTML_EH_MouseOut,    //
  157.     eHTML_EH_Select,      //   text, textarea
  158.     eHTML_EH_Submit,      //   form  
  159.     eHTML_EH_KeyDown,     //
  160.     eHTML_EH_KeyPress,    //
  161.     eHTML_EH_KeyUp        //
  162. };
  165. // Base class for html node.
  166. class NCBI_XHTML_EXPORT CHTMLNode : public CNCBINode
  167. {
  168.     typedef CNCBINode CParent;
  169. public:
  170.     CHTMLNode(void)
  171.     { }
  172.     CHTMLNode(const char* tagname)
  173.         : CParent(tagname)
  174.     { }
  175.     CHTMLNode(const char* tagname, const char* text)
  176.         : CParent(tagname)
  177.     {
  178.         AppendPlainText(text);
  179.     }
  180.     CHTMLNode(const char* tagname, const string& text)
  181.         : CParent(tagname)
  182.     {
  183.         AppendPlainText(text);
  184.     }
  185.     CHTMLNode(const char* tagname, CNCBINode* node)
  186.         : CParent(tagname)
  187.     {
  188.         AppendChild(node);
  189.     }
  190.     CHTMLNode(const string& tagname)
  191.         : CParent(tagname)
  192.     { }
  193.     CHTMLNode(const string& tagname, const char* text)
  194.         : CParent(tagname)
  195.     {
  196.         AppendPlainText(text);
  197.     }
  198.     CHTMLNode(const string& tagname, const string& text)
  199.         : CParent(tagname)
  200.     {
  201.         AppendPlainText(text);
  202.     }
  203.     CHTMLNode(const string& tagname, CNCBINode* node)
  204.         : CParent(tagname)
  205.     {
  206.         AppendChild(node);
  207.     }
  208.     ~CHTMLNode(void);
  210.     // Convenient way to set some common attributes.
  211.     CHTMLNode* SetClass(const string& class_name);
  212.     CHTMLNode* SetStyle(const string& style);
  213.     CHTMLNode* SetId(const string& id);
  214.     CHTMLNode* SetWidth(int width);
  215.     CHTMLNode* SetWidth(const string& width);
  216.     CHTMLNode* SetHeight(int height);
  217.     CHTMLNode* SetHeight(const string& width);
  218.     CHTMLNode* SetSize(int size);
  219.     CHTMLNode* SetAlign(const string& align);
  220.     CHTMLNode* SetVAlign(const string& align);
  221.     CHTMLNode* SetBgColor(const string& color);
  222.     CHTMLNode* SetColor(const string& color);
  223.     CHTMLNode* SetNameAttribute(const string& name);
  224.     const string& GetNameAttribute(void) const;
  225.     CHTMLNode* SetTitle(const string& title);
  226.     CHTMLNode* SetAccessKey(char key);
  228.     // Convenient way to add CHTMLPlainText or CHTMLText.
  229.     void AppendPlainText(const char* text, bool noEncode = false);
  230.     void AppendPlainText(const string& text, bool noEncode = false);
  231.     void AppendHTMLText (const char* text);
  232.     void AppendHTMLText (const string& text);
  234.     // Get event handler name.
  235.     string GetEventHandlerName(const EHTML_EH_Attribute event) const;
  236.     // Set tag event handler.
  237.     void SetEventHandler(const EHTML_EH_Attribute event, const string& value);
  239.     // Attach the specified popup menu to HTML node.
  240.     // Popup menu will be shown when the "event" occurs.
  241.     // NOTES:
  242.     //   2) For eKurdin menu type the parameter "event" cannot be an
  243.     //      eHTML_EH_MouseOut, because it is used to hide the menu.
  244.     //   3) For eKurdinSide menu type the event parameters are not used.
  245.     void AttachPopupMenu(const CHTMLPopupMenu*  menu,
  246.                          EHTML_EH_Attribute     event = eHTML_EH_MouseOver);
  247. };
  250. // <@XXX@> mapping node.
  251. class NCBI_XHTML_EXPORT CHTMLTagNode : public CNCBINode
  252. {
  253.     typedef CNCBINode CParent;
  254. public:
  255.     CHTMLTagNode(const char* tag);
  256.     CHTMLTagNode(const string& tag);
  257.     ~CHTMLTagNode(void);
  259.     virtual CNcbiOstream& PrintChildren(CNcbiOstream& out, TMode mode);
  260. };
  263. // Dual print node.
  264. class NCBI_XHTML_EXPORT CHTMLDualNode : public CNCBINode
  265. {
  266.     typedef CNCBINode CParent;
  267. public:
  268.     CHTMLDualNode(const char* html, const char* plain);
  269.     CHTMLDualNode(CNCBINode* child, const char* plain);
  270.     ~CHTMLDualNode(void);
  272.     virtual CNcbiOstream& PrintChildren(CNcbiOstream& out, TMode mode);
  274. protected:
  275.     string m_Plain;
  276. };
  279. // A text node that contains plain text.
  280. class NCBI_XHTML_EXPORT CHTMLPlainText : public CNCBINode
  281. {
  282.     typedef CNCBINode CParent;
  283. public:
  284.     CHTMLPlainText(const char* text, bool noEncode = false);
  285.     CHTMLPlainText(const string& text, bool noEncode = false);
  286.     ~CHTMLPlainText(void);
  287.     
  288.     const string& GetText(void) const;
  289.     void SetText(const string& text);
  291.     bool NoEncode(void) const
  292.     {
  293.         return m_NoEncode;
  294.     }
  295.     void SetNoEncode(bool noEncode = true)
  296.     {
  297.         m_NoEncode = noEncode;
  298.     }
  300.     virtual CNcbiOstream& PrintBegin(CNcbiOstream& out, TMode mode);
  302. private:
  303.     bool   m_NoEncode;
  304.     string m_Text;
  305. };
  308. // A text node that contains html text with tags and possibly <@TAG@>.
  309. class NCBI_XHTML_EXPORT CHTMLText : public CNCBINode
  310. {
  311.     typedef CNCBINode CParent;
  312. public:
  313.     CHTMLText(const char* text);
  314.     CHTMLText(const string& text);
  315.     ~CHTMLText(void);
  316.     
  317.     const string& GetText(void) const;
  318.     void SetText(const string& text);
  320.     virtual CNcbiOstream& PrintBegin(CNcbiOstream& out, TMode mode);
  322. private:
  323.     CNcbiOstream& x_PrintBegin(CNcbiOstream& out, TMode mode,
  324.                                const string& s) const;
  325. private:
  326.     string m_Text;
  327. };
  330. // HTML tag base class.
  331. class NCBI_XHTML_EXPORT CHTMLOpenElement: public CHTMLNode
  332. {
  333.     typedef CHTMLNode CParent;
  334. public:
  335.     CHTMLOpenElement(const char* tagname)
  336.         : CParent(tagname), m_NoWrap(false)
  337.     { }
  338.     CHTMLOpenElement(const char* tagname, const char* text)
  339.         : CParent(tagname, text), m_NoWrap(false)
  340.     { }
  341.     CHTMLOpenElement(const char* tagname, const string& text)
  342.         : CParent(tagname, text), m_NoWrap(false)
  343.     { }
  344.     CHTMLOpenElement(const char* tagname, CNCBINode* node)
  345.         : CParent(tagname, node), m_NoWrap(false)
  346.     { }
  347.     CHTMLOpenElement(const string& tagname)
  348.         : CParent(tagname), m_NoWrap(false)
  349.     { }
  350.     CHTMLOpenElement(const string& tagname, const char* text)
  351.         : CParent(tagname, text), m_NoWrap(false)
  352.     { }
  353.     CHTMLOpenElement(const string& tagname, const string& text)
  354.         : CParent(tagname, text), m_NoWrap(false)
  355.     { }
  356.     CHTMLOpenElement(const string& tagname, CNCBINode* node)
  357.         : CParent(tagname, node), m_NoWrap(false)
  358.     { }
  359.     ~CHTMLOpenElement(void);
  361.     // Print tag itself.
  362.     virtual CNcbiOstream& PrintBegin(CNcbiOstream &, TMode mode);
  364.     // Set NOWRAP attribute (NOTE: it is depricated in HTML 4.0)
  365.     virtual void SetNoWrap(bool noWrap = true)
  366.         { m_NoWrap = noWrap; }
  368. protected:
  369.     bool m_NoWrap;
  372. };
  375. // HTML inline tag
  376. class NCBI_XHTML_EXPORT CHTMLInlineElement: public CHTMLOpenElement
  377. {
  378.     typedef CHTMLOpenElement CParent;
  379. public:
  380.     CHTMLInlineElement(const char* tagname)
  381.         : CParent(tagname)
  382.     { }
  383.     CHTMLInlineElement(const char* tagname, const char* text)
  384.         : CParent(tagname, text)
  385.     { }
  386.     CHTMLInlineElement(const char* tagname, const string& text)
  387.         : CParent(tagname, text)
  388.     { }
  389.     CHTMLInlineElement(const char* tagname, CNCBINode* node)
  390.         : CParent(tagname, node)
  391.     { }
  392.     CHTMLInlineElement(const string& tagname)
  393.         : CParent(tagname)
  394.     { }
  395.     CHTMLInlineElement(const string& tagname, const char* text)
  396.         : CParent(tagname, text)
  397.     { }
  398.     CHTMLInlineElement(const string& tagname, const string& text)
  399.         : CParent(tagname, text)
  400.     { }
  401.     CHTMLInlineElement(const string& tagname, CNCBINode* node)
  402.         : CParent(tagname, node)
  403.     { }
  404.     ~CHTMLInlineElement(void);
  406.     // Print tag close.
  407.     virtual CNcbiOstream& PrintEnd(CNcbiOstream &, TMode mode);   
  408. };
  411. // HTML tag
  412. class NCBI_XHTML_EXPORT CHTMLElement: public CHTMLInlineElement
  413. {
  414.     typedef CHTMLInlineElement CParent;
  415. public:
  416.     CHTMLElement(const char* tagname)
  417.         : CParent(tagname)
  418.     { }
  419.     CHTMLElement(const char* tagname, const char* text)
  420.         : CParent(tagname, text)
  421.     { }
  422.     CHTMLElement(const char* tagname, const string& text)
  423.         : CParent(tagname, text)
  424.     { }
  425.     CHTMLElement(const char* tagname, CNCBINode* node)
  426.         : CParent(tagname, node)
  427.     { }
  428.     CHTMLElement(const string& tagname)
  429.         : CParent(tagname)
  430.     { }
  431.     CHTMLElement(const string& tagname, const char* text)
  432.         : CParent(tagname, text)
  433.     { }
  434.     CHTMLElement(const string& tagname, const string& text)
  435.         : CParent(tagname, text)
  436.     { }
  437.     CHTMLElement(const string& tagname, CNCBINode* node)
  438.         : CParent(tagname, node)
  439.     { }
  440.     ~CHTMLElement(void);
  442.     // Print tag close.
  443.     virtual CNcbiOstream& PrintEnd(CNcbiOstream &, TMode mode);   
  444. };
  447. // HTML block element.
  448. class NCBI_XHTML_EXPORT CHTMLBlockElement: public CHTMLElement
  449. {
  450.     typedef CHTMLElement CParent;
  451. public:
  452.     CHTMLBlockElement(const char* tagname)
  453.         : CParent(tagname)
  454.     { }
  455.     CHTMLBlockElement(const char* tagname, const char* text)
  456.         : CParent(tagname, text)
  457.     { }
  458.     CHTMLBlockElement(const char* tagname, const string& text)
  459.         : CParent(tagname, text)
  460.     { }
  461.     CHTMLBlockElement(const char* tagname, CNCBINode* node)
  462.         : CParent(tagname, node)
  463.     { }
  464.     CHTMLBlockElement(const string& tagname)
  465.         : CParent(tagname)
  466.     { }
  467.     CHTMLBlockElement(const string& tagname, const char* text)
  468.         : CParent(tagname, text)
  469.     { }
  470.     CHTMLBlockElement(const string& tagname, const string& text)
  471.         : CParent(tagname, text)
  472.     { }
  473.     CHTMLBlockElement(const string& tagname, CNCBINode* node)
  474.         : CParent(tagname, node)
  475.     { }
  476.     ~CHTMLBlockElement(void);
  478.     // Close tag.
  479.     virtual CNcbiOstream& PrintEnd(CNcbiOstream &, TMode mode);   
  480. };
  483. // HTML comment.
  485. class NCBI_XHTML_EXPORT CHTMLComment : public CHTMLNode
  486. {
  487.     typedef CHTMLNode CParent;
  488.     static const char sm_TagName[];
  489. public:
  490.     CHTMLComment(void)
  491.         : CParent(sm_TagName)
  492.     { }
  493.     CHTMLComment(const char* text)
  494.         : CParent(sm_TagName)
  495.     {
  496.         AppendPlainText(text);
  497.     }
  498.     CHTMLComment(const string& text)
  499.         : CParent(sm_TagName)
  500.     {
  501.         AppendPlainText(text);
  502.     }
  503.     CHTMLComment(CNCBINode* node)
  504.         : CParent(sm_TagName)
  505.     {
  506.         AppendChild(node);
  507.     }
  508.     ~CHTMLComment(void);
  510.     virtual CNcbiOstream& Print(CNcbiOstream& out, TMode mode = eHTML);
  511.     virtual CNcbiOstream& PrintBegin(CNcbiOstream &, TMode mode);
  512.     virtual CNcbiOstream& PrintEnd(CNcbiOstream &, TMode mode);
  513. };
  516. // <list> tag.
  517. class NCBI_XHTML_EXPORT CHTMLListElement : public CHTMLElement
  518. {
  519.     typedef CHTMLElement CParent;
  520. public:
  521.     CHTMLListElement(const char* tagname, bool compact = false)
  522.         : CParent(tagname)
  523.     {
  524.         if ( compact ) {
  525.             SetCompact();
  526.         }
  527.     }
  528.     CHTMLListElement(const char* tagname, const char* type,
  529.                      bool compact = false)
  530.         : CParent(tagname)
  531.     {
  532.         SetType(type);
  533.         if ( compact ) {
  534.             SetCompact();
  535.         }
  536.     }
  537.     CHTMLListElement(const char* tagname, const string& type,
  538.                      bool compact = false)
  539.         : CParent(tagname)
  540.     {
  541.         SetType(type);
  542.         if ( compact ) {
  543.             SetCompact();
  544.         }
  545.     }
  546.     ~CHTMLListElement(void);
  548.     CHTMLListElement* AppendItem(const char* text);
  549.     CHTMLListElement* AppendItem(const string& text);
  550.     CHTMLListElement* AppendItem(CNCBINode* node);
  552.     CHTMLListElement* SetType(const char* type);
  553.     CHTMLListElement* SetType(const string& type);
  554.     CHTMLListElement* SetCompact(void);
  556.     CNcbiOstream& PrintChildren(CNcbiOstream& out, TMode mode);
  557. };
  560. // HTML special char.
  561. class NCBI_XHTML_EXPORT CHTMLSpecialChar: public CHTMLDualNode
  562. {
  563.     typedef CHTMLDualNode CParent;
  564. public:
  565.     // The "html" argument will be automagically wrapped into '&...;',
  566.     // e.g. 'amp' --> '&amp;'
  567.     CHTMLSpecialChar(const char* html, const char* plain, int count = 1);
  568.     ~CHTMLSpecialChar(void);
  570.     virtual CNcbiOstream& PrintChildren(CNcbiOstream& out, TMode mode);
  571. private:
  572.     string m_Html;
  573.     int    m_Count;
  574. };
  577. // <html> tag
  578. class NCBI_XHTML_EXPORT CHTML_html : public CHTMLElement
  579. {
  580.     // CParent, constructors, destructor.
  581.     DECLARE_HTML_ELEMENT_COMMON_WITH_INIT(html, CHTMLElement);
  582.    
  583.     // Enable using popup menus, set URL for popup menu library.
  584.     // If "menu_lib_url" is not defined, then using default URL.
  585.     // use_dynamic_menu - enable/disable using dynamic popup menus 
  586.     // (default it is disabled).
  587.     // NOTE: 1) If we not change value "menu_script_url", namely use default
  588.     //          value for it, then we can skip call this function.
  589.     //       2) Dynamic menu work only in new browsers. They use one container
  590.     //          for all menus instead of separately container for each menu in 
  591.     //          nondynamic mode. This parameter have effect only with eSmith
  592.     //          menu type.
  593.     void EnablePopupMenu(CHTMLPopupMenu::EType type = CHTMLPopupMenu::eSmith,
  594.                          const string&         menu_script_url  = kEmptyStr,
  595.                          bool                  use_dynamic_menu = false);
  596. private:
  597.     // Init members.
  598.     void Init(void);
  599.     
  600.     // Print all self childrens (automatic include code for support 
  601.     // popup menus, if it needed).
  602.     virtual CNcbiOstream& PrintChildren(CNcbiOstream& out, TMode mode);
  604.     // The popup menu info structure.
  605.     struct SPopupMenuInfo {
  606.         SPopupMenuInfo() 
  607.             : m_UseDynamicMenu(false)
  608.         { };
  609.         SPopupMenuInfo(const string& url, bool use_dynamic_menu)
  610.             : m_Url(url), m_UseDynamicMenu(use_dynamic_menu)
  611.         { }
  612.         string m_Url;
  613.         bool   m_UseDynamicMenu; // Only for eSmith menu type.
  614.     };
  615.     // The popup menus usage info.
  616.     typedef map<CHTMLPopupMenu::EType, SPopupMenuInfo> TPopupMenus;
  617.     TPopupMenus m_PopupMenus;
  618. };
  622. // Table classes.
  624. class CHTML_table;   // Table
  625. class CHTML_tr;      // Row
  626. class CHTML_tc;      // Any cell
  627. class CHTML_th;      // Header cell
  628. class CHTML_td;      // Data cell
  629. class CHTML_tc_Cache;
  630. class CHTML_tr_Cache;
  631. class CHTML_table_Cache;
  634. class NCBI_XHTML_EXPORT CHTML_tc : public CHTMLElement
  635. {
  636.     typedef CHTMLElement CParent;
  637. public:
  638.     typedef unsigned TIndex;
  639.     CHTML_tc(const char* tagname)
  640.         : CParent(tagname), m_Parent(0)
  641.     { }
  642.     CHTML_tc(const char* tagname, const char* text)
  643.         : CParent(tagname, text), m_Parent(0)
  644.     { }
  645.     CHTML_tc(const char* tagname, const string& text)
  646.         : CParent(tagname, text), m_Parent(0)
  647.     { }
  648.     CHTML_tc(const char* tagname, CNCBINode* node)
  649.         : CParent(tagname, node), m_Parent(0)
  650.     { }
  651.     ~CHTML_tc(void);
  653.     // Type for row and column indexing.
  654.     CHTML_tc* SetRowSpan(TIndex span);
  655.     CHTML_tc* SetColSpan(TIndex span);
  657.     void ResetTableCache(void);
  659. protected:
  660.     virtual void DoSetAttribute(const string& name,
  661.                                 const string& value, bool optional);
  662.     friend class CHTML_tr;
  663.     friend class CHTML_tc_Cache;
  665.     CHTML_tr* m_Parent;
  666. };
  669. class NCBI_XHTML_EXPORT CHTML_tr : public CHTMLElement
  670. {
  671.     typedef CHTMLElement CParent;
  672. public:
  673.     typedef unsigned TIndex;
  675.     CHTML_tr(void);
  676.     CHTML_tr(CNCBINode* node);
  677.     CHTML_tr(const string& text);
  679.     void ResetTableCache(void);
  681.     virtual CNcbiOstream& PrintChildren(CNcbiOstream& out, TMode mode);
  682.     virtual CNcbiOstream& PrintEnd(CNcbiOstream& out, TMode mode);
  684. protected:
  685.     virtual void DoAppendChild(CNCBINode* node);
  686.     void AppendCell(CHTML_tc* cell);
  687.     size_t GetTextLength(TMode mode);
  689.     friend class CHTML_table;
  690.     friend class CHTML_tr_Cache;
  692.     CHTML_table* m_Parent;
  693. };
  696. // <table> tag.
  698. class NCBI_XHTML_EXPORT CHTML_table : public CHTMLElement
  699. {
  700.     typedef CHTMLElement CParent;
  701. public:
  702.     // Type for row and column indexing.
  703.     typedef unsigned TIndex;
  704.     enum ECellType {
  705.         eAnyCell,
  706.         eDataCell,
  707.         eHeaderCell
  708.     };
  710.     CHTML_table(void);
  711.     ~CHTML_table(void);
  713.     // Return row, will add rows if needed.
  714.     // Throws exception if it is not left upper corner of cell.
  715.     CHTML_tr* Row(TIndex row);
  717.     // Get/set current insertion point.
  718.     void SetCurrentCell(TIndex row, TIndex col)
  719.         { m_CurrentRow = row; m_CurrentCol = col; }
  720.     TIndex GetCurrentRow(void) const
  721.         { return m_CurrentRow; }
  722.     TIndex GetCurrentCol(void) const
  723.         { return m_CurrentCol; }
  725.     class CTableInfo;
  727.     // Return cell, will add rows/columns if needed.
  728.     // Throws exception if it is not left upper corner of cell
  729.     // also sets current insertion point.
  730.     CHTML_tc* Cell(TIndex row, TIndex column, ECellType type = eAnyCell);
  731.     CHTML_tc* Cell(TIndex row, TIndex column, ECellType type,
  732.                    TIndex rowSpan, TIndex colSpan);
  733.     CHTML_tc* HeaderCell(TIndex row, TIndex column)
  734.         { return Cell(row, column, eHeaderCell); }
  735.     CHTML_tc* DataCell(TIndex row, TIndex column)
  736.         { return Cell(row, column, eDataCell); }
  738.     CHTML_tc* NextCell(ECellType type = eAnyCell);
  739.     CHTML_tc* NextHeaderCell(void)
  740.         { return NextCell(eHeaderCell); }
  741.     CHTML_tc* NextDataCell(void)
  742.         { return NextCell(eDataCell); }
  744.     CHTML_tc* NextRowCell(ECellType type = eAnyCell);
  745.     CHTML_tc* NextRowHeaderCell(void)
  746.         { return NextRowCell(eHeaderCell); }
  747.     CHTML_tc* NextRowDataCell(void)
  748.         { return NextRowCell(eDataCell); }
  750.     // Check table contents for validaty, throws exception if invalid.
  751.     void CheckTable(void) const;
  752.     // Return width of table in columns. Should call CheckTable before.
  753.     TIndex CalculateNumberOfColumns(void) const;
  754.     TIndex CalculateNumberOfRows(void) const;
  756.     // Return cell of insertion.
  757.     CHTML_tc* InsertAt(TIndex row, TIndex column, CNCBINode* node);
  758.     CHTML_tc* InsertAt(TIndex row, TIndex column, const string& text);
  759.     CHTML_tc* InsertTextAt(TIndex row, TIndex column, const string& text);
  761.     CHTML_tc* InsertNextCell(CNCBINode* node);
  762.     CHTML_tc* InsertNextCell(const string& text);
  764.     CHTML_tc* InsertNextRowCell(CNCBINode* node);
  765.     CHTML_tc* InsertNextRowCell(const string& text);
  767.     void ColumnWidth(CHTML_table*, TIndex column, const string & width);
  769.     CHTML_table* SetCellSpacing(int spacing);
  770.     CHTML_table* SetCellPadding(int padding);
  772.     void ResetTableCache(void);
  774.     virtual CNcbiOstream& PrintBegin(CNcbiOstream &, TMode mode);
  776.     // If to print horizontal row separator (affects ePlainText mode only).
  777.     enum ERowPlainSep {
  778.         ePrintRowSep,   // print
  779.         eSkipRowSep     // do not print
  780.     };
  781.     // Set rows and cols separators (affects ePlainText mode only).
  782.     void SetPlainSeparators(const string& col_left     = kEmptyStr,
  783.                             const string& col_middle   = " ",
  784.                             const string& col_right    = kEmptyStr,
  785.                             const char    row_sep_char = '-',
  786.                             ERowPlainSep  is_row_sep   = eSkipRowSep);
  788. protected:
  789.     TIndex m_CurrentRow, m_CurrentCol;
  790.     mutable auto_ptr<CHTML_table_Cache> m_Cache;
  791.     CHTML_table_Cache& GetCache(void) const;
  792.     friend class CHTML_table_Cache;
  793.     friend class CHTML_tr;
  795.     virtual void DoAppendChild(CNCBINode* node);
  796.     void AppendRow(CHTML_tr* row);
  798.     string       m_ColSepL, m_ColSepM, m_ColSepR;
  799.     char         m_RowSepChar;
  800.     ERowPlainSep m_IsRowSep;
  801. };
  804. // <form> tag
  805. class NCBI_XHTML_EXPORT CHTML_form : public CHTMLElement
  806. {
  807.     typedef CHTMLElement CParent;
  808. public:
  809.     enum EMethod {
  810.         eGet,
  811.         ePost,
  812.         ePostData
  813.     };
  815.     CHTML_form(void);
  816.     CHTML_form(const string& url, EMethod method = eGet);
  817.     CHTML_form(const string& url, CNCBINode* node, EMethod method = eGet);
  818.     ~CHTML_form(void);
  820.     void Init(const string& url, EMethod method = eGet);
  822.     void AddHidden(const string& name, const string& value);
  823.     void AddHidden(const string& name, int value);
  824. };
  827. // <legend> tag.
  828. class NCBI_XHTML_EXPORT CHTML_legend : public CHTMLElement
  829. {
  830.     typedef CHTMLElement CParent;
  831. public:
  832.     CHTML_legend(const string& legend);
  833.     CHTML_legend(CHTMLNode* legend);
  834.     ~CHTML_legend(void);
  835. };
  838. // <fieldset> tag.
  839. class NCBI_XHTML_EXPORT CHTML_fieldset : public CHTMLElement
  840. {
  841.     typedef CHTMLElement CParent;
  842. public:
  843.     CHTML_fieldset(void);
  844.     CHTML_fieldset(const string& legend);
  845.     CHTML_fieldset(CHTML_legend* legend);
  846.     ~CHTML_fieldset(void);
  847. };
  850. // <label> tag.
  851. class NCBI_XHTML_EXPORT CHTML_label : public CHTMLInlineElement
  852. {
  853.     typedef CHTMLInlineElement CParent;
  854. public:
  855.     CHTML_label(const string& text);
  856.     CHTML_label(const string& text, const string& idRef);
  857.     ~CHTML_label(void);
  859.     void SetFor(const string& idRef);
  860. };
  863. // <textarea> tag.
  864. class NCBI_XHTML_EXPORT CHTML_textarea : public CHTMLElement
  865. {
  866.     typedef CHTMLElement CParent;
  867. public:
  868.     CHTML_textarea(const string& name, int cols, int rows);
  869.     CHTML_textarea(const string& name, int cols, int rows,
  870.                    const string& value);
  871.     ~CHTML_textarea(void);
  872. };
  875. // <input> tag.
  876. class NCBI_XHTML_EXPORT CHTML_input : public CHTMLOpenElement
  877. {
  878.     typedef CHTMLOpenElement CParent;
  879. public:
  880.     CHTML_input(const char* type, const string& name);
  881.     ~CHTML_input(void);
  882. };
  885. // <input type=checkbox> tag.
  886. class NCBI_XHTML_EXPORT CHTML_checkbox : public CHTML_input
  887. {
  888.     typedef CHTML_input CParent;
  889.     static const char sm_InputType[];
  890. public:
  891.     CHTML_checkbox(const string& name);
  892.     CHTML_checkbox(const string& name, bool checked,
  893.                    const string& description = kEmptyStr);
  894.     CHTML_checkbox(const string& name, const string& value);
  895.     CHTML_checkbox(const string& name, const string& value,
  896.                    bool checked, const string& description = kEmptyStr);
  897.     ~CHTML_checkbox(void);
  898. };
  901. // <input type=hidden> tag.
  902. class NCBI_XHTML_EXPORT CHTML_hidden : public CHTML_input
  903. {
  904.     typedef CHTML_input CParent;
  905.     static const char sm_InputType[];
  906. public:
  907.     CHTML_hidden(const string& name, const string& value);
  908.     CHTML_hidden(const string& name, int value);
  909.     ~CHTML_hidden(void);
  910. };
  913. // <input type=image> tag.
  914. class NCBI_XHTML_EXPORT CHTML_image : public CHTML_input
  915. {
  916.     typedef CHTML_input CParent;
  917.     static const char sm_InputType[];
  918. public:
  919.     CHTML_image(const string& name, const string& src, 
  920.                 const string& alt = kEmptyStr);
  921.     CHTML_image(const string& name, const string& src, int border,
  922.                 const string& alt = kEmptyStr);
  923.     ~CHTML_image(void);
  924. };
  927. // <input type=radio> tag.
  928. class NCBI_XHTML_EXPORT CHTML_radio : public CHTML_input
  929. {
  930.     typedef CHTML_input CParent;
  931.     static const char sm_InputType[];
  932. public:
  933.     CHTML_radio(const string& name, const string& value);
  934.     CHTML_radio(const string& name, const string& value,
  935.                 bool checked, const string& description = kEmptyStr);
  936.     ~CHTML_radio(void);
  937. };
  940. // <input type=text> tag.
  941. class NCBI_XHTML_EXPORT CHTML_reset : public CHTML_input
  942. {
  943.     typedef CHTML_input CParent;
  944.     static const char sm_InputType[];
  945. public:
  946.     CHTML_reset(const string& label = kEmptyStr);
  947.     ~CHTML_reset(void);
  948. };
  951. // <input type=submit> tag.
  952. class NCBI_XHTML_EXPORT CHTML_submit : public CHTML_input
  953. {
  954.     typedef CHTML_input CParent;
  955.     static const char sm_InputType[];
  956. public:
  957.     CHTML_submit(const string& name);
  958.     CHTML_submit(const string& name, const string& label);
  959.     ~CHTML_submit(void);
  960. };
  963. // <button> tag.
  964. /*
  965.   commented out because it's not supported in most browsers
  966.   class CHTML_button : public CHTMLElement
  967.   {
  968.   typedef CHTMLElement CParent;
  969.   public:
  970.   enum EButtonType {
  971.   eSubmit,
  972.   eReset,
  973.   eButton
  974.   };
  975.   CHTML_button(const string& text, EButtonType type);
  976.   CHTML_button(CNCBINode* contents, EButtonType type);
  977.   CHTML_button(const string& text, const string& name,
  978.   const string& value = kEmptyStr);
  979.   CHTML_button(CNCBINode* contents, const string& name,
  980.   const string& value = kEmptyStr);
  981.   ~CHTML_button(void);
  983.   CHTML_button* SetType(EButtonType type);
  984.   CHTML_button* SetSubmit(const string& name,
  985.   const string& value = kEmptyStr);
  986.   };
  987. */
  990. // <input type=text> tag.
  991. class NCBI_XHTML_EXPORT CHTML_text : public CHTML_input
  992. {
  993.     typedef CHTML_input CParent;
  994.     static const char sm_InputType[];
  995. public:
  996.     CHTML_text(const string& name,
  997.                const string& value = kEmptyStr);
  998.     CHTML_text(const string& name, int size,
  999.                const string& value = kEmptyStr);
  1000.     CHTML_text(const string& name, int size, int maxlength,
  1001.                const string& value = kEmptyStr);
  1002.     ~CHTML_text(void);
  1003. };
  1006. // <input type=file> tag.
  1007. class NCBI_XHTML_EXPORT CHTML_file : public CHTML_input
  1008. {
  1009.     typedef CHTML_input CParent;
  1010.     static const char sm_InputType[];
  1011. public:
  1012.     CHTML_file(const string& name, const string& value = kEmptyStr);
  1013.     ~CHTML_file(void);
  1014. };
  1017. // <select> tag.
  1018. class NCBI_XHTML_EXPORT CHTML_select : public CHTMLElement
  1019. {
  1020.     typedef CHTMLElement CParent;
  1021.     static const char sm_TagName[];
  1022. public:
  1023.     CHTML_select(const string& name, bool multiple = false);
  1024.     CHTML_select(const string& name, int size, bool multiple = false);
  1025.     ~CHTML_select(void);
  1027.     // Return 'this' to allow chained AppendOption().
  1028.     CHTML_select* AppendOption(const string& value, bool selected = false);
  1029.     CHTML_select* AppendOption(const string& value, const char* label,
  1030.                                bool selected = false);
  1031.     CHTML_select* AppendOption(const string& value, const string& label,
  1032.                                bool selected = false);
  1033.     CHTML_select* SetMultiple(void);
  1034. };
  1037. // <option> tag. Rarely used alone. See <select> tag.
  1038. class NCBI_XHTML_EXPORT CHTML_option : public CHTMLElement
  1039. {
  1040.     typedef CHTMLElement CParent;
  1041.     static const char sm_TagName[];
  1042. public:
  1043.     CHTML_option(const string& value, bool selected = false);
  1044.     CHTML_option(const string& value, const char* label,
  1045.                  bool selected = false);
  1046.     CHTML_option(const string& value, const string& label,
  1047.                  bool selected = false);
  1048.     ~CHTML_option(void);
  1050.     CHTML_option* SetValue(const string& value);
  1051.     CHTML_option* SetSelected(void);
  1052. };
  1055. // <a> tag.
  1056. class NCBI_XHTML_EXPORT CHTML_a : public CHTMLInlineElement
  1057. {
  1058.     typedef CHTMLInlineElement CParent;
  1059.     static const char sm_TagName[];
  1060. public:
  1061.     CHTML_a(void);
  1062.     CHTML_a(const string& href);
  1063.     CHTML_a(const string& href, const char* text);
  1064.     CHTML_a(const string& href, const string& text);
  1065.     CHTML_a(const string& href, CNCBINode* node);
  1066.     ~CHTML_a(void);
  1068.     CHTML_a* SetHref(const string& href);
  1069. };
  1072. // <br> tag (break).
  1073. class NCBI_XHTML_EXPORT CHTML_br : public CHTMLOpenElement
  1074. {
  1075.     typedef CHTMLOpenElement CParent;
  1076.     static const char sm_TagName[];
  1077. public:
  1078.     CHTML_br(void);
  1079.     // create "number" of <br> tags
  1080.     CHTML_br(int number);
  1081.     ~CHTML_br(void);
  1083.     virtual CNcbiOstream& PrintBegin(CNcbiOstream &, TMode mode);
  1084. };
  1086. // <img> tag.
  1087. class NCBI_XHTML_EXPORT CHTML_img : public CHTMLOpenElement
  1088. {
  1089.     typedef CHTMLOpenElement CParent;
  1090. public:
  1091.     CHTML_img(const string& url, const string& alt = kEmptyStr);
  1092.     CHTML_img(const string& url, int width, int height, 
  1093.               const string& alt = kEmptyStr);
  1094.     ~CHTML_img(void);
  1095. };
  1098. // <dl> tag.
  1099. class NCBI_XHTML_EXPORT CHTML_dl : public CHTMLElement
  1100. {
  1101.     typedef CHTMLElement CParent;
  1102.     static const char sm_TagName[];
  1103. public:
  1104.     CHTML_dl(bool compact = false);
  1105.     ~CHTML_dl(void);
  1107.     // Return 'this' to allow chained AppendTerm().
  1108.     CHTML_dl* AppendTerm(const string& term, CNCBINode* definition = 0);
  1109.     CHTML_dl* AppendTerm(const string& term, const string& definition);
  1110.     CHTML_dl* AppendTerm(CNCBINode* term, CNCBINode* definition = 0);
  1111.     CHTML_dl* AppendTerm(CNCBINode* term, const string& definition);
  1113.     CHTML_dl* SetCompact(void);
  1114. };
  1117. // <ol> tag.
  1118. class NCBI_XHTML_EXPORT CHTML_ol : public CHTMLListElement
  1119. {
  1120.     typedef CHTMLListElement CParent;
  1121.     static const char sm_TagName[];
  1122. public:
  1123.     CHTML_ol(bool compact = false);
  1124.     CHTML_ol(const char* type, bool compact = false);
  1125.     CHTML_ol(const string& type, bool compact = false);
  1126.     CHTML_ol(int start, bool compact = false);
  1127.     CHTML_ol(int start, const char* type, bool compact = false);
  1128.     CHTML_ol(int start, const string& type, bool compact = false);
  1129.     ~CHTML_ol(void);
  1131.     CHTML_ol* SetStart(int start);
  1132. };
  1135. // <ul> tag.
  1136. class NCBI_XHTML_EXPORT CHTML_ul : public CHTMLListElement
  1137. {
  1138.     typedef CHTMLListElement CParent;
  1139.     static const char sm_TagName[];
  1140. public:
  1141.     CHTML_ul(bool compact = false);
  1142.     CHTML_ul(const char* type, bool compact = false);
  1143.     CHTML_ul(const string& type, bool compact = false);
  1144.     ~CHTML_ul(void);
  1145. };
  1148. // <dir> tag.
  1149. class NCBI_XHTML_EXPORT CHTML_dir : public CHTMLListElement
  1150. {
  1151.     typedef CHTMLListElement CParent;
  1152.     static const char sm_TagName[];
  1153. public:
  1154.     CHTML_dir(bool compact = false);
  1155.     CHTML_dir(const char* type, bool compact = false);
  1156.     CHTML_dir(const string& type, bool compact = false);
  1157.     ~CHTML_dir(void);
  1158. };
  1161. // <menu> tag.
  1162. class NCBI_XHTML_EXPORT CHTML_menu : public CHTMLListElement
  1163. {
  1164.     typedef CHTMLListElement CParent;
  1165.     static const char sm_TagName[];
  1166. public:
  1167.     CHTML_menu(bool compact = false);
  1168.     CHTML_menu(const char* type, bool compact = false);
  1169.     CHTML_menu(const string& type, bool compact = false);
  1170.     ~CHTML_menu(void);
  1171. };
  1174. // <font> tag.
  1175. class NCBI_XHTML_EXPORT CHTML_font : public CHTMLInlineElement
  1176. {
  1177.     typedef CHTMLInlineElement CParent;
  1178.     static const char sm_TagName[];
  1179. public:
  1180.     CHTML_font(void);
  1181.     CHTML_font(int size,
  1182.                CNCBINode* node = 0);
  1183.     CHTML_font(int size,
  1184.                const char* text);
  1185.     CHTML_font(int size,
  1186.                const string& text);
  1187.     CHTML_font(int size, bool absolute,
  1188.                CNCBINode* node = 0);
  1189.     CHTML_font(int size, bool absolute,
  1190.                const string& text);
  1191.     CHTML_font(int size, bool absolute,
  1192.                const char* text);
  1193.     CHTML_font(const string& typeface,
  1194.                CNCBINode* node = 0);
  1195.     CHTML_font(const string& typeface,
  1196.                const string& text);
  1197.     CHTML_font(const string& typeface,
  1198.                const char* text);
  1199.     CHTML_font(const string& typeface, int size,
  1200.                CNCBINode* node = 0);
  1201.     CHTML_font(const string& typeface, int size,
  1202.                const string& text);
  1203.     CHTML_font(const string& typeface, int size,
  1204.                const char* text);
  1205.     CHTML_font(const string& typeface, int size, bool absolute,
  1206.                CNCBINode* node = 0);
  1207.     CHTML_font(const string& typeface, int size, bool absolute,
  1208.                const string& text);
  1209.     CHTML_font(const string& typeface, int size, bool absolute,
  1210.                const char* text);
  1211.     ~CHTML_font(void);
  1213.     CHTML_font* SetTypeFace(const string& typeface);
  1214.     CHTML_font* SetFontSize(int size, bool absolute);
  1215.     CHTML_font* SetRelativeSize(int size);
  1216. };
  1219. class NCBI_XHTML_EXPORT CHTML_basefont : public CHTMLOpenElement
  1220. {
  1221.     typedef CHTMLOpenElement CParent;
  1222.     static const char sm_TagName[];
  1223. public:
  1224.     CHTML_basefont(int size);
  1225.     CHTML_basefont(const string& typeface);
  1226.     CHTML_basefont(const string& typeface, int size);
  1227.     ~CHTML_basefont(void);
  1229.     CHTML_basefont* SetTypeFace(const string& typeface);
  1230. };
  1233. class NCBI_XHTML_EXPORT CHTML_color : public CHTML_font
  1234. {
  1235.     typedef CHTML_font CParent;
  1236. public:
  1237.     CHTML_color(const string& color, CNCBINode* node = 0);
  1238.     CHTML_color(const string& color, const string& text);
  1239.     ~CHTML_color(void);
  1240. };
  1243. // <hr> tag.
  1244. class NCBI_XHTML_EXPORT CHTML_hr : public CHTMLOpenElement
  1245. {
  1246.     typedef CHTMLOpenElement CParent;
  1247.     static const char sm_TagName[];
  1248. public:
  1249.     CHTML_hr(bool noShade = false);
  1250.     CHTML_hr(int size, bool noShade = false);
  1251.     CHTML_hr(int size, int width, bool noShade = false);
  1252.     CHTML_hr(int size, const string& width, bool noShade = false);
  1253.     ~CHTML_hr(void);
  1255.     CHTML_hr* SetNoShade(void);
  1256.     CHTML_hr* SetNoShade(bool noShade);
  1258.     virtual CNcbiOstream& PrintBegin(CNcbiOstream &, TMode mode);
  1259. };
  1262. // <meta> tag.
  1263. class NCBI_XHTML_EXPORT CHTML_meta : public CHTMLOpenElement
  1264. {
  1265.     typedef CHTMLOpenElement CParent;
  1266.     static const char sm_TagName[];
  1267. public:
  1268.     enum EType {
  1269.         eName,
  1270.         eHttpEquiv
  1271.     }; 
  1272.     CHTML_meta(EType mtype, const string& var, const string& content);
  1273.     ~CHTML_meta(void);
  1274. };
  1277. // <scrpt> tag.
  1278. class NCBI_XHTML_EXPORT CHTML_script : public CHTMLElement
  1279. {
  1280.     typedef CHTMLElement CParent;
  1281.     static const char sm_TagName[];
  1282. public:
  1283.     CHTML_script(const string& stype);
  1284.     CHTML_script(const string& stype, const string& url);
  1285.     ~CHTML_script(void);
  1287.     CHTML_script* AppendScript(const string& script);
  1288. };
  1291. // Other tags (default implementation).
  1293. DECLARE_HTML_ELEMENT( head,       CHTMLElement);
  1294. DECLARE_HTML_ELEMENT( body,       CHTMLElement);
  1295. DECLARE_HTML_ELEMENT( base,       CHTMLElement);
  1296. DECLARE_HTML_ELEMENT( isindex,    CHTMLOpenElement);
  1297. DECLARE_HTML_ELEMENT( link,       CHTMLOpenElement);
  1298. DECLARE_HTML_ELEMENT( noscript,   CHTMLElement);
  1299. DECLARE_HTML_ELEMENT( object,     CHTMLElement);
  1300. DECLARE_HTML_ELEMENT( style,      CHTMLElement);
  1301. DECLARE_HTML_ELEMENT( title,      CHTMLElement);
  1302. DECLARE_HTML_ELEMENT( address,    CHTMLElement);
  1303. DECLARE_HTML_ELEMENT( blockquote, CHTMLBlockElement);
  1304. DECLARE_HTML_ELEMENT( center,     CHTMLElement);
  1305. DECLARE_HTML_ELEMENT( div,        CHTMLBlockElement);
  1306. DECLARE_HTML_ELEMENT( h1,         CHTMLBlockElement);
  1307. DECLARE_HTML_ELEMENT( h2,         CHTMLBlockElement);
  1308. DECLARE_HTML_ELEMENT( h3,         CHTMLBlockElement);
  1309. DECLARE_HTML_ELEMENT( h4,         CHTMLBlockElement);
  1310. DECLARE_HTML_ELEMENT( h5,         CHTMLBlockElement);
  1311. DECLARE_HTML_ELEMENT( h6,         CHTMLBlockElement);
  1312. DECLARE_HTML_ELEMENT( p,          CHTMLBlockElement);
  1313. DECLARE_HTML_ELEMENT( pnop,       CHTMLOpenElement);
  1314. DECLARE_HTML_ELEMENT( pre,        CHTMLBlockElement);
  1315. DECLARE_HTML_ELEMENT( dt,         CHTMLElement);
  1316. DECLARE_HTML_ELEMENT( dd,         CHTMLElement);
  1317. DECLARE_HTML_ELEMENT( li,         CHTMLBlockElement);
  1318. DECLARE_HTML_ELEMENT( caption,    CHTMLElement);
  1319. DECLARE_HTML_ELEMENT( col,        CHTMLElement);
  1320. DECLARE_HTML_ELEMENT( colgroup,   CHTMLElement);
  1321. DECLARE_HTML_ELEMENT( thead,      CHTMLElement);
  1322. DECLARE_HTML_ELEMENT( tbody,      CHTMLElement);
  1323. DECLARE_HTML_ELEMENT( tfoot,      CHTMLElement);
  1324. DECLARE_HTML_ELEMENT( th,         CHTML_tc);
  1325. DECLARE_HTML_ELEMENT( td,         CHTML_tc);
  1326. DECLARE_HTML_ELEMENT( applet,     CHTMLElement);
  1327. DECLARE_HTML_ELEMENT( param,      CHTMLOpenElement);
  1328. DECLARE_HTML_ELEMENT( cite,       CHTMLInlineElement);
  1329. DECLARE_HTML_ELEMENT( code,       CHTMLInlineElement);
  1330. DECLARE_HTML_ELEMENT( dfn,        CHTMLElement);
  1331. DECLARE_HTML_ELEMENT( em,         CHTMLInlineElement);
  1332. DECLARE_HTML_ELEMENT( kbd,        CHTMLInlineElement);
  1333. DECLARE_HTML_ELEMENT( samp,       CHTMLElement);
  1334. DECLARE_HTML_ELEMENT( strike,     CHTMLInlineElement);
  1335. DECLARE_HTML_ELEMENT( strong,     CHTMLInlineElement);
  1336. DECLARE_HTML_ELEMENT( var,        CHTMLInlineElement);
  1337. DECLARE_HTML_ELEMENT( b,          CHTMLInlineElement);
  1338. DECLARE_HTML_ELEMENT( big,        CHTMLInlineElement);
  1339. DECLARE_HTML_ELEMENT( i,          CHTMLInlineElement);
  1340. DECLARE_HTML_ELEMENT( s,          CHTMLInlineElement);
  1341. DECLARE_HTML_ELEMENT( small,      CHTMLInlineElement);
  1342. DECLARE_HTML_ELEMENT( sub,        CHTMLInlineElement);
  1343. DECLARE_HTML_ELEMENT( sup,        CHTMLInlineElement);
  1344. DECLARE_HTML_ELEMENT( tt,         CHTMLInlineElement);
  1345. DECLARE_HTML_ELEMENT( u,          CHTMLInlineElement);
  1346. DECLARE_HTML_ELEMENT( blink,      CHTMLInlineElement);
  1347. DECLARE_HTML_ELEMENT( span,       CHTMLInlineElement);
  1348. DECLARE_HTML_ELEMENT( map,        CHTMLElement);
  1349. DECLARE_HTML_ELEMENT( area,       CHTMLElement);
  1351. DECLARE_HTML_SPECIAL_CHAR( nbsp, " ");
  1352. DECLARE_HTML_SPECIAL_CHAR( gt,   ">");
  1353. DECLARE_HTML_SPECIAL_CHAR( lt,   "<");
  1354. DECLARE_HTML_SPECIAL_CHAR( quot, """);
  1355. DECLARE_HTML_SPECIAL_CHAR( amp,  "&");
  1356. DECLARE_HTML_SPECIAL_CHAR( copy, "(c)");
  1357. DECLARE_HTML_SPECIAL_CHAR( reg,  "(r)");
  1360. #include <html/html.inl>
  1363. END_NCBI_SCOPE
  1366. /* @} */
  1369. /*
  1370.  * ===========================================================================
  1371.  * $Log: html.hpp,v $
  1372.  * Revision 1000.5  2004/06/01 19:15:12  gouriano
  1373.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.75
  1374.  *
  1375.  * Revision 1.75  2004/04/05 15:50:49  ivanov
  1376.  * Cosmetic changes
  1377.  *
  1378.  * Revision 1.74  2004/04/01 14:14:01  lavr
  1379.  * Spell "occurred", "occurrence", and "occurring"
  1380.  *
  1381.  * Revision 1.73  2004/02/03 19:45:41  ivanov
  1382.  * Binded dummy names for the unnamed nodes
  1383.  *
  1384.  * Revision 1.72  2004/02/02 14:08:06  ivanov
  1385.  * Added export specifier to the macro for declare HTML classes
  1386.  *
  1387.  * Revision 1.71  2004/01/26 16:26:42  ivanov
  1388.  * Added NOWRAP attribute support
  1389.  *
  1390.  * Revision 1.70  2003/12/31 19:00:45  ivanov
  1391.  * Added default constructor for CHTML_a
  1392.  *
  1393.  * Revision 1.69  2003/12/02 14:18:52  ivanov
  1394.  * AttachPopupMenu() comment changes
  1395.  *
  1396.  * Revision 1.68  2003/11/05 18:41:06  dicuccio
  1397.  * Added export specifiers
  1398.  *
  1399.  * Revision 1.67  2003/11/03 17:02:53  ivanov
  1400.  * Some formal code rearrangement. Move log to end.
  1401.  *
  1402.  * Revision 1.66  2003/11/03 14:47:39  ivanov
  1403.  * Some formal code rearrangement
  1404.  *
  1405.  * Revision 1.65  2003/10/01 15:54:31  ivanov
  1406.  * Added comments for AttachPopupMenu
  1407.  *
  1408.  * Revision 1.64  2003/04/25 13:45:26  siyan
  1409.  * Added doxygen groupings
  1410.  *
  1411.  * Revision 1.63  2003/02/14 16:18:29  ucko
  1412.  * Override CHTMLListItem::PrintChildren (so we can indent them in text
  1413.  * mode); make <li> a block element for proper text display.
  1414.  *
  1415.  * Revision 1.62  2002/12/24 14:56:20  ivanov
  1416.  * Fix for R1.76:  HTML classes for tags <h1-6>, <p>, <div>. <pre>, <blockquote>
  1417.  * now inherits from CHTMLBlockElement (not CHTMElement as before)
  1418.  *
  1419.  * Revision 1.61  2002/12/20 19:19:30  ivanov
  1420.  * Added SPAN tag support
  1421.  *
  1422.  * Revision 1.60  2002/12/09 22:12:25  ivanov
  1423.  * Added support for Sergey Kurdin's popup menu.
  1424.  * Added CHTMLNode::AttachPopupMenu().
  1425.  *
  1426.  * Revision 1.59  2002/09/25 01:24:29  dicuccio
  1427.  * Added CHTMLHelper::StripTags() - strips HTML comments and tags from any
  1428.  * string
  1429.  *
  1430.  * Revision 1.58  2002/02/13 20:17:06  ivanov
  1431.  * Added support of dynamic popup menus. Changed EnablePopupMenu().
  1432.  *
  1433.  * Revision 1.57  2002/01/29 20:00:18  ivanov
  1434.  * (plain text) CHTML_table:: set def. medium sep. to " " instead of "t"
  1435.  *
  1436.  * Revision 1.56  2002/01/28 17:56:43  vakatov
  1437.  * (plain text) CHTML_table:: set def. medium sep. to "t" instead of "t|t"
  1438.  *
  1439.  * Revision 1.55  2002/01/17 23:39:35  ivanov
  1440.  * Added means to print HTML tables in plain text mode
  1441.  *
  1442.  * Revision 1.54  2001/08/14 16:51:33  ivanov
  1443.  * Change mean for init JavaScript popup menu & add it to HTML document.
  1444.  * Remove early redefined classes for tags HEAD and BODY.
  1445.  *
  1446.  * Revision 1.53  2001/07/16 19:45:22  ivanov
  1447.  * Changed default value for JS menu lib path in CHTML_html::InitPopupMenus().
  1448.  *
  1449.  * Revision 1.52  2001/07/16 13:54:42  ivanov
  1450.  * Added support JavaScript popups menu (jsmenu.[ch]pp)
  1451.  *
  1452.  * Revision 1.51  2001/06/08 19:01:41  ivanov
  1453.  * Added base classes: CHTMLDualNode, CHTMLSpecialChar
  1454.  *     (and based on it: CHTML_nbsp, _gt, _lt, _quot, _amp, _copy, _reg)
  1455.  * Added realization for tags <meta> (CHTML_meta) and <script> (CHTML_script)
  1456.  * Changed base class for tags LINK, PARAM, ISINDEX -> CHTMLOpenElement
  1457.  * Added tags: OBJECT, NOSCRIPT
  1458.  * Added attribute "alt" for CHTML_img
  1459.  * Added CHTMLComment::Print() for disable print html-comments in plaintext mode
  1460.  *
  1461.  * Revision 1.50  2001/06/05 15:36:10  ivanov
  1462.  * Added attribute "alt" to CHTML_image
  1463.  *
  1464.  * Revision 1.49  2001/05/17 14:55:24  lavr
  1465.  * Typos corrected
  1466.  *
  1467.  * Revision 1.48  2000/10/18 13:25:46  vasilche
  1468.  * Added missing constructors to CHTML_font.
  1469.  *
  1470.  * Revision 1.47  2000/09/27 14:11:10  vasilche
  1471.  * Newline 'n' will not be generated after tags LABEL, A, FONT, CITE, CODE, EM,
  1472.  * KBD, STRIKE STRONG, VAR, B, BIG, I, S, SMALL, SUB, SUP, TT, U and BLINK.
  1473.  *
  1474.  * Revision 1.46  2000/08/15 19:40:16  vasilche
  1475.  * Added CHTML_label::SetFor() method for setting HTML attribute FOR.
  1476.  *
  1477.  * Revision 1.45  2000/07/25 15:26:00  vasilche
  1478.  * Added newline symbols before table and after each table row in text mode.
  1479.  *
  1480.  * Revision 1.44  2000/07/18 19:08:48  vasilche
  1481.  * Fixed uninitialized members.
  1482.  * Fixed NextCell to advance to next cell.
  1483.  *
  1484.  * Revision 1.43  2000/07/18 17:21:34  vasilche
  1485.  * Added possibility to force output of empty attribute value.
  1486.  * Added caching to CHTML_table, now large tables work much faster.
  1487.  * Changed algorithm of emitting EOL symbols in html output.
  1488.  *
  1489.  * Revision 1.42  2000/07/12 16:37:37  vasilche
  1490.  * Added new HTML4 tags: LABEL, BUTTON, FIELDSET, LEGEND.
  1491.  * Added methods for setting common attributes: STYLE, ID, TITLE, ACCESSKEY.
  1492.  *
  1493.  * Revision 1.41  1999/12/28 21:01:03  vasilche
  1494.  * Fixed conflict on MS VC between bool and const string& arguments by
  1495.  * adding const char* argument.
  1496.  *
  1497.  * Revision 1.40  1999/12/28 18:55:28  vasilche
  1498.  * Reduced size of compiled object files:
  1499.  * 1. avoid inline or implicit virtual methods (especially destructors).
  1500.  * 2. avoid std::string's methods usage in inline methods.
  1501.  * 3. avoid string literals ("xxx") in inline methods.
  1502.  *
  1503.  * Revision 1.39  1999/10/29 18:28:53  vakatov
  1504.  * [MSVC]  bool vs. const string& arg confusion
  1505.  *
  1506.  * Revision 1.38  1999/10/28 13:40:29  vasilche
  1507.  * Added reference counters to CNCBINode.
  1508.  *
  1509.  * Revision 1.37  1999/08/20 16:14:36  golikov
  1510.  * 'non-<TR> tag' bug fixed
  1511.  *
  1512.  * Revision 1.36  1999/05/28 18:04:05  vakatov
  1513.  * CHTMLNode::  added attribute "CLASS"
  1514.  *
  1515.  * Revision 1.35  1999/05/20 16:49:11  pubmed
  1516.  * Changes for SaveAsText: all Print() methods get mode parameter that can be 
  1517.  * HTML or PlainText
  1518.  *
  1519.  * Revision 1.34  1999/05/10 17:01:11  vasilche
  1520.  * Fixed warning on Sun by renaming CHTML_font::SetSize() -> SetFontSize().
  1521.  *
  1522.  * Revision 1.33  1999/05/10 14:26:09  vakatov
  1523.  * Fixes to compile and link with the "egcs" C++ compiler under Linux
  1524.  *
  1525.  * Revision 1.32  1999/04/27 14:49:57  vasilche
  1526.  * Added FastCGI interface.
  1527.  * CNcbiContext renamed to CCgiContext.
  1528.  *
  1529.  * Revision 1.31  1999/04/22 14:20:10  vasilche
  1530.  * Now CHTML_select::AppendOption and CHTML_option constructor accept option
  1531.  * name always as first argument.
  1532.  *
  1533.  * Revision 1.30  1999/04/15 22:05:16  vakatov
  1534.  * Include NCBI C++ headers before the standard ones
  1535.  *
  1536.  * Revision 1.29  1999/04/15 19:48:16  vasilche
  1537.  * Fixed several warnings detected by GCC
  1538.  *
  1539.  * Revision 1.28  1999/04/08 19:00:24  vasilche
  1540.  * Added current cell pointer to CHTML_table
  1541.  *
  1542.  * Revision 1.27  1999/03/01 21:03:27  vasilche
  1543.  * Added CHTML_file input element.
  1544.  * Changed CHTML_form constructors.
  1545.  *
  1546.  * Revision 1.26  1999/02/26 21:03:30  vasilche
  1547.  * CAsnWriteNode made simple node. Use CHTML_pre explicitly.
  1548.  * Fixed bug in CHTML_table::Row.
  1549.  * Added CHTML_table::HeaderCell & DataCell methods.
  1550.  *
  1551.  * Revision 1.25  1999/02/02 17:57:46  vasilche
  1552.  * Added CHTML_table::Row(int row).
  1553.  * Linkbar now have equal image spacing.
  1554.  *
  1555.  * Revision 1.24  1999/01/28 21:58:05  vasilche
  1556.  * QueryBox now inherits from CHTML_table (not CHTML_form as before).
  1557.  * Use 'new CHTML_form("url", queryBox)' as replacement of old QueryBox.
  1558.  *
  1559.  * Revision 1.23  1999/01/28 16:58:58  vasilche
  1560.  * Added several constructors for CHTML_hr.
  1561.  * Added CHTMLNode::SetSize method.
  1562.  *
  1563.  * Revision 1.22  1999/01/25 19:34:14  vasilche
  1564.  * String arguments which are added as HTML text now treated as plain text.
  1565.  *
  1566.  * Revision 1.21  1999/01/21 21:12:54  vasilche
  1567.  * Added/used descriptions for HTML submit/select/text.
  1568.  * Fixed some bugs in paging.
  1569.  * 
  1570.  * Revision 1.20  1999/01/14 21:25:16  vasilche
  1571.  * Changed CPageList to work via form image input elements.
  1572.  *
  1573.  * Revision 1.19  1999/01/11 22:05:48  vasilche
  1574.  * Fixed CHTML_font size.
  1575.  * Added CHTML_image input element.
  1576.  *
  1577.  * Revision 1.18  1999/01/11 15:13:32  vasilche
  1578.  * Fixed CHTML_font size.
  1579.  * CHTMLHelper extracted to separate file.
  1580.  *
  1581.  * Revision 1.17  1999/01/07 16:41:53  vasilche
  1582.  * CHTMLHelper moved to separate file.
  1583.  * TagNames of CHTML classes ara available via s_GetTagName() static
  1584.  * method.
  1585.  * Input tag types ara available via s_GetInputType() static method.
  1586.  * Initial selected database added to CQueryBox.
  1587.  * Background colors added to CPagerBax & CSmallPagerBox.
  1588.  *
  1589.  * Revision 1.16  1999/01/05 21:47:10  vasilche
  1590.  * Added 'current page' to CPageList.
  1591.  * CPageList doesn't display forward/backward if empty.
  1592.  *
  1593.  * Revision 1.15  1999/01/04 20:06:09  vasilche
  1594.  * Redesigned CHTML_table.
  1595.  * Added selection support to HTML forms (via hidden values).
  1596.  *
  1597.  * Revision 1.13  1998/12/28 21:48:12  vasilche
  1598.  * Made Lewis's 'tool' compilable
  1599.  *
  1600.  * Revision 1.12  1998/12/28 16:48:05  vasilche
  1601.  * Removed creation of QueryBox in CHTMLPage::CreateView()
  1602.  * CQueryBox extends from CHTML_form
  1603.  * CButtonList, CPageList, CPagerBox, CSmallPagerBox extend from CNCBINode.
  1604.  *
  1605.  * Revision 1.11  1998/12/24 16:15:36  vasilche
  1606.  * Added CHTMLComment class.
  1607.  * Added TagMappers from static functions.
  1608.  *
  1609.  * Revision 1.10  1998/12/23 21:20:56  vasilche
  1610.  * Added more HTML tags (almost all).
  1611.  * Importent ones: all lists (OL, UL, DIR, MENU), fonts (FONT, BASEFONT).
  1612.  *
  1613.  * Revision 1.9  1998/12/23 14:28:07  vasilche
  1614.  * Most of closed HTML tags made via template.
  1615.  *
  1616.  * Revision 1.8  1998/12/21 22:24:56  vasilche
  1617.  * A lot of cleaning.
  1618.  *
  1619.  * Revision 1.7  1998/12/09 23:02:55  lewisg
  1620.  * update to new cgiapp class
  1621.  *
  1622.  * Revision 1.6  1998/12/08 00:34:55  lewisg
  1623.  * cleanup
  1624.  *
  1625.  * Revision 1.5  1998/12/03 22:49:10  lewisg
  1626.  * added HTMLEncode() and CHTML_img
  1627.  *
  1628.  * Revision 1.4  1998/12/01 19:09:05  lewisg
  1629.  * uses CCgiApplication and new page factory
  1630.  * ===========================================================================
  1631.  */
  1633. #endif  /* HTML___HTML__HPP */