--HG--
branch : compatibility-develop
hg/compatibility-develop
ulukyn 6 years ago
commit c487580686

@ -84,6 +84,9 @@ namespace NLGUI
// NOTE: Does not check combinator // NOTE: Does not check combinator
bool match(const CHtmlElement &elm) const; bool match(const CHtmlElement &elm) const;
// debug
std::string toString() const;
private: private:
bool matchClass(const CHtmlElement &elm) const; bool matchClass(const CHtmlElement &elm) const;
bool matchAttributes(const CHtmlElement &elm) const; bool matchAttributes(const CHtmlElement &elm) const;

@ -61,7 +61,7 @@ namespace NLGUI
Height=-1; Height=-1;
MaxWidth=-1; MaxWidth=-1;
MaxHeight=-1; MaxHeight=-1;
BorderWidth=1; BorderWidth=-1;
BackgroundColor=NLMISC::CRGBA::Black; BackgroundColor=NLMISC::CRGBA::Black;
BackgroundColorOver=NLMISC::CRGBA::Black; BackgroundColorOver=NLMISC::CRGBA::Black;
} }
@ -134,6 +134,12 @@ namespace NLGUI
void getStyleParams(const std::string &styleString, CStyleParams &style, const CStyleParams &current) const; void getStyleParams(const std::string &styleString, CStyleParams &style, const CStyleParams &current) const;
void getStyleParams(const TStyle &styleRules, CStyleParams &style, const CStyleParams &current) const; void getStyleParams(const TStyle &styleRules, CStyleParams &style, const CStyleParams &current) const;
// extract from styleRules into style.StyleRules (expand shorthand, normalize, calculate current font-size)
void normalize(const TStyle &styleRules, CStyleParams &style, const CStyleParams &current) const;
// apply style.StyleRyles
void apply(CStyleParams &style, const CStyleParams &current) const;
// merge src into dest by overwriting key in dest // merge src into dest by overwriting key in dest
void merge(TStyle &dst, const TStyle &src) const; void merge(TStyle &dst, const TStyle &src) const;
@ -170,7 +176,7 @@ namespace NLGUI
Current.Height=-1; Current.Height=-1;
Current.MaxWidth=-1; Current.MaxWidth=-1;
Current.MaxHeight=-1; Current.MaxHeight=-1;
Current.BorderWidth=1; Current.BorderWidth=-1;
Current.StyleRules.clear(); Current.StyleRules.clear();
} }

@ -23,7 +23,6 @@
#include "nel/gui/group_tree.h" #include "nel/gui/group_tree.h"
#include "nel/gui/ctrl_button.h" #include "nel/gui/ctrl_button.h"
#include "nel/gui/group_table.h" #include "nel/gui/group_table.h"
#include "nel/gui/libwww_types.h"
#include "nel/gui/html_element.h" #include "nel/gui/html_element.h"
#include "nel/gui/css_style.h" #include "nel/gui/css_style.h"
@ -108,7 +107,7 @@ namespace NLGUI
void refresh(); void refresh();
// submit form // submit form
void submitForm (uint formId, const char *submitButtonType, const char *submitButtonName, const char *submitButtonValue, sint32 x, sint32 y); void submitForm(uint button, sint32 x, sint32 y);
// Browse error // Browse error
void browseError (const char *msg); void browseError (const char *msg);
@ -333,7 +332,7 @@ namespace NLGUI
// Add a button in the current paragraph. actionHandler, actionHandlerParams and tooltip can be NULL. // Add a button in the current paragraph. actionHandler, actionHandlerParams and tooltip can be NULL.
CCtrlButton *addButton(CCtrlButton::EType type, const std::string &name, const std::string &normalBitmap, const std::string &pushedBitmap, CCtrlButton *addButton(CCtrlButton::EType type, const std::string &name, const std::string &normalBitmap, const std::string &pushedBitmap,
const std::string &overBitmap, const char *actionHandler, const char *actionHandlerParams, const char *tooltip, const std::string &overBitmap, const char *actionHandler, const char *actionHandlerParams, const std::string &tooltip,
const CStyleParams &style = CStyleParams()); const CStyleParams &style = CStyleParams());
// Set the background color // Set the background color
@ -393,6 +392,7 @@ namespace NLGUI
bool _BrowseNextTime; bool _BrowseNextTime;
bool _PostNextTime; bool _PostNextTime;
uint _PostFormId; uint _PostFormId;
std::string _PostFormAction;
std::string _PostFormSubmitType; std::string _PostFormSubmitType;
std::string _PostFormSubmitButton; std::string _PostFormSubmitButton;
std::string _PostFormSubmitValue; std::string _PostFormSubmitValue;
@ -415,6 +415,7 @@ namespace NLGUI
// True when the <lua> element has been encountered // True when the <lua> element has been encountered
bool _ParsingLua; bool _ParsingLua;
bool _IgnoreText; bool _IgnoreText;
bool _IgnoreChildElements;
// the script to execute // the script to execute
std::string _LuaScript; std::string _LuaScript;
bool _LuaHrefHack; bool _LuaHrefHack;
@ -473,6 +474,64 @@ namespace NLGUI
}; };
std::vector<HTMLOListElement> _UL; std::vector<HTMLOListElement> _UL;
class HTMLMeterElement {
public:
enum EValueRegion {
VALUE_OPTIMUM = 0,
VALUE_SUB_OPTIMAL,
VALUE_EVEN_LESS_GOOD
};
public:
HTMLMeterElement()
: value(0.f), min(0.f), max(1.f), low(0.f), high(1.f), optimum(0.5f)
{}
// read attributes from html element
void readValues(const CHtmlElement &elm);
// return value ratio to min-max
float getValueRatio() const;
// return optimum region based current value
EValueRegion getValueRegion() const;
// return meter bar color
NLMISC::CRGBA getBarColor(const CHtmlElement &elm, CCssStyle &style) const;
// return meter value bar color based value and optimum range
NLMISC::CRGBA getValueColor(const CHtmlElement &elm, CCssStyle &style) const;
float value;
float min;
float max;
float low;
float high;
float optimum;
};
class HTMLProgressElement
{
public:
HTMLProgressElement()
: value(0.f), max(1.f)
{}
// read attributes from html element
void readValues(const CHtmlElement &elm);
// return value ratio to min-max
float getValueRatio() const;
// return meter bar color
NLMISC::CRGBA getBarColor(const CHtmlElement &elm, CCssStyle &style) const;
// return meter value bar color based value and optimum range
NLMISC::CRGBA getValueColor(const CHtmlElement &elm, CCssStyle &style) const;
float value;
float max;
};
// A mode // A mode
std::vector<bool> _A; std::vector<bool> _A;
inline bool getA() const inline bool getA() const
@ -608,6 +667,9 @@ namespace NLGUI
sint InitialSelection; // initial selection for the combo box sint InitialSelection; // initial selection for the combo box
}; };
// <form> element "id" attribute
std::string id;
// The action the form has to perform // The action the form has to perform
std::string Action; std::string Action;
@ -615,6 +677,25 @@ namespace NLGUI
std::vector<CEntry> Entries; std::vector<CEntry> Entries;
}; };
std::vector<CForm> _Forms; std::vector<CForm> _Forms;
// submit buttons added to from
struct SFormSubmitButton
{
SFormSubmitButton(const std::string &form, const std::string &name, const std::string &value, const std::string &type, const std::string &formAction="")
: form(form), name(name), value(value), type(type), formAction(formAction)
{ }
std::string form; // form 'id'
std::string name; // submit button name
std::string value; // submit button value
std::string type; // button type, ie 'image'
std::string formAction; // override form action attribute (url)
};
// submit buttons added to form
std::vector<SFormSubmitButton> _FormSubmit;
std::vector<CInterfaceGroup *> _Groups; std::vector<CInterfaceGroup *> _Groups;
// Cells parameters // Cells parameters
@ -824,12 +905,34 @@ namespace NLGUI
// :before, :after rendering // :before, :after rendering
void renderPseudoElement(const std::string &pseudo, const CHtmlElement &elm); void renderPseudoElement(const std::string &pseudo, const CHtmlElement &elm);
// apply background from current style (for html, body)
void applyBackground(const CHtmlElement &elm);
void insertFormImageButton(const std::string &name,
const std::string &tooltip,
const std::string &src,
const std::string &over,
const std::string &formId,
const std::string &formAction = "",
uint32 minWidth = 0,
const std::string &templateName = "");
void insertFormTextButton(const std::string &name,
const std::string &tooltip,
const std::string &value,
const std::string &formId,
const std::string &formAction = "",
uint32 minWidth = 0,
const std::string &templateName = "");
// HTML elements // HTML elements
void htmlA(const CHtmlElement &elm); void htmlA(const CHtmlElement &elm);
void htmlAend(const CHtmlElement &elm); void htmlAend(const CHtmlElement &elm);
void htmlBASE(const CHtmlElement &elm); void htmlBASE(const CHtmlElement &elm);
void htmlBODY(const CHtmlElement &elm); void htmlBODY(const CHtmlElement &elm);
void htmlBR(const CHtmlElement &elm); void htmlBR(const CHtmlElement &elm);
void htmlBUTTON(const CHtmlElement &elm);
void htmlBUTTONend(const CHtmlElement &elm);
void htmlDD(const CHtmlElement &elm); void htmlDD(const CHtmlElement &elm);
void htmlDDend(const CHtmlElement &elm); void htmlDDend(const CHtmlElement &elm);
//void htmlDEL(const CHtmlElement &elm); //void htmlDEL(const CHtmlElement &elm);
@ -857,6 +960,7 @@ namespace NLGUI
void htmlLUA(const CHtmlElement &elm); void htmlLUA(const CHtmlElement &elm);
void htmlLUAend(const CHtmlElement &elm); void htmlLUAend(const CHtmlElement &elm);
void htmlMETA(const CHtmlElement &elm); void htmlMETA(const CHtmlElement &elm);
void htmlMETER(const CHtmlElement &elm);
void htmlOBJECT(const CHtmlElement &elm); void htmlOBJECT(const CHtmlElement &elm);
void htmlOBJECTend(const CHtmlElement &elm); void htmlOBJECTend(const CHtmlElement &elm);
void htmlOL(const CHtmlElement &elm); void htmlOL(const CHtmlElement &elm);
@ -867,6 +971,7 @@ namespace NLGUI
void htmlPend(const CHtmlElement &elm); void htmlPend(const CHtmlElement &elm);
void htmlPRE(const CHtmlElement &elm); void htmlPRE(const CHtmlElement &elm);
void htmlPREend(const CHtmlElement &elm); void htmlPREend(const CHtmlElement &elm);
void htmlPROGRESS(const CHtmlElement &elm);
void htmlSCRIPT(const CHtmlElement &elm); void htmlSCRIPT(const CHtmlElement &elm);
void htmlSCRIPTend(const CHtmlElement &elm); void htmlSCRIPTend(const CHtmlElement &elm);
void htmlSELECT(const CHtmlElement &elm); void htmlSELECT(const CHtmlElement &elm);

@ -47,8 +47,6 @@ namespace NLGUI
// defined style and :before/:after pseudo elements // defined style and :before/:after pseudo elements
TStyle Style; TStyle Style;
TStyle StyleBefore;
TStyle StyleAfter;
// hierarchy // hierarchy
CHtmlElement *parent; CHtmlElement *parent;
@ -79,6 +77,16 @@ namespace NLGUI
// debug // debug
std::string toString(bool tree = false, uint depth = 0) const; std::string toString(bool tree = false, uint depth = 0) const;
// query, get, set pseudo element style rules
void clearPseudo();
bool hasPseudo(const std::string &key) const;
TStyle getPseudo(const std::string &key) const;
void setPseudo(const std::string &key, const TStyle &style);
private:
// pseudo elements like ":before" and ":after"
std::map<std::string, TStyle> _Pseudo;
}; };
} }

