diff --git a/mozilla/content/base/src/Makefile.in b/mozilla/content/base/src/Makefile.in index 0f8ce8cc58b..fe729022efb 100644 --- a/mozilla/content/base/src/Makefile.in +++ b/mozilla/content/base/src/Makefile.in @@ -79,6 +79,8 @@ EXPORTS = \ nsAtomListUtils.h \ nsAttrName.h \ nsContentList.h \ + nsGkAtomList.h \ + nsGkAtoms.h \ nsNodeInfoManager.h \ nsPropertyTable.h \ nsStubDocumentObserver.h \ @@ -112,6 +114,7 @@ CPPSRCS = \ nsGenericDOMDataNode.cpp \ nsGenericDOMNodeList.cpp \ nsGenericElement.cpp \ + nsGkAtoms.cpp \ nsHTMLContentSerializer.cpp \ nsImageLoadingContent.cpp \ nsMappedAttributes.cpp \ diff --git a/mozilla/content/base/src/nsContentList.cpp b/mozilla/content/base/src/nsContentList.cpp index 8c2ced146e7..87a2a117a1f 100644 --- a/mozilla/content/base/src/nsContentList.cpp +++ b/mozilla/content/base/src/nsContentList.cpp @@ -330,7 +330,7 @@ nsContentList::nsContentList(nsIDocument *aDocument, mFuncMayDependOnAttr(PR_FALSE) { NS_ASSERTION(mDeep || mRootContent, "Must have root content for non-deep list!"); - if (nsLayoutAtoms::wildcard == mMatchAtom) { + if (nsLayoutAtoms::_asterix == mMatchAtom) { mMatchAll = PR_TRUE; } else { diff --git a/mozilla/content/base/src/nsContentUtils.cpp b/mozilla/content/base/src/nsContentUtils.cpp index 6106c425705..9cae9b12026 100644 --- a/mozilla/content/base/src/nsContentUtils.cpp +++ b/mozilla/content/base/src/nsContentUtils.cpp @@ -1735,7 +1735,7 @@ nsContentUtils::LookupNamespaceURI(nsIContent* aNamespaceResolver, NS_ENSURE_TRUE(name, NS_ERROR_OUT_OF_MEMORY); } else { - name = nsLayoutAtoms::xmlnsNameSpace; + name = nsLayoutAtoms::xmlns; } // Trace up the content parent chain looking for the namespace // declaration that declares aNamespacePrefix. @@ -1790,9 +1790,9 @@ nsContentUtils::GetNodeInfoFromQName(const nsAString& aNamespaceURI, // "http://www.w3.org/2000/xmlns/", or if the namespaceURI is // "http://www.w3.org/2000/xmlns/" and neither the qualifiedName nor its // prefix is "xmlns". - PRBool xmlPrefix = prefix == nsLayoutAtoms::xmlNameSpace; - PRBool xmlns = (*aNodeInfo)->Equals(nsLayoutAtoms::xmlnsNameSpace, nil) || - prefix == nsLayoutAtoms::xmlnsNameSpace; + PRBool xmlPrefix = prefix == nsLayoutAtoms::xml; + PRBool xmlns = (*aNodeInfo)->Equals(nsLayoutAtoms::xmlns, nil) || + prefix == nsLayoutAtoms::xmlns; return (prefix && DOMStringIsNull(aNamespaceURI)) || (xmlPrefix && nsID != kNameSpaceID_XML) || diff --git a/mozilla/content/base/src/nsGenericElement.cpp b/mozilla/content/base/src/nsGenericElement.cpp index 4cfc89f41e4..96b3fdc272c 100644 --- a/mozilla/content/base/src/nsGenericElement.cpp +++ b/mozilla/content/base/src/nsGenericElement.cpp @@ -478,7 +478,7 @@ nsNode3Tearoff::LookupPrefix(const nsAString& aNamespaceURI, aNamespaceURI, eCaseMatters)) { // If the localName is "xmlns", the prefix we output should be // null. - if (name->LocalName() != nsLayoutAtoms::xmlnsNameSpace) { + if (name->LocalName() != nsLayoutAtoms::xmlns) { name->LocalName()->ToString(aPrefix); } @@ -4131,7 +4131,7 @@ nsGenericElement::SetAttrAndNotify(PRInt32 aNamespaceID, } if (aNamespaceID == kNameSpaceID_XMLEvents && - aName == nsHTMLAtoms::_event && mNodeInfo->GetDocument()) { + aName == nsHTMLAtoms::event && mNodeInfo->GetDocument()) { mNodeInfo->GetDocument()->AddXMLEventsContent(this); } diff --git a/mozilla/content/base/src/nsGkAtomList.h b/mozilla/content/base/src/nsGkAtomList.h new file mode 100755 index 00000000000..7dac9d99b88 --- /dev/null +++ b/mozilla/content/base/src/nsGkAtomList.h @@ -0,0 +1,1309 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Mozilla Foundation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/****** + + This file contains the list of all atoms used by gklayout + See nsGkAtoms.h for access to the atoms + + It is designed to be used as inline input to nsGkAtoms.cpp and nsGkAtoms.h + *only* through the magic of C preprocessing. + + All entires must be enclosed in the macro GK_ATOM which will have cruel + and unusual things done to it + + The first argument to GK_ATOM is the C++ name of the atom + The second argument it GK_ATOM is the string value of the atom + + ******/ + +// OUTPUT_CLASS=nsGkAtoms +// MACRO_NAME=GK_ATOM +#ifdef WINCE +#undef small +#endif + +//--------------------------------------------------------------------------- +// Generic atoms +//--------------------------------------------------------------------------- + +GK_ATOM(_empty, "") +GK_ATOM(_baseHref, "_base_href") +GK_ATOM(_baseTarget, "_base_target") +GK_ATOM(mozdirty, "_moz_dirty") +GK_ATOM(menuactive, "_moz-menuactive") +GK_ATOM(_poundDefault, "#default") +GK_ATOM(_asterix, "*") +GK_ATOM(a, "a") +GK_ATOM(abbr, "abbr") +GK_ATOM(abort, "abort") +GK_ATOM(above, "above") +GK_ATOM(absoluteList, "Absolute-list") +GK_ATOM(acceltext, "acceltext") +GK_ATOM(accept, "accept") +GK_ATOM(acceptcharset, "accept-charset") +GK_ATOM(accesskey, "accesskey") +GK_ATOM(action, "action") +GK_ATOM(actuate, "actuate") +GK_ATOM(align, "align") +GK_ATOM(alink, "alink") +GK_ATOM(all, "all") +GK_ATOM(allowevents, "allowevents") +GK_ATOM(allownegativeassertions, "allownegativeassertions") +GK_ATOM(allowuntrusted, "allowuntrusted") +GK_ATOM(alt, "alt") +GK_ATOM(always, "always") +GK_ATOM(ancestor, "ancestor") +GK_ATOM(ancestorOrSelf, "ancestor-or-self") +GK_ATOM(_and, "and") +GK_ATOM(any, "any") +GK_ATOM(applet, "applet") +GK_ATOM(applyImports, "apply-imports") +GK_ATOM(applyTemplates, "apply-templates") +GK_ATOM(archive, "archive") +GK_ATOM(area, "area") +GK_ATOM(ascending, "ascending") +GK_ATOM(attribute, "attribute") +GK_ATOM(attributeSet, "attribute-set") +GK_ATOM(aural, "aural") +GK_ATOM(_auto, "auto") +GK_ATOM(autocheck, "autocheck") +GK_ATOM(autorepeatbutton, "autorepeatbutton") +GK_ATOM(axis, "axis") +GK_ATOM(b, "b") +GK_ATOM(background, "background") +GK_ATOM(base, "base") +GK_ATOM(basefont, "basefont") +GK_ATOM(baseLevel, "BaseLevel") // PRUint8 +GK_ATOM(baseline, "baseline") +GK_ATOM(bdo, "bdo") +GK_ATOM(below, "below") +GK_ATOM(bgcolor, "bgcolor") +GK_ATOM(big, "big") +GK_ATOM(binding, "binding") +GK_ATOM(bindings, "bindings") +GK_ATOM(blankrow, "blankrow") +GK_ATOM(blockquote, "blockquote") +GK_ATOM(blur, "blur") +GK_ATOM(body, "body") +GK_ATOM(boolean, "boolean") +GK_ATOM(border, "border") +GK_ATOM(bordercolor, "bordercolor") +GK_ATOM(bottom, "bottom") +GK_ATOM(bottommargin, "bottommargin") +GK_ATOM(bottompadding, "bottompadding") +GK_ATOM(box, "box") +GK_ATOM(br, "br") +GK_ATOM(braille, "braille") +GK_ATOM(broadcast, "broadcast") +GK_ATOM(broadcaster, "broadcaster") +GK_ATOM(broadcasterset, "broadcasterset") +GK_ATOM(browser, "browser") +GK_ATOM(bulletList, "Bullet-list") +GK_ATOM(bulletinboard, "bulletinboard") +GK_ATOM(button, "button") +GK_ATOM(callTemplate, "call-template") +GK_ATOM(cancel, "cancel") +GK_ATOM(canvas, "canvas") +GK_ATOM(caption, "caption") +GK_ATOM(captionList, "Caption-list") +GK_ATOM(capture, "capture") +GK_ATOM(caseOrder, "case-order") +GK_ATOM(cdataSectionElements, "cdata-section-elements") +GK_ATOM(ceiling, "ceiling") +GK_ATOM(cellpadding, "cellpadding") +GK_ATOM(cellspacing, "cellspacing") +GK_ATOM(center, "center") +GK_ATOM(ch, "ch") +GK_ATOM(change, "change") +GK_ATOM(_char, "char") +GK_ATOM(charcode, "charcode") +GK_ATOM(charoff, "charoff") +GK_ATOM(charset, "charset") +GK_ATOM(charType, "charType") // PRUint8 +GK_ATOM(checkbox, "checkbox") +GK_ATOM(checked, "checked") +GK_ATOM(child, "child") +GK_ATOM(children, "children") +GK_ATOM(choose, "choose") +GK_ATOM(cite, "cite") +GK_ATOM(_class, "class") +GK_ATOM(classid, "classid") +GK_ATOM(clear, "clear") +GK_ATOM(click, "click") +GK_ATOM(clickcount, "clickcount") +GK_ATOM(clip, "clip") +GK_ATOM(close, "close") +GK_ATOM(closed, "closed") +GK_ATOM(coalesceduplicatearcs, "coalesceduplicatearcs") +GK_ATOM(code, "code") +GK_ATOM(codebase, "codebase") +GK_ATOM(codetype, "codetype") +GK_ATOM(col, "col") +GK_ATOM(colgroup, "colgroup") +GK_ATOM(colGroupList, "ColGroup-list") +GK_ATOM(collapse, "collapse") +GK_ATOM(collapsed, "collapsed") +GK_ATOM(color, "color") +GK_ATOM(cols, "cols") +GK_ATOM(colspan, "colspan") +GK_ATOM(column, "column") +GK_ATOM(columns, "columns") +GK_ATOM(combobox, "combobox") +GK_ATOM(command, "command") +GK_ATOM(commands, "commands") +GK_ATOM(commandset, "commandset") +GK_ATOM(commandupdate, "commandupdate") +GK_ATOM(commandupdater, "commandupdater") +GK_ATOM(comment, "comment") +GK_ATOM(compact, "compact") +GK_ATOM(concat, "concat") +GK_ATOM(conditions, "conditions") +GK_ATOM(constructor, "constructor") +GK_ATOM(container, "container") +GK_ATOM(containment, "containment") +GK_ATOM(contains, "contains") +GK_ATOM(content, "content") +GK_ATOM(headerContentDisposition, "content-disposition") +GK_ATOM(headerContentLanguage, "content-language") +GK_ATOM(contentLocation, "content-location") +GK_ATOM(headerContentScriptType, "content-script-type") +GK_ATOM(headerContentStyleType, "content-style-type") +GK_ATOM(headerContentType, "content-type") +GK_ATOM(context, "context") +GK_ATOM(contextmenu, "contextmenu") +GK_ATOM(control, "control") +GK_ATOM(coords, "coords") +GK_ATOM(copy, "copy") +GK_ATOM(copyOf, "copy-of") +GK_ATOM(count, "count") +GK_ATOM(crop, "crop") +GK_ATOM(curpos, "curpos") +GK_ATOM(current, "current") +GK_ATOM(cycler, "cycler") +GK_ATOM(data, "data") +GK_ATOM(dataType, "data-type") +GK_ATOM(datasources, "datasources") +GK_ATOM(datetime, "datetime") +GK_ATOM(dblclick, "dblclick") +GK_ATOM(dd, "dd") +GK_ATOM(debug, "debug") +GK_ATOM(decimalFormat, "decimal-format") +GK_ATOM(decimalSeparator, "decimal-separator") +GK_ATOM(deck, "deck") +GK_ATOM(declare, "declare") +GK_ATOM(_default, "default") +GK_ATOM(headerDefaultStyle, "default-style") +GK_ATOM(defaultAction, "defaultAction") +GK_ATOM(defaultchecked, "defaultchecked") +GK_ATOM(defaultselected, "defaultselected") +GK_ATOM(defaultvalue, "defaultvalue") +GK_ATOM(defer, "defer") +GK_ATOM(del, "del") +GK_ATOM(descendant, "descendant") +GK_ATOM(descendantOrSelf, "descendant-or-self") +GK_ATOM(descending, "descending") +GK_ATOM(description, "description") +GK_ATOM(destructor, "destructor") +GK_ATOM(dfn, "dfn") +GK_ATOM(dialog, "dialog") +GK_ATOM(digit, "digit") +GK_ATOM(dir, "dir") +GK_ATOM(disableOutputEscaping, "disable-output-escaping") +GK_ATOM(disabled, "disabled") +GK_ATOM(display, "display") +GK_ATOM(div, "div") +GK_ATOM(dl, "dl") +GK_ATOM(doctypePublic, "doctype-public") +GK_ATOM(doctypeSystem, "doctype-system") +GK_ATOM(document, "document") +GK_ATOM(DOMAttrModified, "DOMAttrModified") +GK_ATOM(DOMCharacterDataModified, "DOMCharacterDataModified") +GK_ATOM(DOMNodeInserted, "DOMNodeInserted") +GK_ATOM(DOMNodeInsertedIntoDocument, "DOMNodeInsertedInfoDocument") +GK_ATOM(DOMNodeRemoved, "DOMNodeRemoved") +GK_ATOM(DOMNodeRemovedFromDocument, "DOMNodeRemovedFromDocument") +GK_ATOM(DOMSubtreeModified, "DOMSubtreeModified") +GK_ATOM(dragdrop, "dragdrop") +GK_ATOM(dragenter, "dragenter") +GK_ATOM(dragevent, "dragevent") +GK_ATOM(dragexit, "dragexit") +GK_ATOM(draggesture, "draggesture") +GK_ATOM(dragover, "dragover") +GK_ATOM(dragSession, "dragSession") +GK_ATOM(dropAfter, "dropAfter") +GK_ATOM(dropBefore, "dropBefore") +GK_ATOM(dropOn, "dropOn") +GK_ATOM(dt, "dt") +GK_ATOM(editable, "editable") +GK_ATOM(editor, "editor") +GK_ATOM(editorDisplayList, "EditorDisplay-List") +GK_ATOM(element, "element") +GK_ATOM(elementAvailable, "element-available") +GK_ATOM(elements, "elements") +GK_ATOM(em, "em") +GK_ATOM(embed, "embed") +GK_ATOM(embeddingLevel, "EmbeddingLevel") // PRUint8 +GK_ATOM(embossed, "embossed") +GK_ATOM(empty, "empty") +GK_ATOM(encoding, "encoding") +GK_ATOM(enctype, "enctype") +GK_ATOM(end, "end") +GK_ATOM(endsInDiacritic, "EndsInDiacritic") // PRUint32 +GK_ATOM(equalsize, "equalsize") +GK_ATOM(error, "error") +GK_ATOM(even, "even") +GK_ATOM(event, "event") +GK_ATOM(events, "events") +GK_ATOM(excludes, "excludes") +GK_ATOM(extends, "extends") +GK_ATOM(extensionElementPrefixes, "extension-element-prefixes") +GK_ATOM(face, "face") +GK_ATOM(fallback, "fallback") +GK_ATOM(_false, "false") +GK_ATOM(field, "field") +GK_ATOM(fieldset, "fieldset") +GK_ATOM(fixed, "fixed") +GK_ATOM(fixedList, "Fixed-list") +GK_ATOM(flags, "flags") +GK_ATOM(flex, "flex") +GK_ATOM(flexgroup, "flexgroup") +GK_ATOM(floatList, "Float-list") +GK_ATOM(floor, "floor") +GK_ATOM(focus, "focus") +GK_ATOM(following, "following") +GK_ATOM(followingSibling, "following-sibling") +GK_ATOM(font, "font") +GK_ATOM(fontWeight, "font-weight") +GK_ATOM(fontpicker, "fontpicker") +GK_ATOM(_for, "for") +GK_ATOM(forEach, "for-each") +GK_ATOM(form, "form") +GK_ATOM(format, "format") +GK_ATOM(formatNumber, "format-number") +GK_ATOM(frame, "frame") +GK_ATOM(frameborder, "frameborder") +GK_ATOM(frameset, "frameset") +GK_ATOM(from, "from") +GK_ATOM(functionAvailable, "function-available") +GK_ATOM(generateId, "generate-id") +GK_ATOM(getter, "getter") +GK_ATOM(grid, "grid") +GK_ATOM(gripper, "gripper") +GK_ATOM(grippy, "grippy") +GK_ATOM(group, "group") +GK_ATOM(groupingSeparator, "grouping-separator") +GK_ATOM(groupingSize, "grouping-size") +GK_ATOM(gutter, "gutter") +GK_ATOM(h1, "h1") +GK_ATOM(h2, "h2") +GK_ATOM(h3, "h3") +GK_ATOM(h4, "h4") +GK_ATOM(h5, "h5") +GK_ATOM(h6, "h6") +GK_ATOM(handheld, "handheld") +GK_ATOM(handler, "handler") +GK_ATOM(handlers, "handlers") +GK_ATOM(hbox, "hbox") +GK_ATOM(head, "head") +GK_ATOM(headers, "headers") +GK_ATOM(height, "height") +GK_ATOM(hidden, "hidden") +GK_ATOM(hidechrome, "hidechrome") +GK_ATOM(horizontal, "horizontal") +GK_ATOM(hr, "hr") +GK_ATOM(href, "href") +GK_ATOM(hreflang, "hreflang") +GK_ATOM(hspace, "hspace") +GK_ATOM(html, "html") +GK_ATOM(httpEquiv, "http-equiv") +GK_ATOM(i, "i") +GK_ATOM(id, "id") +GK_ATOM(_if, "if") +GK_ATOM(iframe, "iframe") +GK_ATOM(ignorekeys, "ignorekeys") +GK_ATOM(ilayer, "ilayer") +GK_ATOM(image, "image") +GK_ATOM(img, "img") +GK_ATOM(implementation, "implementation") +GK_ATOM(implements, "implements") +GK_ATOM(import, "import") +GK_ATOM(include, "include") +GK_ATOM(includes, "includes") +GK_ATOM(increment, "increment") +GK_ATOM(indent, "indent") +GK_ATOM(index, "index") +GK_ATOM(infer, "infer") +GK_ATOM(infinity, "infinity") +GK_ATOM(inherits, "inherits") +GK_ATOM(inheritstyle, "inheritstyle") +GK_ATOM(input, "input") +GK_ATOM(ins, "ins") +GK_ATOM(insertafter, "insertafter") +GK_ATOM(insertbefore, "insertbefore") +GK_ATOM(instanceOf, "instanceOf") +GK_ATOM(iscontainer, "iscontainer") +GK_ATOM(isempty, "isempty") +GK_ATOM(isindex, "isindex") +GK_ATOM(ismap, "ismap") +GK_ATOM(key, "key") +GK_ATOM(keycode, "keycode") +GK_ATOM(keydown, "keydown") +GK_ATOM(keypress, "keypress") +GK_ATOM(keyset, "keyset") +GK_ATOM(keytext, "keytext") +GK_ATOM(keyup, "keyup") +GK_ATOM(label, "label") +GK_ATOM(lang, "lang") +GK_ATOM(last, "last") +GK_ATOM(layer, "layer") +GK_ATOM(layout, "layout") +GK_ATOM(leaf, "leaf") +GK_ATOM(left, "left") +GK_ATOM(leftmargin, "leftmargin") +GK_ATOM(leftpadding, "leftpadding") +GK_ATOM(legend, "legend") +GK_ATOM(length, "length") +GK_ATOM(level, "level") +GK_ATOM(li, "li") +GK_ATOM(link, "link") +GK_ATOM(listbox, "listbox") +GK_ATOM(listboxbody, "listboxbody") +GK_ATOM(listcell, "listcell") +GK_ATOM(listcol, "listcol") +GK_ATOM(listcols, "listcols") +GK_ATOM(listener, "listener") +GK_ATOM(listhead, "listhead") +GK_ATOM(listheader, "listheader") +GK_ATOM(listitem, "listitem") +GK_ATOM(listrows, "listrows") +GK_ATOM(load, "load") +GK_ATOM(localName, "local-name") +GK_ATOM(longdesc, "longdesc") +GK_ATOM(lowerFirst, "lower-first") +GK_ATOM(lowsrc, "lowsrc") +GK_ATOM(ltr, "ltr") +GK_ATOM(map, "map") +GK_ATOM(marginheight, "marginheight") +GK_ATOM(marginwidth, "marginwidth") +GK_ATOM(marquee, "marquee") +GK_ATOM(match, "match") +GK_ATOM(maxheight, "maxheight") +GK_ATOM(maxlength, "maxlength") +GK_ATOM(maxpos, "maxpos") +GK_ATOM(maxwidth, "maxwidth") +GK_ATOM(mayscript, "mayscript") +GK_ATOM(media, "media") +GK_ATOM(mediaType, "media-type") +GK_ATOM(member, "member") +GK_ATOM(menu, "menu") +GK_ATOM(menubar, "menubar") +GK_ATOM(menubutton, "menubutton") +GK_ATOM(menugenerated, "menugenerated") +GK_ATOM(menuitem, "menuitem") +GK_ATOM(menulist, "menulist") +GK_ATOM(menupopup, "menupopup") +GK_ATOM(menutobedisplayed, "menutobedisplayed") +GK_ATOM(message, "message") +GK_ATOM(meta, "meta") +GK_ATOM(method, "method") +GK_ATOM(middle, "middle") +GK_ATOM(minheight, "minheight") +GK_ATOM(minusSign, "minus-sign") +GK_ATOM(minwidth, "minwidth") +GK_ATOM(mod, "mod") +GK_ATOM(mode, "mode") +GK_ATOM(modifiers, "modifiers") +GK_ATOM(mousedown, "mousedown") +GK_ATOM(mousemove, "mousemove") +GK_ATOM(mouseout, "mouseout") +GK_ATOM(mouseover, "mouseover") +GK_ATOM(mousethrough, "mousethrough") +GK_ATOM(mouseup, "mouseup") +GK_ATOM(msthemecompatible, "msthemecompatible") +GK_ATOM(multicol, "multicol") +GK_ATOM(multiple, "multiple") +GK_ATOM(name, "name") +GK_ATOM(_namespace, "namespace") +GK_ATOM(namespaceAlias, "namespace-alias") +GK_ATOM(namespaceUri, "namespace-uri") +GK_ATOM(NaN, "NaN") +GK_ATOM(nativescrollbar, "nativescrollbar") +GK_ATOM(never, "never") +GK_ATOM(nextBidi, "NextBidi") +GK_ATOM(no, "no") +GK_ATOM(node, "node") +GK_ATOM(noembed, "noembed") +GK_ATOM(noframes, "noframes") +GK_ATOM(nohref, "nohref") +GK_ATOM(none, "none") +GK_ATOM(noresize, "noresize") +GK_ATOM(normal, "normal") +GK_ATOM(normalizeSpace, "normalize-space") +GK_ATOM(noscript, "noscript") +GK_ATOM(noshade, "noshade") +GK_ATOM(_not, "not") +GK_ATOM(nowrap, "nowrap") +GK_ATOM(number, "number") +GK_ATOM(object, "object") +GK_ATOM(observer, "observer") +GK_ATOM(observes, "observes") +GK_ATOM(odd, "odd") +GK_ATOM(ol, "ol") +GK_ATOM(omitXmlDeclaration, "omit-xml-declaration") +GK_ATOM(onabort, "onabort") +GK_ATOM(onbeforeunload, "onbeforeunload") +GK_ATOM(onblur, "onblur") +GK_ATOM(onbroadcast, "onbroadcast") +GK_ATOM(onchange, "onchange") +GK_ATOM(onclick, "onclick") +GK_ATOM(onclose, "onclose") +GK_ATOM(oncommand, "oncommand") +GK_ATOM(oncommandupdate, "oncommandupdate") +GK_ATOM(oncompositionend, "oncompositionend") +GK_ATOM(oncompositionstart, "oncompositionstart") +GK_ATOM(oncontextmenu, "oncontextmenu") +GK_ATOM(ondblclick, "ondblclick") +GK_ATOM(onDOMActivate, "onDOMActivate") +GK_ATOM(onDOMAttrModified, "onDOMAttrModified") +GK_ATOM(onDOMCharacterDataModified, "onDOMCharacterDataModified") +GK_ATOM(onDOMFocusIn, "onDOMFocusIn") +GK_ATOM(onDOMFocusOut, "onDOMFocusOut") +GK_ATOM(onDOMNodeInserted, "onDOMNodeInserted") +GK_ATOM(onDOMNodeInsertedIntoDocument, "onDOMNodeInsertedIntoDocument") +GK_ATOM(onDOMNodeRemoved, "onDOMNodeRemoved") +GK_ATOM(onDOMNodeRemovedFromDocument, "onDOMNodeRemovedFromDocument") +GK_ATOM(onDOMSubtreeModified, "onDOMSubtreeModified") +GK_ATOM(ondragdrop, "ondragdrop") +GK_ATOM(ondragenter, "ondragenter") +GK_ATOM(ondragexit, "ondragexit") +GK_ATOM(ondraggesture, "ondraggesture") +GK_ATOM(ondragover, "ondragover") +GK_ATOM(onerror, "onerror") +GK_ATOM(onfocus, "onfocus") +GK_ATOM(onget, "onget") +GK_ATOM(oninput, "oninput") +GK_ATOM(onkeydown, "onkeydown") +GK_ATOM(onkeypress, "onkeypress") +GK_ATOM(onkeyup, "onkeyup") +GK_ATOM(onLoad, "onLoad") +GK_ATOM(onload, "onload") +GK_ATOM(onmousedown, "onmousedown") +GK_ATOM(onmousemove, "onmousemove") +GK_ATOM(onmouseout, "onmouseout") +GK_ATOM(onmouseover, "onmouseover") +GK_ATOM(onmouseup, "onmouseup") +GK_ATOM(onoverflow, "onoverflow") +GK_ATOM(onoverflowchanged, "onoverflowchanged") +GK_ATOM(onpagehide, "onpagehide") +GK_ATOM(onpageshow, "onpageshow") +GK_ATOM(onpaint, "onpaint") +GK_ATOM(onpopuphidden, "onpopuphidden") +GK_ATOM(onpopuphiding, "onpopuphiding") +GK_ATOM(onpopupshowing, "onpopupshowing") +GK_ATOM(onpopupshown, "onpopupshown") +GK_ATOM(onreset, "onreset") +GK_ATOM(onresize, "onresize") +GK_ATOM(onscroll, "onscroll") +GK_ATOM(onselect, "onselect") +GK_ATOM(onset, "onset") +GK_ATOM(onsubmit, "onsubmit") +GK_ATOM(ontext, "ontext") +GK_ATOM(onunderflow, "onunderflow") +GK_ATOM(onunload, "onunload") +GK_ATOM(open, "open") +GK_ATOM(optgroup, "optgroup") +GK_ATOM(option, "option") +GK_ATOM(_or, "or") +GK_ATOM(order, "order") +GK_ATOM(ordinal, "ordinal") +GK_ATOM(orient, "orient") +GK_ATOM(otherwise, "otherwise") +GK_ATOM(output, "output") +GK_ATOM(overflow, "overflow") +GK_ATOM(overflowList, "Overflow-list") +GK_ATOM(overflowchanged, "overflowchanged") +GK_ATOM(overflowOutOfFlowList, "OverflowOutOfFlow-list") +GK_ATOM(overlay, "overlay") +GK_ATOM(p, "p") +GK_ATOM(pack, "pack") +GK_ATOM(page, "page") +GK_ATOM(pageincrement, "pageincrement") +GK_ATOM(pagex, "pagex") +GK_ATOM(pagey, "pagey") +GK_ATOM(palettename, "palettename") +GK_ATOM(param, "param") +GK_ATOM(parameter, "parameter") +GK_ATOM(parent, "parent") +GK_ATOM(parsetype, "parsetype") +GK_ATOM(patternSeparator, "pattern-separator") +GK_ATOM(perMille, "per-mille") +GK_ATOM(percent, "percent") +GK_ATOM(persist, "persist") +GK_ATOM(phase, "phase") +GK_ATOM(plaintext, "plaintext") +GK_ATOM(pointSize, "point-size") +GK_ATOM(popup, "popup") +GK_ATOM(popupList, "Popup-list") +GK_ATOM(popupalign, "popupalign") +GK_ATOM(popupanchor, "popupanchor") +GK_ATOM(popupgroup, "popupgroup") +GK_ATOM(popuphidden, "popuphidden") +GK_ATOM(popuphiding, "popuphiding") +GK_ATOM(popupset, "popupset") +GK_ATOM(popupshowing, "popupshowing") +GK_ATOM(popupshown, "popupshown") +GK_ATOM(position, "position") +GK_ATOM(pre, "pre") +GK_ATOM(preceding, "preceding") +GK_ATOM(precedingSibling, "preceding-sibling") +GK_ATOM(predicate, "predicate") +GK_ATOM(preserve, "preserve") +GK_ATOM(preserveSpace, "preserve-space") +GK_ATOM(preventdefault, "preventdefault") +GK_ATOM(primary, "primary") +GK_ATOM(print, "print") +GK_ATOM(priority, "priority") +GK_ATOM(processingInstruction, "processing-instruction") +GK_ATOM(profile, "profile") +GK_ATOM(progressmeter, "progressmeter") +GK_ATOM(progressNormal, "progressNormal") +GK_ATOM(progressUndetermined, "progressUndetermined") +GK_ATOM(projection, "projection") +GK_ATOM(prompt, "prompt") +GK_ATOM(propagate, "propagate") +GK_ATOM(properties, "properties") +GK_ATOM(property, "property") +GK_ATOM(q, "q") +GK_ATOM(radio, "radio") +GK_ATOM(radiogroup, "radiogroup") +GK_ATOM(readonly, "readonly") +GK_ATOM(ref, "ref") +GK_ATOM(refresh, "refresh") +GK_ATOM(rel, "rel") +GK_ATOM(removeelement, "removeelement") +GK_ATOM(repeat, "repeat") +GK_ATOM(reset, "reset") +GK_ATOM(resizeafter, "resizeafter") +GK_ATOM(resizebefore, "resizebefore") +GK_ATOM(resizer, "resizer") +GK_ATOM(resource, "resource") +GK_ATOM(resources, "resources") +GK_ATOM(rev, "rev") +GK_ATOM(reverse, "reverse") +GK_ATOM(right, "right") +GK_ATOM(rightmargin, "rightmargin") +GK_ATOM(rightpadding, "rightpadding") +GK_ATOM(round, "round") +GK_ATOM(row, "row") +GK_ATOM(rows, "rows") +GK_ATOM(rowspan, "rowspan") +GK_ATOM(rtl, "rtl") +GK_ATOM(rule, "rule") +GK_ATOM(rules, "rules") +GK_ATOM(s, "s") +GK_ATOM(scheme, "scheme") +GK_ATOM(scope, "scope") +GK_ATOM(screen, "screen") +GK_ATOM(screenX, "screenX") +GK_ATOM(screenY, "screenY") +GK_ATOM(script, "script") +GK_ATOM(scrollbar, "scrollbar") +GK_ATOM(scrollbarbutton, "scrollbarbutton") +GK_ATOM(scrollbox, "scrollbox") +GK_ATOM(scrollcorner, "scrollcorner") +GK_ATOM(scrolling, "scrolling") +GK_ATOM(select, "select") +GK_ATOM(selected, "selected") +GK_ATOM(selectedIndex, "selectedIndex") +GK_ATOM(selectedindex, "selectedindex") +GK_ATOM(self, "self") +GK_ATOM(seltype, "seltype") +GK_ATOM(setcookie, "set-cookie") +GK_ATOM(setter, "setter") +GK_ATOM(shape, "shape") +GK_ATOM(show, "show") +GK_ATOM(simple, "simple") +GK_ATOM(single, "single") +GK_ATOM(size, "size") +GK_ATOM(sizemode, "sizemode") +GK_ATOM(sizetopopup, "sizetopopup") +GK_ATOM(slider, "slider") +GK_ATOM(small, "small") +GK_ATOM(smooth, "smooth") +GK_ATOM(sort, "sort") +GK_ATOM(sortActive, "sortActive") +GK_ATOM(sortDirection, "sortDirection") +GK_ATOM(sorted, "sorted") +GK_ATOM(sortLocked, "sortLocked") +GK_ATOM(sortResource, "sortResource") +GK_ATOM(sortResource2, "sortResource2") +GK_ATOM(sortSeparators, "sortSeparators") +GK_ATOM(sortStaticsLast, "sortStaticsLast") +GK_ATOM(space, "space") +GK_ATOM(spacer, "spacer") +GK_ATOM(span, "span") +GK_ATOM(spinner, "spinner") +GK_ATOM(splitter, "splitter") +GK_ATOM(spring, "spring") +GK_ATOM(src, "src") +GK_ATOM(stack, "stack") +GK_ATOM(standalone, "standalone") +GK_ATOM(standby, "standby") +GK_ATOM(start, "start") +GK_ATOM(startsWith, "starts-with") +GK_ATOM(state, "state") +GK_ATOM(statedatasource, "statedatasource") +GK_ATOM(staticHint, "staticHint") +GK_ATOM(statustext, "statustext") +GK_ATOM(stop, "stop") +GK_ATOM(stretch, "stretch") +GK_ATOM(strike, "strike") +GK_ATOM(string, "string") +GK_ATOM(stringLength, "string-length") +GK_ATOM(stripSpace, "strip-space") +GK_ATOM(strong, "strong") +GK_ATOM(style, "style") +GK_ATOM(stylesheet, "stylesheet") +GK_ATOM(subject, "subject") +GK_ATOM(submit, "submit") +GK_ATOM(substring, "substring") +GK_ATOM(substringAfter, "substring-after") +GK_ATOM(substringBefore, "substring-before") +GK_ATOM(sum, "sum") +GK_ATOM(summary, "summary") +GK_ATOM(systemProperty, "system-property") +GK_ATOM(tab, "tab") +GK_ATOM(tabbox, "tabbox") +GK_ATOM(tabindex, "tabindex") +GK_ATOM(table, "table") +GK_ATOM(tabpanel, "tabpanel") +GK_ATOM(tabpanels, "tabpanels") +GK_ATOM(tag, "tag") +GK_ATOM(target, "target") +GK_ATOM(targets, "targets") +GK_ATOM(tbody, "tbody") +GK_ATOM(td, "td") +GK_ATOM(_template, "template") +GK_ATOM(terminate, "terminate") +GK_ATOM(test, "test") +GK_ATOM(text, "text") +GK_ATOM(textarea, "textarea") +GK_ATOM(textbox, "textbox") +GK_ATOM(textnode, "textnode") +GK_ATOM(tfoot, "tfoot") +GK_ATOM(th, "th") +GK_ATOM(thead, "thead") +GK_ATOM(thumb, "thumb") +GK_ATOM(title, "title") +GK_ATOM(titlebar, "titlebar") +GK_ATOM(titletip, "titletip") +GK_ATOM(toggled, "toggled") +GK_ATOM(toolbar, "toolbar") +GK_ATOM(toolbarbutton, "toolbarbutton") +GK_ATOM(toolbaritem, "toolbaritem") +GK_ATOM(toolbox, "toolbox") +GK_ATOM(tooltip, "tooltip") +GK_ATOM(tooltiptext, "tooltiptext") +GK_ATOM(top, "top") +GK_ATOM(topmargin, "topmargin") +GK_ATOM(toppadding, "toppadding") +GK_ATOM(tr, "tr") +GK_ATOM(transform, "transform") +GK_ATOM(translate, "translate") +GK_ATOM(transparent, "transparent") +GK_ATOM(tree, "tree") +GK_ATOM(treecell, "treecell") +GK_ATOM(treechildren, "treechildren") +GK_ATOM(treecol, "treecol") +GK_ATOM(treecols, "treecols") +GK_ATOM(treeitem, "treeitem") +GK_ATOM(treerow, "treerow") +GK_ATOM(treeseparator, "treeseparator") +GK_ATOM(triple, "triple") +GK_ATOM(_true, "true") +GK_ATOM(tt, "tt") +GK_ATOM(tty, "tty") +GK_ATOM(tv, "tv") +GK_ATOM(type, "type") +GK_ATOM(u, "u") +GK_ATOM(ul, "ul") +GK_ATOM(underflow, "underflow") +GK_ATOM(unload, "unload") +GK_ATOM(unparsedEntityUri, "unparsed-entity-uri") +GK_ATOM(upperFirst, "upper-first") +GK_ATOM(uri, "uri") +GK_ATOM(use, "use") +GK_ATOM(useAttributeSets, "use-attribute-sets") +GK_ATOM(usemap, "usemap") +GK_ATOM(validate, "validate") +GK_ATOM(valign, "valign") +GK_ATOM(value, "value") +GK_ATOM(valueOf, "value-of") +GK_ATOM(valuetype, "valuetype") +GK_ATOM(variable, "variable") +GK_ATOM(vbox, "vbox") +GK_ATOM(vcard_name, "vcard_name") +GK_ATOM(vendor, "vendor") +GK_ATOM(vendorUrl, "vendor-url") +GK_ATOM(version, "version") +GK_ATOM(vertical, "vertical") +GK_ATOM(visibility, "visibility") +GK_ATOM(vlink, "vlink") +GK_ATOM(vspace, "vspace") +GK_ATOM(wbr, "wbr") +GK_ATOM(when, "when") +GK_ATOM(widget, "widget") +GK_ATOM(width, "width") +GK_ATOM(window, "window") +GK_ATOM(headerWindowTarget, "window-target") +GK_ATOM(withParam, "with-param") +GK_ATOM(wizard, "wizard") +GK_ATOM(wrap, "wrap") +GK_ATOM(xml, "xml") +GK_ATOM(xmlns, "xmlns") +GK_ATOM(xmp, "xmp") +GK_ATOM(xulcontentsgenerated, "xulcontentsgenerated") +GK_ATOM(yes, "yes") +GK_ATOM(z_index, "z-index") +GK_ATOM(zeroDigit, "zero-digit") + + +#ifdef MOZ_SVG +GK_ATOM(percentage, "%") +GK_ATOM(alignment_baseline, "alignment-baseline") +GK_ATOM(amplitude, "amplitude") +GK_ATOM(baseline_shift, "baseline-shift") +GK_ATOM(circle, "circle") +GK_ATOM(clip_path, "clip-path") +GK_ATOM(clip_rule, "clip-rule") +GK_ATOM(clipPath, "clipPath") +GK_ATOM(clipPathUnits, "clipPathUnits") +GK_ATOM(cm, "cm") +GK_ATOM(cursor, "cursor") +GK_ATOM(cx, "cx") +GK_ATOM(cy, "cy") +GK_ATOM(d, "d") +GK_ATOM(defs, "defs") +GK_ATOM(deg, "deg") +GK_ATOM(desc, "desc") +GK_ATOM(direction, "direction") +GK_ATOM(disable, "disable") +GK_ATOM(discrete, "discrete") +GK_ATOM(dominant_baseline, "dominant-baseline") +GK_ATOM(dx, "dx") +GK_ATOM(dy, "dy") +GK_ATOM(ellipse, "ellipse") +GK_ATOM(ex, "ex") +GK_ATOM(exact, "exact") +GK_ATOM(exponent, "exponent") +GK_ATOM(feBlend, "feBlend") +GK_ATOM(feColorMatrix, "feColorMatrix") +GK_ATOM(feComponentTransfer, "feComponentTransfer") +GK_ATOM(feComposite, "feComposite") +GK_ATOM(feConvolveMatrix, "feConvolveMatrix") +GK_ATOM(feDiffuseLighting, "feDiffuseLighting") +GK_ATOM(feDisplacementMap, "feDisplacementMap") +GK_ATOM(feFlood, "feFlood") +GK_ATOM(feFuncA, "feFuncA") +GK_ATOM(feFuncB, "feFuncB") +GK_ATOM(feFuncG, "feFuncG") +GK_ATOM(feFuncR, "feFuncR") +GK_ATOM(feGaussianBlur, "feGaussianBlur") +GK_ATOM(feImage, "feImage") +GK_ATOM(feMerge, "feMerge") +GK_ATOM(feMergeNode, "feMergeNode") +GK_ATOM(feMorphology, "feMorphology") +GK_ATOM(feOffset, "feOffset") +GK_ATOM(feSpecularLighting, "feSpecularLighting") +GK_ATOM(feTile, "feTile") +GK_ATOM(feTurbulence, "feTurbulence") +GK_ATOM(fill, "fill") +GK_ATOM(fill_opacity, "fill-opacity") +GK_ATOM(fill_rule, "fill-rule") +GK_ATOM(filter, "filter") +GK_ATOM(filterRes, "filterRes") +GK_ATOM(filterUnits, "filterUnits") +GK_ATOM(font_family, "font-family") +GK_ATOM(font_size, "font-size") +GK_ATOM(font_size_adjust, "font-size-adjust") +GK_ATOM(font_stretch, "font-stretch") +GK_ATOM(font_style, "font-style") +GK_ATOM(font_variant, "font-variant") +#ifdef MOZ_SVG_FOREIGNOBJECT +GK_ATOM(foreignObject, "foreignObject") +#endif +GK_ATOM(fx, "fx") +GK_ATOM(fy, "fy") +GK_ATOM(g, "g") +GK_ATOM(gamma, "gamma") +GK_ATOM(generic, "generic") +GK_ATOM(glyph_orientation_horizontal, "glyph-orientation-horizontal") +GK_ATOM(glyph_orientation_vertical, "glyph-orientation-vertical") +GK_ATOM(grad, "grad") +GK_ATOM(gradientTransform, "gradientTransform") +GK_ATOM(gradientUnits, "gradientUnits") +GK_ATOM(identity, "identity") +GK_ATOM(image_rendering, "image-rendering") +GK_ATOM(in, "in") +GK_ATOM(intercept, "intercept") +GK_ATOM(kerning, "kerning") +GK_ATOM(letter_spacing, "letter-spacing") +GK_ATOM(line, "line") +GK_ATOM(linear, "linear") +GK_ATOM(linearGradient, "linearGradient") +GK_ATOM(magnify, "magnify") +GK_ATOM(marker, "marker") +GK_ATOM(marker_end, "marker-end") +GK_ATOM(marker_mid, "marker-mid") +GK_ATOM(marker_start, "marker-start") +GK_ATOM(markerHeight, "markerHeight") +GK_ATOM(markerUnits, "markerUnits") +GK_ATOM(markerWidth, "markerWidth") +GK_ATOM(mask, "mask") +GK_ATOM(matrix, "matrix") +GK_ATOM(metadata, "metadata") +GK_ATOM(mm, "mm") +GK_ATOM(objectBoundingBox, "objectBoundingBox") +GK_ATOM(offset, "offset") +GK_ATOM(onSVGAbort, "onSVGAbort") +GK_ATOM(onSVGError, "onSVGError") +GK_ATOM(onSVGLoad, "onSVGLoad") +GK_ATOM(onSVGResize, "onSVGResize") +GK_ATOM(onSVGScroll, "onSVGScroll") +GK_ATOM(onSVGUnload, "onSVGUnload") +GK_ATOM(onSVGZoom, "onSVGZoom") +GK_ATOM(onzoom, "onzoom") +GK_ATOM(opacity, "opacity") +GK_ATOM(pad, "pad") +GK_ATOM(path, "path") +GK_ATOM(pathLength, "pathLength") +GK_ATOM(pattern, "pattern") +GK_ATOM(patternContentUnits, "patternContentUnits") +GK_ATOM(patternTransform, "patternTransform") +GK_ATOM(patternUnits, "patternUnits") +GK_ATOM(pc, "pc") +GK_ATOM(pointer_events, "pointer-events") +GK_ATOM(points, "points") +GK_ATOM(polygon, "polygon") +GK_ATOM(polyline, "polyline") +GK_ATOM(preserveAspectRatio, "preserveAspectRatio") +GK_ATOM(primitiveUnits, "primitiveUnits") +GK_ATOM(pt, "pt") +GK_ATOM(px, "px") +GK_ATOM(r, "r") +GK_ATOM(rad, "rad") +GK_ATOM(radialGradient, "radialGradient") +GK_ATOM(rect, "rect") +GK_ATOM(reflect, "reflect") +GK_ATOM(refX, "refX") +GK_ATOM(refY, "refY") +GK_ATOM(requiredExtensions, "requiredExtensions") +GK_ATOM(requiredFeatures, "requiredFeatures") +GK_ATOM(result, "result") +GK_ATOM(rotate, "rotate") +GK_ATOM(rx, "rx") +GK_ATOM(ry, "ry") +GK_ATOM(scale, "scale") +GK_ATOM(shape_rendering, "shape-rendering") +GK_ATOM(skewX, "skewX") +GK_ATOM(skewY, "skewY") +GK_ATOM(slope, "slope") +GK_ATOM(spacing, "spacing") +GK_ATOM(spreadMethod, "spreadMethod") +GK_ATOM(startOffset, "startOffset") +GK_ATOM(stdDeviation, "stdDeviation") +GK_ATOM(stop_color, "stop-color") +GK_ATOM(stop_opacity, "stop-opacity") +GK_ATOM(stroke, "stroke") +GK_ATOM(stroke_dasharray, "stroke-dasharray") +GK_ATOM(stroke_dashoffset, "stroke-dashoffset") +GK_ATOM(stroke_linecap, "stroke-linecap") +GK_ATOM(stroke_linejoin, "stroke-linejoin") +GK_ATOM(stroke_miterlimit, "stroke-miterlimit") +GK_ATOM(stroke_opacity, "stroke-opacity") +GK_ATOM(stroke_width, "stroke-width") +GK_ATOM(strokeWidth, "strokeWidth") +GK_ATOM(svg, "svg") +GK_ATOM(svgSwitch, "switch") +GK_ATOM(symbol, "symbol") +GK_ATOM(systemLanguage, "systemLanguage") +GK_ATOM(tableValues, "tableValues") +GK_ATOM(text_anchor, "text-anchor") +GK_ATOM(text_decoration, "text-decoration") +GK_ATOM(text_rendering, "text-rendering") +GK_ATOM(textPath, "textPath") +GK_ATOM(tref, "tref") +GK_ATOM(tspan, "tspan") +GK_ATOM(unicode_bidi, "unicode-bidi") +GK_ATOM(userSpaceOnUse, "userSpaceOnUse") +GK_ATOM(viewBox, "viewBox") +GK_ATOM(word_spacing, "word-spacing") +GK_ATOM(x, "x") +GK_ATOM(x1, "x1") +GK_ATOM(x2, "x2") +GK_ATOM(y, "y") +GK_ATOM(y1, "y1") +GK_ATOM(y2, "y2") +GK_ATOM(zoomAndPan, "zoomAndPan") +#endif + +#ifdef MOZ_MATHML +GK_ATOM(MOZcolumnline, "-moz-math-columnline") // different from columnlines_ +GK_ATOM(MOZfirstcolumn, "-moz-math-firstcolumn") +GK_ATOM(MOZfirstrow, "-moz-math-firstrow") +GK_ATOM(MOZfontsize, "-moz-math-font-size") // different from fontsize_ +GK_ATOM(MOZfontstyle, "-moz-math-font-style") // different from fontstyle_ +GK_ATOM(MOZlastcolumn, "-moz-math-lastcolumn") +GK_ATOM(MOZlastrow, "-moz-math-lastrow") +GK_ATOM(MOZrowline, "-moz-math-rowline") // different from rowlines_ +GK_ATOM(abs_, "abs") +GK_ATOM(accent_, "accent") +GK_ATOM(accentunder_, "accentunder") +GK_ATOM(actiontype_, "actiontype") +GK_ATOM(alignmentscope_, "alignmentscope") +GK_ATOM(annotation_, "annotation") +GK_ATOM(apply_, "apply") +GK_ATOM(arccos_, "arccos") +GK_ATOM(arcsin_, "arcsin") +GK_ATOM(arctan_, "arctan") +GK_ATOM(bevelled_, "bevelled") +GK_ATOM(bvar_, "bvar") +GK_ATOM(ci_, "ci") +GK_ATOM(cn_, "cn") +GK_ATOM(columnalign_, "columnalign") +GK_ATOM(columnlines_, "columnlines") +GK_ATOM(columnspacing_, "columnspacing") +GK_ATOM(columnspan_, "columnspan") +GK_ATOM(columnwidth_, "columnwidth") +GK_ATOM(compose_, "compose") +GK_ATOM(condition_, "condition") +GK_ATOM(conjugate_, "conjugate") +GK_ATOM(cos_, "cos") +GK_ATOM(cosh_, "cosh") +GK_ATOM(cot_, "cot") +GK_ATOM(coth_, "coth") +GK_ATOM(csc_, "csc") +GK_ATOM(csch_, "csch") +GK_ATOM(degree_, "degree") +GK_ATOM(denomalign_, "denomalign") +GK_ATOM(depth_, "depth") +GK_ATOM(determinant_, "determinant") +GK_ATOM(diff_, "diff") +GK_ATOM(displaystyle_, "displaystyle") +GK_ATOM(divide_, "divide") +GK_ATOM(edge_, "edge") +GK_ATOM(eq_, "eq") +GK_ATOM(equalcolumns_, "equalcolumns") +GK_ATOM(equalrows_, "equalrows") +GK_ATOM(exists_, "exists") +GK_ATOM(exp_, "exp") +GK_ATOM(factorial_, "factorial") +GK_ATOM(fence_, "fence") +GK_ATOM(fn_, "fn") +GK_ATOM(fontfamily_, "fontfamily") +GK_ATOM(fontsize_, "fontsize") +GK_ATOM(fontstyle_, "fontstyle") +GK_ATOM(fontweight_, "fontweight") +GK_ATOM(forall_, "forall") +GK_ATOM(framespacing_, "framespacing") +GK_ATOM(geq_, "geq") +GK_ATOM(groupalign_, "groupalign") +GK_ATOM(gt_, "gt") +GK_ATOM(ident_, "ident") +GK_ATOM(implies_, "implies") +GK_ATOM(int_, "int") +GK_ATOM(intersect_, "intersect") +GK_ATOM(interval_, "interval") +GK_ATOM(inverse_, "inverse") +GK_ATOM(lambda_, "lambda") +GK_ATOM(largeop_, "largeop") +GK_ATOM(leq_, "leq") +GK_ATOM(limit_, "limit") +GK_ATOM(linebreak_, "linebreak") +GK_ATOM(linethickness_, "linethickness") +GK_ATOM(list_, "list") +GK_ATOM(ln_, "ln") +GK_ATOM(log_, "log") +GK_ATOM(logbase_, "logbase") +GK_ATOM(lowlimit_, "lowlimit") +GK_ATOM(lquote_, "lquote") +GK_ATOM(lspace_, "lspace") +GK_ATOM(lt_, "lt") +GK_ATOM(maction_, "maction") +GK_ATOM(maligngroup_, "maligngroup") +GK_ATOM(malignmark_, "malignmark") +GK_ATOM(mathbackground_, "mathbackground") +GK_ATOM(mathcolor_, "mathcolor") +GK_ATOM(mathsize_, "mathsize") +GK_ATOM(mathvariant_, "mathvariant") +GK_ATOM(matrixrow_, "matrixrow") +GK_ATOM(maxsize_, "maxsize") +GK_ATOM(mean_, "mean") +GK_ATOM(median_, "median") +GK_ATOM(mediummathspace_, "mediummathspace") +GK_ATOM(menclose_, "menclose") +GK_ATOM(merror_, "merror") +GK_ATOM(mfenced_, "mfenced") +GK_ATOM(mfrac_, "mfrac") +GK_ATOM(mi_, "mi") +GK_ATOM(minlabelspacing_, "minlabelspacing") +GK_ATOM(minsize_, "minsize") +GK_ATOM(minus_, "minus") +GK_ATOM(mlabeledtr_, "mlabeledtr") +GK_ATOM(mmultiscripts_, "mmultiscripts") +GK_ATOM(mn_, "mn") +GK_ATOM(mo_, "mo") +GK_ATOM(moment_, "moment") +GK_ATOM(movablelimits_, "movablelimits") +GK_ATOM(mover_, "mover") +GK_ATOM(mpadded_, "mpadded") +GK_ATOM(mphantom_, "mphantom") +GK_ATOM(mprescripts_, "mprescripts") +GK_ATOM(mroot_, "mroot") +GK_ATOM(mrow_, "mrow") +GK_ATOM(ms_, "ms") +GK_ATOM(mspace_, "mspace") +GK_ATOM(msqrt_, "msqrt") +GK_ATOM(mstyle_, "mstyle") +GK_ATOM(msub_, "msub") +GK_ATOM(msubsup_, "msubsup") +GK_ATOM(msup_, "msup") +GK_ATOM(mtable_, "mtable") +GK_ATOM(mtd_, "mtd") +GK_ATOM(mtext_, "mtext") +GK_ATOM(mtr_, "mtr") +GK_ATOM(munder_, "munder") +GK_ATOM(munderover_, "munderover") +GK_ATOM(neq_, "neq") +GK_ATOM(notation_, "notation") +GK_ATOM(notin_, "notin") +GK_ATOM(notprsubset_, "notprsubset") +GK_ATOM(notsubset_, "notsubset") +GK_ATOM(numalign_, "numalign") +GK_ATOM(other_, "other") +GK_ATOM(partialdiff_, "partialdiff") +GK_ATOM(plus_, "plus") +GK_ATOM(power_, "power") +GK_ATOM(product_, "product") +GK_ATOM(prsubset_, "prsubset") +GK_ATOM(quotient_, "quotient") +GK_ATOM(reln_, "reln") +GK_ATOM(rem_, "rem") +GK_ATOM(root_, "root") +GK_ATOM(rowalign_, "rowalign") +GK_ATOM(rowlines_, "rowlines") +GK_ATOM(rowspacing_, "rowspacing") +GK_ATOM(rquote_, "rquote") +GK_ATOM(rspace_, "rspace") +GK_ATOM(scriptlevel_, "scriptlevel") +GK_ATOM(scriptminsize_, "scriptminsize") +GK_ATOM(scriptsizemultiplier_, "scriptsizemultiplier") +GK_ATOM(sdev_, "sdev") +GK_ATOM(sec_, "sec") +GK_ATOM(sech_, "sech") +GK_ATOM(selection_, "selection") +GK_ATOM(semantics_, "semantics") +GK_ATOM(sep_, "sep") +GK_ATOM(separator_, "separator") +GK_ATOM(separators_, "separators") +GK_ATOM(set_, "set") +GK_ATOM(setdiff_, "setdiff") +GK_ATOM(side_, "side") +GK_ATOM(sin_, "sin") +GK_ATOM(sinh_, "sinh") +GK_ATOM(stretchy_, "stretchy") +GK_ATOM(subscriptshift_, "subscriptshift") +GK_ATOM(subset_, "subset") +GK_ATOM(superscriptshift_, "superscriptshift") +GK_ATOM(symmetric_, "symmetric") +GK_ATOM(tan_, "tan") +GK_ATOM(tanh_, "tanh") +GK_ATOM(tendsto_, "tendsto") +GK_ATOM(thickmathspace_, "thickmathspace") +GK_ATOM(thinmathspace_, "thinmathspace") +GK_ATOM(times_, "times") +GK_ATOM(transpose_, "transpose") +GK_ATOM(union_, "union") +GK_ATOM(uplimit_, "uplimit") +GK_ATOM(var_, "var") +GK_ATOM(vector_, "vector") +GK_ATOM(verythickmathspace_, "verythickmathspace") +GK_ATOM(verythinmathspace_, "verythinmathspace") +GK_ATOM(veryverythickmathspace_, "veryverythickmathspace") +GK_ATOM(veryverythinmathspace_, "veryverythinmathspace") +GK_ATOM(xor_, "xor") +GK_ATOM(math, "math") // the only one without an underscore +#endif + +#ifndef DISABLE_XFORMS_HOOKS +GK_ATOM(avg, "avg") +GK_ATOM(booleanFromString, "boolean-from-string") +GK_ATOM(countNonEmpty, "count-non-empty") +GK_ATOM(daysFromDate, "days-from-date") +GK_ATOM(init, "init") +GK_ATOM(instance, "instance") +GK_ATOM(max, "max") +GK_ATOM(min, "min") +GK_ATOM(months, "months") +GK_ATOM(now, "now") +GK_ATOM(seconds, "seconds") +GK_ATOM(secondsFromDateTime, "seconds-from-dateTime") +#endif + +//--------------------------------------------------------------------------- +// Special atoms +//--------------------------------------------------------------------------- + +// Node types +GK_ATOM(cdataTagName, "#cdata-section") +GK_ATOM(commentTagName, "#comment") +GK_ATOM(documentFragmentNodeName, "#document-fragment") +GK_ATOM(documentTypeNodeName, "#document-type") +GK_ATOM(processingInstructionTagName, "#processing-instruction") +GK_ATOM(textTagName, "#text") + +// Frame types +GK_ATOM(areaFrame, "AreaFrame") +GK_ATOM(bcTableCellFrame, "BCTableCellFrame") // table cell in border collapsing model +GK_ATOM(blockFrame, "BlockFrame") +GK_ATOM(boxFrame, "BoxFrame") +GK_ATOM(brFrame, "BRFrame") +GK_ATOM(bulletFrame, "BulletFrame") +GK_ATOM(columnSetFrame, "ColumnSetFrame") +GK_ATOM(directionalFrame, "DirectionalFrame") +GK_ATOM(fieldSetFrame, "FieldSetFrame") +GK_ATOM(frameSetFrame, "FrameSetFrame") +GK_ATOM(gfxButtonControlFrame, "gfxButtonControlFrame") +GK_ATOM(HTMLCanvasFrame, "HTMLCanvasFrame") +GK_ATOM(subDocumentFrame, "subDocumentFrame") +GK_ATOM(imageBoxFrame, "ImageBoxFrame") +GK_ATOM(imageFrame, "ImageFrame") +GK_ATOM(imageControlFrame, "ImageControlFrame") +GK_ATOM(inlineFrame, "InlineFrame") +GK_ATOM(legendFrame, "LegendFrame") +GK_ATOM(letterFrame, "LetterFrame") +GK_ATOM(lineFrame, "LineFrame") +GK_ATOM(listControlFrame,"ListControlFrame") +GK_ATOM(objectFrame, "ObjectFrame") +GK_ATOM(pageFrame, "PageFrame") +GK_ATOM(pageBreakFrame, "PageBreakFrame") +GK_ATOM(pageContentFrame, "PageContentFrame") +GK_ATOM(placeholderFrame, "PlaceholderFrame") +GK_ATOM(positionedInlineFrame, "PositionedInlineFrame") +GK_ATOM(canvasFrame, "CanvasFrame") +GK_ATOM(rootFrame, "RootFrame") +GK_ATOM(scrollFrame, "ScrollFrame") +GK_ATOM(sequenceFrame, "SequenceFrame") +GK_ATOM(tableCaptionFrame, "TableCaptionFrame") +GK_ATOM(tableCellFrame, "TableCellFrame") +GK_ATOM(tableColFrame, "TableColFrame") +GK_ATOM(tableColGroupFrame, "TableColGroupFrame") +GK_ATOM(tableFrame, "TableFrame") +GK_ATOM(tableOuterFrame, "TableOuterFrame") +GK_ATOM(tableRowGroupFrame, "TableRowGroupFrame") +GK_ATOM(tableRowFrame, "TableRowFrame") +GK_ATOM(textInputFrame,"TextInputFrame") +GK_ATOM(textFrame, "TextFrame") +GK_ATOM(viewportFrame, "ViewportFrame") +#ifdef MOZ_SVG +GK_ATOM(svgCircleFrame, "SVGCircleFrame") +GK_ATOM(svgClipPathFrame, "SVGClipPathFrame") +GK_ATOM(svgDefsFrame, "SVGDefsFrame") +GK_ATOM(svgEllipseFrame, "SVGEllipseFrame") +GK_ATOM(svgFilterFrame, "SVGFilterFrame") +#ifdef MOZ_SVG_FOREIGNOBJECT +GK_ATOM(svgForeignObjectFrame, "SVGForeignObjectFrame") +#endif +GK_ATOM(svgGenericContainerFrame, "SVGGenericContainerFrame") +GK_ATOM(svgGFrame, "SVGGFrame") +GK_ATOM(svgGlyphFrame, "SVGGlyphFrame") +GK_ATOM(svgGradientFrame, "SVGGradientFrame") +GK_ATOM(svgImageFrame, "SVGImageFrame") +GK_ATOM(svgInnerSVGFrame, "SVGInnerSVGFrame") +GK_ATOM(svgLinearGradientFrame, "SVGLinearGradientFrame") +GK_ATOM(svgLineFrame, "SVGLineFrame") +GK_ATOM(svgMarkerFrame, "SVGMarkerFrame") +GK_ATOM(svgOuterSVGFrame, "SVGOuterSVGFrame") +GK_ATOM(svgPathFrame, "SVGPathFrame") +GK_ATOM(svgPathGeometryFrame, "SVGPathGeometryFrame") +GK_ATOM(svgPatternFrame, "SVGPatternFrame") +GK_ATOM(svgPolygonFrame, "SVGPolygonFrame") +GK_ATOM(svgPolylineFrame, "SVGPolylineFrame") +GK_ATOM(svgRadialGradientFrame, "SVGRadialGradientFrame") +GK_ATOM(svgRectFrame, "SVGRectFrame") +GK_ATOM(svgStopFrame, "SVGStopFrame") +GK_ATOM(svgTextFrame, "SVGTextFrame") +GK_ATOM(svgTextPathFrame, "SVGTextPathFrame") +GK_ATOM(svgTSpanFrame, "SVGTSpanFrame") +GK_ATOM(svgUseFrame, "SVGUseFrame") +#endif +#ifdef MOZ_MATHML +GK_ATOM(ordinaryMathMLFrame, "OrdinaryMathMLFrame") +GK_ATOM(operatorOrdinaryMathMLFrame, "OperatorOrdinaryMathMLFrame") +GK_ATOM(operatorInvisibleMathMLFrame, "OperatorInvisibleMathMLFrame") +GK_ATOM(operatorUserDefinedMathMLFrame, "OperatorUserDefinedMathMLFrame") +GK_ATOM(innerMathMLFrame, "InnerMathMLFrame") // 'inner' in TeX +GK_ATOM(italicIdentifierMathMLFrame, "ItalicIdentifierMathMLFrame") +GK_ATOM(uprightIdentifierMathMLFrame, "UprightIdentifierMathMLFrame") +#endif + +// Frame property names +GK_ATOM(boxMetricsProperty, "BoxMetricsProperty") // nsBoxLayoutMetrics* +GK_ATOM(changeListProperty, "ChangeListProperty") // void* +GK_ATOM(collapseOffsetProperty, "CollapseOffsetProperty") // nsPoint* +GK_ATOM(computedOffsetProperty, "ComputedOffsetProperty") // nsPoint* +GK_ATOM(IBSplitSpecialPrevSibling, "IBSplitSpecialPrevSibling")// nsIFrame* +GK_ATOM(IBSplitSpecialSibling, "IBSplitSpecialSibling") // nsIFrame* +GK_ATOM(lineCursorProperty, "LineCursorProperty") // nsLineBox* +GK_ATOM(maxElementWidthProperty, "MaxElementWidthProperty") // nscoord* +GK_ATOM(overflowAreaProperty, "OverflowArea") // nsRect* +GK_ATOM(overflowProperty, "OverflowProperty") // list of nsIFrame* +GK_ATOM(overflowLinesProperty, "OverflowLinesProperty") // list of nsLineBox* +GK_ATOM(overflowOutOfFlowsProperty, "OverflowOutOfFlowsProperty") // nsFrameList* +GK_ATOM(overflowPlaceholdersProperty, "OverflowPlaceholdersProperty") // nsFrameList* +GK_ATOM(rowUnpaginatedHeightProperty, "RowUnpaginatedHeightProperty") // nscoord* +GK_ATOM(spaceManagerProperty, "SpaceManagerProperty") // the space manager for a block +GK_ATOM(tableBCProperty, "TableBCProperty") // table border collapsing info (e.g. damage area, table border widths) +GK_ATOM(viewProperty, "ViewProperty") + +// Languages for lang-specific transforms +GK_ATOM(Japanese, "ja") +GK_ATOM(Chinese, "zh-CN") +GK_ATOM(Taiwanese, "zh-TW") +GK_ATOM(HongKongChinese, "zh-HK") +GK_ATOM(Unicode, "x-unicode") diff --git a/mozilla/content/html/content/src/nsHTMLAtoms.cpp b/mozilla/content/base/src/nsGkAtoms.cpp old mode 100644 new mode 100755 similarity index 76% rename from mozilla/content/html/content/src/nsHTMLAtoms.cpp rename to mozilla/content/base/src/nsGkAtoms.cpp index 681f24c656a..1b5eabd9449 --- a/mozilla/content/html/content/src/nsHTMLAtoms.cpp +++ b/mozilla/content/base/src/nsGkAtoms.cpp @@ -15,8 +15,8 @@ * The Original Code is mozilla.org code. * * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 1998 + * Mozilla Foundation. + * Portions created by the Initial Developer are Copyright (C) 2006 * the Initial Developer. All Rights Reserved. * * Contributor(s): @@ -34,23 +34,22 @@ * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ -#include "nsHTMLAtoms.h" +#include "nsGkAtoms.h" #include "nsStaticAtom.h" -#include "nsMemory.h" // define storage for all atoms -#define HTML_ATOM(_name, _value) nsIAtom* nsHTMLAtoms::_name; -#include "nsHTMLAtomList.h" -#undef HTML_ATOM +#define GK_ATOM(_name, _value) nsIAtom* nsGkAtoms::_name; +#include "nsGkAtomList.h" +#undef GK_ATOM -static const nsStaticAtom HTMLAtoms_info[] = { -#define HTML_ATOM(name_, value_) { value_, &nsHTMLAtoms::name_ }, -#include "nsHTMLAtomList.h" -#undef HTML_ATOM +static const nsStaticAtom GkAtoms_info[] = { +#define GK_ATOM(name_, value_) { value_, &nsGkAtoms::name_ }, +#include "nsGkAtomList.h" +#undef GK_ATOM }; -void nsHTMLAtoms::AddRefAtoms() +void nsGkAtoms::AddRefAtoms() { - NS_RegisterStaticAtoms(HTMLAtoms_info, NS_ARRAY_LENGTH(HTMLAtoms_info)); + NS_RegisterStaticAtoms(GkAtoms_info, NS_ARRAY_LENGTH(GkAtoms_info)); } diff --git a/mozilla/content/xbl/src/nsXBLAtoms.cpp b/mozilla/content/base/src/nsGkAtoms.h old mode 100644 new mode 100755 similarity index 68% rename from mozilla/content/xbl/src/nsXBLAtoms.cpp rename to mozilla/content/base/src/nsGkAtoms.h index 8a85bcc6e6f..8b23304ce80 --- a/mozilla/content/xbl/src/nsXBLAtoms.cpp +++ b/mozilla/content/base/src/nsGkAtoms.h @@ -15,12 +15,11 @@ * The Original Code is mozilla.org code. * * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 1998 + * Mozilla Foundation. + * Portions created by the Initial Developer are Copyright (C) 2006 * the Initial Developer. All Rights Reserved. * * Contributor(s): - * Original Author: David W. Hyatt (hyatt@netscape.com) * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), @@ -35,25 +34,32 @@ * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ +#ifndef nsGkAtoms_h___ +#define nsGkAtoms_h___ -#include "nsXBLAtoms.h" -#include "nsStaticAtom.h" -#include "nsMemory.h" +#include "nsIAtom.h" -// define storage for all atoms -#define XBL_ATOM(_name, _value) nsIAtom* nsXBLAtoms::_name; -#include "nsXBLAtomList.h" -#undef XBL_ATOM +/** + * This class wraps up the creation (and destruction) of the standard + * set of atoms used by gklayout. This objects are created when gklayout + * is loaded and they destroyed when gklayout is unloaded. + */ +class nsGkAtoms { +public: -static const nsStaticAtom XBLAtoms_info[] = { -#define XBL_ATOM(name_, value_) { value_, &nsXBLAtoms::name_ }, -#include "nsXBLAtomList.h" -#undef XBL_ATOM + static void AddRefAtoms(); + + /* Declare all atoms + + The atom names and values are stored in nsGkAtomList.h and + are brought to you by the magic of C preprocessing + + Add new atoms to nsGkAtomList and all support logic will be auto-generated + */ +#define GK_ATOM(_name, _value) static nsIAtom* _name; +#include "nsGkAtomList.h" +#undef GK_ATOM }; -void nsXBLAtoms::AddRefAtoms() { - NS_RegisterStaticAtoms(XBLAtoms_info, - NS_ARRAY_LENGTH(XBLAtoms_info)); -} - +#endif /* nsGkAtoms_h___ */ diff --git a/mozilla/content/base/src/nsPlainTextSerializer.cpp b/mozilla/content/base/src/nsPlainTextSerializer.cpp index 357186df817..863d8a909b9 100644 --- a/mozilla/content/base/src/nsPlainTextSerializer.cpp +++ b/mozilla/content/base/src/nsPlainTextSerializer.cpp @@ -1792,7 +1792,7 @@ PRBool nsPlainTextSerializer::IsCurrentNodeConverted(const nsIParserNode* aNode) { nsAutoString value; - nsresult rv = GetAttributeValue(aNode, nsHTMLAtoms::kClass, value); + nsresult rv = GetAttributeValue(aNode, nsHTMLAtoms::_class, value); return (NS_SUCCEEDED(rv) && (value.EqualsIgnoreCase("moz-txt", 7) || value.EqualsIgnoreCase("\"moz-txt", 8))); diff --git a/mozilla/content/base/src/nsScriptLoader.cpp b/mozilla/content/base/src/nsScriptLoader.cpp index 1c54efb254c..601294d03c0 100644 --- a/mozilla/content/base/src/nsScriptLoader.cpp +++ b/mozilla/content/base/src/nsScriptLoader.cpp @@ -292,7 +292,7 @@ nsScriptLoader::IsScriptEventHandler(nsIScriptElement *aScriptElement) nsAutoString forAttr, eventAttr; if (!contElement->GetAttr(kNameSpaceID_None, nsHTMLAtoms::_for, forAttr) || - !contElement->GetAttr(kNameSpaceID_None, nsHTMLAtoms::_event, eventAttr)) { + !contElement->GetAttr(kNameSpaceID_None, nsHTMLAtoms::event, eventAttr)) { return PR_FALSE; } diff --git a/mozilla/content/base/src/nsXMLContentSerializer.cpp b/mozilla/content/base/src/nsXMLContentSerializer.cpp index 719fee60c52..74c3e7eb1f5 100644 --- a/mozilla/content/base/src/nsXMLContentSerializer.cpp +++ b/mozilla/content/base/src/nsXMLContentSerializer.cpp @@ -600,7 +600,7 @@ nsXMLContentSerializer::AppendElementStart(nsIDOMElement *aElement, // XXXbz what if we have both "xmlns" in the null namespace and "xmlns" // in the xmlns namespace? (namespaceID == kNameSpaceID_None && - attrName == nsLayoutAtoms::xmlnsNameSpace)) { + attrName == nsLayoutAtoms::xmlns)) { content->GetAttr(namespaceID, attrName, uriStr); if (!name->GetPrefix()) { diff --git a/mozilla/content/base/src/nsXMLNameSpaceMap.cpp b/mozilla/content/base/src/nsXMLNameSpaceMap.cpp index 4f091744141..3b1391d7510 100755 --- a/mozilla/content/base/src/nsXMLNameSpaceMap.cpp +++ b/mozilla/content/base/src/nsXMLNameSpaceMap.cpp @@ -58,9 +58,9 @@ nsXMLNameSpaceMap::Create() nsXMLNameSpaceMap *map = new nsXMLNameSpaceMap(); NS_ENSURE_TRUE(map, nsnull); - nsresult rv = map->AddPrefix(nsLayoutAtoms::xmlnsNameSpace, + nsresult rv = map->AddPrefix(nsLayoutAtoms::xmlns, kNameSpaceID_XMLNS); - rv |= map->AddPrefix(nsLayoutAtoms::xmlNameSpace, kNameSpaceID_XML); + rv |= map->AddPrefix(nsLayoutAtoms::xml, kNameSpaceID_XML); if (NS_FAILED(rv)) { delete map; diff --git a/mozilla/content/events/src/nsXMLEventsElement.cpp b/mozilla/content/events/src/nsXMLEventsElement.cpp index 067986627aa..9cd19ec2c53 100644 --- a/mozilla/content/events/src/nsXMLEventsElement.cpp +++ b/mozilla/content/events/src/nsXMLEventsElement.cpp @@ -74,7 +74,7 @@ nsXMLEventsElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsIAtom* aPref { if (mNodeInfo->Equals(nsHTMLAtoms::listener) && mNodeInfo->GetDocument() && aNameSpaceID == kNameSpaceID_None && - aName == nsHTMLAtoms::_event) + aName == nsHTMLAtoms::event) mNodeInfo->GetDocument()->AddXMLEventsContent(this); return nsXMLElement::SetAttr(aNameSpaceID, aName, aPrefix, aValue, aNotify); diff --git a/mozilla/content/events/src/nsXMLEventsManager.cpp b/mozilla/content/events/src/nsXMLEventsManager.cpp index 1ed27652157..12bdec14bed 100644 --- a/mozilla/content/events/src/nsXMLEventsManager.cpp +++ b/mozilla/content/events/src/nsXMLEventsManager.cpp @@ -63,7 +63,7 @@ PRBool nsXMLEventsListener::InitXMLEventsListener(nsIDocument * aDocument, else nameSpaceID = kNameSpaceID_XMLEvents; nsAutoString eventType; - aContent->GetAttr(nameSpaceID, nsHTMLAtoms::_event, eventType); + aContent->GetAttr(nameSpaceID, nsHTMLAtoms::event, eventType); if (eventType.IsEmpty()) return PR_FALSE; nsAutoString handlerURIStr; @@ -361,7 +361,7 @@ nsXMLEventsManager::AttributeChanged(nsIDocument* aDocument, PRInt32 aModType) { if (aNameSpaceID == kNameSpaceID_XMLEvents && - (aAttribute == nsHTMLAtoms::_event || + (aAttribute == nsHTMLAtoms::event || aAttribute == nsHTMLAtoms::handler || aAttribute == nsHTMLAtoms::target || aAttribute == nsHTMLAtoms::observer || diff --git a/mozilla/content/html/content/src/Makefile.in b/mozilla/content/html/content/src/Makefile.in index 4ce12e36282..7ce6be7fe9e 100644 --- a/mozilla/content/html/content/src/Makefile.in +++ b/mozilla/content/html/content/src/Makefile.in @@ -75,7 +75,6 @@ REQUIRES = xpcom \ $(NULL) EXPORTS = \ - nsHTMLAtomList.h \ nsHTMLAtoms.h \ nsImageMapUtils.h \ $(NULL) @@ -84,7 +83,6 @@ CPPSRCS = \ nsGenericHTMLElement.cpp \ nsGenericDOMHTMLCollection.cpp \ nsFormSubmission.cpp \ - nsHTMLAtoms.cpp \ nsImageMapUtils.cpp \ nsHTMLAnchorElement.cpp \ nsHTMLAppletElement.cpp \ diff --git a/mozilla/content/html/content/src/nsGenericHTMLElement.cpp b/mozilla/content/html/content/src/nsGenericHTMLElement.cpp index 895eae297ec..bdc0529d716 100644 --- a/mozilla/content/html/content/src/nsGenericHTMLElement.cpp +++ b/mozilla/content/html/content/src/nsGenericHTMLElement.cpp @@ -489,14 +489,14 @@ nsGenericHTMLElement::SetDir(const nsAString& aDir) nsresult nsGenericHTMLElement::GetClassName(nsAString& aClassName) { - GetAttr(kNameSpaceID_None, nsHTMLAtoms::kClass, aClassName); + GetAttr(kNameSpaceID_None, nsHTMLAtoms::_class, aClassName); return NS_OK; } nsresult nsGenericHTMLElement::SetClassName(const nsAString& aClassName) { - SetAttr(kNameSpaceID_None, nsHTMLAtoms::kClass, aClassName, PR_TRUE); + SetAttr(kNameSpaceID_None, nsHTMLAtoms::_class, aClassName, PR_TRUE); return NS_OK; } @@ -1779,7 +1779,7 @@ nsGenericHTMLElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute, const nsAttrValue* nsGenericHTMLElement::GetClasses() const { - return mAttrsAndChildren.GetAttr(nsHTMLAtoms::kClass); + return mAttrsAndChildren.GetAttr(nsHTMLAtoms::_class); } nsIAtom * @@ -1791,7 +1791,7 @@ nsGenericHTMLElement::GetIDAttributeName() const nsIAtom * nsGenericHTMLElement::GetClassAttributeName() const { - return nsHTMLAtoms::kClass; + return nsHTMLAtoms::_class; } nsresult @@ -2027,7 +2027,7 @@ nsGenericHTMLElement::ParseAttribute(PRInt32 aNamespaceID, aValue, aResult); return PR_TRUE; } - if (aAttribute == nsHTMLAtoms::kClass) { + if (aAttribute == nsHTMLAtoms::_class) { aResult.ParseAtomArray(aValue); return PR_TRUE; diff --git a/mozilla/content/html/content/src/nsHTMLAtomList.h b/mozilla/content/html/content/src/nsHTMLAtomList.h deleted file mode 100644 index efefaa65b8d..00000000000 --- a/mozilla/content/html/content/src/nsHTMLAtomList.h +++ /dev/null @@ -1,312 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 mozilla.org code. - * - * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 1999 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * Brian Ryner - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -/****** - - This file contains the list of all HTML atoms - See nsHTMLAtoms.h for access to the atoms - - It is designed to be used as inline input to nsHTMLAtoms.cpp *only* - through the magic of C preprocessing. - - All entires must be enclosed in the macro HTML_ATOM which will have cruel - and unusual things done to it - - The first argument to HTML_ATOM is the C++ name of the atom - The second argument it HTML_ATOM is the string value of the atom - - ******/ - -// OUTPUT_CLASS=nsHTMLAtoms -// MACRO_NAME=HTML_ATOM -#ifdef WINCE -#undef small -#endif - -HTML_ATOM(_baseHref, NS_HTML_BASE_HREF) -HTML_ATOM(_baseTarget, NS_HTML_BASE_TARGET) -HTML_ATOM(a, "a") -HTML_ATOM(abbr, "abbr") -HTML_ATOM(above, "above") -HTML_ATOM(accept, "accept") -HTML_ATOM(acceptcharset, "accept-charset") -HTML_ATOM(accesskey, "accesskey") -HTML_ATOM(action, "action") -HTML_ATOM(align, "align") -HTML_ATOM(alink, "alink") -HTML_ATOM(alt, "alt") -HTML_ATOM(applet, "applet") -HTML_ATOM(archive, "archive") -HTML_ATOM(area, "area") -HTML_ATOM(autocheck, "autocheck") -HTML_ATOM(axis, "axis") -HTML_ATOM(background, "background") -HTML_ATOM(base, "base") -HTML_ATOM(basefont, "basefont") -HTML_ATOM(below, "below") -HTML_ATOM(bdo, "bdo") -HTML_ATOM(bgcolor, "bgcolor") -HTML_ATOM(big, "big") -HTML_ATOM(blockquote, "blockquote") -HTML_ATOM(body, "body") -HTML_ATOM(border, "border") -HTML_ATOM(bordercolor, "bordercolor") -HTML_ATOM(bottommargin, "bottommargin") -HTML_ATOM(bottompadding, "bottompadding") -HTML_ATOM(br, "br") -HTML_ATOM(b, "b") -HTML_ATOM(button, "button") -HTML_ATOM(canvas, "canvas") -HTML_ATOM(caption, "caption") -HTML_ATOM(cellpadding, "cellpadding") -HTML_ATOM(cellspacing, "cellspacing") -HTML_ATOM(ch, "ch") -HTML_ATOM(_char, "char") -HTML_ATOM(charoff, "charoff") -HTML_ATOM(charset, "charset") -HTML_ATOM(checked, "checked") -HTML_ATOM(cite, "cite") -HTML_ATOM(kClass, "class") -HTML_ATOM(classid, "classid") -HTML_ATOM(clear, "clear") -HTML_ATOM(clip, "clip") -HTML_ATOM(code, "code") -HTML_ATOM(codebase, "codebase") -HTML_ATOM(codetype, "codetype") -HTML_ATOM(color, "color") -HTML_ATOM(col, "col") -HTML_ATOM(colgroup, "colgroup") -HTML_ATOM(cols, "cols") -HTML_ATOM(colspan, "colspan") -HTML_ATOM(combobox, "combobox") -HTML_ATOM(compact, "compact") -HTML_ATOM(content, "content") -HTML_ATOM(contentLocation, "content-location") -HTML_ATOM(coords, "coords") -HTML_ATOM(dd, "dd") -HTML_ATOM(defaultAction, "defaultAction") //XML Events -HTML_ATOM(defaultchecked, "defaultchecked") -HTML_ATOM(defaultselected, "defaultselected") -HTML_ATOM(defaultvalue, "defaultvalue") -HTML_ATOM(declare, "declare") -HTML_ATOM(defer, "defer") -HTML_ATOM(del, "del") -HTML_ATOM(dir, "dir") -HTML_ATOM(div, "div") -HTML_ATOM(disabled, "disabled") -HTML_ATOM(dl, "dl") -HTML_ATOM(dt, "dt") -HTML_ATOM(datetime, "datetime") -HTML_ATOM(data, "data") -HTML_ATOM(dfn, "dfn") -HTML_ATOM(em, "em") -HTML_ATOM(embed, "embed") -HTML_ATOM(encoding, "encoding") -HTML_ATOM(enctype, "enctype") -HTML_ATOM(_event, "event") -HTML_ATOM(face, "face") -HTML_ATOM(fieldset, "fieldset") -HTML_ATOM(font, "font") -HTML_ATOM(fontWeight, "font-weight") -HTML_ATOM(_for, "for") -HTML_ATOM(form, "form") -HTML_ATOM(frame, "frame") -HTML_ATOM(frameborder, "frameborder") -HTML_ATOM(frameset, "frameset") -HTML_ATOM(gutter, "gutter") -HTML_ATOM(h1, "h1") -HTML_ATOM(h2, "h2") -HTML_ATOM(h3, "h3") -HTML_ATOM(h4, "h4") -HTML_ATOM(h5, "h5") -HTML_ATOM(h6, "h6") -HTML_ATOM(handler, "handler") //XML Events -HTML_ATOM(head, "head") -HTML_ATOM(headerContentDisposition, "content-disposition") -HTML_ATOM(headerContentLanguage, "content-language") -HTML_ATOM(headerContentScriptType, "content-script-type") -HTML_ATOM(headerContentStyleType, "content-style-type") -HTML_ATOM(headerContentType, "content-type") -HTML_ATOM(headerDefaultStyle, "default-style") -HTML_ATOM(headerWindowTarget, "window-target") -HTML_ATOM(headers, "headers") -HTML_ATOM(height, "height") -HTML_ATOM(hidden, "hidden") -HTML_ATOM(hr, "hr") -HTML_ATOM(href, "href") -HTML_ATOM(hreflang, "hreflang") -HTML_ATOM(hspace, "hspace") -HTML_ATOM(html, "html") -HTML_ATOM(httpEquiv, "http-equiv") -HTML_ATOM(i, "i") -HTML_ATOM(id, "id") -HTML_ATOM(iframe, "iframe") -HTML_ATOM(ilayer, "ilayer") -HTML_ATOM(img, "img") -HTML_ATOM(index, "index") -HTML_ATOM(input, "input") -HTML_ATOM(ins, "ins") -HTML_ATOM(isindex, "isindex") -HTML_ATOM(ismap, "ismap") -HTML_ATOM(label, "label") -HTML_ATOM(lang, "lang") -HTML_ATOM(layer, "layer") -HTML_ATOM(layout, "layout") -HTML_ATOM(li, "li") -HTML_ATOM(link, "link") -HTML_ATOM(listener, "listener") //XML Events -HTML_ATOM(left, "left") -HTML_ATOM(leftmargin, "leftmargin") -HTML_ATOM(leftpadding, "leftpadding") -HTML_ATOM(legend, "legend") -HTML_ATOM(length, "length") -HTML_ATOM(longdesc, "longdesc") -HTML_ATOM(lowsrc, "lowsrc") -HTML_ATOM(map, "map") -HTML_ATOM(marginheight, "marginheight") -HTML_ATOM(marginwidth, "marginwidth") -HTML_ATOM(marquee, "marquee") -HTML_ATOM(maxlength, "maxlength") -HTML_ATOM(mayscript, "mayscript") -HTML_ATOM(media, "media") -HTML_ATOM(menu, "menu") -HTML_ATOM(meta, "meta") -HTML_ATOM(method, "method") -HTML_ATOM(msthemecompatible, "msthemecompatible") -HTML_ATOM(multicol, "multicol") -HTML_ATOM(multiple, "multiple") -HTML_ATOM(name, "name") -HTML_ATOM(noembed, "noembed") -HTML_ATOM(noframes, "noframes") -HTML_ATOM(nohref, "nohref") -HTML_ATOM(noresize, "noresize") -HTML_ATOM(noscript, "noscript") -HTML_ATOM(noshade, "noshade") -HTML_ATOM(nowrap, "nowrap") -HTML_ATOM(object, "object") -HTML_ATOM(observer, "observer") //XML Events -HTML_ATOM(ol, "ol") -HTML_ATOM(optgroup, "optgroup") -HTML_ATOM(option, "option") -HTML_ATOM(overflow, "overflow") -HTML_ATOM(p, "p") -HTML_ATOM(pagex, "pagex") -HTML_ATOM(pagey, "pagey") -HTML_ATOM(param, "param") -HTML_ATOM(phase, "phase") //XML Events -HTML_ATOM(plaintext, "plaintext") -HTML_ATOM(pointSize, "point-size") -HTML_ATOM(pre, "pre") -HTML_ATOM(profile, "profile") -HTML_ATOM(prompt, "prompt") -HTML_ATOM(propagate, "propagate") //XML Events -HTML_ATOM(q, "q") -HTML_ATOM(readonly, "readonly") -HTML_ATOM(refresh, "refresh") -HTML_ATOM(rel, "rel") -HTML_ATOM(repeat, "repeat") -HTML_ATOM(rev, "rev") -HTML_ATOM(rightmargin, "rightmargin") -HTML_ATOM(rightpadding, "rightpadding") -HTML_ATOM(rows, "rows") -HTML_ATOM(rowspan, "rowspan") -HTML_ATOM(rules, "rules") -HTML_ATOM(s, "s") -HTML_ATOM(scheme, "scheme") -HTML_ATOM(scope, "scope") -HTML_ATOM(script, "script") -HTML_ATOM(scrolling, "scrolling") -HTML_ATOM(select, "select") -HTML_ATOM(selected, "selected") -HTML_ATOM(selectedindex, "selectedindex") -HTML_ATOM(setcookie, "set-cookie") -HTML_ATOM(shape, "shape") -HTML_ATOM(simple, "simple") -HTML_ATOM(size, "size") -HTML_ATOM(small, "small") -HTML_ATOM(spacer, "spacer") -HTML_ATOM(span, "span") -HTML_ATOM(src, "src") -HTML_ATOM(standby, "standby") -HTML_ATOM(start, "start") -HTML_ATOM(strike, "strike") -HTML_ATOM(strong, "strong") -HTML_ATOM(style, "style") -HTML_ATOM(summary, "summary") -HTML_ATOM(tabindex, "tabindex") -HTML_ATOM(table, "table") -HTML_ATOM(target, "target") -HTML_ATOM(tbody, "tbody") -HTML_ATOM(td, "td") -HTML_ATOM(tfoot, "tfoot") -HTML_ATOM(thead, "thead") -HTML_ATOM(text, "text") -HTML_ATOM(textarea, "textarea") -HTML_ATOM(th, "th") -HTML_ATOM(title, "title") -HTML_ATOM(top, "top") -HTML_ATOM(topmargin, "topmargin") -HTML_ATOM(toppadding, "toppadding") -HTML_ATOM(tr, "tr") -HTML_ATOM(tt, "tt") -HTML_ATOM(type, "type") -HTML_ATOM(u, "u") -HTML_ATOM(ul, "ul") -HTML_ATOM(usemap, "usemap") -HTML_ATOM(valign, "valign") -HTML_ATOM(value, "value") -HTML_ATOM(valuetype, "valuetype") -HTML_ATOM(variable, "variable") -HTML_ATOM(vcard_name, "vcard_name") -HTML_ATOM(version, "version") -HTML_ATOM(visibility, "visibility") -HTML_ATOM(vlink, "vlink") -HTML_ATOM(vspace, "vspace") -HTML_ATOM(wbr, "wbr") -HTML_ATOM(width, "width") -HTML_ATOM(wrap, "wrap") -HTML_ATOM(wrappedFramePseudo, ":-moz-wrapped-frame") -HTML_ATOM(xmp, "xmp") -HTML_ATOM(zindex, "zindex") -HTML_ATOM(z_index, "z-index") - -#ifdef DEBUG -HTML_ATOM(iform, "IForm") -HTML_ATOM(form_control_list, "FormControlList") -#endif - diff --git a/mozilla/content/html/content/src/nsHTMLAtoms.h b/mozilla/content/html/content/src/nsHTMLAtoms.h index 0986fb833bf..80bea155c7f 100644 --- a/mozilla/content/html/content/src/nsHTMLAtoms.h +++ b/mozilla/content/html/content/src/nsHTMLAtoms.h @@ -37,32 +37,7 @@ #ifndef nsHTMLAtoms_h___ #define nsHTMLAtoms_h___ -#include "nsIAtom.h" - -#define NS_HTML_BASE_HREF "_base_href" -#define NS_HTML_BASE_TARGET "_base_target" - -/** - * This class wraps up the creation (and destruction) of the standard - * set of html atoms used during normal html handling. This objects - * are created when the first html content object is created and they - * are destroyed when the last html content object is destroyed. - */ -class nsHTMLAtoms { -public: - - static void AddRefAtoms(); - - /* Declare all atoms - - The atom names and values are stored in nsHTMLAtomList.h and - are brought to you by the magic of C preprocessing - - Add new atoms to nsHTMLAtomList and all support logic will be auto-generated - */ -#define HTML_ATOM(_name, _value) static nsIAtom* _name; -#include "nsHTMLAtomList.h" -#undef HTML_ATOM -}; +#include "nsGkAtoms.h" +typedef class nsGkAtoms nsHTMLAtoms; #endif /* nsHTMLAtoms_h___ */ diff --git a/mozilla/content/html/content/src/nsHTMLScriptElement.cpp b/mozilla/content/html/content/src/nsHTMLScriptElement.cpp index f4d8c7e5468..af4cf3714c0 100644 --- a/mozilla/content/html/content/src/nsHTMLScriptElement.cpp +++ b/mozilla/content/html/content/src/nsHTMLScriptElement.cpp @@ -535,7 +535,7 @@ NS_IMPL_BOOL_ATTR(nsHTMLScriptElement, Defer, defer) NS_IMPL_URI_ATTR(nsHTMLScriptElement, Src, src) NS_IMPL_STRING_ATTR(nsHTMLScriptElement, Type, type) NS_IMPL_STRING_ATTR(nsHTMLScriptElement, HtmlFor, _for) -NS_IMPL_STRING_ATTR(nsHTMLScriptElement, Event, _event) +NS_IMPL_STRING_ATTR(nsHTMLScriptElement, Event, event) nsresult nsHTMLScriptElement::GetInnerHTML(nsAString& aInnerHTML) @@ -707,7 +707,7 @@ nsHTMLScriptElement::MaybeProcessScript() if (mScriptEventHandler) { nsAutoString event_val; - GetAttr(kNameSpaceID_None, nsHTMLAtoms::_event, event_val); + GetAttr(kNameSpaceID_None, nsHTMLAtoms::event, event_val); mScriptEventHandler->ParseEventString(event_val); } } diff --git a/mozilla/content/svg/content/src/Makefile.in b/mozilla/content/svg/content/src/Makefile.in index ae05e2dbf6e..e47ece375f7 100644 --- a/mozilla/content/svg/content/src/Makefile.in +++ b/mozilla/content/svg/content/src/Makefile.in @@ -80,7 +80,6 @@ CPPSRCS = \ nsSVGAnimatedPreserveAspectRatio.cpp \ nsSVGAnimatedString.cpp \ nsSVGAnimatedTransformList.cpp \ - nsSVGAtoms.cpp \ nsSVGCircleElement.cpp \ nsSVGClassValue.cpp \ nsSVGClipPathElement.cpp \ @@ -160,7 +159,6 @@ EXPORTS = \ nsSVGRect.h \ nsSVGPoint.h \ nsSVGMatrix.h \ - nsSVGAtomList.h \ nsSVGAtoms.h \ nsISVGPathFlatten.h \ $(NULL) diff --git a/mozilla/content/svg/content/src/nsSVGAtomList.h b/mozilla/content/svg/content/src/nsSVGAtomList.h deleted file mode 100644 index c91f8c4aa85..00000000000 --- a/mozilla/content/svg/content/src/nsSVGAtomList.h +++ /dev/null @@ -1,287 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- - * - * ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 mozilla.org code. - * - * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 1999 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -/****** - - This file contains the list of all SVG nsIAtoms and their values - - It is designed to be used as inline input to nsSVGAtoms.cpp *only* - through the magic of C preprocessing. - - All entires must be enclosed in the macro SVG_ATOM which will have cruel - and unusual things done to it - - It is recommended (but not strictly necessary) to keep all entries - in alphabetical order - - The first argument to SVG_ATOM is the C++ identifier of the atom - The second argument is the string value of the atom - - ******/ - -// tags -SVG_ATOM(circle, "circle") -SVG_ATOM(clipPath, "clipPath") -SVG_ATOM(defs, "defs") -SVG_ATOM(desc, "desc") -SVG_ATOM(ellipse, "ellipse") -SVG_ATOM(feBlend, "feBlend") -SVG_ATOM(feColorMatrix, "feColorMatrix") -SVG_ATOM(feComponentTransfer, "feComponentTransfer") -SVG_ATOM(feComposite, "feComposite") -SVG_ATOM(feConvolveMatrix, "feConvolveMatrix") -SVG_ATOM(feDiffuseLighting, "feDiffuseLighting") -SVG_ATOM(feDisplacementMap, "feDisplacementMap") -SVG_ATOM(feFlood, "feFlood") -SVG_ATOM(feFuncR, "feFuncR") -SVG_ATOM(feFuncG, "feFuncG") -SVG_ATOM(feFuncB, "feFuncB") -SVG_ATOM(feFuncA, "feFuncA") -SVG_ATOM(feGaussianBlur, "feGaussianBlur") -SVG_ATOM(feImage, "feImage") -SVG_ATOM(feMerge, "feMerge") -SVG_ATOM(feMergeNode, "feMergeNode") -SVG_ATOM(feMorphology, "feMorphology") -SVG_ATOM(feOffset, "feOffset") -SVG_ATOM(feSpecularLighting, "feSpecularLighting") -SVG_ATOM(feTile, "feTile") -SVG_ATOM(feTurbulence, "feTurbulence") -SVG_ATOM(filter, "filter") -#ifdef MOZ_SVG_FOREIGNOBJECT -SVG_ATOM(foreignObject, "foreignObject") -#endif -SVG_ATOM(g, "g") -SVG_ATOM(generic, "generic") -SVG_ATOM(image, "image") -SVG_ATOM(line, "line") -SVG_ATOM(linearGradient, "linearGradient") -SVG_ATOM(marker, "marker") -SVG_ATOM(metadata, "metadata") -SVG_ATOM(path, "path") -SVG_ATOM(pattern, "pattern") -SVG_ATOM(polygon, "polygon") -SVG_ATOM(polyline, "polyline") -SVG_ATOM(radialGradient, "radialGradient") -SVG_ATOM(rect, "rect") -SVG_ATOM(script, "script") -SVG_ATOM(stop, "stop") -SVG_ATOM(svg, "svg") -SVG_ATOM(svgSwitch, "switch") // switch is a C++ keyword, hence svgSwitch -SVG_ATOM(symbol, "symbol") -SVG_ATOM(text, "text") -SVG_ATOM(textPath, "textPath") -SVG_ATOM(title, "title") -SVG_ATOM(tref, "tref") -SVG_ATOM(tspan, "tspan") -SVG_ATOM(use, "use") - - -// properties and attributes -SVG_ATOM(alignment_baseline, "alignment-baseline") -SVG_ATOM(align, "align") -SVG_ATOM(amplitude, "amplitude") -SVG_ATOM(_auto, "auto") -SVG_ATOM(baseline_shift, "baseline-shift") -SVG_ATOM(_class, "class") -SVG_ATOM(clip, "clip") -SVG_ATOM(clip_path, "clip-path") -SVG_ATOM(clip_rule, "clip-rule") -SVG_ATOM(clipPathUnits, "clipPathUnits") -SVG_ATOM(color, "color") -SVG_ATOM(cursor, "cursor") -SVG_ATOM(cx, "cx") -SVG_ATOM(cy, "cy") -SVG_ATOM(d, "d") -SVG_ATOM(direction, "direction") -SVG_ATOM(discrete, "discrete") -SVG_ATOM(display, "display") -SVG_ATOM(dominant_baseline, "dominant-baseline") -SVG_ATOM(dx, "dx") -SVG_ATOM(dy, "dy") -SVG_ATOM(exact, "exact") -SVG_ATOM(exponent, "exponent") -SVG_ATOM(fill, "fill") -SVG_ATOM(fill_opacity, "fill-opacity") -SVG_ATOM(fill_rule, "fill-rule") -// defined above - SVG_ATOM(filter, "filter") -SVG_ATOM(filterRes, "filterRes") -SVG_ATOM(filterUnits, "filterUnits") -SVG_ATOM(font_family, "font-family") -SVG_ATOM(font_size, "font-size") -SVG_ATOM(font_size_adjust, "font-size-adjust") -SVG_ATOM(font_stretch, "font-stretch") -SVG_ATOM(font_style, "font-style") -SVG_ATOM(font_variant, "font-variant") -SVG_ATOM(font_weight, "font-weight") -SVG_ATOM(fx, "fx") -SVG_ATOM(fy, "fy") -SVG_ATOM(gamma, "gamma") -SVG_ATOM(glyph_orientation_horizontal, "glyph-orientation-horizontal") -SVG_ATOM(glyph_orientation_vertical, "glyph-orientation-vertical") -SVG_ATOM(gradientUnits, "gradientUnits") -SVG_ATOM(gradientTransform, "gradientTransform") -SVG_ATOM(height, "height") -SVG_ATOM(href, "href") -SVG_ATOM(id, "id") -SVG_ATOM(identity, "identity") -SVG_ATOM(image_rendering, "image-rendering") -SVG_ATOM(intercept, "intercept") -SVG_ATOM(kerning, "kerning") -SVG_ATOM(letter_spacing, "letter-spacing") -SVG_ATOM(linear, "linear") -// defined above - SVG_ATOM(marker, "marker") -SVG_ATOM(marker_end, "marker-end") -SVG_ATOM(marker_mid, "marker-mid") -SVG_ATOM(marker_start, "marker-start") -SVG_ATOM(markerHeight, "markerHeight") -SVG_ATOM(markerUnits, "markerUnits") -SVG_ATOM(markerWidth, "markerWidth") -SVG_ATOM(mask, "mask") -SVG_ATOM(media, "media") -SVG_ATOM(method, "method") -SVG_ATOM(offset, "offset") -SVG_ATOM(onabort, "onabort") -SVG_ATOM(onclick, "onclick") -SVG_ATOM(onerror, "onerror") -SVG_ATOM(onload, "onload") -SVG_ATOM(onmousedown, "onmousedown") -SVG_ATOM(onmouseup, "onmouseup") -SVG_ATOM(onmouseover, "onmouseover") -SVG_ATOM(onmousemove, "onmousemove") -SVG_ATOM(onmouseout, "onmouseout") -SVG_ATOM(onresize, "onresize") -SVG_ATOM(onscroll, "onscroll") -SVG_ATOM(onunload, "onunload") -SVG_ATOM(onzoom, "onzoom") -SVG_ATOM(opacity, "opacity") -SVG_ATOM(orient, "orient") -SVG_ATOM(overflow, "overflow") -SVG_ATOM(pathLength, "pathLength") -SVG_ATOM(patternContentUnits, "patternContentUnits") -SVG_ATOM(patternTransform, "patternTransform") -SVG_ATOM(patternUnits, "patternUnits") -SVG_ATOM(pointer_events, "pointer-events") -SVG_ATOM(points, "points") -SVG_ATOM(preserveAspectRatio, "preserveAspectRatio") -SVG_ATOM(primitiveUnits, "primitiveUnits") -SVG_ATOM(r, "r") -SVG_ATOM(refX, "refX") -SVG_ATOM(refY, "refY") -SVG_ATOM(requiredExtensions, "requiredExtensions") -SVG_ATOM(requiredFeatures, "requiredFeatures") -SVG_ATOM(result, "result") -SVG_ATOM(rx, "rx") -SVG_ATOM(ry, "ry") -SVG_ATOM(shape_rendering, "shape-rendering") -SVG_ATOM(slope, "slope") -SVG_ATOM(space, "space") -SVG_ATOM(spacing, "spacing") -SVG_ATOM(spreadMethod, "spreadMethod") -SVG_ATOM(stdDeviation, "stdDeviation") -SVG_ATOM(startOffset, "startOffset") -SVG_ATOM(stop_color, "stop-color") -SVG_ATOM(stop_opacity, "stop-opacity") -SVG_ATOM(stretch, "stretch") -SVG_ATOM(stroke, "stroke") -SVG_ATOM(stroke_dasharray, "stroke-dasharray") -SVG_ATOM(stroke_dashoffset, "stroke-dashoffset") -SVG_ATOM(stroke_linecap, "stroke-linecap") -SVG_ATOM(stroke_linejoin, "stroke-linejoin") -SVG_ATOM(stroke_miterlimit, "stroke-miterlimit") -SVG_ATOM(stroke_opacity, "stroke-opacity") -SVG_ATOM(stroke_width, "stroke-width") -SVG_ATOM(strokeWidth, "strokeWidth") -SVG_ATOM(style, "style") -SVG_ATOM(systemLanguage, "systemLanguage") -SVG_ATOM(table, "table") -SVG_ATOM(tableValues, "tableValues") -SVG_ATOM(text_anchor, "text-anchor") -SVG_ATOM(text_decoration, "text-decoration") -SVG_ATOM(text_rendering, "text-rendering") -// SVG_ATOM(title, "title") <-- already exists for the 'title' element -SVG_ATOM(transform, "transform") -SVG_ATOM(type, "type") -SVG_ATOM(unicode_bidi, "unicode-bidi") -SVG_ATOM(viewBox, "viewBox") -SVG_ATOM(visibility, "visibility") -SVG_ATOM(width, "width") -SVG_ATOM(word_spacing, "word-spacing") -SVG_ATOM(x, "x") -SVG_ATOM(x1, "x1") -SVG_ATOM(x2, "x2") -SVG_ATOM(y, "y") -SVG_ATOM(y1, "y1") -SVG_ATOM(y2, "y2") -SVG_ATOM(zoomAndPan, "zoomAndPan") - -// transformation keywords -SVG_ATOM(matrix, "matrix") -SVG_ATOM(rotate, "rotate") -SVG_ATOM(scale, "scale") -SVG_ATOM(skewX, "skewX") -SVG_ATOM(skewY, "skewY") -SVG_ATOM(translate, "translate") - -// length units -SVG_ATOM(cm, "cm") -SVG_ATOM(ems, "em") -SVG_ATOM(exs, "ex") -SVG_ATOM(in, "in") -SVG_ATOM(mm, "mm") -SVG_ATOM(pc, "pc") -SVG_ATOM(percentage, "%") -SVG_ATOM(pt, "pt") -SVG_ATOM(px, "px") - -// Spread Methods -SVG_ATOM(pad, "pad") -SVG_ATOM(reflect, "reflect") -SVG_ATOM(repeat, "repeat") - -// Gradient/Marker/ClipPath/Pattern Units -SVG_ATOM(userSpaceOnUse, "userSpaceOnUse") -SVG_ATOM(objectBoundingBox, "objectBoundingBox") - -// Zoom and Pan options -SVG_ATOM(disable, "disable") -SVG_ATOM(magnify, "magnify") - -// angle units -SVG_ATOM(deg, "deg") -SVG_ATOM(grad, "grad") -SVG_ATOM(rad, "rad") diff --git a/mozilla/content/svg/content/src/nsSVGAtoms.cpp b/mozilla/content/svg/content/src/nsSVGAtoms.cpp deleted file mode 100644 index 2b32d21c94b..00000000000 --- a/mozilla/content/svg/content/src/nsSVGAtoms.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- - * - * ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 mozilla.org code. - * - * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 1998 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -#include "nsSVGAtoms.h" -#include "nsStaticAtom.h" -#include "nsMemory.h" - -// define storage for all atoms -#define SVG_ATOM(_name, _value) nsIAtom* nsSVGAtoms::_name; -#include "nsSVGAtomList.h" -#undef SVG_ATOM - -static const nsStaticAtom SVGAtoms_info[] = { -#define SVG_ATOM(name_, value_) { value_, &nsSVGAtoms::name_ }, -#include "nsSVGAtomList.h" -#undef SVG_ATOM -}; - -void nsSVGAtoms::AddRefAtoms() { - - NS_RegisterStaticAtoms(SVGAtoms_info, NS_ARRAY_LENGTH(SVGAtoms_info)); -} - diff --git a/mozilla/content/svg/content/src/nsSVGAtoms.h b/mozilla/content/svg/content/src/nsSVGAtoms.h index 5661daa496b..7d86e8161e9 100644 --- a/mozilla/content/svg/content/src/nsSVGAtoms.h +++ b/mozilla/content/svg/content/src/nsSVGAtoms.h @@ -38,32 +38,8 @@ #ifndef nsSVGAtoms_h___ #define nsSVGAtoms_h___ -#include "prtypes.h" -#include "nsIAtom.h" - -/** - * This class wraps up the creation and destruction of the standard - * set of SVG atoms used during normal SVG handling. This object - * is created when the first SVG content object is created, and - * destroyed when the last such content object is destroyed. - */ -class nsSVGAtoms { -public: - - static void AddRefAtoms(); - - /* Declare all atoms - - The atom names and values are stored in nsCSSAtomList.h and - are brought to you by the magic of C preprocessing - - Add new atoms to nsCSSAtomList and all support logic will be auto-generated - */ -#define SVG_ATOM(_name, _value) static nsIAtom* _name; -#include "nsSVGAtomList.h" -#undef SVG_ATOM - -}; +#include "nsGkAtoms.h" +typedef class nsGkAtoms nsSVGAtoms; #endif /* nsSVGAtoms_h___ */ diff --git a/mozilla/content/svg/content/src/nsSVGElement.cpp b/mozilla/content/svg/content/src/nsSVGElement.cpp index ae2034e9b27..57fd365e9ae 100644 --- a/mozilla/content/svg/content/src/nsSVGElement.cpp +++ b/mozilla/content/svg/content/src/nsSVGElement.cpp @@ -363,7 +363,7 @@ nsSVGElement::sFontSpecificationMap[] = { { &nsSVGAtoms::font_stretch }, { &nsSVGAtoms::font_style }, { &nsSVGAtoms::font_variant }, - { &nsSVGAtoms::font_weight }, + { &nsSVGAtoms::fontWeight }, { nsnull } }; diff --git a/mozilla/content/svg/content/src/nsSVGLength.cpp b/mozilla/content/svg/content/src/nsSVGLength.cpp index ace9615ecfe..6e5fd0f75c0 100644 --- a/mozilla/content/svg/content/src/nsSVGLength.cpp +++ b/mozilla/content/svg/content/src/nsSVGLength.cpp @@ -356,10 +356,10 @@ nsSVGLength::GetValueAsString(nsAString & aValueAsString) UnitAtom = nsSVGAtoms::pc; break; case SVG_LENGTHTYPE_EMS: - UnitAtom = nsSVGAtoms::ems; + UnitAtom = nsSVGAtoms::em; break; case SVG_LENGTHTYPE_EXS: - UnitAtom = nsSVGAtoms::exs; + UnitAtom = nsSVGAtoms::ex; break; case SVG_LENGTHTYPE_PERCENTAGE: UnitAtom = nsSVGAtoms::percentage; @@ -410,9 +410,9 @@ nsSVGLength::SetValueAsString(const nsAString & aValueAsString) unitType = SVG_LENGTHTYPE_PT; else if (unitAtom == nsSVGAtoms::pc) unitType = SVG_LENGTHTYPE_PC; - else if (unitAtom == nsSVGAtoms::ems) + else if (unitAtom == nsSVGAtoms::em) unitType = SVG_LENGTHTYPE_EMS; - else if (unitAtom == nsSVGAtoms::exs) + else if (unitAtom == nsSVGAtoms::ex) unitType = SVG_LENGTHTYPE_EXS; else if (unitAtom == nsSVGAtoms::percentage) unitType = SVG_LENGTHTYPE_PERCENTAGE; diff --git a/mozilla/content/xbl/src/Makefile.in b/mozilla/content/xbl/src/Makefile.in index 96dbffb08fb..6529b8314b4 100644 --- a/mozilla/content/xbl/src/Makefile.in +++ b/mozilla/content/xbl/src/Makefile.in @@ -70,12 +70,10 @@ REQUIRES = xpcom \ $(NULL) EXPORTS = \ - nsXBLAtomList.h \ nsXBLAtoms.h \ $(NULL) CPPSRCS = \ - nsXBLAtoms.cpp \ nsXBLBinding.cpp \ nsXBLPrototypeBinding.cpp \ nsXBLPrototypeResources.cpp \ diff --git a/mozilla/content/xbl/src/nsXBLAtomList.h b/mozilla/content/xbl/src/nsXBLAtomList.h deleted file mode 100644 index 88a83d91ac6..00000000000 --- a/mozilla/content/xbl/src/nsXBLAtomList.h +++ /dev/null @@ -1,147 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 mozilla.org code. - * - * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 1999 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * Original Author: David W. Hyatt (hyatt@netscape.com) - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -/****** - - This file contains the list of all XBL nsIAtoms and their values - - It is designed to be used as inline input to nsXBLAtoms.cpp *only* - through the magic of C preprocessing. - - All entires must be enclosed in the macro XBL_ATOM which will have cruel - and unusual things done to it - - It is recommended (but not strictly necessary) to keep all entries - in alphabetical order - - The first argument to XBL_ATOM is the C++ identifier of the atom - The second argument is the string value of the atom - - ******/ - -// OUTPUT_CLASS=nsXBLAtoms -// MACRO_NAME=XBL_ATOM - -XBL_ATOM(binding, "binding") -XBL_ATOM(bindings, "bindings") -XBL_ATOM(handlers, "handlers") -XBL_ATOM(handler, "handler") -XBL_ATOM(resources, "resources") -XBL_ATOM(image, "image") -XBL_ATOM(stylesheet, "stylesheet") -XBL_ATOM(implementation, "implementation") -XBL_ATOM(implements, "implements") -XBL_ATOM(method, "method") -XBL_ATOM(property, "property") -XBL_ATOM(field, "field") -XBL_ATOM(event, "event") -XBL_ATOM(phase, "phase") -XBL_ATOM(action, "action") -XBL_ATOM(command, "command") -XBL_ATOM(modifiers, "modifiers") -XBL_ATOM(clickcount, "clickcount") -XBL_ATOM(charcode, "charcode") -XBL_ATOM(keycode, "keycode") -XBL_ATOM(key, "key") -XBL_ATOM(onget, "onget") -XBL_ATOM(onset, "onset") -XBL_ATOM(name, "name") -XBL_ATOM(getter, "getter") -XBL_ATOM(setter, "setter") -XBL_ATOM(body, "body") -XBL_ATOM(readonly, "readonly") -XBL_ATOM(parameter, "parameter") -XBL_ATOM(children, "children") -XBL_ATOM(extends, "extends") -XBL_ATOM(display, "display") -XBL_ATOM(inherits, "inherits") -XBL_ATOM(includes, "includes") -XBL_ATOM(excludes, "excludes") -XBL_ATOM(content, "content") -XBL_ATOM(constructor, "constructor") -XBL_ATOM(destructor, "destructor") -XBL_ATOM(inheritstyle, "inheritstyle") -XBL_ATOM(button, "button") -XBL_ATOM(group, "group") -XBL_ATOM(preventdefault, "preventdefault") -XBL_ATOM(contextmenu, "contextmenu") -XBL_ATOM(dragenter, "dragenter") -XBL_ATOM(dragover, "dragover") -XBL_ATOM(dragexit, "dragexit") -XBL_ATOM(dragdrop, "dragdrop") -XBL_ATOM(dragevent, "dragevent") -XBL_ATOM(draggesture, "draggesture") -XBL_ATOM(focus, "focus") -XBL_ATOM(blur, "blur") -XBL_ATOM(input, "input") -XBL_ATOM(select, "select") -XBL_ATOM(change, "change") -XBL_ATOM(submit, "submit") -XBL_ATOM(reset, "reset") -XBL_ATOM(keyup, "keyup") -XBL_ATOM(keydown, "keydown") -XBL_ATOM(keypress, "keypress") -XBL_ATOM(abort, "abort") -XBL_ATOM(error, "error") -XBL_ATOM(load, "load") -XBL_ATOM(unload, "unload") -XBL_ATOM(mousedown, "mousedown") -XBL_ATOM(mouseup, "mouseup") -XBL_ATOM(click, "click") -XBL_ATOM(dblclick, "dblclick") -XBL_ATOM(mouseover, "mouseover") -XBL_ATOM(mouseout, "mouseout") -XBL_ATOM(mousemove, "mousemove") -XBL_ATOM(DOMNodeRemoved, "DOMNodeRemoved") -XBL_ATOM(DOMNodeInserted, "DOMNodeInserted") -XBL_ATOM(DOMNodeRemovedFromDocument, "DOMNodeRemovedFromDocument") -XBL_ATOM(DOMNodeInsertedIntoDocument, "DOMNodeInsertedInfoDocument") -XBL_ATOM(DOMSubtreeModified, "DOMSubtreeModified") -XBL_ATOM(DOMAttrModified, "DOMAttrModified") -XBL_ATOM(DOMCharacterDataModified, "DOMCharacterDataModified") -XBL_ATOM(overflow, "overflow") -XBL_ATOM(underflow, "underflow") -XBL_ATOM(overflowchanged, "overflowchanged") -XBL_ATOM(popupshown, "popupshown") -XBL_ATOM(popupshowing, "popupshowing") -XBL_ATOM(popuphidden, "popuphidden") -XBL_ATOM(popuphiding, "popuphiding") -XBL_ATOM(close, "close") -XBL_ATOM(commandupdate, "commandupdate") -XBL_ATOM(broadcast, "broadcast") -XBL_ATOM(allowuntrusted, "allowuntrusted") diff --git a/mozilla/content/xbl/src/nsXBLAtoms.h b/mozilla/content/xbl/src/nsXBLAtoms.h index bee4d11d8e9..e26d0033028 100644 --- a/mozilla/content/xbl/src/nsXBLAtoms.h +++ b/mozilla/content/xbl/src/nsXBLAtoms.h @@ -38,30 +38,7 @@ #ifndef nsXBLAtoms_h___ #define nsXBLAtoms_h___ -#include "nsIAtom.h" - -/** - * This class wraps up the creation and destruction of the standard - * set of XBL atoms used during normal XBL handling. This object - * is created when the first XBL content object is created, and - * destroyed when the last such content object is destroyed. - */ -class nsXBLAtoms { -public: - - static void AddRefAtoms(); - - /* Declare all atoms - - The atom names and values are stored in nsCSSAtomList.h and - are brought to you by the magic of C preprocessing - - Add new atoms to nsCSSAtomList and all support logic will be auto-generated - */ -#define XBL_ATOM(_name, _value) static nsIAtom* _name; -#include "nsXBLAtomList.h" -#undef XBL_ATOM - -}; +#include "nsGkAtoms.h" +typedef class nsGkAtoms nsXBLAtoms; #endif /* nsXBLAtoms_h___ */ diff --git a/mozilla/content/xbl/src/nsXBLBinding.cpp b/mozilla/content/xbl/src/nsXBLBinding.cpp index 6bf8dcad0dd..349039bb930 100644 --- a/mozilla/content/xbl/src/nsXBLBinding.cpp +++ b/mozilla/content/xbl/src/nsXBLBinding.cpp @@ -497,7 +497,7 @@ nsXBLBinding::GenerateAnonymousContent() nsIAtom *localName = ni->NameAtom(); if (ni->NamespaceID() != kNameSpaceID_XUL || (localName != nsXULAtoms::observes && - localName != nsXULAtoms::templateAtom)) { + localName != nsXULAtoms::_template)) { hasContent = PR_FALSE; break; } @@ -573,7 +573,7 @@ nsXBLBinding::GenerateAnonymousContent() nsIAtom *localName = ni->NameAtom(); if (ni->NamespaceID() != kNameSpaceID_XUL || (localName != nsXULAtoms::observes && - localName != nsXULAtoms::templateAtom)) { + localName != nsXULAtoms::_template)) { // Kill all anonymous content. mContent = nsnull; bindingManager->SetContentListFor(mBoundElement, nsnull); diff --git a/mozilla/content/xslt/src/base/Makefile.in b/mozilla/content/xslt/src/base/Makefile.in index f66cc1713c2..bc994b5e622 100644 --- a/mozilla/content/xslt/src/base/Makefile.in +++ b/mozilla/content/xslt/src/base/Makefile.in @@ -67,14 +67,14 @@ endif CPPSRCS = txDouble.cpp \ txList.cpp \ - txAtoms.cpp \ txExpandedNameMap.cpp \ txNamespaceMap.cpp \ txURIUtils.cpp ifdef MOZ_XSLT_STANDALONE CPPSRCS += txSimpleErrorObserver.cpp \ - txStringUtils.cpp + txStringUtils.cpp \ + txAtoms.cpp endif # we don't want the shared lib, but we want to force the creation of a diff --git a/mozilla/content/xslt/src/base/txAtoms.cpp b/mozilla/content/xslt/src/base/txAtoms.cpp deleted file mode 100644 index cb44abfa7ce..00000000000 --- a/mozilla/content/xslt/src/base/txAtoms.cpp +++ /dev/null @@ -1,102 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 TransforMiiX XSLT processor code. - * - * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 2001 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * Peter Van der Beken - * - * Alternatively, the contents of this file may be used under the terms of - * either the GNU General Public License Version 2 or later (the "GPL"), or - * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -#include "txAtoms.h" -#include "nsStaticAtom.h" -#include "nsMemory.h" - -// define storage for all atoms -#define TX_ATOM(_name, _value) nsIAtom* txXMLAtoms::_name; -XML_ATOMS -#undef TX_ATOM - -#define TX_ATOM(_name, _value) nsIAtom* txXPathAtoms::_name; -#include "txXPathAtomList.h" -#undef TX_ATOM - -#define TX_ATOM(_name, _value) nsIAtom* txXSLTAtoms::_name; -#include "txXSLTAtomList.h" -#undef TX_ATOM - -#define TX_ATOM(_name, _value) nsIAtom* txHTMLAtoms::_name; -#include "txHTMLAtomList.h" -#undef TX_ATOM - -static const nsStaticAtom XMLAtoms_info[] = { -#define TX_ATOM(name_, value_) { value_, &txXMLAtoms::name_ }, -XML_ATOMS -#undef TX_ATOM -}; - -static const nsStaticAtom XPathAtoms_info[] = { -#define TX_ATOM(name_, value_) { value_, &txXPathAtoms::name_ }, -#include "txXPathAtomList.h" -#undef TX_ATOM -}; - -static const nsStaticAtom XSLTAtoms_info[] = { -#define TX_ATOM(name_, value_) { value_, &txXSLTAtoms::name_ }, -#include "txXSLTAtomList.h" -#undef TX_ATOM -}; - -static const nsStaticAtom HTMLAtoms_info[] = { -#define TX_ATOM(name_, value_) { value_, &txHTMLAtoms::name_ }, -#include "txHTMLAtomList.h" -#undef TX_ATOM -}; - -void txXMLAtoms::init() -{ - NS_RegisterStaticAtoms(XMLAtoms_info, NS_ARRAY_LENGTH(XMLAtoms_info)); -} - -void txXPathAtoms::init() -{ - NS_RegisterStaticAtoms(XPathAtoms_info, NS_ARRAY_LENGTH(XPathAtoms_info)); -} - -void txXSLTAtoms::init() -{ - NS_RegisterStaticAtoms(XSLTAtoms_info, NS_ARRAY_LENGTH(XSLTAtoms_info)); -} - -void txHTMLAtoms::init() -{ - NS_RegisterStaticAtoms(HTMLAtoms_info, NS_ARRAY_LENGTH(HTMLAtoms_info)); -} diff --git a/mozilla/content/xslt/src/base/txAtoms.h b/mozilla/content/xslt/src/base/txAtoms.h index b9b584f40c0..1f69624836b 100644 --- a/mozilla/content/xslt/src/base/txAtoms.h +++ b/mozilla/content/xslt/src/base/txAtoms.h @@ -39,6 +39,16 @@ #ifndef TRANSFRMX_ATOMS_H #define TRANSFRMX_ATOMS_H +#ifndef TX_EXE + +#include "nsGkAtoms.h" +typedef class nsGkAtoms txXPathAtoms; +typedef class nsGkAtoms txXMLAtoms; +typedef class nsGkAtoms txXSLTAtoms; +typedef class nsGkAtoms txHTMLAtoms; + +#else + class nsIAtom; /* @@ -50,14 +60,10 @@ class nsIAtom; * be auto-generated. */ -#ifdef TX_EXE #define DOM_ATOMS \ TX_ATOM(comment, "#comment") \ TX_ATOM(document, "#document") \ TX_ATOM(text, "#text") -#else -#define DOM_ATOMS -#endif #define XML_ATOMS \ TX_ATOM(_empty, "") \ @@ -103,3 +109,5 @@ public: #undef TX_ATOM #endif + +#endif diff --git a/mozilla/content/xslt/src/xpath/nsXFormsXPathEvaluator.cpp b/mozilla/content/xslt/src/xpath/nsXFormsXPathEvaluator.cpp index 3a75b11ee1d..f6396bfd6d3 100644 --- a/mozilla/content/xslt/src/xpath/nsXFormsXPathEvaluator.cpp +++ b/mozilla/content/xslt/src/xpath/nsXFormsXPathEvaluator.cpp @@ -208,7 +208,7 @@ nsXFormsXPathEvaluator::XFormsParseContextImpl::resolveFunctionCall( else if (aName == txXPathAtoms::daysFromDate) { aFnCall = new XFormsFunctionCall(XFormsFunctionCall::DAYSFROMDATE); } - else if (aName == txXPathAtoms::ifFunc) { + else if (aName == txXPathAtoms::_if) { aFnCall = new XFormsFunctionCall(XFormsFunctionCall::IF); } else if (aName == txXPathAtoms::index) { diff --git a/mozilla/content/xslt/src/xpath/txXFormsFunctionCall.cpp b/mozilla/content/xslt/src/xpath/txXFormsFunctionCall.cpp index f213efb5f62..b0bc5e5f05a 100644 --- a/mozilla/content/xslt/src/xpath/txXFormsFunctionCall.cpp +++ b/mozilla/content/xslt/src/xpath/txXFormsFunctionCall.cpp @@ -544,7 +544,7 @@ XFormsFunctionCall::getNameAtom(nsIAtom** aAtom) } case IF: { - *aAtom = txXPathAtoms::ifFunc; + *aAtom = txXPathAtoms::_if; break; } case INDEX: diff --git a/mozilla/content/xslt/src/xpath/txXPathAtomList.h b/mozilla/content/xslt/src/xpath/txXPathAtomList.h deleted file mode 100644 index f72bc6d1738..00000000000 --- a/mozilla/content/xslt/src/xpath/txXPathAtomList.h +++ /dev/null @@ -1,111 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 TransforMiiX XSLT processor code. - * - * The Initial Developer of the Original Code is - * Jonas Sicking. - * Portions created by the Initial Developer are Copyright (C) 2001 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * Jonas Sicking - * - * Alternatively, the contents of this file may be used under the terms of - * either the GNU General Public License Version 2 or later (the "GPL"), or - * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -// OUTPUT_CLASS=txXPathAtoms -// MACRO_NAME=TX_ATOM - -TX_ATOM(_and, "and") -TX_ATOM(_asterix, "*") -TX_ATOM(boolean, "boolean") -TX_ATOM(ceiling, "ceiling") -TX_ATOM(comment, "comment") -TX_ATOM(concat, "concat") -TX_ATOM(contains, "contains") -TX_ATOM(count, "count") -TX_ATOM(div, "div") -TX_ATOM(_false, "false") -TX_ATOM(floor, "floor") -TX_ATOM(id, "id") -TX_ATOM(lang, "lang") -TX_ATOM(last, "last") -TX_ATOM(localName, "local-name") -TX_ATOM(mod, "mod") -TX_ATOM(name, "name") -TX_ATOM(namespaceUri, "namespace-uri") -TX_ATOM(node, "node") -TX_ATOM(normalizeSpace, "normalize-space") -TX_ATOM(_not, "not") -TX_ATOM(number, "number") -TX_ATOM(_or, "or") -TX_ATOM(position, "position") -TX_ATOM(processingInstruction, "processing-instruction") -TX_ATOM(round, "round") -TX_ATOM(startsWith, "starts-with") -TX_ATOM(string, "string") -TX_ATOM(stringLength, "string-length") -TX_ATOM(substring, "substring") -TX_ATOM(substringAfter, "substring-after") -TX_ATOM(substringBefore, "substring-before") -TX_ATOM(sum, "sum") -TX_ATOM(text, "text") -TX_ATOM(translate, "translate") -TX_ATOM(_true, "true") - -// XPath Axes -TX_ATOM(ancestor, "ancestor") -TX_ATOM(ancestorOrSelf, "ancestor-or-self") -TX_ATOM(attribute, "attribute") -TX_ATOM(child, "child") -TX_ATOM(descendant, "descendant") -TX_ATOM(descendantOrSelf, "descendant-or-self") -TX_ATOM(following, "following") -TX_ATOM(followingSibling, "following-sibling") -TX_ATOM(_namespace, "namespace") -TX_ATOM(parent, "parent") -TX_ATOM(preceding, "preceding") -TX_ATOM(precedingSibling, "preceding-sibling") -TX_ATOM(self, "self") - - -#ifndef DISABLE_XFORMS_HOOKS // Dummy variable, nobody sets me! -// XForms XPath Extensions -TX_ATOM(avg, "avg") -TX_ATOM(booleanFromString, "boolean-from-string") -TX_ATOM(countNonEmpty, "count-non-empty") -TX_ATOM(daysFromDate, "days-from-date") -TX_ATOM(ifFunc, "if") -TX_ATOM(index, "index") -TX_ATOM(instance, "instance") -TX_ATOM(min, "min") -TX_ATOM(max, "max") -TX_ATOM(months, "months") -TX_ATOM(now, "now") -TX_ATOM(property, "property") -TX_ATOM(seconds, "seconds") -TX_ATOM(secondsFromDateTime, "seconds-from-dateTime") -#endif diff --git a/mozilla/content/xslt/src/xslt/txHTMLAtomList.h b/mozilla/content/xslt/src/xslt/txHTMLAtomList.h deleted file mode 100644 index a786381557b..00000000000 --- a/mozilla/content/xslt/src/xslt/txHTMLAtomList.h +++ /dev/null @@ -1,97 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 TransforMiiX XSLT processor code. - * - * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 2001 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * Peter Van der Beken - * - * Alternatively, the contents of this file may be used under the terms of - * either the GNU General Public License Version 2 or later (the "GPL"), or - * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -// OUTPUT_CLASS=txHTMLAtoms -// MACRO_NAME=TX_ATOM - -TX_ATOM(area, "area") -TX_ATOM(base, "base") -TX_ATOM(basefont, "basefont") -TX_ATOM(br, "br") -TX_ATOM(button, "button") -TX_ATOM(checked, "checked") -TX_ATOM(col, "col") -TX_ATOM(compact, "compact") -TX_ATOM(content, "content") -TX_ATOM(declare, "declare") -TX_ATOM(defer, "defer") -TX_ATOM(dir, "dir") -TX_ATOM(disabled, "disabled") -TX_ATOM(dl, "dl") -TX_ATOM(frame, "frame") -TX_ATOM(headerDefaultStyle, "default-style") -TX_ATOM(head, "head") -TX_ATOM(hr, "hr") -TX_ATOM(href, "href") -TX_ATOM(httpEquiv, "http-equiv") -TX_ATOM(img, "img") -TX_ATOM(input, "input") -TX_ATOM(isindex, "isindex") -TX_ATOM(ismap, "ismap") -TX_ATOM(li, "li") -TX_ATOM(link, "link") -TX_ATOM(media, "media") -TX_ATOM(menu, "menu") -TX_ATOM(meta, "meta") -TX_ATOM(multiple, "multiple") -TX_ATOM(noresize, "noresize") -TX_ATOM(noshade, "noshade") -TX_ATOM(nowrap, "nowrap") -TX_ATOM(object, "object") -TX_ATOM(ol, "ol") -TX_ATOM(optgroup, "optgroup") -TX_ATOM(option, "option") -TX_ATOM(p, "p") -TX_ATOM(param, "param") -TX_ATOM(readonly, "readonly") -TX_ATOM(refresh, "refresh") -TX_ATOM(script, "script") -TX_ATOM(select, "select") -TX_ATOM(selected, "selected") -TX_ATOM(src, "src") -TX_ATOM(style, "style") -TX_ATOM(table, "table") -TX_ATOM(target, "target") -TX_ATOM(tbody, "tbody") -TX_ATOM(td, "td") -TX_ATOM(textarea, "textarea") -TX_ATOM(th, "th") -TX_ATOM(title, "title") -TX_ATOM(tr, "tr") -TX_ATOM(type, "type") -TX_ATOM(ul, "ul") diff --git a/mozilla/content/xslt/src/xslt/txXSLTAtomList.h b/mozilla/content/xslt/src/xslt/txXSLTAtomList.h deleted file mode 100644 index 9b0347726b5..00000000000 --- a/mozilla/content/xslt/src/xslt/txXSLTAtomList.h +++ /dev/null @@ -1,151 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 TransforMiiX XSLT processor code. - * - * The Initial Developer of the Original Code is - * Jonas Sicking. - * Portions created by the Initial Developer are Copyright (C) 2001 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * Jonas Sicking - * - * Alternatively, the contents of this file may be used under the terms of - * either the GNU General Public License Version 2 or later (the "GPL"), or - * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -// OUTPUT_CLASS=txXSLTAtoms -// MACRO_NAME=TX_ATOM - -// XSLT elements -TX_ATOM(applyImports, "apply-imports") -TX_ATOM(applyTemplates, "apply-templates") -TX_ATOM(attribute, "attribute") -TX_ATOM(attributeSet, "attribute-set") -TX_ATOM(callTemplate, "call-template") -TX_ATOM(choose, "choose") -TX_ATOM(comment, "comment") -TX_ATOM(copy, "copy") -TX_ATOM(copyOf, "copy-of") -TX_ATOM(decimalFormat, "decimal-format") -TX_ATOM(element, "element") -TX_ATOM(fallback, "fallback") -TX_ATOM(forEach, "for-each") -TX_ATOM(_if, "if") -TX_ATOM(import, "import") -TX_ATOM(include, "include") -TX_ATOM(key, "key") -TX_ATOM(message, "message") -TX_ATOM(namespaceAlias, "namespace-alias") -TX_ATOM(number, "number") -TX_ATOM(otherwise, "otherwise") -TX_ATOM(output, "output") -TX_ATOM(param, "param") -TX_ATOM(preserveSpace, "preserve-space") -TX_ATOM(processingInstruction, "processing-instruction") -TX_ATOM(sort, "sort") -TX_ATOM(stripSpace, "strip-space") -TX_ATOM(stylesheet, "stylesheet") -TX_ATOM(_template, "template") -TX_ATOM(text, "text") -TX_ATOM(transform, "transform") -TX_ATOM(valueOf, "value-of") -TX_ATOM(variable, "variable") -TX_ATOM(when, "when") -TX_ATOM(withParam, "with-param") - -// XSLT attributes -TX_ATOM(caseOrder, "case-order") -TX_ATOM(cdataSectionElements, "cdata-section-elements") -TX_ATOM(count, "count") -TX_ATOM(dataType, "data-type") -TX_ATOM(decimalSeparator, "decimal-separator") -TX_ATOM(digit, "digit") -TX_ATOM(disableOutputEscaping, "disable-output-escaping") -TX_ATOM(doctypePublic, "doctype-public") -TX_ATOM(doctypeSystem, "doctype-system") -TX_ATOM(elements, "elements") -TX_ATOM(encoding, "encoding") -TX_ATOM(extensionElementPrefixes, "extension-element-prefixes") -TX_ATOM(format, "format") -TX_ATOM(from, "from") -TX_ATOM(groupingSeparator, "grouping-separator") -TX_ATOM(groupingSize, "grouping-size") -TX_ATOM(href, "href") -TX_ATOM(indent, "indent") -TX_ATOM(infinity, "infinity") -TX_ATOM(lang, "lang") -TX_ATOM(level, "level") -TX_ATOM(match, "match") -TX_ATOM(method, "method") -TX_ATOM(mediaType, "media-type") -TX_ATOM(minusSign, "minus-sign") -TX_ATOM(mode, "mode") -TX_ATOM(name, "name") -TX_ATOM(_namespace, "namespace") -TX_ATOM(NaN, "NaN") -TX_ATOM(omitXmlDeclaration, "omit-xml-declaration") -TX_ATOM(order, "order") -TX_ATOM(patternSeparator, "pattern-separator") -TX_ATOM(perMille, "per-mille") -TX_ATOM(percent, "percent") -TX_ATOM(priority, "priority") -TX_ATOM(select, "select") -TX_ATOM(standalone, "standalone") -TX_ATOM(test, "test") -TX_ATOM(terminate, "terminate") -TX_ATOM(use, "use") -TX_ATOM(useAttributeSets, "use-attribute-sets") -TX_ATOM(value, "value") -TX_ATOM(version, "version") -TX_ATOM(zeroDigit, "zero-digit") - -// XSLT functions -TX_ATOM(current, "current") -TX_ATOM(document, "document") -TX_ATOM(elementAvailable, "element-available") -TX_ATOM(formatNumber, "format-number") -TX_ATOM(functionAvailable, "function-available") -TX_ATOM(generateId, "generate-id") -TX_ATOM(unparsedEntityUri, "unparsed-entity-uri") -TX_ATOM(systemProperty, "system-property") - -// XSLT properties -TX_ATOM(vendor, "vendor") -TX_ATOM(vendorUrl, "vendor-url") - -// XSLT attribute values -TX_ATOM(any, "any") -TX_ATOM(ascending, "ascending") -TX_ATOM(descending, "descending") -TX_ATOM(html, "html") -TX_ATOM(lowerFirst, "lower-first") -TX_ATOM(multiple, "multiple") -TX_ATOM(no, "no") -TX_ATOM(single, "single") -TX_ATOM(upperFirst, "upper-first") -TX_ATOM(xml, "xml") -TX_ATOM(yes, "yes") -TX_ATOM(_poundDefault, "#default") diff --git a/mozilla/content/xslt/src/xslt/txXSLTProcessor.cpp b/mozilla/content/xslt/src/xslt/txXSLTProcessor.cpp index fa739a5558e..a0b8e4c2995 100644 --- a/mozilla/content/xslt/src/xslt/txXSLTProcessor.cpp +++ b/mozilla/content/xslt/src/xslt/txXSLTProcessor.cpp @@ -62,12 +62,12 @@ txXSLTProcessor::init() if (NS_FAILED(txHTMLOutput::init())) { return MB_FALSE; } -#endif txXMLAtoms::init(); txXPathAtoms::init(); txXSLTAtoms::init(); txHTMLAtoms::init(); +#endif if (!txHandlerTable::init()) return MB_FALSE; diff --git a/mozilla/content/xtf/src/nsXTFElementWrapper.cpp b/mozilla/content/xtf/src/nsXTFElementWrapper.cpp index 48195311326..183eeb3a8ce 100644 --- a/mozilla/content/xtf/src/nsXTFElementWrapper.cpp +++ b/mozilla/content/xtf/src/nsXTFElementWrapper.cpp @@ -59,7 +59,7 @@ nsXTFElementWrapper::nsXTFElementWrapper(nsINodeInfo* aNodeInfo) : nsXTFElementWrapperBase(aNodeInfo), mNotificationMask(0), mIntrinsicState(0), - mTmpAttrName(nsLayoutAtoms::wildcard) // XXX this is a hack, but names + mTmpAttrName(nsLayoutAtoms::_asterix) // XXX this is a hack, but names // have to have a value { } diff --git a/mozilla/content/xul/content/src/Makefile.in b/mozilla/content/xul/content/src/Makefile.in index 727601e1dff..dcc1dc7c8bf 100644 --- a/mozilla/content/xul/content/src/Makefile.in +++ b/mozilla/content/xul/content/src/Makefile.in @@ -43,8 +43,11 @@ VPATH = @srcdir@ include $(DEPTH)/config/autoconf.mk MODULE = xul + +ifdef MOZ_XUL LIBRARY_NAME = gkconxulcon_s LIBXUL_LIBRARY = 1 +endif REQUIRES = xpcom \ string \ @@ -70,14 +73,9 @@ REQUIRES = xpcom \ $(NULL) EXPORTS = \ - nsXULAtomList.h \ nsXULAtoms.h \ $(NULL) -CPPSRCS = \ - nsXULAtoms.cpp \ - $(NULL) - ifdef MOZ_XUL CPPSRCS += \ nsXULElement.cpp \ diff --git a/mozilla/content/xul/content/src/nsXULAtomList.h b/mozilla/content/xul/content/src/nsXULAtomList.h deleted file mode 100644 index 51d5d1e6adf..00000000000 --- a/mozilla/content/xul/content/src/nsXULAtomList.h +++ /dev/null @@ -1,312 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 mozilla.org code. - * - * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 1999 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * Original Author: David W. Hyatt (hyatt@netscape.com) - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -/****** - - This file contains the list of all XUL nsIAtoms and their values - - It is designed to be used as inline input to nsXULAtoms.cpp *only* - through the magic of C preprocessing. - - All entires must be enclosed in the macro XUL_ATOM which will have cruel - and unusual things done to it - - It is recommended (but not strictly necessary) to keep all entries - in alphabetical order - - The first argument to XUL_ATOM is the C++ identifier of the atom - The second argument is the string value of the atom - - ******/ - -// OUTPUT_CLASS=nsXULAtoms -// MACRO_NAME=XUL_ATOM - -XUL_ATOM(_template, "template") -XUL_ATOM(_empty, "") -XUL_ATOM(_false, "false") -XUL_ATOM(_star, "*") -XUL_ATOM(_true, "true") -XUL_ATOM(acceltext, "acceltext") // Text to use for the accelerator -XUL_ATOM(accesskey, "accesskey") // The shortcut key for a menu or menu item -XUL_ATOM(action, "action") -XUL_ATOM(align, "align") -XUL_ATOM(allowevents, "allowevents") // Lets events be handled on the cell contents or in menus. -XUL_ATOM(allownegativeassertions, "allownegativeassertions") -XUL_ATOM(always, "always") -XUL_ATOM(attribute, "attribute") -XUL_ATOM(autorepeatbutton, "autorepeatbutton") -XUL_ATOM(baseline, "baseline") -XUL_ATOM(binding, "binding") -XUL_ATOM(bindings, "bindings") -XUL_ATOM(blankrow, "blankrow") -XUL_ATOM(bottom, "bottom") -XUL_ATOM(box, "box") -XUL_ATOM(broadcaster, "broadcaster") // A broadcaster -XUL_ATOM(broadcasterset, "broadcasterset") -XUL_ATOM(browser, "browser") -XUL_ATOM(bulletinboard, "bulletinboard") -XUL_ATOM(button, "button") -XUL_ATOM(canvas, "canvas") -XUL_ATOM(center, "center") -XUL_ATOM(checkbox, "checkbox") -XUL_ATOM(checked, "checked") -XUL_ATOM(child, "child") -XUL_ATOM(clazz, "class") -XUL_ATOM(closed, "closed") -XUL_ATOM(coalesceduplicatearcs, "coalesceduplicatearcs") -XUL_ATOM(collapse, "collapse") -XUL_ATOM(collapsed, "collapsed") -XUL_ATOM(column, "column") -XUL_ATOM(columns, "columns") -XUL_ATOM(command, "command") -XUL_ATOM(commands, "commands") -XUL_ATOM(commandset, "commandset") -XUL_ATOM(commandupdater, "commandupdater") -XUL_ATOM(conditions, "conditions") -XUL_ATOM(container, "container") -XUL_ATOM(containment, "containment") -XUL_ATOM(content, "content") -XUL_ATOM(context, "context") -XUL_ATOM(contextmenu, "contextmenu") -XUL_ATOM(control, "control") -XUL_ATOM(crop, "crop") -XUL_ATOM(curpos, "curpos") -XUL_ATOM(current, "current") -XUL_ATOM(cycler, "cycler") -XUL_ATOM(datasources, "datasources") -XUL_ATOM(debug, "debug") -XUL_ATOM(deck, "deck") -XUL_ATOM(defaultz, "default") -XUL_ATOM(description, "description") -XUL_ATOM(dialog, "dialog") -XUL_ATOM(dir, "dir") -XUL_ATOM(disabled, "disabled") -XUL_ATOM(dragSession, "dragSession") -XUL_ATOM(dropAfter, "dropAfter") -XUL_ATOM(dropBefore, "dropBefore") -XUL_ATOM(dropOn, "dropOn") -XUL_ATOM(editable, "editable") -XUL_ATOM(editor, "editor") -XUL_ATOM(element, "element") -XUL_ATOM(empty, "empty") -XUL_ATOM(end, "end") -XUL_ATOM(equalsize, "equalsize") -XUL_ATOM(even, "even") -XUL_ATOM(events, "events") -XUL_ATOM(fixed, "fixed") -XUL_ATOM(flags, "flags") -XUL_ATOM(flex, "flex") -XUL_ATOM(flexgroup, "flexgroup") -XUL_ATOM(focus, "focus") -XUL_ATOM(fontpicker, "fontpicker") -XUL_ATOM(grid, "grid") -XUL_ATOM(gripper, "gripper") -XUL_ATOM(grippy, "grippy") -XUL_ATOM(hbox, "hbox") -XUL_ATOM(height, "height") -XUL_ATOM(hidden, "hidden") -XUL_ATOM(hidechrome, "hidechrome") -XUL_ATOM(horizontal, "horizontal") -XUL_ATOM(id, "id") -XUL_ATOM(iframe, "iframe") -XUL_ATOM(ignorekeys, "ignorekeys") // Alignment for popups -XUL_ATOM(image, "image") -XUL_ATOM(increment, "increment") -XUL_ATOM(index, "index") -XUL_ATOM(infer, "infer") -XUL_ATOM(insertafter, "insertafter") -XUL_ATOM(insertbefore, "insertbefore") -XUL_ATOM(instanceOf, "instanceOf") -XUL_ATOM(iscontainer, "iscontainer") -XUL_ATOM(isempty, "isempty") -XUL_ATOM(key, "key") // The key element / attribute -XUL_ATOM(keycode, "keycode") // The keycode attribute -XUL_ATOM(keyset, "keyset") -XUL_ATOM(keytext, "keytext") // The keytext attribute -XUL_ATOM(label, "label") -XUL_ATOM(leaf,"leaf") -XUL_ATOM(left, "left") -XUL_ATOM(listbox, "listbox") -XUL_ATOM(listboxbody, "listboxbody") -XUL_ATOM(listcell, "listcell") -XUL_ATOM(listcol, "listcol") -XUL_ATOM(listcols, "listcols") -XUL_ATOM(listhead, "listhead") -XUL_ATOM(listheader, "listheader") -XUL_ATOM(listitem, "listitem") -XUL_ATOM(listrows, "listrows") -XUL_ATOM(ltr, "ltr") -XUL_ATOM(maxheight, "maxheight") -XUL_ATOM(maxpos, "maxpos") -XUL_ATOM(maxwidth, "maxwidth") -XUL_ATOM(member, "member") -XUL_ATOM(menu, "menu") // Represents an XP menu -XUL_ATOM(menuactive, "_moz-menuactive") // Whether or not a menu is active (without necessarily being open) -XUL_ATOM(menubar, "menubar") // An XP menu bar. -XUL_ATOM(menubutton, "menubutton") -XUL_ATOM(menugenerated, "menugenerated") // Internal -XUL_ATOM(menuitem, "menuitem") // Represents an XP menu item -XUL_ATOM(menulist, "menulist") -XUL_ATOM(menupopup, "menupopup") // The XP menu's children. -XUL_ATOM(menutobedisplayed, "menutobedisplayed") // The menu is about to be displayed at the next sync w/ frame -XUL_ATOM(middle, "middle") -XUL_ATOM(minheight, "minheight") -XUL_ATOM(minwidth, "minwidth") -XUL_ATOM(mode, "mode") -XUL_ATOM(modifiers, "modifiers") // The modifiers attribute -XUL_ATOM(mousethrough, "mousethrough") -XUL_ATOM(nativescrollbar, "nativescrollbar") -XUL_ATOM(never, "never") -XUL_ATOM(object, "object") -XUL_ATOM(observes, "observes") // The observes element -XUL_ATOM(odd, "odd") -XUL_ATOM(open, "open") // Whether or not a menu, tree, etc. is open -XUL_ATOM(ordinal, "ordinal") -XUL_ATOM(orient, "orient") -XUL_ATOM(overlay, "overlay") -XUL_ATOM(pack, "pack") -XUL_ATOM(page, "page") -XUL_ATOM(pageincrement, "pageincrement") -XUL_ATOM(palettename, "palettename") -XUL_ATOM(parent, "parent") -XUL_ATOM(parsetype, "parsetype") -XUL_ATOM(persist, "persist") -XUL_ATOM(popup, "popup") // The popup for a context menu, popup menu, or tooltip -XUL_ATOM(popupalign, "popupalign") // Alignment for popups -XUL_ATOM(popupanchor, "popupanchor") // Anchor for popups -XUL_ATOM(popupgroup, "popupgroup") // Contains popup menus, context menus, and tooltips -XUL_ATOM(popupset, "popupset") -XUL_ATOM(position, "position") -XUL_ATOM(predicate, "predicate") -XUL_ATOM(primary, "primary") -XUL_ATOM(progressNormal, "progressNormal") -XUL_ATOM(progressUndetermined, "progressUndetermined") -XUL_ATOM(progressmeter, "progressmeter") -XUL_ATOM(properties, "properties") -XUL_ATOM(property, "property") -XUL_ATOM(radio, "radio") -XUL_ATOM(radiogroup, "radiogroup") -XUL_ATOM(ref, "ref") -XUL_ATOM(removeelement, "removeelement") -XUL_ATOM(resizeafter, "resizeafter") -XUL_ATOM(resizebefore, "resizebefore") -XUL_ATOM(resizer, "resizer") -XUL_ATOM(resource, "resource") -XUL_ATOM(reverse, "reverse") -XUL_ATOM(right, "right") -XUL_ATOM(row, "row") -XUL_ATOM(rows, "rows") -XUL_ATOM(rtl, "rtl") -XUL_ATOM(rule, "rule") -XUL_ATOM(screenX, "screenX") -XUL_ATOM(screenY, "screenY") -XUL_ATOM(scrollbar, "scrollbar") -XUL_ATOM(scrollbarbutton, "scrollbarbutton") -XUL_ATOM(scrollbox, "scrollbox") -XUL_ATOM(scrollcorner, "scrollcorner") -XUL_ATOM(selected, "selected") -XUL_ATOM(selectedIndex, "selectedIndex") -XUL_ATOM(seltype, "seltype") -XUL_ATOM(sizemode, "sizemode") // when set, measure strings to determine preferred width -XUL_ATOM(sizetopopup, "sizetopopup") // Whether or not menus size to their popup children (used by menulists) -XUL_ATOM(slider, "slider") -XUL_ATOM(smooth, "smooth") -XUL_ATOM(sort, "sort") -XUL_ATOM(sortActive, "sortActive") -XUL_ATOM(sortDirection, "sortDirection") -XUL_ATOM(sortLocked, "sortLocked") -XUL_ATOM(sortResource, "sortResource") -XUL_ATOM(sortResource2, "sortResource2") -XUL_ATOM(sortSeparators, "sortSeparators") -XUL_ATOM(sortStaticsLast, "sortStaticsLast") -XUL_ATOM(sorted, "sorted") -XUL_ATOM(spinner, "spinner") -XUL_ATOM(splitter, "splitter") -XUL_ATOM(spring, "spring") -XUL_ATOM(stack, "stack") -XUL_ATOM(start, "start") -XUL_ATOM(state, "state") -XUL_ATOM(statedatasource,"statedatasource") -XUL_ATOM(staticHint, "staticHint") -XUL_ATOM(statustext, "statustext") -XUL_ATOM(stretch, "stretch") -XUL_ATOM(style, "style") -XUL_ATOM(subject, "subject") -XUL_ATOM(tab, "tab") -XUL_ATOM(tabbox, "tabbox") -XUL_ATOM(tabpanel, "tabpanel") -XUL_ATOM(tabpanels, "tabpanels") -XUL_ATOM(tag, "tag") -XUL_ATOM(targets, "targets") -XUL_ATOM(templateAtom, "template") // A XUL template -XUL_ATOM(text, "text") -XUL_ATOM(textarea, "textarea") -XUL_ATOM(textbox, "textbox") -XUL_ATOM(textnode, "textnode") -XUL_ATOM(thumb, "thumb") -XUL_ATOM(titlebar, "titlebar") -XUL_ATOM(titletip, "titletip") -XUL_ATOM(toggled, "toggled") -XUL_ATOM(toolbar, "toolbar") -XUL_ATOM(toolbarbutton, "toolbarbutton") -XUL_ATOM(toolbaritem, "toolbaritem") -XUL_ATOM(toolbox, "toolbox") -XUL_ATOM(tooltip, "tooltip") -XUL_ATOM(tooltiptext, "tooltiptext") -XUL_ATOM(top, "top") -XUL_ATOM(tree, "tree") -XUL_ATOM(treecell, "treecell") -XUL_ATOM(treechildren, "treechildren") -XUL_ATOM(treecol, "treecol") -XUL_ATOM(treecols, "treecols") -XUL_ATOM(treeitem, "treeitem") -XUL_ATOM(treerow, "treerow") -XUL_ATOM(treeseparator, "treeseparator") -XUL_ATOM(triple, "triple") -XUL_ATOM(type, "type") -XUL_ATOM(uri, "uri") -XUL_ATOM(validate, "validate") -XUL_ATOM(value, "value") -XUL_ATOM(vbox, "vbox") -XUL_ATOM(vertical, "vertical") -XUL_ATOM(widget, "widget") -XUL_ATOM(width, "width") -XUL_ATOM(window, "window") -XUL_ATOM(wizard, "wizard") -XUL_ATOM(xulcontentsgenerated, "xulcontentsgenerated") diff --git a/mozilla/content/xul/content/src/nsXULAtoms.cpp b/mozilla/content/xul/content/src/nsXULAtoms.cpp deleted file mode 100644 index 470170686da..00000000000 --- a/mozilla/content/xul/content/src/nsXULAtoms.cpp +++ /dev/null @@ -1,60 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (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 mozilla.org code. - * - * The Initial Developer of the Original Code is - * Netscape Communications Corporation. - * Portions created by the Initial Developer are Copyright (C) 1998 - * the Initial Developer. All Rights Reserved. - * - * Contributor(s): - * Original Author: David W. Hyatt (hyatt@netscape.com) - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * - * ***** END LICENSE BLOCK ***** */ - -#include "nsXULAtoms.h" -#include "nsStaticAtom.h" -#include "nsMemory.h" - -// define storage for all atoms -#define XUL_ATOM(_name, _value) nsIAtom* nsXULAtoms::_name; -#include "nsXULAtomList.h" -#undef XUL_ATOM - - -static const nsStaticAtom XULAtoms_info[] = { -#define XUL_ATOM(name_, value_) { value_, &nsXULAtoms::name_ }, -#include "nsXULAtomList.h" -#undef XUL_ATOM -}; - -void nsXULAtoms::AddRefAtoms() -{ - NS_RegisterStaticAtoms(XULAtoms_info, - NS_ARRAY_LENGTH(XULAtoms_info)); -} - diff --git a/mozilla/content/xul/content/src/nsXULAtoms.h b/mozilla/content/xul/content/src/nsXULAtoms.h index 21f5893fd0a..6cf18c838d3 100644 --- a/mozilla/content/xul/content/src/nsXULAtoms.h +++ b/mozilla/content/xul/content/src/nsXULAtoms.h @@ -38,30 +38,7 @@ #ifndef nsXULAtoms_h___ #define nsXULAtoms_h___ -#include "nsIAtom.h" - -/** - * This class wraps up the creation and destruction of the standard - * set of xul atoms used during normal xul handling. This object - * is created when the first xul content object is created, and - * destroyed when the last such content object is destroyed. - */ -class nsXULAtoms { -public: - - static void AddRefAtoms(); - - /* Declare all atoms - - The atom names and values are stored in nsCSSAtomList.h and - are brought to you by the magic of C preprocessing - - Add new atoms to nsCSSAtomList and all support logic will be auto-generated - */ -#define XUL_ATOM(_name, _value) static nsIAtom* _name; -#include "nsXULAtomList.h" -#undef XUL_ATOM - -}; +#include "nsGkAtoms.h" +typedef class nsGkAtoms nsXULAtoms; #endif /* nsXULAtoms_h___ */ diff --git a/mozilla/content/xul/content/src/nsXULElement.cpp b/mozilla/content/xul/content/src/nsXULElement.cpp index 5ceeeb192b7..b59277b8597 100644 --- a/mozilla/content/xul/content/src/nsXULElement.cpp +++ b/mozilla/content/xul/content/src/nsXULElement.cpp @@ -1217,7 +1217,7 @@ nsXULElement::ParseAttribute(PRInt32 aNamespaceID, return PR_TRUE; } - if (aAttribute == nsXULAtoms::clazz) { + if (aAttribute == nsXULAtoms::_class) { aResult.ParseAtomArray(aValue); return PR_TRUE; } @@ -2102,7 +2102,7 @@ nsXULElement::GetID() const const nsAttrValue* nsXULElement::GetClasses() const { - return FindLocalOrProtoAttr(kNameSpaceID_None, nsXULAtoms::clazz); + return FindLocalOrProtoAttr(kNameSpaceID_None, nsXULAtoms::_class); } NS_IMETHODIMP @@ -2193,7 +2193,7 @@ nsXULElement::GetIDAttributeName() const nsIAtom * nsXULElement::GetClassAttributeName() const { - return nsXULAtoms::clazz; + return nsXULAtoms::_class; } // Controllers Methods @@ -2284,7 +2284,7 @@ nsXULElement::GetBoxObject(nsIBoxObject** aResult) NS_IMPL_XUL_STRING_ATTR(Id, id) -NS_IMPL_XUL_STRING_ATTR(ClassName, clazz) +NS_IMPL_XUL_STRING_ATTR(ClassName, _class) NS_IMPL_XUL_STRING_ATTR(Align, align) NS_IMPL_XUL_STRING_ATTR(Dir, dir) NS_IMPL_XUL_STRING_ATTR(Flex, flex) @@ -2910,7 +2910,7 @@ nsXULPrototypeElement::SetAttrAt(PRUint32 aPos, const nsAString& aValue, return NS_OK; } - else if (mAttributes[aPos].mName.Equals(nsXULAtoms::clazz)) { + else if (mAttributes[aPos].mName.Equals(nsXULAtoms::_class)) { // Compute the element's class list mAttributes[aPos].mValue.ParseAtomArray(aValue); diff --git a/mozilla/content/xul/document/src/nsXULDocument.cpp b/mozilla/content/xul/document/src/nsXULDocument.cpp index c9fffd6fdf3..f0f186579aa 100644 --- a/mozilla/content/xul/document/src/nsXULDocument.cpp +++ b/mozilla/content/xul/document/src/nsXULDocument.cpp @@ -1038,7 +1038,7 @@ nsXULDocument::AttributeChanged(nsIContent* aElement, PRInt32 aNameSpaceID, NS_STATIC_CAST(BroadcastListener*, entry->mListeners[i]); if ((bl->mAttribute == aAttribute) || - (bl->mAttribute == nsXULAtoms::_star)) { + (bl->mAttribute == nsXULAtoms::_asterix)) { nsCOMPtr listener = do_QueryInterface(bl->mListener); diff --git a/mozilla/content/xul/templates/src/nsXULContentBuilder.cpp b/mozilla/content/xul/templates/src/nsXULContentBuilder.cpp index 745df8f89ad..5be551422a2 100644 --- a/mozilla/content/xul/templates/src/nsXULContentBuilder.cpp +++ b/mozilla/content/xul/templates/src/nsXULContentBuilder.cpp @@ -1004,7 +1004,7 @@ nsXULContentBuilder::IsDirectlyContainedBy(nsIContent* aChild, nsIContent* aPare //