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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
html.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：30k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

html.cxx：源码内容
  1. /*
  2.  * html.cxx
  3.  *
  4.  * HTML classes.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: html.cxx,v $
  30.  * Revision 1.17  1998/11/30 04:51:51  robertj
  31.  * New directory structure
  32.  *
  33.  * Revision 1.16  1998/09/23 06:22:04  robertj
  34.  * Added open source copyright license.
  35.  *
  36.  * Revision 1.15  1998/01/26 02:49:15  robertj
  37.  * GNU support.
  38.  *
  39.  * Revision 1.14  1997/06/16 13:18:03  robertj
  40.  * Set Is() function to be const as it should have been.
  41.  *
  42.  * Revision 1.13  1996/08/19 13:40:31  robertj
  43.  * Fixed incorrect formatting of HTML tags (cosmetic only).
  44.  *
  45.  * Revision 1.12  1996/06/28 13:08:55  robertj
  46.  * Changed PHTML class so can create html fragments.
  47.  * Fixed nesting problem in tables.
  48.  *
  49.  * Revision 1.11  1996/06/01 04:18:45  robertj
  50.  * Fixed bug in RadioButton, having 2 VALUE fields
  51.  *
  52.  * Revision 1.10  1996/04/29 12:21:22  robertj
  53.  * Fixed spelling error in assert.
  54.  * Fixed check box HTML, should always have a value.
  55.  * Added display of value of unclosed HTML element.
  56.  *
  57.  * Revision 1.9  1996/04/14 02:52:04  robertj
  58.  * Added hidden fields to HTML.
  59.  *
  60.  * Revision 1.8  1996/03/31 09:03:07  robertj
  61.  * Changed HTML token so doesn't have trailing CRLF.
  62.  *
  63.  * Revision 1.7  1996/03/16 04:54:06  robertj
  64.  * Made the assert for unclosed HTML elements only on debug version.
  65.  *
  66.  * Revision 1.6  1996/03/12 11:30:33  robertj
  67.  * Fixed resetting of HTML output using operator=.
  68.  *
  69.  * Revision 1.5  1996/03/10 13:14:55  robertj
  70.  * Simplified some of the classes and added catch all string for attributes.
  71.  *
  72.  * Revision 1.4  1996/02/25 11:14:22  robertj
  73.  * Radio button support for forms.
  74.  *
  75.  * Revision 1.3  1996/02/19 13:31:51  robertj
  76.  * Removed MSC_VER test as now completely removed from WIN16 library.
  77.  *
  78.  * Revision 1.2  1996/02/08 12:24:30  robertj
  79.  * Further implementation.
  80.  *
  81.  * Revision 1.1  1996/02/03 11:18:46  robertj
  82.  * Initial revision
  83.  *
  84.  * Revision 1.3  1996/01/28 02:49:16  robertj
  85.  * Further implementation.
  86.  *
  87.  * Revision 1.2  1996/01/26 02:24:30  robertj
  88.  * Further implemetation.
  89.  *
  90.  * Revision 1.1  1996/01/23 13:04:32  robertj
  91.  * Initial revision
  92.  *
  93.  */
  95. #ifdef __GNUC__
  96. #pragma implementation "html.h"
  97. #endif
  99. #include <ptlib.h>
  100. #include <ptclib/html.h>
  103. //////////////////////////////////////////////////////////////////////////////
  104. // PHTML
  106. PHTML::PHTML(ElementInSet initialState)
  107. {
  108.   memset(elementSet, 0, sizeof(elementSet));
  109.   tableNestLevel = 0;
  110.   initialElement = initialState;
  111.   switch (initialState) {
  112.     case NumElementsInSet :
  113.       break;
  114.     case InBody :
  115.       Set(InBody);
  116.       break;
  117.     case InForm :
  118.       Set(InBody);
  119.       Set(InForm);
  120.       break;
  121.     default :
  122.       PAssertAlways(PInvalidParameter);
  123.   }
  124. }
  127. PHTML::PHTML(const char * cstr)
  128. {
  129.   memset(elementSet, 0, sizeof(elementSet));
  130.   tableNestLevel = 0;
  131.   initialElement = NumElementsInSet;
  132.   *this << Title(cstr) << Body() << Heading(1) << cstr << Heading(1);
  133. }
  136. PHTML::PHTML(const PString & str)
  137. {
  138.   memset(elementSet, 0, sizeof(elementSet));
  139.   tableNestLevel = 0;
  140.   initialElement = NumElementsInSet;
  141.   *this << Title(str) << Body() << Heading(1) << str << Heading(1);
  142. }
  145. PHTML::~PHTML()
  146. {
  147. #ifndef NDEBUG
  148.   if (initialElement != NumElementsInSet) {
  149.     Clr(initialElement);
  150.     Clr(InBody);
  151.   }
  152.   for (PINDEX i = 0; i < PARRAYSIZE(elementSet); i++)
  153.     PAssert(elementSet[i] == 0, psprintf("Failed to close element %u", i));
  154. #endif
  155. }
  158. PHTML & PHTML::operator=(const char * cstr)
  159. {
  160.   PStringStream::operator=("");
  161.   memset(elementSet, 0, sizeof(elementSet));
  162.   if (cstr != NULL && *cstr != '')
  163.     *this << Title(cstr) << Body() << Heading(1) << cstr << Heading(1);
  164.   return *this;
  165. }
  168. PHTML & PHTML::operator=(const PString & str)
  169. {
  170.   return operator=((const char *)str);
  171. }
  174. PHTML & PHTML::operator=(const PHTML &)
  175. {
  176.   PAssertAlways(PLogicError);
  177.   return *this;
  178. }
  181. BOOL PHTML::Is(ElementInSet elmt) const
  182. {
  183.   return (elementSet[elmt>>3]&(1<<(elmt&7))) != 0;
  184. }
  187. void PHTML::Set(ElementInSet elmt)
  188. {
  189.   elementSet[elmt>>3] |= (1<<(elmt&7));
  190. }
  193. void PHTML::Clr(ElementInSet elmt)
  194. {
  195.   elementSet[elmt>>3] &= ~(1<<(elmt&7));
  196. }
  199. void PHTML::Toggle(ElementInSet elmt)
  200. {
  201.   elementSet[elmt>>3] ^= (1<<(elmt&7));
  202. }
  205. void PHTML::Element::Output(PHTML & html) const
  206. {
  207.   PAssert(reqElement == NumElementsInSet || html.Is(reqElement),
  208.                                                 "HTML element out of context");
  210.   if (crlf == BothCRLF || (crlf == OpenCRLF && !html.Is(inElement)))
  211.     html << "rn";
  213.   html << '<';
  214.   if (html.Is(inElement))
  215.     html << '/';
  216.   html << name;
  218.   AddAttr(html);
  220.   if (attr != NULL)
  221.     html << ' ' << attr;
  223.   html << '>';
  224.   if (crlf == BothCRLF || (crlf == CloseCRLF && html.Is(inElement)))
  225.     html << "rn";
  227.   if (inElement != NumElementsInSet)
  228.     html.Toggle(inElement);
  229. }
  232. void PHTML::Element::AddAttr(PHTML &) const
  233. {
  234. }
  237. PHTML::HTML::HTML(const char * attr)
  238.   : Element("HTML", attr, InHTML, NumElementsInSet, BothCRLF)
  239. {
  240. }
  242. PHTML::Head::Head()
  243.   : Element("HEAD", NULL, InHead, NumElementsInSet, BothCRLF)
  244. {
  245. }
  247. void PHTML::Head::Output(PHTML & html) const
  248. {
  249.   PAssert(!html.Is(InBody), "HTML element out of context");
  250.   if (!html.Is(InHTML))
  251.     html << HTML();
  252.   Element::Output(html);
  253. }
  256. PHTML::Body::Body(const char * attr)
  257.   : Element("BODY", attr, InBody, NumElementsInSet, BothCRLF)
  258. {
  259. }
  262. void PHTML::Body::Output(PHTML & html) const
  263. {
  264.   if (!html.Is(InHTML))
  265.     html << HTML();
  266.   if (html.Is(InTitle))
  267.     html << Title();
  268.   if (html.Is(InHead))
  269.     html << Head();
  270.   Element::Output(html);
  271.   if (!html.Is(InBody))
  272.     html << HTML();
  273. }
  276. PHTML::Title::Title()
  277.   : Element("TITLE", NULL, InTitle, InHead, CloseCRLF)
  278. {
  279.   titleString = NULL;
  280. }
  282. PHTML::Title::Title(const char * titleCStr)
  283.   : Element("TITLE", NULL, InTitle, InHead, CloseCRLF)
  284. {
  285.   titleString = titleCStr;
  286. }
  288. PHTML::Title::Title(const PString & titleStr)
  289.   : Element("TITLE", NULL, InTitle, InHead, CloseCRLF)
  290. {
  291.   titleString = titleStr;
  292. }
  294. void PHTML::Title::Output(PHTML & html) const
  295. {
  296.   PAssert(!html.Is(InBody), "HTML element out of context");
  297.   if (!html.Is(InHead))
  298.     html << Head();
  299.   if (html.Is(InTitle)) {
  300.     if (titleString != NULL)
  301.       html << titleString;
  302.     Element::Output(html);
  303.   }
  304.   else {
  305.     Element::Output(html);
  306.     if (titleString != NULL) {
  307.       html << titleString;
  308.       Element::Output(html);
  309.     }
  310.   }
  311. }
  314. PHTML::Banner::Banner(const char * attr)
  315.   : Element("BANNER", attr, NumElementsInSet, InBody, BothCRLF)
  316. {
  317. }
  320. PHTML::Division::Division(const char * attr)
  321.   : Element("DIV", attr, InDivision, InBody, BothCRLF)
  322. {
  323. }
  326. PHTML::Heading::Heading(int number,
  327.                         int sequence,
  328.                         int skip,
  329.                         const char * attr)
  330.   : Element("H", attr, InHeading, InBody, CloseCRLF)
  331. {
  332.   num = number;
  333.   srcString = NULL;
  334.   seqNum = sequence;
  335.   skipSeq = skip;
  336. }
  338. PHTML::Heading::Heading(int number,
  339.                         const char * image,
  340.                         int sequence,
  341.                         int skip,
  342.                         const char * attr)
  343.   : Element("H", attr, InHeading, InBody, CloseCRLF)
  344. {
  345.   num = number;
  346.   srcString = image;
  347.   seqNum = sequence;
  348.   skipSeq = skip;
  349. }
  351. PHTML::Heading::Heading(int number,
  352.                         const PString & imageStr,
  353.                         int sequence,
  354.                         int skip,
  355.                         const char * attr)
  356.   : Element("H", attr, InHeading, InBody, CloseCRLF)
  357. {
  358.   num = number;
  359.   srcString = imageStr;
  360.   seqNum = sequence;
  361.   skipSeq = skip;
  362. }
  364. void PHTML::Heading::AddAttr(PHTML & html) const
  365. {
  366.   PAssert(num >= 1 && num <= 6, "Bad heading number");
  367.   html << num;
  368.   if (srcString != NULL)
  369.     html << " SRC="" << srcString << '"';
  370.   if (seqNum > 0)
  371.     html << " SEQNUM=" << seqNum;
  372.   if (skipSeq > 0)
  373.     html << " SKIP=" << skipSeq;
  374. }
  377. PHTML::BreakLine::BreakLine(const char * attr)
  378.   : Element("BR", attr, NumElementsInSet, InBody, CloseCRLF)
  379. {
  380. }
  383. PHTML::Paragraph::Paragraph(const char * attr)
  384.   : Element("P", attr, NumElementsInSet, InBody, OpenCRLF)
  385. {
  386. }
  389. PHTML::PreFormat::PreFormat(int widthInChars, const char * attr)
  390.   : Element("PRE", attr, InPreFormat, InBody, CloseCRLF)
  391. {
  392.   width = widthInChars;
  393. }
  396. void PHTML::PreFormat::AddAttr(PHTML & html) const
  397. {
  398.   if (width > 0)
  399.     html << " WIDTH=" << width;
  400. }
  403. PHTML::HotLink::HotLink(const char * href, const char * attr)
  404.   : Element("A", attr, InAnchor, InBody, NoCRLF)
  405. {
  406.   hrefString = href;
  407. }
  409. void PHTML::HotLink::AddAttr(PHTML & html) const
  410. {
  411.   if (hrefString != NULL && *hrefString != '')
  412.     html << " HREF="" << hrefString << '"';
  413.   else
  414.     PAssert(html.Is(InAnchor), PInvalidParameter);
  415. }
  418. PHTML::Target::Target(const char * name, const char * attr)
  419.   : Element("A", attr, NumElementsInSet, InBody, NoCRLF)
  420. {
  421.   nameString = name;
  422. }
  424. void PHTML::Target::AddAttr(PHTML & html) const
  425. {
  426.   if (nameString != NULL && *nameString != '')
  427.     html << " NAME="" << nameString << '"';
  428. }
  431. PHTML::ImageElement::ImageElement(const char * n,
  432.                                   const char * attr,
  433.                                   ElementInSet elmt,
  434.                                   ElementInSet req,
  435.                                   OptionalCRLF c,
  436.                                   const char * image)
  437.   : Element(n, attr, elmt, req, c)
  438. {
  439.   srcString = image;
  440. }
  443. void PHTML::ImageElement::AddAttr(PHTML & html) const
  444. {
  445.   if (srcString != NULL)
  446.     html << " SRC="" << srcString << '"';
  447. }
  450. PHTML::Image::Image(const char * src, int w, int h, const char * attr)
  451.   : ImageElement("IMG", attr, NumElementsInSet, InBody, NoCRLF, src)
  452. {
  453.   altString = NULL;
  454.   width = w;
  455.   height = h;
  456. }
  458. PHTML::Image::Image(const char * src,
  459.                     const char * alt,
  460.                     int w, int h,
  461.                     const char * attr)
  462.   : ImageElement("IMG", attr, NumElementsInSet, InBody, NoCRLF, src)
  463. {
  464.   altString = alt;
  465.   width = w;
  466.   height = h;
  467. }
  469. void PHTML::Image::AddAttr(PHTML & html) const
  470. {
  471.   PAssert(srcString != NULL && *srcString != '', PInvalidParameter);
  472.   if (altString != NULL)
  473.     html << " ALT="" << altString << '"';
  474.   if (width != 0)
  475.     html << " WIDTH=" << width;
  476.   if (height != 0)
  477.     html << " HEIGHT=" << height;
  478.   ImageElement::AddAttr(html);
  479. }
  482. PHTML::HRule::HRule(const char * image, const char * attr)
  483.   : ImageElement("HR", attr, NumElementsInSet, InBody, BothCRLF, image)
  484. {
  485. }
  488. PHTML::Note::Note(const char * image, const char * attr)
  489.   : ImageElement("NOTE", attr, InNote, InBody, BothCRLF, image)
  490. {
  491. }
  494. PHTML::Address::Address(const char * attr)
  495.   : Element("ADDRESS", attr, InAddress, InBody, BothCRLF)
  496. {
  497. }
  500. PHTML::BlockQuote::BlockQuote(const char * attr)
  501.   : Element("BQ", attr, InBlockQuote, InBody, BothCRLF)
  502. {
  503. }
  506. PHTML::Credit::Credit(const char * attr)
  507.   : Element("CREDIT", attr, NumElementsInSet, InBlockQuote, OpenCRLF)
  508. {
  509. }
  511. PHTML::SetTab::SetTab(const char * id, const char * attr)
  512.   : Element("TAB", attr, NumElementsInSet, InBody, NoCRLF)
  513. {
  514.   ident = id;
  515. }
  517. void PHTML::SetTab::AddAttr(PHTML & html) const
  518. {
  519.   PAssert(ident != NULL && *ident != '', PInvalidParameter);
  520.   html << " ID=" << ident;
  521. }
  524. PHTML::Tab::Tab(int indent, const char * attr)
  525.   : Element("TAB", attr, NumElementsInSet, InBody, NoCRLF)
  526. {
  527.   ident = NULL;
  528.   indentSize = indent;
  529. }
  531. PHTML::Tab::Tab(const char * id, const char * attr)
  532.   : Element("TAB", attr, NumElementsInSet, InBody, NoCRLF)
  533. {
  534.   ident = id;
  535.   indentSize = 0;
  536. }
  538. void PHTML::Tab::AddAttr(PHTML & html) const
  539. {
  540.   PAssert(indentSize!=0 || (ident!=NULL && *ident!=''), PInvalidParameter);
  541.   if (indentSize > 0)
  542.     html << " INDENT=" << indentSize;
  543.   else
  544.     html << " TO=" << ident;
  545. }
  548. PHTML::SimpleList::SimpleList(const char * attr)
  549.   : Element("UL", attr, InList, InBody, BothCRLF)
  550. {
  551. }
  553. void PHTML::SimpleList::AddAttr(PHTML & html) const
  554. {
  555.   html << " PLAIN";
  556. }
  559. PHTML::BulletList::BulletList(const char * attr)
  560.   : Element("UL", attr, InList, InBody, BothCRLF)
  561. {
  562. }
  565. PHTML::OrderedList::OrderedList(int seqNum, const char * attr)
  566.   : Element("OL", attr, InList, InBody, BothCRLF)
  567. {
  568.   sequenceNum = seqNum;
  569. }
  571. void PHTML::OrderedList::AddAttr(PHTML & html) const
  572. {
  573.   if (sequenceNum > 0)
  574.     html << " SEQNUM=" << sequenceNum;
  575.   if (sequenceNum < 0)
  576.     html << " CONTINUE";
  577. }
  580. PHTML::DefinitionList::DefinitionList(const char * attr)
  581.   : Element("DL", attr, InList, InBody, BothCRLF)
  582. {
  583. }
  586. PHTML::ListHeading::ListHeading(const char * attr)
  587.   : Element("LH", attr, InListHeading, InList, CloseCRLF)
  588. {
  589. }
  591. PHTML::ListItem::ListItem(int skip, const char * attr)
  592.   : Element("LI", attr, NumElementsInSet, InList, OpenCRLF)
  593. {
  594.   skipSeq = skip;
  595. }
  597. void PHTML::ListItem::AddAttr(PHTML & html) const
  598. {
  599.   if (skipSeq > 0)
  600.     html << " SKIP=" << skipSeq;
  601. }
  604. PHTML::DefinitionTerm::DefinitionTerm(const char * attr)
  605.   : Element("DT", attr, NumElementsInSet, InList, NoCRLF)
  606. {
  607. }
  609. void PHTML::DefinitionTerm::Output(PHTML & html) const
  610. {
  611.   PAssert(!html.Is(InDefinitionTerm), "HTML definition item missing");
  612.   Element::Output(html);
  613.   html.Set(InDefinitionTerm);
  614. }
  617. PHTML::DefinitionItem::DefinitionItem(const char * attr)
  618.   : Element("DD", attr, NumElementsInSet, InList, NoCRLF)
  619. {
  620. }
  622. void PHTML::DefinitionItem::Output(PHTML & html) const
  623. {
  624.   PAssert(html.Is(InDefinitionTerm), "HTML definition term missing");
  625.   Element::Output(html);
  626.   html.Clr(InDefinitionTerm);
  627. }
  630. PHTML::TableStart::TableStart(const char * attr)
  631.   : Element("TABLE", attr, InTable, InBody, BothCRLF)
  632. {
  633.   borderFlag = FALSE;
  634. }
  636. PHTML::TableStart::TableStart(BorderCodes border, const char * attr)
  637.   : Element("TABLE", attr, InTable, InBody, BothCRLF)
  638. {
  639.   borderFlag = border == Border;
  640. }
  642. void PHTML::TableStart::Output(PHTML & html) const
  643. {
  644.   if (html.tableNestLevel > 0)
  645.     html.Clr(InTable);
  646.   Element::Output(html);
  647. }
  649. void PHTML::TableStart::AddAttr(PHTML & html) const
  650. {
  651.   if (borderFlag)
  652.     html << " BORDER";
  653.   html.tableNestLevel++;
  654. }
  657. PHTML::TableEnd::TableEnd()
  658.   : Element("TABLE", "", InTable, InBody, BothCRLF)
  659. {
  660. }
  662. void PHTML::TableEnd::Output(PHTML & html) const
  663. {
  664.   PAssert(html.tableNestLevel > 0, "Table nesting error");
  665.   Element::Output(html);
  666.   html.tableNestLevel--;
  667.   if (html.tableNestLevel > 0)
  668.     html.Set(InTable);
  669. }
  672. PHTML::TableRow::TableRow(const char * attr)
  673.   : Element("TR", attr, NumElementsInSet, InTable, OpenCRLF)
  674. {
  675. }
  678. PHTML::TableHeader::TableHeader(const char * attr)
  679.   : Element("TH", attr, NumElementsInSet, InTable, CloseCRLF)
  680. {
  681. }
  684. PHTML::TableData::TableData(const char * attr)
  685.   : Element("TD", attr, NumElementsInSet, InTable, NoCRLF)
  686. {
  687. }
  690. PHTML::Form::Form(const char * method,
  691.                   const char * action,
  692.                   const char * mimeType,
  693.                   const char * script)
  694.   : Element("FORM", NULL, InForm, InBody, BothCRLF)
  695. {
  696.   methodString = method;
  697.   actionString = action;
  698.   mimeTypeString = mimeType;
  699.   scriptString = script;
  700. }
  702. void PHTML::Form::AddAttr(PHTML & html) const
  703. {
  704.   if (methodString != NULL)
  705.     html << " METHOD=" << methodString;
  706.   if (actionString != NULL)
  707.     html << " ACTION="" << actionString << '"';
  708.   if (mimeTypeString != NULL)
  709.     html << " ENCTYPE="" << mimeTypeString << '"';
  710.   if (scriptString != NULL)
  711.     html << " SCRIPT="" << scriptString << '"';
  712. }
  715. PHTML::FieldElement::FieldElement(const char * n,
  716.                                   const char * attr,
  717.                                   ElementInSet elmt,
  718.                                   OptionalCRLF c,
  719.                                   DisableCodes disabled)
  720.   : Element(n, attr, elmt, InForm, c)
  721. {
  722.   disabledFlag = disabled == Disabled;
  723. }
  725. void PHTML::FieldElement::AddAttr(PHTML & html) const
  726. {
  727.   if (disabledFlag)
  728.     html << " DISABLED";
  729. }
  732. PHTML::Select::Select(const char * fname, const char * attr)
  733.   : FieldElement("SELECT", attr, InSelect, BothCRLF, Enabled)
  734. {
  735.   nameString = fname;
  736. }
  738. PHTML::Select::Select(const char * fname,
  739.                       DisableCodes disabled,
  740.                       const char * attr)
  741.   : FieldElement("SELECT", attr, InSelect, BothCRLF, disabled)
  742. {
  743.   nameString = fname;
  744. }
  746. void PHTML::Select::AddAttr(PHTML & html) const
  747. {
  748.   if (!html.Is(InSelect)) {
  749.     PAssert(nameString != NULL && *nameString != '', PInvalidParameter);
  750.     html << " NAME="" << nameString << '"';
  751.   }
  752.   FieldElement::AddAttr(html);
  753. }
  756. PHTML::Option::Option(const char * attr)
  757.   : FieldElement("OPTION", attr, NumElementsInSet, NoCRLF, Enabled)
  758. {
  759.   selectedFlag = FALSE;
  760. }
  762. PHTML::Option::Option(SelectionCodes select,
  763.                       const char * attr)
  764.   : FieldElement("OPTION", attr, NumElementsInSet, NoCRLF, Enabled)
  765. {
  766.   selectedFlag = select == Selected;
  767. }
  769. PHTML::Option::Option(DisableCodes disabled,
  770.                       const char * attr)
  771.   : FieldElement("OPTION", attr, NumElementsInSet, NoCRLF, disabled)
  772. {
  773.   selectedFlag = FALSE;
  774. }
  776. PHTML::Option::Option(SelectionCodes select,
  777.                       DisableCodes disabled,
  778.                       const char * attr)
  779.   : FieldElement("OPTION", attr, NumElementsInSet, NoCRLF, disabled)
  780. {
  781.   selectedFlag = select == Selected;
  782. }
  784. void PHTML::Option::AddAttr(PHTML & html) const
  785. {
  786.   if (selectedFlag)
  787.     html << " SELECTED";
  788.   FieldElement::AddAttr(html);
  789. }
  792. PHTML::FormField::FormField(const char * n,
  793.                             const char * attr,
  794.                             ElementInSet elmt,
  795.                             OptionalCRLF c,
  796.                             DisableCodes disabled,
  797.                             const char * fname)
  798.   : FieldElement(n, attr, elmt, c, disabled)
  799. {
  800.   nameString = fname;
  801. }
  803. void PHTML::FormField::AddAttr(PHTML & html) const
  804. {
  805.   PAssert(nameString != NULL && *nameString != '', PInvalidParameter);
  806.   html << " NAME="" << nameString << '"';
  807.   FieldElement::AddAttr(html);
  808. }
  811. PHTML::TextArea::TextArea(const char * fname,
  812.                           DisableCodes disabled,
  813.                           const char * attr)
  814.   : FormField("TEXTAREA", attr, InSelect, BothCRLF, disabled, fname)
  815. {
  816.   numRows = numCols = 0;
  817. }
  819. PHTML::TextArea::TextArea(const char * fname,
  820.                           int rows, int cols,
  821.                           DisableCodes disabled,
  822.                           const char * attr)
  823.   : FormField("TEXTAREA", attr, InSelect, BothCRLF, disabled, fname)
  824. {
  825.   numRows = rows;
  826.   numCols = cols;
  827. }
  829. void PHTML::TextArea::AddAttr(PHTML & html) const
  830. {
  831.   if (numRows > 0)
  832.     html << " ROWS=" << numRows;
  833.   if (numCols > 0)
  834.     html << " COLS=" << numCols;
  835.   FormField::AddAttr(html);
  836. }
  839. PHTML::InputField::InputField(const char * type,
  840.                               const char * fname,
  841.                               DisableCodes disabled,
  842.                               const char * attr)
  843.   : FormField("INPUT", attr, NumElementsInSet, NoCRLF, disabled, fname)
  844. {
  845.   typeString = type;
  846. }
  848. void PHTML::InputField::AddAttr(PHTML & html) const
  849. {
  850.   PAssert(typeString != NULL && *typeString != '', PInvalidParameter);
  851.   html << " TYPE=" << typeString;
  852.   FormField::AddAttr(html);
  853. }
  856. PHTML::HiddenField::HiddenField(const char * fname,
  857.                                 const char * value,
  858.                                 const char * attr)
  859.   : InputField("hidden", fname, Enabled, attr)
  860. {
  861.   valueString = value;
  862. }
  864. void PHTML::HiddenField::AddAttr(PHTML & html) const
  865. {
  866.   InputField::AddAttr(html);
  867.   PAssert(valueString != NULL, PInvalidParameter);
  868.   html << " VALUE="" << valueString << '"';
  869. }
  872. PHTML::InputText::InputText(const char * fname,
  873.                             int size,
  874.                             const char * init,
  875.                             const char * attr)
  876.   : InputField("text", fname, Enabled, attr)
  877. {
  878.   width = size;
  879.   length = 0;
  880.   value = init;
  881. }
  883. PHTML::InputText::InputText(const char * fname,
  884.                             int size,
  885.                             DisableCodes disabled,
  886.                             const char * attr)
  887.   : InputField("text", fname, disabled, attr)
  888. {
  889.   width = size;
  890.   length = 0;
  891.   value = NULL;
  892. }
  894. PHTML::InputText::InputText(const char * fname,
  895.                             int size,
  896.                             int maxLength,
  897.                             DisableCodes disabled,
  898.                             const char * attr)
  899.   : InputField("text", fname, disabled, attr)
  900. {
  901.   width = size;
  902.   length = maxLength;
  903.   value = NULL;
  904. }
  906. PHTML::InputText::InputText(const char * fname,
  907.                             int size,
  908.                             const char * init,
  909.                             int maxLength,
  910.                             DisableCodes disabled,
  911.                             const char * attr)
  912.   : InputField("text", fname, disabled, attr)
  913. {
  914.   width = size;
  915.   length = maxLength;
  916.   value = init;
  917. }
  919. PHTML::InputText::InputText(const char * type,
  920.                             const char * fname,
  921.                             int size,
  922.                             const char * init,
  923.                             int maxLength,
  924.                             DisableCodes disabled,
  925.                             const char * attr)
  926.   : InputField(type, fname, disabled, attr)
  927. {
  928.   width = size;
  929.   length = maxLength;
  930.   value = init;
  931. }
  933. void PHTML::InputText::AddAttr(PHTML & html) const
  934. {
  935.   InputField::AddAttr(html);
  936.   html << " SIZE=" << width;
  937.   if (length > 0)
  938.     html << " MAXLENGTH=" << length;
  939.   if (value != NULL)
  940.     html << " VALUE="" << value << '"';
  941. }
  944. PHTML::InputPassword::InputPassword(const char * fname,
  945.                                     int size,
  946.                                     const char * init,
  947.                                     const char * attr)
  948.   : InputText("password", fname, size, init, 0, Enabled, attr)
  949. {
  950. }
  952. PHTML::InputPassword::InputPassword(const char * fname,
  953.                                     int size,
  954.                                     DisableCodes disabled,
  955.                                     const char * attr)
  956.   : InputText("password", fname, size, NULL, 0, disabled, attr)
  957. {
  958. }
  960. PHTML::InputPassword::InputPassword(const char * fname,
  961.                                     int size,
  962.                                     int maxLength,
  963.                                     DisableCodes disabled,
  964.                                     const char * attr)
  965.   : InputText("password", fname, size, NULL, maxLength, disabled, attr)
  966. {
  967. }
  969. PHTML::InputPassword::InputPassword(const char * fname,
  970.                                     int size,
  971.                                     const char * init,
  972.                                     int maxLength,
  973.                                     DisableCodes disabled,
  974.                                     const char * attr)
  975.   : InputText("password", fname, size, init, maxLength, disabled, attr)
  976. {
  977. }
  980. PHTML::RadioButton::RadioButton(const char * fname,
  981.                                 const char * value,
  982.                                 const char * attr)
  983.   : InputField("radio", fname, Enabled, attr)
  984. {
  985.   valueString = value;
  986.   checkedFlag = FALSE;
  987. }
  989. PHTML::RadioButton::RadioButton(const char * fname,
  990.                                 const char * value,
  991.                                 DisableCodes disabled,
  992.                                 const char * attr)
  993.   : InputField("radio", fname, disabled, attr)
  994. {
  995.   valueString = value;
  996.   checkedFlag = FALSE;
  997. }
  999. PHTML::RadioButton::RadioButton(const char * fname,
  1000.                                 const char * value,
  1001.                                 CheckedCodes check,
  1002.                                 DisableCodes disabled,
  1003.                                 const char * attr)
  1004.   : InputField("radio", fname, disabled, attr)
  1005. {
  1006.   valueString = value;
  1007.   checkedFlag = check == Checked;
  1008. }
  1010. PHTML::RadioButton::RadioButton(const char * type,
  1011.                                 const char * fname,
  1012.                                 const char * value,
  1013.                                 CheckedCodes check,
  1014.                                 DisableCodes disabled,
  1015.                                 const char * attr)
  1016.   : InputField(type, fname, disabled, attr)
  1017. {
  1018.   valueString = value;
  1019.   checkedFlag = check == Checked;
  1020. }
  1022. void PHTML::RadioButton::AddAttr(PHTML & html) const
  1023. {
  1024.   InputField::AddAttr(html);
  1025.   PAssert(valueString != NULL, PInvalidParameter);
  1026.   html << " VALUE=" << valueString;
  1027.   if (checkedFlag)
  1028.     html << " CHECKED";
  1029. }
  1032. PHTML::CheckBox::CheckBox(const char * fname, const char * attr)
  1033.   : RadioButton("checkbox", fname, "TRUE", UnChecked, Enabled, attr)
  1034. {
  1035. }
  1037. PHTML::CheckBox::CheckBox(const char * fname,
  1038.                           DisableCodes disabled,
  1039.                           const char * attr)
  1040.   : RadioButton("checkbox", fname, "TRUE", UnChecked, disabled, attr)
  1041. {
  1042. }
  1044. PHTML::CheckBox::CheckBox(const char * fname,
  1045.                           CheckedCodes check,
  1046.                           DisableCodes disabled,
  1047.                           const char * attr)
  1048.   : RadioButton("checkbox", fname, "TRUE", check, disabled, attr)
  1049. {
  1050. }
  1053. PHTML::InputRange::InputRange(const char * fname,
  1054.                               int min, int max, int value,
  1055.                               DisableCodes disabled,
  1056.                               const char * attr)
  1057.   : InputField("range", fname, disabled, attr)
  1058. {
  1059.   PAssert(min <= max, PInvalidParameter);
  1060.   minValue = min;
  1061.   maxValue = max;
  1062.   if (value < min)
  1063.     initValue = min;
  1064.   else if (value > max)
  1065.     initValue = max;
  1066.   else
  1067.     initValue = value;
  1068. }
  1070. void PHTML::InputRange::AddAttr(PHTML & html) const
  1071. {
  1072.   InputField::AddAttr(html);
  1073.   PINDEX max = PMAX(-minValue, maxValue);
  1074.   PINDEX width = 3;
  1075.   while (max > 10) {
  1076.     width++;
  1077.     max /= 10;
  1078.   }
  1079.   html << " SIZE=" << width
  1080.        << " MIN=" << minValue
  1081.        << " MAX=" << maxValue
  1082.        << " VALUE=" << initValue;
  1083. }
  1086. PHTML::InputFile::InputFile(const char * fname,
  1087.                             const char * accept,
  1088.                             DisableCodes disabled,
  1089.                             const char * attr)
  1090.   : InputField("file", fname, disabled, attr)
  1091. {
  1092.   acceptString = accept;
  1093. }
  1095. void PHTML::InputFile::AddAttr(PHTML & html) const
  1096. {
  1097.   InputField::AddAttr(html);
  1098.   if (acceptString != NULL)
  1099.     html << " ACCEPT="" << acceptString << '"';
  1100. }
  1103. PHTML::InputImage::InputImage(const char * fname,
  1104.                               const char * src,
  1105.                               DisableCodes disabled,
  1106.                               const char * attr)
  1107.   : InputField("image", fname, disabled, attr)
  1108. {
  1109.   srcString = src;
  1110. }
  1112. PHTML::InputImage::InputImage(const char * type,
  1113.                               const char * fname,
  1114.                               const char * src,
  1115.                               DisableCodes disabled,
  1116.                               const char * attr)
  1117.   : InputField(type, fname, disabled, attr)
  1118. {
  1119.   srcString = src;
  1120. }
  1122. void PHTML::InputImage::AddAttr(PHTML & html) const
  1123. {
  1124.   InputField::AddAttr(html);
  1125.   if (srcString != NULL)
  1126.     html << " SRC="" << srcString << '"';
  1127. }
  1130. PHTML::InputScribble::InputScribble(const char * fname,
  1131.                                     const char * src,
  1132.                                     DisableCodes disabled,
  1133.                                     const char * attr)
  1134.   : InputImage("scribble", fname, src, disabled, attr)
  1135. {
  1136. }
  1138. PHTML::ResetButton::ResetButton(const char * title,
  1139.                                 const char * fname,
  1140.                                 const char * src,
  1141.                                 DisableCodes disabled,
  1142.                                 const char * attr)
  1143.   : InputImage("reset", fname != NULL ? fname : "reset", src, disabled, attr)
  1144. {
  1145.   titleString = title;
  1146. }
  1148. PHTML::ResetButton::ResetButton(const char * type,
  1149.                                 const char * title,
  1150.                                 const char * fname,
  1151.                                 const char * src,
  1152.                                 DisableCodes disabled,
  1153.                                 const char * attr)
  1154.   : InputImage(type, fname, src, disabled, attr)
  1155. {
  1156.   titleString = title;
  1157. }
  1159. void PHTML::ResetButton::AddAttr(PHTML & html) const
  1160. {
  1161.   InputImage::AddAttr(html);
  1162.   if (titleString != NULL)
  1163.     html << " VALUE="" << titleString << '"';
  1164. }
  1167. PHTML::SubmitButton::SubmitButton(const char * title,
  1168.                                   const char * fname,
  1169.                                   const char * src,
  1170.                                   DisableCodes disabled,
  1171.                                   const char * attr)
  1172.   : ResetButton("submit",
  1173.                   title, fname != NULL ? fname : "submit", src, disabled, attr)
  1174. {
  1175. }
  1177. // End Of File ///////////////////////////////////////////////////////////////