@ -21,7 +21,6 @@
#define CL_LIB_WWW_H #define CL_LIB_WWW_H
#include "nel/misc/rgba.h" #include "nel/misc/rgba.h"
#include "nel/gui/libwww_types.h"
// forward declaration to avoid curl.h inclusion everywhere // forward declaration to avoid curl.h inclusion everywhere
typedef void CURL; typedef void CURL;
@ -32,251 +31,146 @@ namespace NLGUI
class CCtrlScroll; class CCtrlScroll;
class CGroupList; class CGroupList;
// *************************************************************************** // List of HTML elements. Does not need to be sorted
typedef enum _HTMLElement {
// Legacy function from libwww HTML_HTML,
SGML_dtd * HTML_dtd (void); HTML_BODY,
// meta
// Init the libwww HTML_BASE,
void initLibWWW(); HTML_HEAD,
HTML_LINK,
// *************************************************************************** HTML_META,
HTML_STYLE,
// Some DTD table HTML_TITLE,
// content sectioning
// Here, modify the DTD table to change the HTML parser (add new tags for exemples) HTML_ADDRESS,
HTML_ARTICLE,
#undef HTML_ATTR HTML_ASIDE,
#define HTML_ATTR(t,a) MY_HTML_##t##_##a HTML_FOOTER,
HTML_HEADER,
enum HTML_H1,
{ HTML_H2,
HTML_ATTR(HTML,DIR) = 0, HTML_H3,
HTML_ATTR(HTML,LANG), HTML_H4,
HTML_ATTR(HTML,VERSION), HTML_H5,
HTML_ATTR(HTML,STYLE), HTML_H6,
}; HTML_HGROUP,
HTML_MAIN,
enum HTML_NAV,
{ HTML_SECTION,
HTML_ATTR(A,ACCESSKEY) = 0, // text content
HTML_ATTR(A,CHARSET), HTML_BLOCKQUOTE,
HTML_ATTR(A,CLASS), HTML_DD,
HTML_ATTR(A,COORDS), HTML_DIR,
HTML_ATTR(A,DIR), HTML_DIV,
HTML_ATTR(A,HREF), HTML_DL,
HTML_ATTR(A,HREFLANG), HTML_DT,
HTML_ATTR(A,ID), HTML_FIGCAPTION,
HTML_ATTR(A,NAME), HTML_FIGURE,
HTML_ATTR(A,REL), HTML_HR,
HTML_ATTR(A,REV), HTML_LI,
HTML_ATTR(A,SHAPE), HTML_OL,
HTML_ATTR(A,STYLE), HTML_P,
HTML_ATTR(A,TABINDEX), HTML_PRE,
HTML_ATTR(A,TARGET), HTML_UL,
HTML_ATTR(A,TYPE), // inline text
HTML_ATTR(A,TITLE), HTML_A,
HTML_ATTR(A,Z_ACTION_CATEGORY), HTML_ABBR,
HTML_ATTR(A,Z_ACTION_PARAMS), HTML_B,
HTML_ATTR(A,Z_ACTION_SHORTCUT), HTML_BDI,
}; HTML_BDO,
HTML_BR,
enum HTML_CITE,
{ HTML_CODE,
HTML_ATTR(TABLE,ALIGN) = 0, HTML_DATA,
HTML_ATTR(TABLE,BGCOLOR), HTML_DFN,
HTML_ATTR(TABLE,BORDER), HTML_EM,
HTML_ATTR(TABLE,BORDERCOLOR), HTML_I,
HTML_ATTR(TABLE,CELLPADDING), HTML_KBD,
HTML_ATTR(TABLE,CELLSPACING), HTML_MARK,
HTML_ATTR(TABLE,CLASS), HTML_Q,
HTML_ATTR(TABLE,DIR), HTML_RB,
HTML_ATTR(TABLE,FRAME), HTML_RP,
HTML_ATTR(TABLE,ID), HTML_RT,
HTML_ATTR(TABLE,L_MARGIN), HTML_RTC,
HTML_ATTR(TABLE,LANG), HTML_RUBY,
HTML_ATTR(TABLE,NOWRAP), HTML_S,
HTML_ATTR(TABLE,RULES), HTML_SAMP,
HTML_ATTR(TABLE,SUMMARY), HTML_SMALL,
HTML_ATTR(TABLE,STYLE), HTML_SPAN,
HTML_ATTR(TABLE,TITLE), HTML_STRONG,
HTML_ATTR(TABLE,VALIGN), HTML_SUB,
HTML_ATTR(TABLE,WIDTH) HTML_SUP,
}; HTML_TIME,
HTML_TT,
enum HTML_U,
{ HTML_VAR,
HTML_ATTR(TR,ALIGN) = 0, HTML_WBR,
HTML_ATTR(TR,BGCOLOR), // image, multimedia
HTML_ATTR(TR,L_MARGIN), HTML_AREA,
HTML_ATTR(TR,NOWRAP), HTML_AUDIO,
HTML_ATTR(TR,VALIGN), HTML_IMG,
HTML_ATTR(TR,STYLE), HTML_MAP,
}; HTML_TRACK,
HTML_VIDEO,
enum // embedded content
{ HTML_APPLET,
HTML_ATTR(TD,ABBR) = 0, HTML_EMBED,
HTML_ATTR(TD,ALIGN), HTML_IFRAME,
HTML_ATTR(TD,AXIS), HTML_NOEMBED,
HTML_ATTR(TD,BGCOLOR), HTML_OBJECT,
HTML_ATTR(TD,CHAR), HTML_PARAM,
HTML_ATTR(TD,CHAROFF), HTML_PICTURE,
HTML_ATTR(TD,CLASS), HTML_SOURCE,
HTML_ATTR(TD,COLSPAN), // scripting
HTML_ATTR(TD,DIR), HTML_CANVAS,
HTML_ATTR(TD,ID), HTML_NOSCRIPT,
HTML_ATTR(TD,HEADERS), HTML_SCRIPT,
HTML_ATTR(TD,HEIGHT), // demarcating edits
HTML_ATTR(TD,L_MARGIN), HTML_DEL,
HTML_ATTR(TD,LANG), HTML_INS,
HTML_ATTR(TD,NOWRAP), // table
HTML_ATTR(TD,ROWSPAN), HTML_CAPTION,
HTML_ATTR(TD,SCOPE), HTML_COL,
HTML_ATTR(TD,STYLE), HTML_COLGROUP,
HTML_ATTR(TD,TITLE), HTML_TABLE,
HTML_ATTR(TD,VALIGN), HTML_TBODY,
HTML_ATTR(TD,WIDTH), HTML_TD,
}; HTML_TFOOT,
HTML_TH,
enum HTML_THEAD,
{ HTML_TR,
HTML_ATTR(IMG,ALIGN) = 0, // forms
HTML_ATTR(IMG,ALT), HTML_BUTTON,
HTML_ATTR(IMG,BORDER), HTML_DATALIST,
HTML_ATTR(IMG,CLASS), HTML_FIELDSET,
HTML_ATTR(IMG,DIR), HTML_FORM,
HTML_ATTR(IMG,GLOBAL_COLOR), HTML_INPUT,
HTML_ATTR(IMG,HEIGHT), HTML_LABEL,
HTML_ATTR(IMG,HSPACE), HTML_LEGEND,
HTML_ATTR(IMG,ID), HTML_METER,
HTML_ATTR(IMG,ISMAP), HTML_OPTGROUP,
HTML_ATTR(IMG,LANG), HTML_OPTION,
HTML_ATTR(IMG,LONGDESC), HTML_OUTPUT,
HTML_ATTR(IMG,SRC), HTML_PROGRESS,
HTML_ATTR(IMG,STYLE), HTML_SELECT,
HTML_ATTR(IMG,TITLE), HTML_TEXTAREA,
HTML_ATTR(IMG,USEMAP), // interactive elements
HTML_ATTR(IMG,VSPACE), HTML_DETAILS,
HTML_ATTR(IMG,WIDTH), HTML_DIALOG,
// not sorted to keep enum values HTML_MENU,
HTML_ATTR(IMG,DATA_OVER_SRC), HTML_MENUITEM,
}; HTML_SUMMARY,
// -- tags for ryzom --
enum HTML_FONT,
{ HTML_LUA,
HTML_ATTR(INPUT,ACCEPT) = 0, // last entry for unknown elements
HTML_ATTR(INPUT,ACCESSKEY), HTML_NB_ELEMENTS
HTML_ATTR(INPUT,ALIGN), } HTMLElement;
HTML_ATTR(INPUT,ALT),
HTML_ATTR(INPUT,CHECKED), // case insensitive lookup for HTMLElement enum by name
HTML_ATTR(INPUT,CLASS), // return HTML_NB_ELEMENTS if no match
HTML_ATTR(INPUT,DIR), HTMLElement htmlElementLookup(const char *name);
HTML_ATTR(INPUT,DISABLED),
HTML_ATTR(INPUT,GLOBAL_COLOR),
HTML_ATTR(INPUT,ID),
HTML_ATTR(INPUT,LANG),
HTML_ATTR(INPUT,MAXLENGTH),
HTML_ATTR(INPUT,NAME),
HTML_ATTR(INPUT,READONLY),
HTML_ATTR(INPUT,SIZE),
HTML_ATTR(INPUT,SRC),
HTML_ATTR(INPUT,STYLE),
HTML_ATTR(INPUT,TABINDEX),
HTML_ATTR(INPUT,TITLE),
HTML_ATTR(INPUT,TYPE),
HTML_ATTR(INPUT,USEMAP),
HTML_ATTR(INPUT,VALUE),
HTML_ATTR(INPUT,Z_BTN_TMPL),
HTML_ATTR(INPUT,Z_INPUT_TMPL),
HTML_ATTR(INPUT,Z_INPUT_WIDTH),
};
enum
{
HTML_ATTR(TEXTAREA,CLASS) = 0,
HTML_ATTR(TEXTAREA,COLS),
HTML_ATTR(TEXTAREA,DIR),
HTML_ATTR(TEXTAREA,DISABLED),
HTML_ATTR(TEXTAREA,ID),
HTML_ATTR(TEXTAREA,LANG),
HTML_ATTR(TEXTAREA,MAXLENGTH),
HTML_ATTR(TEXTAREA,NAME),
HTML_ATTR(TEXTAREA,READONLY),
HTML_ATTR(TEXTAREA,ROWS),
HTML_ATTR(TEXTAREA,STYLE),
HTML_ATTR(TEXTAREA,TABINDEX),
HTML_ATTR(TEXTAREA,TITLE),
HTML_ATTR(TEXTAREA,Z_INPUT_TMPL),
};
enum
{
HTML_ATTR(P,QUICK_HELP_CONDITION) = 0,
HTML_ATTR(P,QUICK_HELP_EVENTS),
HTML_ATTR(P,QUICK_HELP_LINK),
HTML_ATTR(P,NAME),
HTML_ATTR(P,STYLE),
};
enum
{
HTML_ATTR(DIV,CLASS) = 0,
HTML_ATTR(DIV,ID),
HTML_ATTR(DIV,NAME),
HTML_ATTR(DIV,STYLE),
};
enum
{
HTML_ATTR(SPAN,CLASS) = 0,
HTML_ATTR(SPAN,ID),
HTML_ATTR(SPAN,STYLE),
};
enum
{
HTML_ATTR(H1,CLASS) = 0,
HTML_ATTR(H1,ID),
HTML_ATTR(H1,STYLE),
};
enum
{
HTML_ATTR(H2,CLASS) = 0,
HTML_ATTR(H2,ID),
HTML_ATTR(H2,STYLE),
};
enum
{
HTML_ATTR(H3,CLASS) = 0,
HTML_ATTR(H3,ID),
HTML_ATTR(H3,STYLE),
};
enum
{
HTML_ATTR(H4,CLASS) = 0,
HTML_ATTR(H4,ID),
HTML_ATTR(H4,STYLE),
};
enum
{
HTML_ATTR(H5,CLASS) = 0,
HTML_ATTR(H5,ID),
HTML_ATTR(H5,STYLE),
};
enum
{
HTML_ATTR(H6,CLASS) = 0,
HTML_ATTR(H6,ID),
HTML_ATTR(H6,STYLE),
};
#undef HTML_ATTR
// *************************************************************************** // ***************************************************************************
// Read HTML color value from src and set dest // Read HTML color value from src and set dest

File diff suppressed because it is too large Load Diff

@ -631,19 +631,10 @@ namespace NLGUI
{ {
result.clear(); result.clear();
} }
else if (result.empty() || !current.empty()) else if (!current.empty())
{
// pseudo element like ':before' can only be set on the last selector
if (!result.empty() && !pseudoElement.empty())
{
// failed
result.clear();
}
else
{ {
result.push_back(current); result.push_back(current);
} }
}
return result; return result;
} }

@ -310,5 +310,43 @@ namespace NLGUI
} }
} }
std::string CCssSelector::toString() const
{
std::string ret;
ret += Element;
ret += Id;
if (!Class.empty())
{
for(uint i = 0; i<Class.size(); i++)
ret += "." + Class[i];
}
if (!Attr.empty())
{
for(uint i = 0; i<Attr.size(); ++i)
{
ret += "[" + Attr[i].key;
if (Attr[i].op != ' ')
{
ret += Attr[i].op + Attr[i].value;
}
ret += "]";
}
}
if (!PseudoClass.empty())
{
for(uint i = 0; i<PseudoClass.size(); ++i)
{
ret += ":" + PseudoClass[i];
}
}
if (Combinator != '\0')
{
ret += Combinator;
}
// ret += ":" + PseudoClass;
return ret;
}
} // namespace } // namespace

