src/ptclib/html.cxx

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