html.h
Go to the documentation of this file.
/*
* html.h
*
* HyperText Markup Language stream classes.
*
* Portable Windows Library
*
* Copyright (c) 1993-2002 Equivalence Pty. Ltd.
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is Portable Windows Library.
*
* The Initial Developer of the Original Code is Equivalence Pty. Ltd.
*
* Contributor(s): ______________________________________.
*
* $Revision: 24177 $
* $Author: rjongbloed $
* $Date: 2010-04-05 06:52:04 -0500 (Mon, 05 Apr 2010) $
*/
#ifndef PTLIB_HTML_H
#define PTLIB_HTML_H
#ifdef P_USE_PRAGMA
#pragma interface
#endif
// PHTML
class PHTML : public PStringStream
{
PCLASSINFO(PHTML, PStringStream)
public:
enum ElementInSet {
InHTML,
InHead,
InBody,
InTitle,
InHeading,
InDivision,
InPreFormat,
InAnchor,
InNote,
InAddress,
InBlockQuote,
InCredit,
InBold,
InItalic,
InTeleType,
InUnderline,
InStrikeThrough,
InBig,
InSmall,
InSubscript,
InSuperscript,
InEmphasis,
InCite,
InStrong,
InCode,
InSample,
InKeyboard,
InVariable,
InDefinition,
InQuote,
InAuthor,
InPerson,
InAcronym,
InAbbrev,
InInsertedText,
InDeletedText,
InList,
InListHeading,
InDefinitionTerm,
InTable,
InForm,
InSelect,
InTextArea,
NumElementsInSet
};
PHTML(
ElementInSet initialState = NumElementsInSet
);
PHTML(
const char * cstr
);
PHTML(
const PString & str
);
~PHTML();
PHTML & operator=(
const PHTML & html
) { AssignContents(html); return *this; }
PHTML & operator=(
const PString & str
) { AssignContents(str); return *this; }
PHTML & operator=(
const char * cstr
) { AssignContents(PString(cstr)); return *this; }
PHTML & operator=(
char ch
) { AssignContents(PString(ch)); return *this; }
// New functions for class.
PBoolean Is(ElementInSet elmt) const;
void Set(ElementInSet elmt);
void Clr(ElementInSet elmt);
void Toggle(ElementInSet elmt);
class Element {
public:
virtual ~Element() {}
protected:
enum OptionalCRLF { NoCRLF, OpenCRLF, CloseCRLF, BothCRLF };
Element(
const char * nam,
const char * att,
ElementInSet elmt,
ElementInSet req,
OptionalCRLF opt
) { name = nam; attr= att; inElement = elmt; reqElement = req; crlf = opt; }
virtual void Output(PHTML & html) const;
virtual void AddAttr(PHTML & html) const;
private:
const char * name;
const char * attr;
ElementInSet inElement;
ElementInSet reqElement;
OptionalCRLF crlf;
friend ostream & operator<<(ostream & strm, const Element & elmt)
{ elmt.Output((PHTML&)strm); return strm; }
};
class HTML : public Element {
public:
HTML(const char * attr = NULL);
virtual ~HTML() {}
};
class Head : public Element {
public:
Head();
virtual ~Head() {}
protected:
virtual void Output(PHTML & html) const;
};
class Body : public Element {
public:
Body(const char * attr = NULL);
virtual ~Body() {}
protected:
virtual void Output(PHTML & html) const;
};
class Title : public Element {
public:
Title();
Title(const char * titleCStr);
Title(const PString & titleStr);
virtual ~Title() {}
protected:
virtual void Output(PHTML & html) const;
private:
const char * titleString;
};
class Banner : public Element {
public:
Banner(const char * attr = NULL);
virtual ~Banner() {}
};
class Division : public Element {
public:
Division(const char * attr = NULL);
virtual ~Division() {}
};
class Heading : public Element {
public:
Heading(int number,
int sequence = 0,
int skip = 0,
const char * attr = NULL);
Heading(int number,
const char * image,
int sequence = 0,
int skip = 0,
const char * attr = NULL);
Heading(int number,
const PString & imageStr,
int sequence = 0,
int skip = 0,
const char * attr = NULL);
virtual ~Heading() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
int num;
const char * srcString;
int seqNum, skipSeq;
};
class BreakLine : public Element {
public:
BreakLine(const char * attr = NULL);
virtual ~BreakLine() {}
};
class Paragraph : public Element {
public:
Paragraph(const char * attr = NULL);
virtual ~Paragraph() {}
};
class PreFormat : public Element {
public:
PreFormat(int widthInChars = 0,
const char * attr = NULL);
virtual ~PreFormat() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
int width;
};
class HotLink : public Element {
public:
HotLink(const char * href = NULL, const char * attr = NULL);
virtual ~HotLink() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
const char * hrefString;
};
class Target : public Element {
public:
Target(const char * name = NULL, const char * attr = NULL);
virtual ~Target() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
const char * nameString;
};
class ImageElement : public Element {
protected:
ImageElement(const char * nam,
const char * attr,
ElementInSet elmt,
ElementInSet req,
OptionalCRLF opt,
const char * image);
virtual ~ImageElement() {}
virtual void AddAttr(PHTML & html) const;
const char * srcString;
};
class Image : public ImageElement {
public:
Image(const char * src,
int width = 0,
int height = 0,
const char * attr = NULL);
Image(const char * src,
const char * alt,
int width = 0,
int height = 0,
const char * attr = NULL);
virtual ~Image() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
const char * altString;
int width, height;
};
class HRule : public ImageElement {
public:
HRule(const char * image = NULL, const char * attr = NULL);
virtual ~HRule() {}
};
class Note : public ImageElement {
public:
Note(const char * image = NULL, const char * attr = NULL);
virtual ~Note() {}
};
class Address : public Element {
public:
Address(const char * attr = NULL);
virtual ~Address() {}
};
class BlockQuote : public Element {
public:
BlockQuote(const char * attr = NULL);
virtual ~BlockQuote() {}
};
class Credit : public Element {
public:
Credit(const char * attr = NULL);
virtual ~Credit() {}
};
class SetTab : public Element {
public:
SetTab(const char * id, const char * attr = NULL);
virtual ~SetTab() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
const char * ident;
};
class Tab : public Element {
public:
Tab(int indent, const char * attr = NULL);
Tab(const char * id, const char * attr = NULL);
virtual ~Tab() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
const char * ident;
int indentSize;
};
class Bold : public Element {
public: Bold() : Element("B", NULL, InBold, InBody, NoCRLF) { }
virtual ~Bold() {}
};
class Italic : public Element {
public:
Italic()
: Element("I", NULL, InItalic, InBody, NoCRLF) { }
virtual ~Italic() {}
};
class TeleType : public Element {
public:
TeleType()
: Element("TT", NULL, InTeleType, InBody, NoCRLF) { }
virtual ~TeleType() {}
};
class Underline : public Element {
public:
Underline()
: Element("U", NULL, InUnderline, InBody, NoCRLF) { }
virtual ~Underline() {}
};
class StrikeThrough : public Element {
public:
StrikeThrough()
: Element("S", NULL, InStrikeThrough, InBody, NoCRLF) { }
virtual ~StrikeThrough() {}
};
class Big : public Element {
public:
Big()
: Element("BIG", NULL, InBig, InBody, NoCRLF) { }
virtual ~Big() {}
};
class Small : public Element {
public:
Small()
: Element("SMALL", NULL, InSmall, InBody, NoCRLF) { }
virtual ~Small() {}
};
class Subscript : public Element {
public:
Subscript()
: Element("SUB", NULL, InSubscript, InBody, NoCRLF) { }
virtual ~Subscript() {}
};
class Superscript : public Element {
public:
Superscript()
: Element("SUP", NULL, InSuperscript, InBody, NoCRLF) { }
virtual ~Superscript() {}
};
class Emphasis : public Element {
public:
Emphasis()
: Element("EM", NULL, InEmphasis, InBody, NoCRLF) { }
virtual ~Emphasis() {}
};
class Cite : public Element {
public:
Cite()
: Element("CITE", NULL, InCite, InBody, NoCRLF) { }
virtual ~Cite() {}
};
class Strong : public Element {
public:
Strong()
: Element("STRONG", NULL, InStrong, InBody, NoCRLF) { }
virtual ~Strong() {}
};
class Code : public Element {
public:
Code()
: Element("CODE", NULL, InCode, InBody, NoCRLF) { }
virtual ~Code() {}
};
class Sample : public Element {
public:
Sample()
: Element("SAMP", NULL, InSample, InBody, NoCRLF) { }
virtual ~Sample() {}
};
class Keyboard : public Element {
public:
Keyboard()
: Element("KBD", NULL, InKeyboard, InBody, NoCRLF) { }
virtual ~Keyboard() {}
};
class Variable : public Element {
public:
Variable()
: Element("VAR", NULL, InVariable, InBody, NoCRLF) { }
virtual ~Variable() {}
};
class Definition : public Element {
public:
Definition()
: Element("DFN", NULL, InDefinition, InBody, NoCRLF) { }
virtual ~Definition() {}
};
class Quote : public Element {
public:
Quote()
: Element("Q", NULL, InQuote, InBody, NoCRLF) { }
virtual ~Quote() {}
};
class Author : public Element {
public:
Author()
: Element("AU", NULL, InAuthor, InBody, NoCRLF) { }
virtual ~Author() {}
};
class Person : public Element {
public:
Person()
: Element("PERSON", NULL, InPerson, InBody, NoCRLF) { }
virtual ~Person() {}
};
class Acronym : public Element {
public:
Acronym()
: Element("ACRONYM", NULL, InAcronym, InBody, NoCRLF) { }
virtual ~Acronym() {}
};
class Abbrev : public Element {
public:
Abbrev()
: Element("ABBREV", NULL, InAbbrev, InBody, NoCRLF) { }
virtual ~Abbrev() {}
};
class InsertedText : public Element {
public:
InsertedText()
: Element("INS", NULL, InInsertedText, InBody, NoCRLF) { }
virtual ~InsertedText() {}
};
class DeletedText : public Element {
public:
DeletedText()
: Element("DEL", NULL, InDeletedText, InBody, NoCRLF) { }
public:
virtual ~DeletedText() {}
};
class SimpleList : public Element {
public:
SimpleList(const char * attr = NULL);
virtual ~SimpleList() {}
protected:
virtual void AddAttr(PHTML & html) const;
};
class BulletList : public Element {
public:
BulletList(const char * attr = NULL);
virtual ~BulletList() {}
};
class OrderedList : public Element {
public:
OrderedList(int seqNum = 0, const char * attr = NULL);
virtual ~OrderedList() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
int sequenceNum;
};
class DefinitionList : public Element {
public:
DefinitionList(const char * attr = NULL);
virtual ~DefinitionList() {}
};
class ListHeading : public Element {
public:
ListHeading(const char * attr = NULL);
virtual ~ListHeading() {}
};
class ListItem : public Element {
public:
ListItem(int skip = 0, const char * attr = NULL);
virtual ~ListItem() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
int skipSeq;
};
class DefinitionTerm : public Element {
public:
DefinitionTerm(const char * attr = NULL);
virtual ~DefinitionTerm() {}
protected:
virtual void Output(PHTML & html) const;
};
class DefinitionItem : public Element {
public:
DefinitionItem(const char * attr = NULL);
virtual ~DefinitionItem() {}
protected:
virtual void Output(PHTML & html) const;
};
enum BorderCodes {
NoBorder,
Border
};
class TableStart : public Element {
public:
TableStart(const char * attr = NULL);
TableStart(BorderCodes border, const char * attr = NULL);
virtual ~TableStart() {}
protected:
virtual void Output(PHTML & html) const;
virtual void AddAttr(PHTML & html) const;
private:
PBoolean borderFlag;
};
friend class TableStart;
class TableEnd : public Element {
public:
TableEnd();
virtual ~TableEnd() {}
protected:
virtual void Output(PHTML & html) const;
};
friend class TableEnd;
class TableRow : public Element {
public:
TableRow(const char * attr = NULL);
virtual ~TableRow() {}
};
class TableHeader : public Element {
public:
TableHeader(const char * attr = NULL);
virtual ~TableHeader() {}
};
class TableData : public Element {
public:
TableData(const char * attr = NULL);
virtual ~TableData() {}
};
class Form : public Element {
public:
Form(
const char * method = NULL,
const char * action = NULL,
const char * encoding = NULL,
const char * script = NULL
);
virtual ~Form() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
const char * methodString;
const char * actionString;
const char * mimeTypeString;
const char * scriptString;
};
enum DisableCodes {
Enabled,
Disabled
};
class FieldElement : public Element {
protected:
FieldElement(
const char * nam,
const char * attr,
ElementInSet elmt,
OptionalCRLF opt,
DisableCodes disabled
);
virtual ~FieldElement() {}
virtual void AddAttr(PHTML & html) const;
private:
PBoolean disabledFlag;
};
class Select : public FieldElement {
public:
Select(
const char * fname = NULL,
const char * attr = NULL
);
Select(
const char * fname,
DisableCodes disabled,
const char * attr = NULL
);
virtual ~Select() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
const char * nameString;
};
enum SelectionCodes {
NotSelected,
Selected
};
class Option : public FieldElement {
public:
Option(
const char * attr = NULL
);
Option(
SelectionCodes select,
const char * attr = NULL
);
Option(
DisableCodes disabled,
const char * attr = NULL
);
Option(
SelectionCodes select,
DisableCodes disabled,
const char * attr = NULL
);
virtual ~Option() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
PBoolean selectedFlag;
};
class FormField : public FieldElement {
protected:
FormField(
const char * nam,
const char * attr,
ElementInSet elmt,
OptionalCRLF opt,
DisableCodes disabled,
const char * fname
);
virtual ~FormField() {}
virtual void AddAttr(PHTML & html) const;
private:
const char * nameString;
};
class TextArea : public FormField {
public:
TextArea(
const char * fname,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
TextArea(
const char * fname,
int rows, int cols,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~TextArea() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
int numRows, numCols;
};
class InputField : public FormField {
protected:
InputField(
const char * type,
const char * fname,
DisableCodes disabled,
const char * attr
);
virtual ~InputField() {}
virtual void AddAttr(PHTML & html) const;
private:
const char * typeString;
};
class HiddenField : public InputField {
public:
HiddenField(
const char * fname,
const char * value,
const char * attr = NULL
);
virtual ~HiddenField() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
const char * valueString;
};
class InputText : public InputField {
public:
InputText(
const char * fname,
int size,
const char * init = NULL,
const char * attr = NULL
);
InputText(
const char * fname,
int size,
DisableCodes disabled,
const char * attr = NULL
);
InputText(
const char * fname,
int size,
int maxLength,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
InputText(
const char * fname,
int size,
const char * init,
int maxLength,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~InputText() {}
protected:
InputText(
const char * type,
const char * fname,
int size,
const char * init,
int maxLength,
DisableCodes disabled,
const char * attr
);
virtual void AddAttr(PHTML & html) const;
private:
const char * value;
int width, length;
};
class InputPassword : public InputText {
public:
InputPassword(
const char * fname,
int size,
const char * init = NULL,
const char * attr = NULL
);
InputPassword(
const char * fname,
int size,
DisableCodes disabled,
const char * attr = NULL
);
InputPassword(
const char * fname,
int size,
int maxLength,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
InputPassword(
const char * fname,
int size,
const char * init,
int maxLength,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~InputPassword() {}
};
enum CheckedCodes {
UnChecked,
Checked
};
class RadioButton : public InputField {
public:
RadioButton(
const char * fname,
const char * value,
const char * attr = NULL
);
RadioButton(
const char * fname,
const char * value,
DisableCodes disabled,
const char * attr = NULL
);
RadioButton(
const char * fname,
const char * value,
CheckedCodes check,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~RadioButton() {}
protected:
RadioButton(
const char * type,
const char * fname,
const char * value,
CheckedCodes check,
DisableCodes disabled,
const char * attr
);
virtual void AddAttr(PHTML & html) const;
private:
const char * valueString;
PBoolean checkedFlag;
};
class CheckBox : public RadioButton {
public:
CheckBox(
const char * fname,
const char * attr = NULL
);
CheckBox(
const char * fname,
DisableCodes disabled,
const char * attr = NULL
);
CheckBox(
const char * fname,
CheckedCodes check,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~CheckBox() {}
};
class InputNumber : public InputField {
public:
InputNumber(
const char * fname,
int min, int max,
int value = 0,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~InputNumber() {}
protected:
InputNumber(
const char * type,
const char * fname,
int min, int max,
int value,
DisableCodes disabled,
const char * attr
);
virtual void AddAttr(PHTML & html) const;
private:
void Construct(int min, int max, int value);
int minValue, maxValue, initValue;
};
class InputRange : public InputNumber {
public:
InputRange(
const char * fname,
int min, int max,
int value = 0,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~InputRange() {}
};
class InputFile : public InputField {
public:
InputFile(
const char * fname,
const char * accept = NULL,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~InputFile() {}
protected:
virtual void AddAttr(PHTML & html) const;
private:
const char * acceptString;
};
class InputImage : public InputField {
public:
InputImage(
const char * fname,
const char * src = NULL,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~InputImage() {}
protected:
InputImage(
const char * type,
const char * fname,
const char * src,
DisableCodes disabled,
const char * attr
);
virtual void AddAttr(PHTML & html) const;
private:
const char * srcString;
};
class InputScribble : public InputImage {
public:
InputScribble(
const char * fname,
const char * src = NULL,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~InputScribble() {}
};
class ResetButton : public InputImage {
public:
ResetButton(
const char * title,
const char * fname = NULL,
const char * src = NULL,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~ResetButton() {}
protected:
ResetButton(
const char * type,
const char * title,
const char * fname = NULL,
const char * src = NULL,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual void AddAttr(PHTML & html) const;
private:
const char * titleString;
};
class SubmitButton : public ResetButton {
public:
SubmitButton(
const char * title,
const char * fname = NULL,
const char * src = NULL,
DisableCodes disabled = Enabled,
const char * attr = NULL
);
virtual ~SubmitButton() {}
};
protected:
virtual void AssignContents(const PContainer & c);
private:
ElementInSet initialElement;
BYTE elementSet[NumElementsInSet/8+1];
PINDEX tableNestLevel;
};
#endif // PTLIB_HTML_H
// End Of File ///////////////////////////////////////////////////////////////
PHTML::InSample
Definition: html.h:80
PHTML::operator=
PHTML & operator=(char ch)
Definition: html.h:130
PHTML::Banner
Definition: html.h:200
PHTML::Element::Output
virtual void Output(PHTML &html) const
PHTML::Subscript::Subscript
Subscript()
Definition: html.h:407
PHTML::InputRange
Definition: html.h:929
PHTML::InCite
Definition: html.h:77
PHTML::InHeading
Definition: html.h:59
PHTML::InNote
Definition: html.h:63
PHTML::TableStart
Definition: html.h:576
PHTML::Code::Code
Code()
Definition: html.h:437
PHTML::StrikeThrough::StrikeThrough
StrikeThrough()
Definition: html.h:389
PHTML::Keyboard::Keyboard
Keyboard()
Definition: html.h:449
PHTML::Tab::~Tab
virtual ~Tab()
Definition: html.h:356
PHTML::InputScribble
Definition: html.h:978
PHTML::ListHeading::~ListHeading
virtual ~ListHeading()
Definition: html.h:542
PHTML::InSubscript
Definition: html.h:74
PHTML::Element::OptionalCRLF
OptionalCRLF
Definition: html.h:146
PHTML::Variable
Definition: html.h:453
PHTML::operator=
PHTML & operator=(const PString &str)
Definition: html.h:124
PHTML::BreakLine
Definition: html.h:237
PHTML::BorderCodes
BorderCodes
Definition: html.h:572
PHTML::InListHeading
Definition: html.h:92
PHTML::Superscript
Definition: html.h:411
PHTML::HRule
Definition: html.h:312
PHTML::Strong::Strong
Strong()
Definition: html.h:431
PHTML::TableEnd
friend class TableEnd
Definition: html.h:596
PCLASSINFO
#define PCLASSINFO(cls, par)
Declare all the standard PTLib class information.
Definition: object.h:1049
PHTML::InputRange::~InputRange
virtual ~InputRange()
Definition: html.h:938
PHTML::Head
Definition: html.h:172
PHTML::ImageElement::~ImageElement
virtual ~ImageElement()
Definition: html.h:288
PHTML::Underline::~Underline
virtual ~Underline()
Definition: html.h:385
PHTML::RadioButton::~RadioButton
virtual ~RadioButton()
Definition: html.h:867
PHTML::DeletedText::~DeletedText
virtual ~DeletedText()
Definition: html.h:506
PHTML::Emphasis::~Emphasis
virtual ~Emphasis()
Definition: html.h:421
PHTML::TableRow::~TableRow
virtual ~TableRow()
Definition: html.h:601
PHTML::Superscript::Superscript
Superscript()
Definition: html.h:413
PHTML::NotSelected
Definition: html.h:673
PHTML::Element::operator<<
friend ostream & operator<<(ostream &strm, const Element &elmt)
Definition: html.h:162
PHTML::Element
Definition: html.h:142
PHTML::Cite::Cite
Cite()
Definition: html.h:425
PHTML::InPerson
Definition: html.h:86
PHTML::InPreFormat
Definition: html.h:61
PHTML::OrderedList::~OrderedList
virtual ~OrderedList()
Definition: html.h:526
PHTML::RadioButton
Definition: html.h:847
PHTML::InBlockQuote
Definition: html.h:65
PHTML::Keyboard
Definition: html.h:447
PHTML::Italic::Italic
Italic()
Definition: html.h:371
PHTML::BreakLine::~BreakLine
virtual ~BreakLine()
Definition: html.h:240
PHTML::FieldElement::~FieldElement
virtual ~FieldElement()
Definition: html.h:648
PHTML::InDivision
Definition: html.h:60
PHTML::InputText::~InputText
virtual ~InputText()
Definition: html.h:794
PStringStream
This class is a standard C++ stream class descendent for reading or writing streamed data to or from ...
Definition: pstring.h:1878
PHTML::InTextArea
Definition: html.h:97
PHTML::InCode
Definition: html.h:79
PHTML::Author::Author
Author()
Definition: html.h:473
PHTML::InEmphasis
Definition: html.h:76
PHTML::InputImage::~InputImage
virtual ~InputImage()
Definition: html.h:964
PHTML::TableStart
friend class TableStart
Definition: html.h:587
PHTML::SubmitButton::~SubmitButton
virtual ~SubmitButton()
Definition: html.h:1022
PHTML::Note::~Note
virtual ~Note()
Definition: html.h:321
PHTML::SelectionCodes
SelectionCodes
Definition: html.h:672
PHTML::HotLink
Definition: html.h:260
PHTML::Select::~Select
virtual ~Select()
Definition: html.h:665
PHTML::Bold
Definition: html.h:365
PHTML::Banner::~Banner
virtual ~Banner()
Definition: html.h:203
PHTML::ImageElement
Definition: html.h:280
PHTML::Variable::Variable
Variable()
Definition: html.h:455
PHTML::InputPassword
Definition: html.h:811
PHTML::FieldElement
Definition: html.h:639
PHTML::InsertedText
Definition: html.h:495
PHTML::InSuperscript
Definition: html.h:75
PHTML::DisableCodes
DisableCodes
Definition: html.h:635
PHTML::HTML
Definition: html.h:166
PHTML::InInsertedText
Definition: html.h:89
PHTML::InputImage
Definition: html.h:956
PHTML::InBody
Definition: html.h:57
PHTML::TableRow
Definition: html.h:598
PHTML::Abbrev::~Abbrev
virtual ~Abbrev()
Definition: html.h:493
PHTML::TableEnd
Definition: html.h:589
PHTML::Tab
Definition: html.h:352
PHTML::InList
Definition: html.h:91
PHTML::Head::~Head
virtual ~Head()
Definition: html.h:175
PHTML::DefinitionItem
Definition: html.h:563
PHTML::FormField
Definition: html.h:701
PHTML::Set
void Set(ElementInSet elmt)
PHTML::Target
Definition: html.h:270
PString::PString
PINLINE PString()
Construct an empty string.
PHTML::Big
Definition: html.h:393
PHTML::Code
Definition: html.h:435
PHTML::SubmitButton
Definition: html.h:1013
PHTML::Cite
Definition: html.h:423
PHTML::InDefinition
Definition: html.h:83
PHTML::Small
Definition: html.h:399
PHTML::Underline
Definition: html.h:381
PHTML::InputFile::~InputFile
virtual ~InputFile()
Definition: html.h:949
PHTML::InsertedText::~InsertedText
virtual ~InsertedText()
Definition: html.h:499
PHTML::Big::Big
Big()
Definition: html.h:395
PHTML::TextArea::~TextArea
virtual ~TextArea()
Definition: html.h:730
PHTML::HiddenField::~HiddenField
virtual ~HiddenField()
Definition: html.h:758
PHTML::Toggle
void Toggle(ElementInSet elmt)
PHTML::Strong
Definition: html.h:429
PHTML::Select
Definition: html.h:654
PHTML::Element::Element
Element(const char *nam, const char *att, ElementInSet elmt, ElementInSet req, OptionalCRLF opt)
Definition: html.h:147
PHTML::InForm
Definition: html.h:95
PHTML::Strong::~Strong
virtual ~Strong()
Definition: html.h:433
PHTML::InItalic
Definition: html.h:68
PBoolean
BOOL PBoolean
Definition: object.h:102
PHTML::Is
PBoolean Is(ElementInSet elmt) const
PHTML::InputText
Definition: html.h:765
PHTML::InAcronym
Definition: html.h:87
PHTML::CheckBox::~CheckBox
virtual ~CheckBox()
Definition: html.h:900
PHTML::SetTab
Definition: html.h:342
PHTML::Element::AddAttr
virtual void AddAttr(PHTML &html) const
PHTML::InStrikeThrough
Definition: html.h:71
PHTML::Credit::~Credit
virtual ~Credit()
Definition: html.h:339
PHTML::TeleType::TeleType
TeleType()
Definition: html.h:377
PHTML::Person::Person
Person()
Definition: html.h:479
PHTML::Paragraph::~Paragraph
virtual ~Paragraph()
Definition: html.h:246
PHTML::InSmall
Definition: html.h:73
PHTML::InQuote
Definition: html.h:84
PHTML::DeletedText
Definition: html.h:501
PHTML::AssignContents
virtual void AssignContents(const PContainer &c)
Copy the container contents.
PHTML::UnChecked
Definition: html.h:844
PHTML::~PHTML
~PHTML()
PHTML::Address
Definition: html.h:324
PHTML::Credit
Definition: html.h:336
PHTML::Element::~Element
virtual ~Element()
Definition: html.h:144
PHTML::Small::Small
Small()
Definition: html.h:401
PHTML::Clr
void Clr(ElementInSet elmt)
PHTML::HTML::~HTML
virtual ~HTML()
Definition: html.h:169
PHTML::Small::~Small
virtual ~Small()
Definition: html.h:403
PHTML::Sample::~Sample
virtual ~Sample()
Definition: html.h:445
PHTML::Element::OpenCRLF
Definition: html.h:146
PHTML::Acronym
Definition: html.h:483
PHTML::Sample::Sample
Sample()
Definition: html.h:443
PHTML::BulletList
Definition: html.h:517
PHTML::InVariable
Definition: html.h:82
PHTML::SetTab::~SetTab
virtual ~SetTab()
Definition: html.h:345
PHTML::ListHeading
Definition: html.h:539
PHTML::InBold
Definition: html.h:67
PHTML::Definition::Definition
Definition()
Definition: html.h:461
PHTML::Abbrev::Abbrev
Abbrev()
Definition: html.h:491
PHTML::Acronym::Acronym
Acronym()
Definition: html.h:485
PHTML::Person::~Person
virtual ~Person()
Definition: html.h:481
PHTML::TableHeader::~TableHeader
virtual ~TableHeader()
Definition: html.h:607
PHTML::Definition
Definition: html.h:459
PHTML::Paragraph
Definition: html.h:243
PHTML::DefinitionTerm
Definition: html.h:555
PHTML::DefinitionList::~DefinitionList
virtual ~DefinitionList()
Definition: html.h:536
PHTML::TextArea
Definition: html.h:717
PHTML::BlockQuote::~BlockQuote
virtual ~BlockQuote()
Definition: html.h:333
PHTML::TableHeader
Definition: html.h:604
PHTML::TableData::~TableData
virtual ~TableData()
Definition: html.h:613
PHTML::OrderedList
Definition: html.h:523
PHTML::Selected
Definition: html.h:674
PHTML::PHTML
PHTML(ElementInSet initialState=NumElementsInSet)
Construct a new HTML object.
PHTML::InAnchor
Definition: html.h:62
PHTML::Superscript::~Superscript
virtual ~Superscript()
Definition: html.h:415
PHTML::InStrong
Definition: html.h:78
PHTML::HotLink::~HotLink
virtual ~HotLink()
Definition: html.h:263
PHTML::Quote::~Quote
virtual ~Quote()
Definition: html.h:469
PHTML::InsertedText::InsertedText
InsertedText()
Definition: html.h:497
PHTML::SimpleList
Definition: html.h:509
PString
The character string class.
Definition: pstring.h:108
PHTML::Option
Definition: html.h:676
PHTML::FormField::~FormField
virtual ~FormField()
Definition: html.h:711
PHTML::ResetButton::~ResetButton
virtual ~ResetButton()
Definition: html.h:998
PHTML::Heading
Definition: html.h:212
PHTML::HiddenField
Definition: html.h:751
PHTML::Variable::~Variable
virtual ~Variable()
Definition: html.h:457
PHTML::InAbbrev
Definition: html.h:88
PHTML::Body
Definition: html.h:180
PHTML::Division
Definition: html.h:206
PHTML::Underline::Underline
Underline()
Definition: html.h:383
PHTML::TableStart::~TableStart
virtual ~TableStart()
Definition: html.h:580
PHTML::Person
Definition: html.h:477
PHTML::InputField::~InputField
virtual ~InputField()
Definition: html.h:745
PHTML::Emphasis::Emphasis
Emphasis()
Definition: html.h:419
PHTML::Bold::Bold
Bold()
Definition: html.h:366
PHTML::Emphasis
Definition: html.h:417
PHTML::Cite::~Cite
virtual ~Cite()
Definition: html.h:427
PHTML::Subscript::~Subscript
virtual ~Subscript()
Definition: html.h:409
PHTML::Title
Definition: html.h:188
PContainer
Abstract class to embody the base functionality of a container.
Definition: contain.h:104
PHTML::PreFormat::~PreFormat
virtual ~PreFormat()
Definition: html.h:253
PHTML::Form
Definition: html.h:617
PHTML::Element::CloseCRLF
Definition: html.h:146
PHTML::Form::~Form
virtual ~Form()
Definition: html.h:625
PHTML::ListItem::~ListItem
virtual ~ListItem()
Definition: html.h:548
PHTML::PreFormat
Definition: html.h:249
PHTML::InBig
Definition: html.h:72
PHTML::Body::~Body
virtual ~Body()
Definition: html.h:183
PHTML::DefinitionList
Definition: html.h:533
PHTML::Target::~Target
virtual ~Target()
Definition: html.h:273
PHTML::TableEnd::~TableEnd
virtual ~TableEnd()
Definition: html.h:592
PHTML::ImageElement::srcString
const char * srcString
Definition: html.h:290
PHTML::InputNumber
Definition: html.h:904
PHTML::Note
Definition: html.h:318
PHTML
This class describes a HyperText markup Language string as used by the World Wide Web and the PURL an...
Definition: html.h:49
PHTML::InputNumber::~InputNumber
virtual ~InputNumber()
Definition: html.h:913
PHTML::InSelect
Definition: html.h:96
PHTML::InTitle
Definition: html.h:58
PHTML::Checked
Definition: html.h:845
PHTML::InUnderline
Definition: html.h:70
PHTML::Image::~Image
virtual ~Image()
Definition: html.h:304
PHTML::Quote::Quote
Quote()
Definition: html.h:467
PHTML::Title::~Title
virtual ~Title()
Definition: html.h:193
PHTML::InHTML
Definition: html.h:55
PHTML::CheckBox
Definition: html.h:883
PHTML::InputScribble::~InputScribble
virtual ~InputScribble()
Definition: html.h:986
PHTML::Border
Definition: html.h:574
PHTML::InDeletedText
Definition: html.h:90
PHTML::StrikeThrough
Definition: html.h:387
PHTML::Acronym::~Acronym
virtual ~Acronym()
Definition: html.h:487
PHTML::Sample
Definition: html.h:441
PHTML::Italic::~Italic
virtual ~Italic()
Definition: html.h:373
PHTML::Author
Definition: html.h:471
PHTML::InDefinitionTerm
Definition: html.h:93
PHTML::DefinitionTerm::~DefinitionTerm
virtual ~DefinitionTerm()
Definition: html.h:558
PHTML::Bold::~Bold
virtual ~Bold()
Definition: html.h:367
PHTML::Disabled
Definition: html.h:637
PHTML::InAuthor
Definition: html.h:85
PHTML::Element::NoCRLF
Definition: html.h:146
PHTML::Italic
Definition: html.h:369
PHTML::TeleType::~TeleType
virtual ~TeleType()
Definition: html.h:379
PHTML::Abbrev
Definition: html.h:489
PHTML::operator=
PHTML & operator=(const PHTML &html)
Restart the HTML string output using the specified value as the new title.
Definition: html.h:121
PHTML::Quote
Definition: html.h:465
PHTML::StrikeThrough::~StrikeThrough
virtual ~StrikeThrough()
Definition: html.h:391
PHTML::BlockQuote
Definition: html.h:330
PHTML::InputField
Definition: html.h:737
PHTML::Heading::~Heading
virtual ~Heading()
Definition: html.h:228
PHTML::DeletedText::DeletedText
DeletedText()
Definition: html.h:503
PHTML::InAddress
Definition: html.h:64
PHTML::BulletList::~BulletList
virtual ~BulletList()
Definition: html.h:520
PHTML::Image
Definition: html.h:293
PHTML::Definition::~Definition
virtual ~Definition()
Definition: html.h:463
PHTML::NoBorder
Definition: html.h:573
PHTML::InHead
Definition: html.h:56
PHTML::DefinitionItem::~DefinitionItem
virtual ~DefinitionItem()
Definition: html.h:566
PHTML::InputPassword::~InputPassword
virtual ~InputPassword()
Definition: html.h:840
PHTML::Big::~Big
virtual ~Big()
Definition: html.h:397
PHTML::Option::~Option
virtual ~Option()
Definition: html.h:694
PHTML::Enabled
Definition: html.h:636
PHTML::Author::~Author
virtual ~Author()
Definition: html.h:475
PHTML::HRule::~HRule
virtual ~HRule()
Definition: html.h:315
PHTML::Element::BothCRLF
Definition: html.h:146
PHTML::CheckedCodes
CheckedCodes
Definition: html.h:843
PHTML::InKeyboard
Definition: html.h:81
PHTML::SimpleList::~SimpleList
virtual ~SimpleList()
Definition: html.h:512
PHTML::InTable
Definition: html.h:94
PHTML::Subscript
Definition: html.h:405
PHTML::ResetButton
Definition: html.h:989
PHTML::ElementInSet
ElementInSet
Definition: html.h:54
PHTML::Code::~Code
virtual ~Code()
Definition: html.h:439
PHTML::Keyboard::~Keyboard
virtual ~Keyboard()
Definition: html.h:451
PHTML::Division::~Division
virtual ~Division()
Definition: html.h:209
PHTML::Address::~Address
virtual ~Address()
Definition: html.h:327
PHTML::InputFile
Definition: html.h:941
PHTML::TeleType
Definition: html.h:375
PHTML::TableData
Definition: html.h:610
PHTML::InTeleType
Definition: html.h:69
PHTML::InCredit
Definition: html.h:66
PHTML::operator=
PHTML & operator=(const char *cstr)
Definition: html.h:127
PHTML::NumElementsInSet
Definition: html.h:98
PHTML::ListItem
Definition: html.h:545