@ -89,8 +89,7 @@ namespace NLGUI
} }
elm.Style.clear(); elm.Style.clear();
elm.StyleBefore.clear(); elm.clearPseudo();
elm.StyleAfter.clear();
if (!mRules.empty()) if (!mRules.empty())
{ {
@ -101,13 +100,9 @@ namespace NLGUI
{ {
merge(elm.Style, i->Properties); merge(elm.Style, i->Properties);
} }
else if (i->PseudoElement == ":before") else
{
merge(elm.StyleBefore, i->Properties);
}
else if (i->PseudoElement == ":after")
{ {
merge(elm.StyleAfter, i->Properties); elm.setPseudo(i->PseudoElement, i->Properties);
} }
} }
} }
@ -332,10 +327,18 @@ namespace NLGUI
return; return;
} }
// first pass: normalize(styleRules, style, current);
apply(style, current);
}
// first pass
// - get font-size for 'em' sizes // - get font-size for 'em' sizes
// - split shorthand to its parts // - split shorthand to its parts
// - get TextColor value that could be used for 'currentcolor' // - get TextColor value that could be used for 'currentcolor'
// - normalize values
void CCssStyle::normalize(const TStyle &styleRules, CStyleParams &style, const CStyleParams &current) const
{
TStyle::const_iterator it;
for (it=styleRules.begin(); it != styleRules.end(); ++it) for (it=styleRules.begin(); it != styleRules.end(); ++it)
{ {
// update local copy of applied style // update local copy of applied style
@ -407,6 +410,7 @@ namespace NLGUI
} }
else else
{ {
float tmpf;
std::string unit; std::string unit;
if (getCssLength(tmpf, unit, it->second.c_str())) if (getCssLength(tmpf, unit, it->second.c_str()))
{ {
@ -428,10 +432,39 @@ namespace NLGUI
{ {
parseBackgroundShorthand(it->second, style); parseBackgroundShorthand(it->second, style);
} }
else
if (it->first == "background-repeat")
{
// old ryzom specific value
if (it->second == "1")
style.StyleRules[it->first] = "repeat";
}
else
if (it->first == "background-scale")
{
// replace old ryzom specific rule with background-size
if (it->second != "1")
{
style.StyleRules["background-size"] = "auto";
}
else
{
style.StyleRules["background-size"] = "100%";
} }
// second pass: rest of style TStyle::iterator pos = style.StyleRules.find(it->first);
for (it=styleRules.begin(); it != styleRules.end(); ++it) if (pos != style.StyleRules.end())
style.StyleRules.erase(pos);
}
}
}
// apply style rules
void CCssStyle::apply(CStyleParams &style, const CStyleParams &current) const
{
float tmpf;
TStyle::const_iterator it;
for (it=style.StyleRules.begin(); it != style.StyleRules.end(); ++it)
{ {
if (it->first == "border" || it->first == "border-width") if (it->first == "border" || it->first == "border-width")
{ {
@ -458,6 +491,7 @@ namespace NLGUI
} }
else else
{ {
float tmpf;
std::string unit; std::string unit;
if (getCssLength(tmpf, unit, it->second.c_str())) if (getCssLength(tmpf, unit, it->second.c_str()))
{ {
@ -767,6 +801,42 @@ namespace NLGUI
else else
scanHTMLColor(it->second.c_str(), style.BackgroundColorOver); scanHTMLColor(it->second.c_str(), style.BackgroundColorOver);
} }
else
if (it->first == "background-image")
{
// normalize
std::string image = trim(it->second);
if (toLower(image.substr(0, 4)) == "url(")
{
image = image.substr(4, image.size()-5);
}
style.StyleRules[it->first] = trimQuotes(image);
}
else
if (it->first == "background-repeat")
{
// normalize
std::string val = toLower(trim(it->second));
std::vector<std::string> parts;
NLMISC::splitString(val, " ", parts);
// check for "repeat repeat"
if (parts.size() == 2 && parts[0] == parts[1])
val = parts[0];
style.StyleRules[it->first] = val;
}
else
if (it->first == "background-size")
{
// normalize
std::string val = toLower(trim(it->second));
std::vector<std::string> parts;
NLMISC::splitString(val, " ", parts);
if (parts.size() == 2 && parts[0] == parts[1])
val = parts[0];
style.StyleRules[it->first] = val;
}
} }
// if outer element has underline set, then inner element cannot remove it // if outer element has underline set, then inner element cannot remove it
@ -795,47 +865,169 @@ namespace NLGUI
"background-attachment", "background-origin", "background-clip", "background-color"}; "background-attachment", "background-origin", "background-clip", "background-color"};
std::string values[nbProps]; std::string values[nbProps];
bool found[nbProps] = {false}; bool found[nbProps] = {false};
bool bgClipFound = false;
std::string bgClipValue;
std::string bgPositionX;
std::string bgPositionY;
uint partIndex = 0; uint partIndex = 0;
std::vector<std::string> parts; std::vector<std::string> parts;
std::vector<std::string>::iterator it; std::vector<std::string>::iterator it;
// FIXME: this will fail if url() contains ' ' chars // FIXME: this will fail if url() contains ' ' chars
// FIXME: this will also fail on 'background: rgb(255, 0, 0)'
NLMISC::splitString(value, " ", parts); NLMISC::splitString(value, " ", parts);
bool failed = false; bool failed = false;
for(uint index = 0; index < parts.size(); index++) bool allowSize = false;
uint index = 0;
while(!failed && index < parts.size())
{ {
const std::string val = toLower(trim(parts[index])); std::string val = toLower(parts[index]);
bool matches = false;
for(uint i = 0; i < nbProps; i++) for(uint i = 0; i < nbProps; i++)
{ {
if (found[i]) if (found[i]) continue;
{
continue;
}
if (props[i] == "background-image") if (props[i] == "background-image")
{ {
if (val.substr(0, 4) == "url(") if (val.substr(0, 4) == "url(")
{ {
matches = true;
found[i] = true;
// use original value as 'val' is lowercase // use original value as 'val' is lowercase
values[i] = parts[index]; values[i] = parts[index];
found[i] = true;
} }
} }
else if (props[i] == "background-position") else if (props[i] == "background-position")
{ {
// TODO: uint next = index;
bool loop = false;
do
{
float fval;
std::string unit;
// first loop -> true
// second loop -> false && break
loop = !loop;
val = toLower(parts[next]);
if (val == "center")
{
if (bgPositionX.empty()) bgPositionX = "center";
if (bgPositionY.empty()) bgPositionY = "center";
// consume 'center'
next++;
}
else if (val == "left" || val == "right")
{
bgPositionX = val;
// consume 'left|right'
next++;
if(next < parts.size() && getCssLength(fval, unit, parts[next]))
{
bgPositionX += " " + toString("%.0f%s", fval, unit.c_str());
// consume css length
next++;
}
}
else if (val == "top" || val == "bottom")
{
bgPositionY = val;
// consume top|bottom
next++;
if (next < parts.size() && getCssLength(fval, unit, parts[next]))
{
bgPositionY += " " + toString("%.0f%s", fval, unit.c_str());
// consume css length
next++;
}
}
} while (loop);
//
if (!bgPositionX.empty() && !bgPositionY.empty())
{
matches = true;
found[i] = true;
// consume position values if there were any
index = next-1;
// look ahead to see if size is next
if (next < parts.size() && parts[next] == "/")
allowSize = true;
}
} }
else if (props[i] == "background-size") else if (props[i] == "background-size")
{ {
// TODO: [<length-percentage> | auto ]{1,2} cover | contain if (allowSize && val == "/")
{
uint next = index + 1;
if (next < parts.size())
{
val = toLower(parts[next]);
if (val == "cover" || val == "contain")
{
matches = true;
found[i] = true;
values[i] = val;
index = next;
}
else
{
float fval;
std::string unit;
std::string h, v;
if (val == "auto" || getCssLength(fval, unit, val))
{
if (val == "auto")
h = v = "auto";
else
h = v = toString("%.0f%s", fval, unit.c_str());
next++;
if (next < parts.size())
{
val = toLower(parts[next]);
if (val == "auto")
v = "auto";
else if (getCssLength(fval, unit, val))
v = toString("%.0f%s", fval, unit.c_str());
else
next--; // not size token
}
else
{
// not size token
next--;
}
}
if (!h.empty() && !v.empty())
{
matches = true;
found[i] = true;
values[i] = h + " " + v;
index = next;
}
}
}
else
{
// no size, just '/'
failed = true;
break;
}
}
} }
else if (props[i] == "background-repeat") else if (props[i] == "background-repeat")
{ {
if (val == "repeat-x" || val == "repeat-y" || val == "repeat" || val == "space" || val == "round" || val == "no-repeat") if (val == "repeat-x" || val == "repeat-y" || val == "repeat" || val == "space" || val == "round" || val == "no-repeat")
{ {
matches = true;
found[i] = true;
if (val == "repeat-x") if (val == "repeat-x")
{ {
values[i] = "repeat no-repeat"; values[i] = "repeat no-repeat";
@ -848,63 +1040,104 @@ namespace NLGUI
{ {
std::string horiz = val; std::string horiz = val;
std::string vert = val; std::string vert = val;
if (index+1 < parts.size()) uint next = index + 1;
if (next < parts.size())
{ {
std::string next = toLower(trim(parts[index+1])); val = toLower(parts[next]);
if (next == "repeat" || next == "space" || next == "round" || next == "no-repeat") if (val == "repeat" || val == "space" || val == "round" || val == "no-repeat")
{ {
vert = next; vert = val;
index++; index = next;
} }
} }
if (vert == horiz)
values[i] = vert;
else
values[i] = horiz + " " + vert; values[i] = horiz + " " + vert;
} }
found[i] = true;
} }
} }
else if (props[i] == "background-attachment") else if (props[i] == "background-attachment")
{ {
// TODO: scroll | fixed | local if (val == "scroll" || val == "fixed" || val == "local")
{
matches = true;
found[i] = true;
values[i] = val;
} }
else if (props[i] == "background-origin" || props[i] == "background-clip") }
else if (props[i] == "background-origin")
{ {
// same values for both
if (val == "padding-box" || val == "border-box" || val == "content-box") if (val == "padding-box" || val == "border-box" || val == "content-box")
{ {
matches = true;
found[i] = true;
values[i] = val; values[i] = val;
// first time background-origin is set, also set background-clip
if (!bgClipFound)
bgClipValue = val;
}
}
else if (props[i] == "background-clip")
{
if (val == "text" || val == "padding-box" || val == "border-box" || val == "content-box")
{
matches = true;
found[i] = true; found[i] = true;
bgClipFound = true;
bgClipValue = val;
} }
} }
else if (props[i] == "background-color") else if (props[i] == "background-color")
{ {
CRGBA color; CRGBA color;
if (!scanHTMLColor(val.c_str(), color)) if (val == "transparent" || val == "currentcolor" || scanHTMLColor(val.c_str(), color))
{ {
failed = true; matches = true;
break; found[i] = true;
}
values[i] = val; values[i] = val;
// color should come as last item
break;
} }
} }
// prop was found and parsed
if (found[i])
break;
}
failed = !matches;
index++;
} }
// invalidate whole rule // invalidate whole rule
if (failed) if (failed)
{ {
return; bgClipFound = false;
for(uint i = 0; i < nbProps; i++)
{
found[i] = false;
}
} }
// apply found styles // apply found styles or use default
for(uint i = 0; i < nbProps; i++) for(uint i = 0; i < nbProps; i++)
{ {
if (found[i]) if (found[i])
{
if (props[i] == "background-position")
{
style.StyleRules["background-position-x"] = bgPositionX;
style.StyleRules["background-position-y"] = bgPositionY;
}
else if (props[i] == "background-clip")
{
style.StyleRules["background-clip"] = bgClipValue;
}
else
{ {
style.StyleRules[props[i]] = values[i]; style.StyleRules[props[i]] = values[i];
} }
}
else else
{ {
// fill in default if one is set // fill in default if one is set
@ -914,27 +1147,32 @@ namespace NLGUI
} }
else if (props[i] == "background-position") else if (props[i] == "background-position")
{ {
//style.StyleRules[props[i]] = "0% 0%"; style.StyleRules[props[i]] = "0% 0%";
style.StyleRules["background-position-x"] = "left 0%";
style.StyleRules["background-position-y"] = "top 0%";
} }
else if (props[i] == "background-size") else if (props[i] == "background-size")
{ {
//style.StyleRules[props[i]] = "auto auto"; style.StyleRules[props[i]] = "auto auto";
} }
else if (props[i] == "background-repeat") else if (props[i] == "background-repeat")
{ {
style.StyleRules[props[i]] = "repeat repeat"; style.StyleRules[props[i]] = "repeat";
} }
else if(props[i] == "background-attachment") else if(props[i] == "background-attachment")
{ {
//style.StyleRules[props[i]] = "scroll"; style.StyleRules[props[i]] = "scroll";
} }
else if(props[i] == "background-origin") else if(props[i] == "background-origin")
{ {
//style.StyleRules[props[i]] = "padding-box"; style.StyleRules[props[i]] = "padding-box";
} }
else if (props[i] == "background-clip") else if (props[i] == "background-clip")
{ {
//style.StyleRules[props[i]] = "border-box"; if (bgClipFound)
style.StyleRules[props[i]] = bgClipValue;
else
style.StyleRules[props[i]] = "border-box";
} }
else if (props[i] == "background-color") else if (props[i] == "background-color")
{ {

File diff suppressed because it is too large Load Diff

@ -82,6 +82,46 @@ namespace NLGUI
} }
} }
// ***************************************************************************
void CHtmlElement::clearPseudo()
{
_Pseudo.clear();
}
// ***************************************************************************
bool CHtmlElement::hasPseudo(const std::string &key) const
{
return _Pseudo.find(key) != _Pseudo.end();
}
// ***************************************************************************
TStyle CHtmlElement::getPseudo(const std::string &key) const
{
std::map<std::string, TStyle>::const_iterator it = _Pseudo.find(key);
if (it != _Pseudo.end())
return it->second;
return TStyle();
}
// ***************************************************************************
void CHtmlElement::setPseudo(const std::string &key, const TStyle &style)
{
std::map<std::string, TStyle>::iterator it = _Pseudo.find(key);
if (it != _Pseudo.end())
{
// insert into previous, override previous values if they exist
for(TStyle::const_iterator itStyle = style.begin(); itStyle != style.end(); ++itStyle)
{
it->second[itStyle->first] = itStyle->second;
}
}
else
{
_Pseudo[key] = style;
}
}
// *************************************************************************** // ***************************************************************************
std::string CHtmlElement::toString(bool tree, uint depth) const std::string CHtmlElement::toString(bool tree, uint depth) const
{ {

@ -59,8 +59,6 @@ namespace NLGUI
// recursive function to walk html document // recursive function to walk html document
void CHtmlParser::parseNode(xmlNode *a_node, CHtmlElement &parent, std::string &styleString, std::vector<std::string> &links) const void CHtmlParser::parseNode(xmlNode *a_node, CHtmlElement &parent, std::string &styleString, std::vector<std::string> &links) const
{ {
SGML_dtd *HTML_DTD = HTML_dtd ();
uint childIndex = 0; uint childIndex = 0;
uint element_number; uint element_number;
xmlNode *node = a_node; xmlNode *node = a_node;
@ -73,12 +71,8 @@ namespace NLGUI
else else
if (node->type == XML_ELEMENT_NODE) if (node->type == XML_ELEMENT_NODE)
{ {
// find libwww tag // find html element
for(element_number = 0; element_number<HTML_ELEMENTS; ++element_number) element_number = htmlElementLookup((const char*)node->name);
{
if (xmlStrncasecmp(node->name, (const xmlChar *)HTML_DTD->tags[element_number].name.c_str(), xmlStrlen(node->name)) == 0)
break;
}
// get pointer to previous sibling // get pointer to previous sibling
CHtmlElement *prevSibling = NULL; CHtmlElement *prevSibling = NULL;

@ -29,268 +29,177 @@ using namespace NLMISC;
namespace NLGUI namespace NLGUI
{ {
struct CNameToHtmlElement
// ***************************************************************************
/// the cookie value for session identification (nel cookie)
std::string CurrentCookie;
/// store all cookies we receive and resent them depending of the domain
static std::map<std::string, std::map<std::string, std::string> > HTTPCookies;
// ***************************************************************************
// Some DTD table
// Here, modify the DTD table to change the HTML parser (add new tags for examples)
#undef HTML_ATTR
#define HTML_ATTR(a,b) { (char*) #b }
HTAttr html_attr[] =
{ {
HTML_ATTR(HTML,DIR), HTMLElement ID;
HTML_ATTR(HTML,LANG), const char* Name;
HTML_ATTR(HTML,VERSION), CNameToHtmlElement(HTMLElement id, const char*name)
HTML_ATTR(HTML,STYLE), : ID(id), Name(name) {}
{ 0 }
};
HTAttr a_attr[] =
{
HTML_ATTR(A,ACCESSKEY),
HTML_ATTR(A,CHARSET),
HTML_ATTR(A,CLASS),
HTML_ATTR(A,COORDS),
HTML_ATTR(A,DIR),
HTML_ATTR(A,HREF),
HTML_ATTR(A,HREFLANG),
HTML_ATTR(A,ID),
HTML_ATTR(A,NAME),
HTML_ATTR(A,REL),
HTML_ATTR(A,REV),
HTML_ATTR(A,SHAPE),
HTML_ATTR(A,STYLE),
HTML_ATTR(A,TABINDEX),
HTML_ATTR(A,TARGET),
HTML_ATTR(A,TYPE),
HTML_ATTR(A,TITLE),
HTML_ATTR(A,Z_ACTION_CATEGORY),
HTML_ATTR(A,Z_ACTION_PARAMS),
HTML_ATTR(A,Z_ACTION_SHORTCUT),
{ 0 }
}; };
HTAttr table_attr[] = // sorted list of HTML_ELEMENT enum to TAG name
{ static CNameToHtmlElement htmlElementToName[] =
HTML_ATTR(TABLE,ALIGN), {
HTML_ATTR(TABLE,BGCOLOR), CNameToHtmlElement(HTML_A, "a"),
HTML_ATTR(TABLE,BORDER), CNameToHtmlElement(HTML_ABBR, "abbr"),
HTML_ATTR(TABLE,BORDERCOLOR), CNameToHtmlElement(HTML_ADDRESS, "address"),
HTML_ATTR(TABLE,CELLPADDING), CNameToHtmlElement(HTML_APPLET, "applet"),
HTML_ATTR(TABLE,CELLSPACING), CNameToHtmlElement(HTML_AREA, "area"),
HTML_ATTR(TABLE,CLASS), CNameToHtmlElement(HTML_ARTICLE, "article"),
HTML_ATTR(TABLE,DIR), CNameToHtmlElement(HTML_ASIDE, "aside"),
HTML_ATTR(TABLE,FRAME), CNameToHtmlElement(HTML_AUDIO, "audio"),
HTML_ATTR(TABLE,ID), CNameToHtmlElement(HTML_B, "b"),
HTML_ATTR(TABLE,L_MARGIN), CNameToHtmlElement(HTML_BASE, "base"),
HTML_ATTR(TABLE,LANG), CNameToHtmlElement(HTML_BDI, "bdi"),
HTML_ATTR(TABLE,NOWRAP), CNameToHtmlElement(HTML_BDO, "bdo"),
HTML_ATTR(TABLE,RULES), CNameToHtmlElement(HTML_BLOCKQUOTE, "blockquote"),
HTML_ATTR(TABLE,SUMMARY), CNameToHtmlElement(HTML_BODY, "body"),
HTML_ATTR(TABLE,STYLE), CNameToHtmlElement(HTML_BR, "br"),
HTML_ATTR(TABLE,TITLE), CNameToHtmlElement(HTML_BUTTON, "button"),
HTML_ATTR(TABLE,VALIGN), CNameToHtmlElement(HTML_CANVAS, "canvas"),
HTML_ATTR(TABLE,WIDTH), CNameToHtmlElement(HTML_CAPTION, "caption"),
{ 0 } CNameToHtmlElement(HTML_CITE, "cite"),
CNameToHtmlElement(HTML_CODE, "code"),
CNameToHtmlElement(HTML_COL, "col"),
CNameToHtmlElement(HTML_COLGROUP, "colgroup"),
CNameToHtmlElement(HTML_DATA, "data"),
CNameToHtmlElement(HTML_DATALIST, "datalist"),
CNameToHtmlElement(HTML_DD, "dd"),
CNameToHtmlElement(HTML_DEL, "del"),
CNameToHtmlElement(HTML_DETAILS, "details"),
CNameToHtmlElement(HTML_DFN, "dfn"),
CNameToHtmlElement(HTML_DIALOG, "dialog"),
CNameToHtmlElement(HTML_DIR, "dir"),
CNameToHtmlElement(HTML_DIV, "div"),
CNameToHtmlElement(HTML_DL, "dl"),
CNameToHtmlElement(HTML_DT, "dt"),
CNameToHtmlElement(HTML_EM, "em"),
CNameToHtmlElement(HTML_EMBED, "embed"),
CNameToHtmlElement(HTML_FIELDSET, "fieldset"),
CNameToHtmlElement(HTML_FIGCAPTION, "figcaption"),
CNameToHtmlElement(HTML_FIGURE, "figure"),
CNameToHtmlElement(HTML_FONT, "font"),
CNameToHtmlElement(HTML_FOOTER, "footer"),
CNameToHtmlElement(HTML_FORM, "form"),
CNameToHtmlElement(HTML_H1, "h1"),
CNameToHtmlElement(HTML_H2, "h2"),
CNameToHtmlElement(HTML_H3, "h3"),
CNameToHtmlElement(HTML_H4, "h4"),
CNameToHtmlElement(HTML_H5, "h5"),
CNameToHtmlElement(HTML_H6, "h6"),
CNameToHtmlElement(HTML_HEAD, "head"),
CNameToHtmlElement(HTML_HEADER, "header"),
CNameToHtmlElement(HTML_HGROUP, "hgroup"),
CNameToHtmlElement(HTML_HR, "hr"),
CNameToHtmlElement(HTML_HTML, "html"),
CNameToHtmlElement(HTML_I, "i"),
CNameToHtmlElement(HTML_IFRAME, "iframe"),
CNameToHtmlElement(HTML_IMG, "img"),
CNameToHtmlElement(HTML_INPUT, "input"),
CNameToHtmlElement(HTML_INS, "ins"),
CNameToHtmlElement(HTML_KBD, "kbd"),
CNameToHtmlElement(HTML_LABEL, "label"),
CNameToHtmlElement(HTML_LEGEND, "legend"),
CNameToHtmlElement(HTML_LI, "li"),
CNameToHtmlElement(HTML_LINK, "link"),
CNameToHtmlElement(HTML_LUA, "lua"),
CNameToHtmlElement(HTML_MAIN, "main"),
CNameToHtmlElement(HTML_MAP, "map"),
CNameToHtmlElement(HTML_MARK, "mark"),
CNameToHtmlElement(HTML_MENU, "menu"),
CNameToHtmlElement(HTML_MENUITEM, "menuitem"),
CNameToHtmlElement(HTML_META, "meta"),
CNameToHtmlElement(HTML_METER, "meter"),
CNameToHtmlElement(HTML_NAV, "nav"),
CNameToHtmlElement(HTML_NOEMBED, "noembed"),
CNameToHtmlElement(HTML_NOSCRIPT, "noscript"),
CNameToHtmlElement(HTML_OBJECT, "object"),
CNameToHtmlElement(HTML_OL, "ol"),
CNameToHtmlElement(HTML_OPTGROUP, "optgroup"),
CNameToHtmlElement(HTML_OPTION, "option"),
CNameToHtmlElement(HTML_OUTPUT, "output"),
CNameToHtmlElement(HTML_P, "p"),
CNameToHtmlElement(HTML_PARAM, "param"),
CNameToHtmlElement(HTML_PICTURE, "picture"),
CNameToHtmlElement(HTML_PRE, "pre"),
CNameToHtmlElement(HTML_PROGRESS, "progress"),
CNameToHtmlElement(HTML_Q, "q"),
CNameToHtmlElement(HTML_RB, "rb"),
CNameToHtmlElement(HTML_RP, "rp"),
CNameToHtmlElement(HTML_RT, "rt"),
CNameToHtmlElement(HTML_RTC, "rtc"),
CNameToHtmlElement(HTML_RUBY, "ruby"),
CNameToHtmlElement(HTML_S, "s"),
CNameToHtmlElement(HTML_SAMP, "samp"),
CNameToHtmlElement(HTML_SCRIPT, "script"),
CNameToHtmlElement(HTML_SECTION, "section"),
CNameToHtmlElement(HTML_SELECT, "select"),
CNameToHtmlElement(HTML_SMALL, "small"),
CNameToHtmlElement(HTML_SOURCE, "source"),
CNameToHtmlElement(HTML_SPAN, "span"),
CNameToHtmlElement(HTML_STRONG, "strong"),
CNameToHtmlElement(HTML_STYLE, "style"),
CNameToHtmlElement(HTML_SUB, "sub"),
CNameToHtmlElement(HTML_SUMMARY, "summary"),
CNameToHtmlElement(HTML_SUP, "sup"),
CNameToHtmlElement(HTML_TABLE, "table"),
CNameToHtmlElement(HTML_TBODY, "tbody"),
CNameToHtmlElement(HTML_TD, "td"),
CNameToHtmlElement(HTML_TEXTAREA, "textarea"),
CNameToHtmlElement(HTML_TFOOT, "tfoot"),
CNameToHtmlElement(HTML_TH, "th"),
CNameToHtmlElement(HTML_THEAD, "thead"),
CNameToHtmlElement(HTML_TIME, "time"),
CNameToHtmlElement(HTML_TITLE, "title"),
CNameToHtmlElement(HTML_TR, "tr"),
CNameToHtmlElement(HTML_TRACK, "track"),
CNameToHtmlElement(HTML_TT, "tt"),
CNameToHtmlElement(HTML_U, "u"),
CNameToHtmlElement(HTML_UL, "ul"),
CNameToHtmlElement(HTML_VAR, "var"),
CNameToHtmlElement(HTML_VIDEO, "video"),
CNameToHtmlElement(HTML_WBR, "wbr")
}; };
HTAttr tr_attr[] = HTMLElement htmlElementLookup(const char* name)
{ {
HTML_ATTR(TR,ALIGN), uint end = sizeofarray(htmlElementToName);
HTML_ATTR(TR,BGCOLOR), uint mid = end >> 1;
HTML_ATTR(TR,L_MARGIN), sint ret;
HTML_ATTR(TR,NOWRAP), while(mid < end)
HTML_ATTR(TR,VALIGN),
HTML_ATTR(TR,STYLE),
{ 0 }
};
HTAttr td_attr[] =
{
HTML_ATTR(TD,ABBR),
HTML_ATTR(TD,ALIGN),
HTML_ATTR(TD,AXIS),
HTML_ATTR(TD,BGCOLOR),
HTML_ATTR(TD,CHAR),
HTML_ATTR(TD,CHAROFF),
HTML_ATTR(TD,CLASS),
HTML_ATTR(TD,COLSPAN),
HTML_ATTR(TD,DIR),
HTML_ATTR(TD,ID),
HTML_ATTR(TD,HEADERS),
HTML_ATTR(TD,HEIGHT),
HTML_ATTR(TD,L_MARGIN),
HTML_ATTR(TD,LANG),
HTML_ATTR(TD,NOWRAP),
HTML_ATTR(TD,ROWSPAN),
HTML_ATTR(TD,SCOPE),
HTML_ATTR(TD,STYLE),
HTML_ATTR(TD,TITLE),
HTML_ATTR(TD,VALIGN),
HTML_ATTR(TD,WIDTH),
{ 0 }
};
HTAttr img_attr[] =
{
HTML_ATTR(IMG,ALIGN),
HTML_ATTR(IMG,ALT),
HTML_ATTR(IMG,BORDER),
HTML_ATTR(IMG,CLASS),
HTML_ATTR(IMG,DIR),
HTML_ATTR(IMG,GLOBAL_COLOR),
HTML_ATTR(IMG,HEIGHT),
HTML_ATTR(IMG,HSPACE),
HTML_ATTR(IMG,ID),
HTML_ATTR(IMG,ISMAP),
HTML_ATTR(IMG,LANG),
HTML_ATTR(IMG,LONGDESC),
HTML_ATTR(IMG,SRC),
HTML_ATTR(IMG,STYLE),
HTML_ATTR(IMG,TITLE),
HTML_ATTR(IMG,USEMAP),
HTML_ATTR(IMG,VSPACE),
HTML_ATTR(IMG,WIDTH),
// not sorted to keep enum values
HTML_ATTR(IMG,DATA-OVER-SRC),
{ 0 }
};
HTAttr input_attr[] =
{
HTML_ATTR(INPUT,ACCEPT),
HTML_ATTR(INPUT,ACCESSKEY),
HTML_ATTR(INPUT,ALIGN),
HTML_ATTR(INPUT,ALT),
HTML_ATTR(INPUT,CHECKED),
HTML_ATTR(INPUT,CLASS),
HTML_ATTR(INPUT,DIR),
HTML_ATTR(INPUT,DISABLED),
HTML_ATTR(INPUT,GLOBAL_COLOR),
HTML_ATTR(INPUT,ID),
HTML_ATTR(INPUT,LANG),
HTML_ATTR(INPUT,MAXLENGTH),
HTML_ATTR(INPUT,NAME),
HTML_ATTR(INPUT,READONLY),
HTML_ATTR(INPUT,SIZE),
HTML_ATTR(INPUT,SRC),
HTML_ATTR(INPUT,STYLE),
HTML_ATTR(INPUT,TABINDEX),
HTML_ATTR(INPUT,TITLE),
HTML_ATTR(INPUT,TYPE),
HTML_ATTR(INPUT,USEMAP),
HTML_ATTR(INPUT,VALUE),
HTML_ATTR(INPUT,Z_BTN_TMPL),
HTML_ATTR(INPUT,Z_INPUT_TMPL),
HTML_ATTR(INPUT,Z_INPUT_WIDTH),
{ 0 }
};
HTAttr textarea_attr[] =
{
HTML_ATTR(TEXTAREA,CLASS),
HTML_ATTR(TEXTAREA,COLS),
HTML_ATTR(TEXTAREA,DIR),
HTML_ATTR(TEXTAREA,DISABLED),
HTML_ATTR(TEXTAREA,ID),
HTML_ATTR(TEXTAREA,LANG),
HTML_ATTR(TEXTAREA,MAXLENGTH),
HTML_ATTR(TEXTAREA,NAME),
HTML_ATTR(TEXTAREA,READONLY),
HTML_ATTR(TEXTAREA,ROWS),
HTML_ATTR(TEXTAREA,STYLE),
HTML_ATTR(TEXTAREA,TABINDEX),
HTML_ATTR(TEXTAREA,TITLE),
HTML_ATTR(TEXTAREA,Z_INPUT_TMPL),
{ 0 }
};
HTAttr p_attr[] =
{ {
HTML_ATTR(P,QUICK_HELP_CONDITION), sint ret = nlstricmp(name, htmlElementToName[mid].Name);
HTML_ATTR(P,QUICK_HELP_EVENTS), if (ret == 0)
HTML_ATTR(P,QUICK_HELP_LINK),
HTML_ATTR(P,NAME),
HTML_ATTR(P,STYLE),
{ 0 }
};
HTAttr div_attr[] =
{ {
HTML_ATTR(DIV,CLASS), return htmlElementToName[mid].ID;
HTML_ATTR(DIV,ID), }
HTML_ATTR(DIV,NAME), else if (ret < 0)
HTML_ATTR(DIV,STYLE),
{ 0 }
};
HTAttr span_attr[] =
{ {
HTML_ATTR(SPAN,CLASS), // lower half
HTML_ATTR(SPAN,ID), end = mid;
HTML_ATTR(SPAN,STYLE), mid = end >> 1;
{ 0 } }
}; else
HTAttr h1_attr[] =
{ {
HTML_ATTR(H1,CLASS), // upper half
HTML_ATTR(H1,ID), mid++;
HTML_ATTR(H1,STYLE), mid += (end - mid) >> 1;
{ 0 } }
}; }
HTAttr h2_attr[] = // not found
{ return HTML_NB_ELEMENTS;
HTML_ATTR(H2,CLASS), }
HTML_ATTR(H2,ID),
HTML_ATTR(H2,STYLE),
{ 0 }
};
HTAttr h3_attr[] = // ***************************************************************************
{
HTML_ATTR(H3,CLASS),
HTML_ATTR(H3,ID),
HTML_ATTR(H3,STYLE),
{ 0 }
};
HTAttr h4_attr[] = /// the cookie value for session identification (nel cookie)
{ std::string CurrentCookie;
HTML_ATTR(H4,CLASS),
HTML_ATTR(H4,ID),
HTML_ATTR(H4,STYLE),
{ 0 }
};
HTAttr h5_attr[] = /// store all cookies we receive and resent them depending of the domain
{ static std::map<std::string, std::map<std::string, std::string> > HTTPCookies;
HTML_ATTR(H5,CLASS),
HTML_ATTR(H5,ID),
HTML_ATTR(H5,STYLE),
{ 0 }
};
HTAttr h6_attr[] = // ***************************************************************************
{
HTML_ATTR(H6,CLASS),
HTML_ATTR(H6,ID),
HTML_ATTR(H6,STYLE),
{ 0 }
};
// *************************************************************************** // ***************************************************************************
bool getCssLength (float &value, std::string &unit, const std::string &str) bool getCssLength (float &value, std::string &unit, const std::string &str)
@ -873,58 +782,6 @@ namespace NLGUI
} }
} }
void initLibWWW()
{
static bool initialized = false;
if (!initialized)
{
// Change the HTML DTD
SGML_dtd *HTML_DTD = HTML_dtd ();
HTML_DTD->tags[HTML_HTML].attributes = html_attr;
HTML_DTD->tags[HTML_HTML].number_of_attributes = sizeof(html_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_TABLE].attributes = table_attr;
HTML_DTD->tags[HTML_TABLE].number_of_attributes = sizeof(table_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_TR].attributes = tr_attr;
HTML_DTD->tags[HTML_TR].number_of_attributes = sizeof(tr_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_TD].attributes = td_attr;
HTML_DTD->tags[HTML_TD].number_of_attributes = sizeof(td_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_TH].attributes = td_attr;
HTML_DTD->tags[HTML_TH].number_of_attributes = sizeof(td_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_IMG].attributes = img_attr;
HTML_DTD->tags[HTML_IMG].number_of_attributes = sizeof(img_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_INPUT].attributes = input_attr;
HTML_DTD->tags[HTML_INPUT].number_of_attributes = sizeof(input_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_TEXTAREA].attributes = textarea_attr;
HTML_DTD->tags[HTML_TEXTAREA].number_of_attributes = sizeof(textarea_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_P].attributes = p_attr;
HTML_DTD->tags[HTML_P].number_of_attributes = sizeof(p_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_A].attributes = a_attr;
HTML_DTD->tags[HTML_A].number_of_attributes = sizeof(a_attr) / sizeof(HTAttr) - 1;
//HTML_DTD->tags[HTML_I].attributes = a_attr;
HTML_DTD->tags[HTML_I].number_of_attributes = 0;
HTML_DTD->tags[HTML_DIV].attributes = div_attr;
HTML_DTD->tags[HTML_DIV].number_of_attributes = sizeof(div_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_SPAN].attributes = span_attr;
HTML_DTD->tags[HTML_SPAN].number_of_attributes = sizeof(span_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_H1].attributes = h1_attr;
HTML_DTD->tags[HTML_H1].number_of_attributes = sizeof(h1_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_H2].attributes = h2_attr;
HTML_DTD->tags[HTML_H2].number_of_attributes = sizeof(h2_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_H3].attributes = h3_attr;
HTML_DTD->tags[HTML_H3].number_of_attributes = sizeof(h3_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_H4].attributes = h4_attr;
HTML_DTD->tags[HTML_H4].number_of_attributes = sizeof(h4_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_H5].attributes = h5_attr;
HTML_DTD->tags[HTML_H5].number_of_attributes = sizeof(h5_attr) / sizeof(HTAttr) - 1;
HTML_DTD->tags[HTML_H6].attributes = h6_attr;
HTML_DTD->tags[HTML_H6].number_of_attributes = sizeof(h6_attr) / sizeof(HTAttr) - 1;
// Initialized
initialized = true;
}
}
// *************************************************************************** // ***************************************************************************
} }

@ -1,804 +0,0 @@
/**
libwww Copyright Notice
[This notice should be placed within redistributed or derivative software
code when appropriate. This particular formulation of W3C's notice for
inclusion in libwww code became active on August 14 1998.]
LIBWWW COPYRIGHT NOTICE
libwww: W3C's implementation of HTTP can be found at:
http://www.w3.org/Library/
Copyright ¨ 1995-2002 World Wide Web Consortium,
(Massachusetts Institute of Technology, Institut
National de Recherche en Informatique et en
Automatique, Keio University). All Rights Reserved.
This program is distributed under the W3C's
Intellectual Property License. This program is
distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See W3C License
http://www.w3.org/Consortium/Legal/ for more details.
Copyright ¨ 1995 CERN. "This product includes computer
software created and made available by CERN. This
acknowledgment shall be mentioned in full in any
product which includes the CERN computer software
included herein or parts thereof."
****************************************************************************/
#include "stdpch.h"
#include "nel/gui/libwww_types.h"
#ifdef DEBUG_NEW
#define new DEBUG_NEW
#endif
namespace NLGUI
{
/*
** ATTRIBUTE DEFINITION MACROS (see HTMLPDTD.h)
*/
/*
* redefine the macros, so that the "stringized" attribute name
* is generated
*/
#undef HTML_ATTR
#define HTML_ATTR(t,a) { (char *) #a }
#undef HTML_ATTRIBUTES
#define HTML_ATTRIBUTES(t) { 0 }
/*
** ATTRIBUTE LISTS
*/
static HTAttr no_attr[1] = {
{ 0 }
};
static HTAttr body_attr[HTML_BODY_ATTRIBUTES+1] = { /* to catch images */
HTML_ATTR(BODY,ALINK),
HTML_ATTR(BODY,BACKGROUND),
HTML_ATTR(BODY,BGCOLOR),
HTML_ATTR(BODY,CLASS),
HTML_ATTR(BODY,DIR),
HTML_ATTR(BODY,ID),
HTML_ATTR(BODY,LANG),
HTML_ATTR(BODY,LINK),
HTML_ATTR(BODY,STYLE),
HTML_ATTR(BODY,TEXT),
HTML_ATTR(BODY,TITLE),
HTML_ATTR(BODY,VLINK),
HTML_ATTRIBUTES(BODY)
};
static HTAttr frame_attr[HTML_FRAME_ATTRIBUTES+1] = { /* frame attributes */
HTML_ATTR(FRAME,CLASS),
HTML_ATTR(FRAME,FRAMEBORDER),
HTML_ATTR(FRAME,ID),
HTML_ATTR(FRAME,NAME),
HTML_ATTR(FRAME,MARGINHEIGHT),
HTML_ATTR(FRAME,MARGINWIDTH),
HTML_ATTR(FRAME,NORESIZE),
HTML_ATTR(FRAME,LONGDESC),
HTML_ATTR(FRAME,SCROLLING),
HTML_ATTR(FRAME,SRC),
HTML_ATTR(FRAME,STYLE),
HTML_ATTR(FRAME,TARGET),
HTML_ATTR(FRAME,TITLE),
HTML_ATTRIBUTES(FRAME)
};
static HTAttr frameset_attr[HTML_FRAMESET_ATTRIBUTES+1] = { /* frameset attributes */
HTML_ATTR(FRAMESET,CLASS),
HTML_ATTR(FRAMESET,COLS),
HTML_ATTR(FRAMESET,ID),
HTML_ATTR(FRAMESET,ROWS),
HTML_ATTR(FRAMESET,STYLE),
HTML_ATTR(FRAMESET,TITLE),
HTML_ATTRIBUTES(FRAMESET)
};
static HTAttr a_attr[HTML_A_ATTRIBUTES+1] = { /* Anchor attributes */
HTML_ATTR(A,ACCESSKEY),
HTML_ATTR(A,CHARSET),
HTML_ATTR(A,CLASS),
HTML_ATTR(A,COORDS),
HTML_ATTR(A,DIR),
HTML_ATTR(A,HREF),
HTML_ATTR(A,HREFLANG),
HTML_ATTR(A,ID),
HTML_ATTR(A,NAME),
HTML_ATTR(A,REL),
HTML_ATTR(A,REV),
HTML_ATTR(A,SHAPE),
HTML_ATTR(A,STYLE),
HTML_ATTR(A,TABINDEX),
HTML_ATTR(A,TARGET),
HTML_ATTR(A,TYPE),
HTML_ATTR(A,TITLE),
HTML_ATTRIBUTES(A)
};
static HTAttr applet_attr[HTML_APPLET_ATTRIBUTES+1] = {
HTML_ATTR(APPLET,ALIGN),
HTML_ATTR(APPLET,ALT),
HTML_ATTR(APPLET,ARCHIVE),
HTML_ATTR(APPLET,CLASS),
HTML_ATTR(APPLET,CODE),
HTML_ATTR(APPLET,CODEBASE),
HTML_ATTR(APPLET,HEIGHT),
HTML_ATTR(APPLET,HSPACE),
HTML_ATTR(APPLET,ID),
HTML_ATTR(APPLET,NAME),
HTML_ATTR(APPLET,OBJECT),
HTML_ATTR(APPLET,STYLE),
HTML_ATTR(APPLET,TITLE),
HTML_ATTR(APPLET,VSPACE),
HTML_ATTR(APPLET,WIDTH),
HTML_ATTRIBUTES(APPLET)
};
static HTAttr area_attr[HTML_AREA_ATTRIBUTES+1] = { /* Area attributes */
HTML_ATTR(AREA,ACCESSKEY),
HTML_ATTR(AREA,ALT),
HTML_ATTR(AREA,CLASS),
HTML_ATTR(AREA,COORDS),
HTML_ATTR(AREA,DIR),
HTML_ATTR(AREA,HREF),
HTML_ATTR(AREA,ID),
HTML_ATTR(AREA,NAME),
HTML_ATTR(AREA,NOHREF),
HTML_ATTR(AREA,LANG),
HTML_ATTR(AREA,SHAPE),
HTML_ATTR(AREA,STYLE),
HTML_ATTR(AREA,TABINDEX),
HTML_ATTR(AREA,TARGET),
HTML_ATTR(AREA,TITLE),
HTML_ATTRIBUTES(AREA)
};
static HTAttr base_attr[HTML_BASE_ATTRIBUTES+1] = { /* BASE attributes */
HTML_ATTR(BASE,HREF),
HTML_ATTR(BASE,TARGET),
HTML_ATTRIBUTES(BASE)
};
static HTAttr bdo_attr[HTML_BDO_ATTRIBUTES+1] = {
HTML_ATTR(BDO,CLASS),
HTML_ATTR(BDO,DIR),
HTML_ATTR(BDO,ID),
HTML_ATTR(BDO,LANG),
HTML_ATTR(BDO,STYLE),
HTML_ATTR(BDO,TITLE),
HTML_ATTRIBUTES(BDO)
};
static HTAttr bq_attr[HTML_BQ_ATTRIBUTES+1] = {
HTML_ATTR(BQ,CITE),
HTML_ATTR(BQ,CLASS),
HTML_ATTR(BQ,DIR),
HTML_ATTR(BQ,ID),
HTML_ATTR(BQ,LANG),
HTML_ATTR(BQ,STYLE),
HTML_ATTR(BQ,TITLE),
HTML_ATTRIBUTES(BQ)
};
static HTAttr br_attr[HTML_BR_ATTRIBUTES+1] = {
HTML_ATTR(BR,CLASS),
HTML_ATTR(BR,CLEAR),
HTML_ATTR(BR,ID),
HTML_ATTR(BR,STYLE),
HTML_ATTR(BR,TITLE),
HTML_ATTRIBUTES(BR)
};
static HTAttr button_attr[HTML_BUTTON_ATTRIBUTES+1] = {
HTML_ATTR(BUTTON,ACCESSKEY),
HTML_ATTR(BUTTON,CLASS),
HTML_ATTR(BUTTON,DIR),
HTML_ATTR(BUTTON,DISABLED),
HTML_ATTR(BUTTON,ID),
HTML_ATTR(BUTTON,LANG),
HTML_ATTR(BUTTON,NAME),
HTML_ATTR(BUTTON,STYLE),
HTML_ATTR(BUTTON,TABINDEX),
HTML_ATTR(BUTTON,TITLE),
HTML_ATTR(BUTTON,TYPE),
HTML_ATTR(BUTTON,VALUE),
HTML_ATTRIBUTES(BUTTON),
};
static HTAttr col_attr[HTML_COL_ATTRIBUTES+1] = {
HTML_ATTR(COL,CLASS),
HTML_ATTR(COL,DIR),
HTML_ATTR(COL,ID),
HTML_ATTR(COL,LANG),
HTML_ATTR(COL,SPAN),
HTML_ATTR(COL,STYLE),
HTML_ATTR(COL,TITLE),
HTML_ATTR(COL,WIDTH),
HTML_ATTRIBUTES(COL)
};
static HTAttr changes_attr[HTML_CHANGES_ATTRIBUTES+1] = {
HTML_ATTR(CHANGES,CITE),
HTML_ATTR(CHANGES,CLASS),
HTML_ATTR(CHANGES,DATETIME),
HTML_ATTR(CHANGES,DIR),
HTML_ATTR(CHANGES,ID),
HTML_ATTR(CHANGES,LANG),
HTML_ATTR(CHANGES,STYLE),
HTML_ATTR(CHANGES,TITLE),
HTML_ATTRIBUTES(CHANGES)
};
static HTAttr font_attr[HTML_FONT_ATTRIBUTES+1] = {
HTML_ATTR(FONT,CLASS),
HTML_ATTR(FONT,COLOR),
HTML_ATTR(FONT,DIR),
HTML_ATTR(FONT,FACE),
HTML_ATTR(FONT,ID),
HTML_ATTR(FONT,LANG),
HTML_ATTR(FONT,SIZE),
HTML_ATTR(FONT,STYLE),
HTML_ATTR(FONT,TITLE),
HTML_ATTRIBUTES(FONT)
};
static HTAttr form_attr[HTML_FORM_ATTRIBUTES+1] = {
HTML_ATTR(FORM,ACCEPT),
{ (char *) "ACCEPT-CHARSET" }, /* HTML_ATTR(FORM,ACCEPT_CHARSET) */
HTML_ATTR(FORM,ACTION),
HTML_ATTR(FORM,CLASS),
HTML_ATTR(FORM,DIR),
HTML_ATTR(FORM,ENCTYPE),
HTML_ATTR(FORM,ID),
HTML_ATTR(FORM,LANG),
HTML_ATTR(FORM,METHOD),
HTML_ATTR(FORM,STYLE),
HTML_ATTR(FORM,TARGET),
HTML_ATTR(FORM,TITLE),
HTML_ATTRIBUTES(FORM)
};
static HTAttr gen_attr[HTML_GEN_ATTRIBUTES+1] = { /* General, for many things */
HTML_ATTR(GEN,CLASS),
HTML_ATTR(GEN,DIR),
HTML_ATTR(GEN,ID),
HTML_ATTR(GEN,LANG),
HTML_ATTR(GEN,STYLE),
HTML_ATTR(GEN,TITLE),
HTML_ATTRIBUTES(GEN)
};
static HTAttr block_attr[HTML_BLOCK_ATTRIBUTES+1] = { /* DIV, SPAN, H1-H6 */
HTML_ATTR(BLOCK,ALIGN),
HTML_ATTR(BLOCK,CLASS),
HTML_ATTR(BLOCK,DIR),
HTML_ATTR(BLOCK,ID),
HTML_ATTR(BLOCK,LANG),
HTML_ATTR(BLOCK,STYLE),
HTML_ATTR(BLOCK,TITLE),
HTML_ATTRIBUTES(BLOCK)
};
static HTAttr head_attr[HTML_HEAD_ATTRIBUTES+1] = {
HTML_ATTR(HEAD,DIR),
HTML_ATTR(HEAD,LANG),
HTML_ATTR(HEAD,PROFILE),
HTML_ATTRIBUTES(HEAD)
};
static HTAttr hr_attr[HTML_HR_ATTRIBUTES+1] = {
HTML_ATTR(HR,ALIGN),
HTML_ATTR(HR,CLASS),
HTML_ATTR(HR,DIR),
HTML_ATTR(HR,ID),
HTML_ATTR(HR,LANG),
HTML_ATTR(HR,NOSHADE),
HTML_ATTR(HR,SIZE),
HTML_ATTR(HR,STYLE),
HTML_ATTR(HR,TITLE),
HTML_ATTR(HR,WIDTH),
HTML_ATTRIBUTES(HR)
};
static HTAttr html_attr[HTML_HTML_ATTRIBUTES+1] = {
HTML_ATTR(HTML,DIR),
HTML_ATTR(HTML,LANG),
HTML_ATTR(HTML,VERSION),
HTML_ATTRIBUTES(HTML)
};
static HTAttr iframe_attr[HTML_IFRAME_ATTRIBUTES+1] = {
HTML_ATTR(IFRAME,ALIGN),
HTML_ATTR(IFRAME,CLASS),
HTML_ATTR(IFRAME,FRAMEBORDER),
HTML_ATTR(IFRAME,HEIGHT),
HTML_ATTR(IFRAME,ID),
HTML_ATTR(IFRAME,LONGDESC),
HTML_ATTR(IFRAME,MARGINHEIGHT),
HTML_ATTR(IFRAME,MARGINWIDTH),
HTML_ATTR(IFRAME,NAME),
HTML_ATTR(IFRAME,SCROLLING),
HTML_ATTR(IFRAME,SRC),
HTML_ATTR(IFRAME,STYLE),
HTML_ATTR(IFRAME,TARGET),
HTML_ATTR(IFRAME,TITLE),
HTML_ATTR(IFRAME,WIDTH),
HTML_ATTRIBUTES(IFRAME)
};
static HTAttr img_attr[HTML_IMG_ATTRIBUTES+1] = { /* IMG attributes */
HTML_ATTR(IMG,ALIGN),
HTML_ATTR(IMG,ALT),
HTML_ATTR(IMG,BORDER),
HTML_ATTR(IMG,CLASS),
HTML_ATTR(IMG,DIR),
HTML_ATTR(IMG,HEIGHT),
HTML_ATTR(IMG,HSPACE),
HTML_ATTR(IMG,ID),
HTML_ATTR(IMG,ISMAP),
HTML_ATTR(IMG,LANG),
HTML_ATTR(IMG,LONGDESC),
HTML_ATTR(IMG,SRC),
HTML_ATTR(IMG,STYLE),
HTML_ATTR(IMG,TITLE),
HTML_ATTR(IMG,USEMAP),
HTML_ATTR(IMG,VSPACE),
HTML_ATTR(IMG,WIDTH),
HTML_ATTRIBUTES(IMG)
};
static HTAttr input_attr[HTML_INPUT_ATTRIBUTES+1] = {
HTML_ATTR(INPUT,ACCEPT),
HTML_ATTR(INPUT,ACCESSKEY),
HTML_ATTR(INPUT,ALIGN),
HTML_ATTR(INPUT,ALT),
HTML_ATTR(INPUT,CHECKED),
HTML_ATTR(INPUT,CLASS),
HTML_ATTR(INPUT,DIR),
HTML_ATTR(INPUT,DISABLED),
HTML_ATTR(INPUT,ID),
HTML_ATTR(INPUT,LANG),
HTML_ATTR(INPUT,MAXLENGTH),
HTML_ATTR(INPUT,NAME),
HTML_ATTR(INPUT,READONLY),
HTML_ATTR(INPUT,SIZE),
HTML_ATTR(INPUT,SRC),
HTML_ATTR(INPUT,STYLE),
HTML_ATTR(INPUT,TABINDEX),
HTML_ATTR(INPUT,TITLE),
HTML_ATTR(INPUT,TYPE),
HTML_ATTR(INPUT,USEMAP),
HTML_ATTR(INPUT,VALUE),
HTML_ATTRIBUTES(INPUT)
};
static HTAttr isindex_attr[HTML_ISINDEX_ATTRIBUTES+1] = {
HTML_ATTR(ISINDEX,CLASS),
HTML_ATTR(ISINDEX,DIR),
HTML_ATTR(ISINDEX,ID),
HTML_ATTR(ISINDEX,LANG),
HTML_ATTR(ISINDEX,PROMPT),
HTML_ATTR(ISINDEX,STYLE),
HTML_ATTR(ISINDEX,TITLE),
HTML_ATTRIBUTES(ISINDEX)
};
static HTAttr label_attr[HTML_LABEL_ATTRIBUTES+1] = {
HTML_ATTR(LABEL,ACCESSKEY),
HTML_ATTR(LABEL,CLASS),
HTML_ATTR(LABEL,DIR),
HTML_ATTR(LABEL,FOR),
HTML_ATTR(LABEL,ID),
HTML_ATTR(LABEL,LANG),
HTML_ATTR(LABEL,STYLE),
HTML_ATTR(LABEL,TITLE),
HTML_ATTRIBUTES(LABEL)
};
static HTAttr legend_attr[HTML_LEGEND_ATTRIBUTES+1] = {
HTML_ATTR(LEGEND,ACCESSKEY),
HTML_ATTR(LEGEND,ALIGN),
HTML_ATTR(LEGEND,CLASS),
HTML_ATTR(LEGEND,DIR),
HTML_ATTR(LEGEND,ID),
HTML_ATTR(LEGEND,LANG),
HTML_ATTR(LEGEND,STYLE),
HTML_ATTR(LEGEND,TITLE),
HTML_ATTRIBUTES(LEGEND)
};
static HTAttr li_attr[HTML_LI_ATTRIBUTES+1] = {
HTML_ATTR(LI,CLASS),
HTML_ATTR(LI,COMPACT),
HTML_ATTR(LI,DIR),
HTML_ATTR(LI,ID),
HTML_ATTR(LI,LANG),
HTML_ATTR(LI,STYLE),
HTML_ATTR(LI,TITLE),
HTML_ATTR(LI,TYPE),
HTML_ATTR(LI,VALUE),
HTML_ATTRIBUTES(LI)
};
static HTAttr link_attr[HTML_LINK_ATTRIBUTES+1] = { /* link attributes */
HTML_ATTR(LINK,CHARSET),
HTML_ATTR(LINK,CLASS),
HTML_ATTR(LINK,DIR),
HTML_ATTR(LINK,HREF),
HTML_ATTR(LINK,HREFLANG),
HTML_ATTR(LINK,ID),
HTML_ATTR(LINK,LANG),
HTML_ATTR(LINK,MEDIA),
HTML_ATTR(LINK,REL),
HTML_ATTR(LINK,REV),
HTML_ATTR(LINK,STYLE),
HTML_ATTR(LINK,TARGET),
HTML_ATTR(LINK,TITLE),
HTML_ATTR(LINK,TYPE),
HTML_ATTRIBUTES(LINK)
};
static HTAttr map_attr[HTML_MAP_ATTRIBUTES+1] = {
HTML_ATTR(MAP,CLASS),
HTML_ATTR(MAP,DIR),
HTML_ATTR(MAP,ID),
HTML_ATTR(MAP,LANG),
HTML_ATTR(MAP,NAME),
HTML_ATTR(MAP,STYLE),
HTML_ATTR(MAP,TITLE),
HTML_ATTRIBUTES(MAP)
};
static HTAttr meta_attr[HTML_META_ATTRIBUTES+1] = {
HTML_ATTR(META,CONTENT),
HTML_ATTR(META,DIR),
{ (char *)"HTTP-EQUIV" }, /* HTML_ATTR(META,HTTP_EQUIV) */
HTML_ATTR(META,LANG),
HTML_ATTR(META,NAME),
HTML_ATTR(META,SCHEME),
HTML_ATTRIBUTES(META)
};
static HTAttr nextid_attr[HTML_NEXTID_ATTRIBUTES+1] = {
{ (char *)"N" },
{ 0 } /* Terminate list */
};
static HTAttr object_attr[HTML_OBJECT_ATTRIBUTES+1] = { /* object attributes */
HTML_ATTR(OBJECT,ALIGN),
HTML_ATTR(OBJECT,ARCHIVE),
HTML_ATTR(OBJECT,BORDER),
HTML_ATTR(OBJECT,CLASS),
HTML_ATTR(OBJECT,CLASSID),
HTML_ATTR(OBJECT,CODEBASE),
HTML_ATTR(OBJECT,CODETYPE),
HTML_ATTR(OBJECT,DATA),
HTML_ATTR(OBJECT,DECLARE),
HTML_ATTR(OBJECT,DIR),
HTML_ATTR(OBJECT,HEIGHT),
HTML_ATTR(OBJECT,HSPACE),
HTML_ATTR(OBJECT,ID),
HTML_ATTR(OBJECT,LANG),
HTML_ATTR(OBJECT,NAME),
HTML_ATTR(OBJECT,STANDBY),
HTML_ATTR(OBJECT,STYLE),
HTML_ATTR(OBJECT,TABINDEX),
HTML_ATTR(OBJECT,TITLE),
HTML_ATTR(OBJECT,TYPE),
HTML_ATTR(OBJECT,USEMAP),
HTML_ATTR(OBJECT,VSPACE),
HTML_ATTR(OBJECT,WIDTH),
HTML_ATTRIBUTES(OBJECT)
};
static HTAttr ol_attr[HTML_OL_ATTRIBUTES+1] = {
HTML_ATTR(OL,CLASS),
HTML_ATTR(OL,COMPACT),
HTML_ATTR(OL,DIR),
HTML_ATTR(OL,ID),
HTML_ATTR(OL,LANG),
HTML_ATTR(OL,START),
HTML_ATTR(OL,STYLE),
HTML_ATTR(OL,TITLE),
HTML_ATTR(OL,TYPE),
HTML_ATTRIBUTES(OL)
};
static HTAttr optgroup_attr[HTML_OPTGROUP_ATTRIBUTES+1] = {
HTML_ATTR(OPTGROUP,CLASS),
HTML_ATTR(OPTGROUP,DISABLED),
HTML_ATTR(OPTGROUP,DIR),
HTML_ATTR(OPTGROUP,ID),
HTML_ATTR(OPTGROUP,LABEL),
HTML_ATTR(OPTGROUP,LANG),
HTML_ATTR(OPTGROUP,STYLE),
HTML_ATTR(OPTGROUP,TITLE),
HTML_ATTRIBUTES(OPTGROUP)
};
static HTAttr option_attr[HTML_OPTION_ATTRIBUTES+1] = {
HTML_ATTR(OPTION,CLASS),
HTML_ATTR(OPTION,DISABLED),
HTML_ATTR(OPTION,DIR),
HTML_ATTR(OPTION,ID),
HTML_ATTR(OPTION,LABEL),
HTML_ATTR(OPTION,LANG),
HTML_ATTR(OPTION,SELECTED),
HTML_ATTR(OPTION,STYLE),
HTML_ATTR(OPTION,TITLE),
HTML_ATTR(OPTION,VALUE),
HTML_ATTRIBUTES(OPTION)
};
static HTAttr param_attr[HTML_PARAM_ATTRIBUTES+1] = {
HTML_ATTR(PARAM,ID),
HTML_ATTR(PARAM,NAME),
HTML_ATTR(PARAM,TYPE),
HTML_ATTR(PARAM,VALUE),
HTML_ATTR(PARAM,VALUETYPE),
HTML_ATTRIBUTES(PARAM)
};
static HTAttr pre_attr[HTML_PRE_ATTRIBUTES+1] = {
HTML_ATTR(PRE,CLASS),
HTML_ATTR(PRE,DIR),
HTML_ATTR(PRE,ID),
HTML_ATTR(PRE,LANG),
HTML_ATTR(PRE,STYLE),
HTML_ATTR(PRE,TITLE),
HTML_ATTR(PRE,WIDTH),
HTML_ATTRIBUTES(PRE)
};
static HTAttr script_attr[HTML_SCRIPT_ATTRIBUTES+1] = {
HTML_ATTR(SCRIPT,CHARSET),
HTML_ATTR(SCRIPT,DEFER),
HTML_ATTR(SCRIPT,LANGUAGE),
HTML_ATTR(SCRIPT,SRC),
HTML_ATTR(SCRIPT,TYPE),
HTML_ATTRIBUTES(SCRIPT)
};
static HTAttr select_attr[HTML_SELECT_ATTRIBUTES+1] = {
HTML_ATTR(SELECT,CLASS),
HTML_ATTR(SELECT,DIR),
HTML_ATTR(SELECT,DISABLED),
HTML_ATTR(SELECT,ID),
HTML_ATTR(SELECT,LANG),
HTML_ATTR(SELECT,MULTIPLE),
HTML_ATTR(SELECT,NAME),
HTML_ATTR(SELECT,SIZE),
HTML_ATTR(SELECT,STYLE),
HTML_ATTR(SELECT,TABINDEX),
HTML_ATTR(SELECT,TITLE),
HTML_ATTRIBUTES(SELECT)
};
static HTAttr style_attr[HTML_STYLE_ATTRIBUTES+1] = {
HTML_ATTR(STYLE,DIR),
HTML_ATTR(STYLE,LANG),
HTML_ATTR(STYLE,MEDIA),
HTML_ATTR(STYLE,TITLE),
HTML_ATTR(STYLE,TYPE),
HTML_ATTRIBUTES(STYLE)
};
static HTAttr table_attr[HTML_TABLE_ATTRIBUTES+1] = {
HTML_ATTR(TABLE,ALIGN),
HTML_ATTR(TABLE,BGCOLOR),
HTML_ATTR(TABLE,BORDER),
HTML_ATTR(TABLE,CELLPADDING),
HTML_ATTR(TABLE,CELLSPACING),
HTML_ATTR(TABLE,CLASS),
HTML_ATTR(TABLE,DIR),
HTML_ATTR(TABLE,FRAME),
HTML_ATTR(TABLE,ID),
HTML_ATTR(TABLE,LANG),
HTML_ATTR(TABLE,RULES),
HTML_ATTR(TABLE,SUMMARY),
HTML_ATTR(TABLE,STYLE),
HTML_ATTR(TABLE,TITLE),
HTML_ATTR(TABLE,WIDTH),
HTML_ATTRIBUTES(TABLE)
};
static HTAttr tele_attr[HTML_TELE_ATTRIBUTES+1] = {
HTML_ATTR(TELE,ALIGN),
HTML_ATTR(TELE,CHAR),
HTML_ATTR(TELE,CHAROFF),
HTML_ATTR(TELE,CLASS),
HTML_ATTR(TELE,DIR),
HTML_ATTR(TELE,ID),
HTML_ATTR(TELE,LANG),
HTML_ATTR(TELE,STYLE),
HTML_ATTR(TELE,TITLE),
HTML_ATTR(TELE,VALIGN),
HTML_ATTRIBUTES(TELE)
};
static HTAttr td_attr[HTML_TD_ATTRIBUTES+1] = {
HTML_ATTR(TD,ABBR),
HTML_ATTR(TD,ALIGN),
HTML_ATTR(TD,AXIS),
HTML_ATTR(TD,BGCOLOR),
HTML_ATTR(TD,CHAR),
HTML_ATTR(TD,CHAROFF),
HTML_ATTR(TD,CLASS),
HTML_ATTR(TD,COLSPAN),
HTML_ATTR(TD,DIR),
HTML_ATTR(TD,ID),
HTML_ATTR(TD,HEADERS),
HTML_ATTR(TD,HEIGHT),
HTML_ATTR(TD,LANG),
HTML_ATTR(TD,NOWRAP),
HTML_ATTR(TD,ROWSPAN),
HTML_ATTR(TD,SCOPE),
HTML_ATTR(TD,STYLE),
HTML_ATTR(TD,TITLE),
HTML_ATTR(TD,VALIGN),
HTML_ATTR(TD,WIDTH),
HTML_ATTRIBUTES(TD)
};
static HTAttr textarea_attr[HTML_TEXTAREA_ATTRIBUTES+1] = {
HTML_ATTR(TEXTAREA,CLASS),
HTML_ATTR(TEXTAREA,COLS),
HTML_ATTR(TEXTAREA,DIR),
HTML_ATTR(TEXTAREA,DISABLED),
HTML_ATTR(TEXTAREA,ID),
HTML_ATTR(TEXTAREA,LANG),
HTML_ATTR(TEXTAREA,NAME),
HTML_ATTR(TEXTAREA,READONLY),
HTML_ATTR(TEXTAREA,ROWS),
HTML_ATTR(TEXTAREA,STYLE),
HTML_ATTR(TEXTAREA,TABINDEX),
HTML_ATTR(TEXTAREA,TITLE),
HTML_ATTRIBUTES(TEXTAREA)
};
static HTAttr title_attr[HTML_TITLE_ATTRIBUTES+1] = {
HTML_ATTR(TITLE,DIR),
HTML_ATTR(TITLE,LANG),
HTML_ATTRIBUTES(TITLE)
};
static HTAttr ul_attr[HTML_UL_ATTRIBUTES+1] = {
HTML_ATTR(UL,CLASS),
HTML_ATTR(UL,COMPACT),
HTML_ATTR(UL,DIR),
HTML_ATTR(UL,ID),
HTML_ATTR(UL,LANG),
HTML_ATTR(UL,STYLE),
HTML_ATTR(UL,TITLE),
HTML_ATTR(UL,TYPE),
HTML_ATTRIBUTES(UL)
};
/*
** ELEMENTS
** Must match definitions in HTMLPDTD.html!
** Must be in alphabetical order.
**
** Name, Attributes, content
*/
static HTTag tags[HTML_ELEMENTS] = {
{ "A" , a_attr, HTML_A_ATTRIBUTES },
{ "ABBR" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "ACRONYM" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "ADDRESS" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "APPLET" , applet_attr, HTML_APPLET_ATTRIBUTES },
{ "AREA" , area_attr, HTML_AREA_ATTRIBUTES },
{ "B" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "BASE" , base_attr, HTML_BASE_ATTRIBUTES },
{ "BASEFONT", font_attr, HTML_FONT_ATTRIBUTES },
{ "BDO" , bdo_attr, HTML_BDO_ATTRIBUTES },
{ "BIG" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "BLOCKQUOTE", bq_attr, HTML_BQ_ATTRIBUTES },
{ "BODY" , body_attr, HTML_BODY_ATTRIBUTES },
{ "BR" , br_attr, HTML_BR_ATTRIBUTES },
{ "BUTTON" , button_attr, HTML_BUTTON_ATTRIBUTES },
{ "CAPTION" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "CENTER" , no_attr, 0 },
{ "CITE" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "CODE" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "COL" , col_attr, HTML_COL_ATTRIBUTES },
{ "COLGROUP", col_attr, HTML_COL_ATTRIBUTES },
{ "DD" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "DEL" , changes_attr, HTML_CHANGES_ATTRIBUTES },
{ "DFN" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "DIR" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "DIV" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "DL" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "DT" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "EM" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "FIELDSET", gen_attr, HTML_GEN_ATTRIBUTES },
{ "FONT" , font_attr, HTML_FONT_ATTRIBUTES },
{ "FORM" , form_attr, HTML_FORM_ATTRIBUTES },
{ "FRAME" , frame_attr, HTML_FRAME_ATTRIBUTES },
{ "FRAMESET", frameset_attr,HTML_FRAMESET_ATTRIBUTES },
{ "H1" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "H2" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "H3" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "H4" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "H5" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "H6" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "HEAD" , head_attr, HTML_HEAD_ATTRIBUTES },
{ "HR" , hr_attr, HTML_HR_ATTRIBUTES },
{ "HTML" , html_attr, HTML_HTML_ATTRIBUTES },
{ "I" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "IFRAME" , iframe_attr, HTML_IFRAME_ATTRIBUTES },
{ "IMG" , img_attr, HTML_IMG_ATTRIBUTES },
{ "INPUT" , input_attr, HTML_INPUT_ATTRIBUTES },
{ "INS" , changes_attr, HTML_CHANGES_ATTRIBUTES },
{ "ISINDEX" , isindex_attr, HTML_ISINDEX_ATTRIBUTES },
{ "KBD" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "LABEL" , label_attr, HTML_LABEL_ATTRIBUTES },
{ "LEGEND" , legend_attr, HTML_LEGEND_ATTRIBUTES },
{ "LI" , li_attr, HTML_LI_ATTRIBUTES },
{ "LINK" , link_attr, HTML_LINK_ATTRIBUTES },
{ "MAP" , map_attr, HTML_MAP_ATTRIBUTES },
{ "MENU" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "META" , meta_attr, HTML_META_ATTRIBUTES },
{ "NEXTID" , nextid_attr, 1 },
{ "NOFRAMES", gen_attr, HTML_GEN_ATTRIBUTES },
{ "NOSCRIPT", gen_attr, HTML_GEN_ATTRIBUTES },
{ "OBJECT" , object_attr, HTML_OBJECT_ATTRIBUTES },
{ "OL" , ol_attr, HTML_OL_ATTRIBUTES },
{ "OPTGROUP", optgroup_attr,HTML_OPTGROUP_ATTRIBUTES },
{ "OPTION" , option_attr, HTML_OPTION_ATTRIBUTES },
{ "P" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "PARAM" , param_attr, HTML_PARAM_ATTRIBUTES },
{ "PRE" , pre_attr, HTML_PRE_ATTRIBUTES },
{ "Q" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "S" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "SAMP" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "SCRIPT" , script_attr, HTML_SCRIPT_ATTRIBUTES },
{ "SELECT" , select_attr, HTML_SELECT_ATTRIBUTES },
{ "SMALL" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "SPAN" , block_attr, HTML_BLOCK_ATTRIBUTES },
{ "STRIKE" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "STRONG" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "STYLE" , style_attr, HTML_STYLE_ATTRIBUTES },
{ "SUB" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "SUP" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "TABLE" , table_attr, HTML_TABLE_ATTRIBUTES },
{ "TBODY" , tele_attr, HTML_TELE_ATTRIBUTES },
{ "TD" , td_attr, HTML_TD_ATTRIBUTES },
{ "TEXTAREA", textarea_attr,HTML_TEXTAREA_ATTRIBUTES },
{ "TFOOT" , tele_attr, HTML_TELE_ATTRIBUTES },
{ "TH" , td_attr, HTML_TD_ATTRIBUTES },
{ "THEAD" , tele_attr, HTML_TELE_ATTRIBUTES },
{ "TITLE" , title_attr, HTML_TITLE_ATTRIBUTES },
{ "TR" , tele_attr, HTML_TELE_ATTRIBUTES },
{ "TT" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "U" , gen_attr, HTML_GEN_ATTRIBUTES },
{ "UL" , ul_attr, HTML_UL_ATTRIBUTES },
{ "VAR" , gen_attr, HTML_GEN_ATTRIBUTES },
//
{ "LUA" , gen_attr, HTML_GEN_ATTRIBUTES },
};
static SGML_dtd HTMLP_dtd = {
tags,
HTML_ELEMENTS
};
static SGML_dtd * DTD = &HTMLP_dtd;
SGML_dtd * HTML_dtd (void)
{
return DTD;
}
}// namespace

@ -144,7 +144,7 @@ std::string winCpToCp(const char *str, size_t len, UINT srcCp, UINT dstCp)
wchar_t *tmp = (wchar_t *)_malloca((len + 1) * 4); wchar_t *tmp = (wchar_t *)_malloca((len + 1) * 4);
if (!tmp) if (!tmp)
return std::string(); return std::string();
int tmpLen = MultiByteToWideChar(srcCp, MB_PRECOMPOSED, int tmpLen = MultiByteToWideChar(srcCp, 0,
str, (int)(len + 1), /* include null-termination */ str, (int)(len + 1), /* include null-termination */
tmp, (int)((len + 1) * 4)); tmp, (int)((len + 1) * 4));
if (tmpLen <= 1) if (tmpLen <= 1)
@ -170,7 +170,7 @@ std::wstring winCpToWide(const char *str, size_t len, UINT cp)
wchar_t *tmp = (wchar_t *)_malloca((len + 1) * 4); wchar_t *tmp = (wchar_t *)_malloca((len + 1) * 4);
if (!tmp) if (!tmp)
return std::wstring(); return std::wstring();
int tmpLen = MultiByteToWideChar(cp, MB_PRECOMPOSED, int tmpLen = MultiByteToWideChar(cp, 0,
str, (int)(len + 1), /* include null-termination */ str, (int)(len + 1), /* include null-termination */
tmp, (int)((len + 1) * 4)); tmp, (int)((len + 1) * 4));
if (tmpLen <= 1) if (tmpLen <= 1)

@ -1103,20 +1103,18 @@ REGISTER_ACTION_HANDLER( CHandlerBrowseRefresh, "browse_refresh");
// *************************************************************************** // ***************************************************************************
/** Build the help window for a pact/item/brick and open it.
*/
class CHandlerHTMLSubmitForm : public IActionHandler class CHandlerHTMLSubmitForm : public IActionHandler
{ {
void execute (CCtrlBase *pCaller, const std::string &sParams) void execute (CCtrlBase *pCaller, const std::string &sParams)
{ {
string container = getParam (sParams, "name"); string container = getParam (sParams, "name");
uint form; uint button;
fromString(getParam (sParams, "form"), form); if (!fromString(getParam(sParams, "button"), button))
{
string submit_button = getParam (sParams, "submit_button"); nlwarning("Invalid button index: '%s', expected integer", getParam(sParams, "button").c_str());
string type = getParam (sParams, "submit_button_type"); return;
string value = getParam (sParams, "submit_button_value"); }
sint32 x = pCaller->getEventX(); sint32 x = pCaller->getEventX();
sint32 y = pCaller->getEventY(); sint32 y = pCaller->getEventY();
@ -1127,8 +1125,7 @@ class CHandlerHTMLSubmitForm : public IActionHandler
CGroupHTML *groupHtml = dynamic_cast<CGroupHTML*>(element); CGroupHTML *groupHtml = dynamic_cast<CGroupHTML*>(element);
if (groupHtml) if (groupHtml)
{ {
// Submit the form the url groupHtml->submitForm(button, x, y);
groupHtml->submitForm (form, type.c_str(), submit_button.c_str(), value.c_str(), x, y);
} }
} }
} }

@ -71,6 +71,9 @@ static string getWebAuthKey()
void addWebIGParams (string &url, bool trustedDomain) void addWebIGParams (string &url, bool trustedDomain)
{ {
// no extras parameters added to url if not in trusted domains list
if (!trustedDomain) return;
if(!UserEntity || !NetMngr.getLoginCookie().isValid()) return; if(!UserEntity || !NetMngr.getLoginCookie().isValid()) return;
uint32 cid = NetMngr.getLoginCookie().getUserId() * 16 + PlayerSelectedSlot; uint32 cid = NetMngr.getLoginCookie().getUserId() * 16 + PlayerSelectedSlot;
@ -354,6 +357,9 @@ void CGroupHTMLAuth::addHTTPGetParams (string &url, bool trustedDomain)
void CGroupHTMLAuth::addHTTPPostParams (SFormFields &formfields, bool trustedDomain) void CGroupHTMLAuth::addHTTPPostParams (SFormFields &formfields, bool trustedDomain)
{ {
// no extras parameters added to url if not in trusted domains list
if (!trustedDomain) return;
if(!UserEntity || !NetMngr.getLoginCookie().isValid()) return; if(!UserEntity || !NetMngr.getLoginCookie().isValid()) return;
uint32 cid = NetMngr.getLoginCookie().getUserId() * 16 + PlayerSelectedSlot; uint32 cid = NetMngr.getLoginCookie().getUserId() * 16 + PlayerSelectedSlot;

Loading…
Cancel
Save