mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 355300 There should be only one nsGkAtoms creature 

r=dbaron
This commit is contained in:
timeless%mozdev.org 2006-12-26 17:47:52 +00:00
Родитель b3baf9e836
Коммит 4e651390ef
274 изменённых файлов: 4014 добавлений и 4151 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

7
content/base/src/nsContentList.cpp
Просмотреть файл

@ -52,7 +52,6 @@
#include "nsContentUtils.h"
#include "nsLayoutAtoms.h"
#include "nsHTMLAtoms.h" // XXX until atoms get factored into nsLayoutAtoms
// Form related includes
#include "nsIDOMHTMLFormElement.h"
@ -302,7 +301,7 @@ nsContentList::nsContentList(nsINode* aRootNode,
mFuncMayDependOnAttr(PR_FALSE)
{
NS_ASSERTION(mRootNode, "Must have root");
if (nsLayoutAtoms::_asterix == mMatchAtom) {
if (nsGkAtoms::_asterix == mMatchAtom) {
mMatchAll = PR_TRUE;
}
else {
@ -412,9 +411,9 @@ nsContentList::NamedItem(const nsAString& aName, PRBool aDoFlush)
nsIContent *content = mElements[i];
// XXX Should this pass eIgnoreCase?
if (content &&
(content->AttrValueIs(kNameSpaceID_None, nsHTMLAtoms::name,
(content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name,
name, eCaseMatters) ||
content->AttrValueIs(kNameSpaceID_None, nsHTMLAtoms::id,
content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::id,
name, eCaseMatters))) {
return content;
}

16
content/base/src/nsContentSink.cpp
Просмотреть файл

@ -63,7 +63,7 @@
#include "nsIScrollableView.h"
#include "nsIContentViewer.h"
#include "nsIAtom.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDOMWindowInternal.h"
#include "nsIPrincipal.h"
#include "nsIScriptGlobalObject.h"
@ -300,7 +300,7 @@ nsContentSink::ProcessHTTPHeaders(nsIChannel* aChannel)
nsresult rv = httpchannel->GetResponseHeader(NS_LITERAL_CSTRING("link"),
linkHeader);
if (NS_SUCCEEDED(rv) && !linkHeader.IsEmpty()) {
ProcessHeaderData(nsHTMLAtoms::link,
ProcessHeaderData(nsGkAtoms::link,
NS_ConvertASCIItoUTF16(linkHeader));
}
@ -316,7 +316,7 @@ nsContentSink::ProcessHeaderData(nsIAtom* aHeader, const nsAString& aValue,
mDocument->SetHeaderData(aHeader, aValue);
if (aHeader == nsHTMLAtoms::setcookie) {
if (aHeader == nsGkAtoms::setcookie) {
// Note: Necko already handles cookies set via the channel. We can't just
// call SetCookie on the channel because we want to do some security checks
// here and want to use the prompt associated to our current window, not
@ -357,10 +357,10 @@ nsContentSink::ProcessHeaderData(nsIAtom* aHeader, const nsAString& aValue,
return rv;
}
}
else if (aHeader == nsHTMLAtoms::link) {
else if (aHeader == nsGkAtoms::link) {
rv = ProcessLinkHeader(aContent, aValue);
}
else if (aHeader == nsHTMLAtoms::msthemecompatible) {
else if (aHeader == nsGkAtoms::msthemecompatible) {
// Disable theming for the presshell if the value is no.
// XXXbz don't we want to support this as an HTTP header too?
nsAutoString value(aValue);
@ -373,7 +373,7 @@ nsContentSink::ProcessHeaderData(nsIAtom* aHeader, const nsAString& aValue,
}
// Don't report "refresh" headers back to necko, since our document handles
// them
else if (aHeader != nsHTMLAtoms::refresh && mParser) {
else if (aHeader != nsGkAtoms::refresh && mParser) {
// we also need to report back HTTP-EQUIV headers to the channel
// so that it can process things like pragma: no-cache or other
// cache-control headers. Ideally this should also be the way for
@ -662,10 +662,10 @@ nsContentSink::ProcessMETATag(nsIContent* aContent)
// set any HTTP-EQUIV data into document's header data as well as url
nsAutoString header;
aContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::httpEquiv, header);
aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
if (!header.IsEmpty()) {
nsAutoString result;
aContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::content, result);
aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::content, result);
if (!result.IsEmpty()) {
ToLowerCase(header);
nsCOMPtr<nsIAtom> fieldAtom(do_GetAtom(header));

316
content/base/src/nsContentSink.h
Просмотреть файл

@ -52,7 +52,7 @@
#include "nsCOMArray.h"
#include "nsString.h"
#include "nsAutoPtr.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsTHashtable.h"
#include "nsHashKeys.h"
@ -133,171 +133,171 @@ protected:
// Thanks to Mark Pilgrim and Sam Ruby for the initial whitelist
//
static nsIAtom** const kDefaultAllowedTags [] = {
&nsHTMLAtoms::a,
&nsHTMLAtoms::abbr,
&nsHTMLAtoms::acronym,
&nsHTMLAtoms::address,
&nsHTMLAtoms::area,
&nsHTMLAtoms::b,
&nsHTMLAtoms::bdo,
&nsHTMLAtoms::big,
&nsHTMLAtoms::blockquote,
&nsHTMLAtoms::br,
&nsHTMLAtoms::button,
&nsHTMLAtoms::caption,
&nsHTMLAtoms::center,
&nsHTMLAtoms::cite,
&nsHTMLAtoms::code,
&nsHTMLAtoms::col,
&nsHTMLAtoms::colgroup,
&nsHTMLAtoms::dd,
&nsHTMLAtoms::del,
&nsHTMLAtoms::dfn,
&nsHTMLAtoms::dir,
&nsHTMLAtoms::div,
&nsHTMLAtoms::dl,
&nsHTMLAtoms::dt,
&nsHTMLAtoms::em,
&nsHTMLAtoms::fieldset,
&nsHTMLAtoms::font,
&nsHTMLAtoms::form,
&nsHTMLAtoms::h1,
&nsHTMLAtoms::h2,
&nsHTMLAtoms::h3,
&nsHTMLAtoms::h4,
&nsHTMLAtoms::h5,
&nsHTMLAtoms::h6,
&nsHTMLAtoms::hr,
&nsHTMLAtoms::i,
&nsHTMLAtoms::img,
&nsHTMLAtoms::input,
&nsHTMLAtoms::ins,
&nsHTMLAtoms::kbd,
&nsHTMLAtoms::label,
&nsHTMLAtoms::legend,
&nsHTMLAtoms::li,
&nsHTMLAtoms::listing,
&nsHTMLAtoms::map,
&nsHTMLAtoms::menu,
&nsHTMLAtoms::nobr,
&nsHTMLAtoms::ol,
&nsHTMLAtoms::optgroup,
&nsHTMLAtoms::option,
&nsHTMLAtoms::p,
&nsHTMLAtoms::pre,
&nsHTMLAtoms::q,
&nsHTMLAtoms::s,
&nsHTMLAtoms::samp,
&nsHTMLAtoms::select,
&nsHTMLAtoms::small,
&nsHTMLAtoms::span,
&nsHTMLAtoms::strike,
&nsHTMLAtoms::strong,
&nsHTMLAtoms::sub,
&nsHTMLAtoms::sup,
&nsHTMLAtoms::table,
&nsHTMLAtoms::tbody,
&nsHTMLAtoms::td,
&nsHTMLAtoms::textarea,
&nsHTMLAtoms::tfoot,
&nsHTMLAtoms::th,
&nsHTMLAtoms::thead,
&nsHTMLAtoms::tr,
&nsHTMLAtoms::tt,
&nsHTMLAtoms::u,
&nsHTMLAtoms::ul,
&nsHTMLAtoms::var
&nsGkAtoms::a,
&nsGkAtoms::abbr,
&nsGkAtoms::acronym,
&nsGkAtoms::address,
&nsGkAtoms::area,
&nsGkAtoms::b,
&nsGkAtoms::bdo,
&nsGkAtoms::big,
&nsGkAtoms::blockquote,
&nsGkAtoms::br,
&nsGkAtoms::button,
&nsGkAtoms::caption,
&nsGkAtoms::center,
&nsGkAtoms::cite,
&nsGkAtoms::code,
&nsGkAtoms::col,
&nsGkAtoms::colgroup,
&nsGkAtoms::dd,
&nsGkAtoms::del,
&nsGkAtoms::dfn,
&nsGkAtoms::dir,
&nsGkAtoms::div,
&nsGkAtoms::dl,
&nsGkAtoms::dt,
&nsGkAtoms::em,
&nsGkAtoms::fieldset,
&nsGkAtoms::font,
&nsGkAtoms::form,
&nsGkAtoms::h1,
&nsGkAtoms::h2,
&nsGkAtoms::h3,
&nsGkAtoms::h4,
&nsGkAtoms::h5,
&nsGkAtoms::h6,
&nsGkAtoms::hr,
&nsGkAtoms::i,
&nsGkAtoms::img,
&nsGkAtoms::input,
&nsGkAtoms::ins,
&nsGkAtoms::kbd,
&nsGkAtoms::label,
&nsGkAtoms::legend,
&nsGkAtoms::li,
&nsGkAtoms::listing,
&nsGkAtoms::map,
&nsGkAtoms::menu,
&nsGkAtoms::nobr,
&nsGkAtoms::ol,
&nsGkAtoms::optgroup,
&nsGkAtoms::option,
&nsGkAtoms::p,
&nsGkAtoms::pre,
&nsGkAtoms::q,
&nsGkAtoms::s,
&nsGkAtoms::samp,
&nsGkAtoms::select,
&nsGkAtoms::small,
&nsGkAtoms::span,
&nsGkAtoms::strike,
&nsGkAtoms::strong,
&nsGkAtoms::sub,
&nsGkAtoms::sup,
&nsGkAtoms::table,
&nsGkAtoms::tbody,
&nsGkAtoms::td,
&nsGkAtoms::textarea,
&nsGkAtoms::tfoot,
&nsGkAtoms::th,
&nsGkAtoms::thead,
&nsGkAtoms::tr,
&nsGkAtoms::tt,
&nsGkAtoms::u,
&nsGkAtoms::ul,
&nsGkAtoms::var
};
static nsIAtom** const kDefaultAllowedAttributes [] = {
&nsHTMLAtoms::abbr,
&nsHTMLAtoms::accept,
&nsHTMLAtoms::acceptcharset,
&nsHTMLAtoms::accesskey,
&nsHTMLAtoms::action,
&nsHTMLAtoms::align,
&nsHTMLAtoms::alt,
&nsHTMLAtoms::autocomplete,
&nsHTMLAtoms::axis,
&nsHTMLAtoms::background,
&nsHTMLAtoms::bgcolor,
&nsHTMLAtoms::border,
&nsHTMLAtoms::cellpadding,
&nsHTMLAtoms::cellspacing,
&nsHTMLAtoms::_char,
&nsHTMLAtoms::charoff,
&nsHTMLAtoms::charset,
&nsHTMLAtoms::checked,
&nsHTMLAtoms::cite,
&nsHTMLAtoms::_class,
&nsHTMLAtoms::clear,
&nsHTMLAtoms::cols,
&nsHTMLAtoms::colspan,
&nsHTMLAtoms::color,
&nsHTMLAtoms::compact,
&nsHTMLAtoms::coords,
&nsHTMLAtoms::datetime,
&nsHTMLAtoms::dir,
&nsHTMLAtoms::disabled,
&nsHTMLAtoms::enctype,
&nsHTMLAtoms::_for,
&nsHTMLAtoms::frame,
&nsHTMLAtoms::headers,
&nsHTMLAtoms::height,
&nsHTMLAtoms::href,
&nsHTMLAtoms::hreflang,
&nsHTMLAtoms::hspace,
&nsHTMLAtoms::id,
&nsHTMLAtoms::ismap,
&nsHTMLAtoms::label,
&nsHTMLAtoms::lang,
&nsHTMLAtoms::longdesc,
&nsHTMLAtoms::maxlength,
&nsHTMLAtoms::media,
&nsHTMLAtoms::method,
&nsHTMLAtoms::multiple,
&nsHTMLAtoms::name,
&nsHTMLAtoms::nohref,
&nsHTMLAtoms::noshade,
&nsHTMLAtoms::nowrap,
&nsHTMLAtoms::pointSize,
&nsHTMLAtoms::prompt,
&nsHTMLAtoms::readonly,
&nsHTMLAtoms::rel,
&nsHTMLAtoms::rev,
&nsHTMLAtoms::role,
&nsHTMLAtoms::rows,
&nsHTMLAtoms::rowspan,
&nsHTMLAtoms::rules,
&nsHTMLAtoms::scope,
&nsHTMLAtoms::selected,
&nsHTMLAtoms::shape,
&nsHTMLAtoms::size,
&nsHTMLAtoms::span,
&nsHTMLAtoms::src,
&nsHTMLAtoms::start,
&nsHTMLAtoms::summary,
&nsHTMLAtoms::tabindex,
&nsHTMLAtoms::target,
&nsHTMLAtoms::title,
&nsHTMLAtoms::type,
&nsHTMLAtoms::usemap,
&nsHTMLAtoms::valign,
&nsHTMLAtoms::value,
&nsHTMLAtoms::vspace,
&nsHTMLAtoms::width
&nsGkAtoms::abbr,
&nsGkAtoms::accept,
&nsGkAtoms::acceptcharset,
&nsGkAtoms::accesskey,
&nsGkAtoms::action,
&nsGkAtoms::align,
&nsGkAtoms::alt,
&nsGkAtoms::autocomplete,
&nsGkAtoms::axis,
&nsGkAtoms::background,
&nsGkAtoms::bgcolor,
&nsGkAtoms::border,
&nsGkAtoms::cellpadding,
&nsGkAtoms::cellspacing,
&nsGkAtoms::_char,
&nsGkAtoms::charoff,
&nsGkAtoms::charset,
&nsGkAtoms::checked,
&nsGkAtoms::cite,
&nsGkAtoms::_class,
&nsGkAtoms::clear,
&nsGkAtoms::cols,
&nsGkAtoms::colspan,
&nsGkAtoms::color,
&nsGkAtoms::compact,
&nsGkAtoms::coords,
&nsGkAtoms::datetime,
&nsGkAtoms::dir,
&nsGkAtoms::disabled,
&nsGkAtoms::enctype,
&nsGkAtoms::_for,
&nsGkAtoms::frame,
&nsGkAtoms::headers,
&nsGkAtoms::height,
&nsGkAtoms::href,
&nsGkAtoms::hreflang,
&nsGkAtoms::hspace,
&nsGkAtoms::id,
&nsGkAtoms::ismap,
&nsGkAtoms::label,
&nsGkAtoms::lang,
&nsGkAtoms::longdesc,
&nsGkAtoms::maxlength,
&nsGkAtoms::media,
&nsGkAtoms::method,
&nsGkAtoms::multiple,
&nsGkAtoms::name,
&nsGkAtoms::nohref,
&nsGkAtoms::noshade,
&nsGkAtoms::nowrap,
&nsGkAtoms::pointSize,
&nsGkAtoms::prompt,
&nsGkAtoms::readonly,
&nsGkAtoms::rel,
&nsGkAtoms::rev,
&nsGkAtoms::role,
&nsGkAtoms::rows,
&nsGkAtoms::rowspan,
&nsGkAtoms::rules,
&nsGkAtoms::scope,
&nsGkAtoms::selected,
&nsGkAtoms::shape,
&nsGkAtoms::size,
&nsGkAtoms::span,
&nsGkAtoms::src,
&nsGkAtoms::start,
&nsGkAtoms::summary,
&nsGkAtoms::tabindex,
&nsGkAtoms::target,
&nsGkAtoms::title,
&nsGkAtoms::type,
&nsGkAtoms::usemap,
&nsGkAtoms::valign,
&nsGkAtoms::value,
&nsGkAtoms::vspace,
&nsGkAtoms::width
};
// URIs action, href, src, longdesc, usemap, cite
static
PRBool IsAttrURI(nsIAtom *aName)
{
return (aName == nsHTMLAtoms::action ||
aName == nsHTMLAtoms::href ||
aName == nsHTMLAtoms::src ||
aName == nsHTMLAtoms::longdesc ||
aName == nsHTMLAtoms::usemap ||
aName == nsHTMLAtoms::cite ||
aName == nsHTMLAtoms::background);
return (aName == nsGkAtoms::action ||
aName == nsGkAtoms::href ||
aName == nsGkAtoms::src ||
aName == nsGkAtoms::longdesc ||
aName == nsGkAtoms::usemap ||
aName == nsGkAtoms::cite ||
aName == nsGkAtoms::background);
}
#endif // _nsContentSink_h_

16
content/base/src/nsContentUtils.cpp
Просмотреть файл

@ -90,9 +90,8 @@
#include "nsIDOMHTMLFormElement.h"
#include "nsIForm.h"
#include "nsIFormControl.h"
#include "nsHTMLAtoms.h"
#include "nsISupportsPrimitives.h"
#include "nsLayoutAtoms.h"
#include "nsISupportsPrimitives.h"
#include "imgIDecoderObserver.h"
#include "imgIRequest.h"
#include "imgIContainer.h"
@ -132,7 +131,6 @@ static NS_DEFINE_CID(kXTFServiceCID, NS_XTFSERVICE_CID);
#include "nsXBLPrototypeBinding.h"
#include "nsEscape.h"
#include "nsICharsetConverterManager.h"
#include "nsXULAtoms.h"
#include "nsIEventListenerManager.h"
#include "nsAttrName.h"
#include "nsIDOMUserDataHandler.h"
@ -1655,7 +1653,7 @@ nsContentUtils::GenerateStateKey(nsIContent* aContent,
// Append the control name
nsAutoString name;
aContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::name, name);
aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::name, name);
KeyAppendString(name, aKey);
}
}
@ -1725,7 +1723,7 @@ nsContentUtils::BelongsInForm(nsIDOMHTMLFormElement *aForm,
return PR_TRUE;
}
if (content->Tag() == nsHTMLAtoms::form &&
if (content->Tag() == nsGkAtoms::form &&
content->IsNodeOfType(nsINode::eHTML)) {
// The child is contained within a form, but not the right form
// so we ignore it.
@ -1830,7 +1828,7 @@ nsContentUtils::LookupNamespaceURI(nsIContent* aNamespaceResolver,
NS_ENSURE_TRUE(name, NS_ERROR_OUT_OF_MEMORY);
}
else {
name = nsLayoutAtoms::xmlns;
name = nsGkAtoms::xmlns;
}
// Trace up the content parent chain looking for the namespace
// declaration that declares aNamespacePrefix.
@ -2144,7 +2142,7 @@ nsContentUtils::GetXLinkURI(nsIContent* aContent)
nsGkAtoms::simple, eCaseMatters)) {
nsAutoString value;
// Check that we have a URI
if (aContent->GetAttr(kNameSpaceID_XLink, nsHTMLAtoms::href, value)) {
if (aContent->GetAttr(kNameSpaceID_XLink, nsGkAtoms::href, value)) {
// Resolve it relative to aContent's base URI.
nsCOMPtr<nsIURI> baseURI = aContent->GetBaseURI();
@ -2278,7 +2276,7 @@ nsContentUtils::GetEventArgNames(PRInt32 aNameSpaceID,
// nsJSEventListener is what does the arg magic for onerror, and it does
// not seem to take the namespace into account. So we let onerror in all
// namespaces get the 3 arg names.
if (aEventName == nsLayoutAtoms::onerror) {
if (aEventName == nsGkAtoms::onerror) {
SET_EVENT_ARG_NAMES(gOnErrorNames);
} else if (aNameSpaceID == kNameSpaceID_SVG) {
SET_EVENT_ARG_NAMES(gSVGEventNames);
@ -2869,7 +2867,7 @@ PRBool
nsContentUtils::HasNonEmptyAttr(nsIContent* aContent, PRInt32 aNameSpaceID,
nsIAtom* aName)
{
static nsIContent::AttrValuesArray strings[] = {&nsXULAtoms::_empty, nsnull};
static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::_empty, nsnull};
return aContent->FindAttrValueIn(aNameSpaceID, aName, strings, eCaseMatters)
== nsIContent::ATTR_VALUE_NO_MATCH;
}

8
content/base/src/nsCopySupport.cpp
Просмотреть файл

@ -60,7 +60,7 @@
#include "nsIDOMElement.h"
#include "nsIDOMDocument.h"
#include "nsIHTMLDocument.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
// image copy stuff
#include "nsIImageLoadingContent.h"
@ -329,14 +329,14 @@ nsresult nsCopySupport::IsPlainTextContext(nsISelection *aSel, nsIDocument *aDoc
nsIAtom *atom = selContent->Tag();
if (atom == nsHTMLAtoms::input ||
atom == nsHTMLAtoms::textarea)
if (atom == nsGkAtoms::input ||
atom == nsGkAtoms::textarea)
{
*aIsPlainTextContext = PR_TRUE;
break;
}
if (atom == nsHTMLAtoms::body)
if (atom == nsGkAtoms::body)
{
// check for moz prewrap style on body. If it's there we are
// in a plaintext editor. This is pretty cheezy but I haven't

3
content/base/src/nsDOMDocumentType.cpp
Просмотреть файл

@ -48,7 +48,6 @@
#include "nsDOMString.h"
#include "nsIDOM3Node.h"
#include "nsNodeInfoManager.h"
#include "nsLayoutAtoms.h"
#include "nsIDocument.h"
#include "nsIXPConnect.h"
#include "nsIDOMDocument.h"
@ -86,7 +85,7 @@ NS_NewDOMDocumentType(nsIDOMDocumentType** aDocType,
}
nsCOMPtr<nsINodeInfo> ni;
rv = nimgr->GetNodeInfo(nsLayoutAtoms::documentTypeNodeName, nsnull,
rv = nimgr->GetNodeInfo(nsGkAtoms::documentTypeNodeName, nsnull,
kNameSpaceID_None, getter_AddRefs(ni));
NS_ENSURE_SUCCESS(rv, rv);

37
content/base/src/nsDocument.cpp
Просмотреть файл

@ -111,7 +111,7 @@
#include "nsPIDOMWindow.h"
#include "nsIDOMElement.h"
#include "nsXULAtoms.h"
#include "nsGkAtoms.h"
// for radio group stuff
#include "nsIDOMHTMLInputElement.h"
@ -124,7 +124,6 @@
static NS_DEFINE_CID(kDOMEventGroupCID, NS_DOMEVENTGROUP_CID);
#include "nsHTMLAtoms.h"
#include "nsIDOMUserDataHandler.h"
#include "nsScriptEventManager.h"
#include "nsIDOMXPathEvaluator.h"
@ -1498,12 +1497,12 @@ nsDocument::SetHeaderData(nsIAtom* aHeaderField, const nsAString& aData)
}
}
if (aHeaderField == nsHTMLAtoms::headerContentLanguage) {
if (aHeaderField == nsGkAtoms::headerContentLanguage) {
CopyUTF16toUTF8(aData, mContentLanguage);
}
// Set the default script-type on the root element.
if (aHeaderField == nsHTMLAtoms::headerContentScriptType) {
if (aHeaderField == nsGkAtoms::headerContentScriptType) {
nsIContent *root = GetRootContent();
if (root) {
// Get the script-type ID for this value.
@ -1518,7 +1517,7 @@ nsDocument::SetHeaderData(nsIAtom* aHeaderField, const nsAString& aData)
}
}
if (aHeaderField == nsHTMLAtoms::headerDefaultStyle) {
if (aHeaderField == nsGkAtoms::headerDefaultStyle) {
// switch alternate style sheets based on default
// XXXldb What if we don't have all the sheets yet? Should this use
// the DOM API for preferred stylesheet set that's "coming soon"?
@ -1545,7 +1544,7 @@ nsDocument::SetHeaderData(nsIAtom* aHeaderField, const nsAString& aData)
}
}
if (aHeaderField == nsHTMLAtoms::refresh) {
if (aHeaderField == nsGkAtoms::refresh) {
// We get into this code before we have a script global yet, so get to
// our container via mDocumentContainer.
nsCOMPtr<nsIRefreshURI> refresher = do_QueryReferent(mDocumentContainer);
@ -3239,21 +3238,21 @@ nsDocument::GetBoxObjectFor(nsIDOMElement* aElement, nsIBoxObject** aResult)
nsCAutoString contractID("@mozilla.org/layout/xul-boxobject");
if (namespaceID == kNameSpaceID_XUL) {
if (tag == nsXULAtoms::browser ||
tag == nsXULAtoms::editor ||
tag == nsXULAtoms::iframe)
if (tag == nsGkAtoms::browser ||
tag == nsGkAtoms::editor ||
tag == nsGkAtoms::iframe)
contractID += "-container";
else if (tag == nsXULAtoms::menu)
else if (tag == nsGkAtoms::menu)
contractID += "-menu";
else if (tag == nsXULAtoms::popup ||
tag == nsXULAtoms::menupopup ||
tag == nsXULAtoms::tooltip)
else if (tag == nsGkAtoms::popup ||
tag == nsGkAtoms::menupopup ||
tag == nsGkAtoms::tooltip)
contractID += "-popup";
else if (tag == nsXULAtoms::tree)
else if (tag == nsGkAtoms::tree)
contractID += "-tree";
else if (tag == nsXULAtoms::listbox)
else if (tag == nsGkAtoms::listbox)
contractID += "-listbox";
else if (tag == nsXULAtoms::scrollbox)
else if (tag == nsGkAtoms::scrollbox)
contractID += "-scrollbox";
}
contractID += ";1";
@ -4719,7 +4718,7 @@ nsDocument::RetrieveRelevantHeaders(nsIChannel *aChannel)
nsCAutoString contentDisp;
rv = partChannel->GetContentDisposition(contentDisp);
if (NS_SUCCEEDED(rv) && !contentDisp.IsEmpty()) {
SetHeaderData(nsHTMLAtoms::headerContentDisposition,
SetHeaderData(nsGkAtoms::headerContentDisposition,
NS_ConvertASCIItoUTF16(contentDisp));
}
}
@ -5170,7 +5169,7 @@ nsDocument::OnPageShow(PRBool aPersisted)
if (aPersisted && mRootContent) {
// Send out notifications that our <link> elements are attached.
nsRefPtr<nsContentList> links = NS_GetContentList(mRootContent,
nsHTMLAtoms::link,
nsGkAtoms::link,
kNameSpaceID_Unknown);
if (links) {
@ -5195,7 +5194,7 @@ nsDocument::OnPageHide(PRBool aPersisted)
// but only if this is not a full unload.
if (aPersisted && mRootContent) {
nsRefPtr<nsContentList> links = NS_GetContentList(mRootContent,
nsHTMLAtoms::link,
nsGkAtoms::link,
kNameSpaceID_Unknown);
if (links) {

70
content/base/src/nsDocumentEncoder.cpp
Просмотреть файл

@ -65,7 +65,7 @@
#include "nsIDOMRange.h"
#include "nsIDOMDocument.h"
#include "nsICharsetConverterManager.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsIContent.h"
#include "nsIEnumerator.h"
#include "nsISelectionPrivate.h"
@ -1112,13 +1112,13 @@ nsHTMLCopyEncoder::SetSelection(nsISelection* aSelection)
{
// checking for selection inside a plaintext form widget
nsIAtom *atom = selContent->Tag();
if (atom == nsHTMLAtoms::input ||
atom == nsHTMLAtoms::textarea)
if (atom == nsGkAtoms::input ||
atom == nsGkAtoms::textarea)
{
mIsTextWidget = PR_TRUE;
break;
}
else if (atom == nsHTMLAtoms::body)
else if (atom == nsGkAtoms::body)
{
// check for moz prewrap style on body. If it's there we are
// in a plaintext editor. This is pretty cheezy but I haven't
@ -1260,32 +1260,32 @@ nsHTMLCopyEncoder::IncludeInContext(nsIDOMNode *aNode)
nsIAtom *tag = content->Tag();
return (tag == nsHTMLAtoms::b ||
tag == nsHTMLAtoms::i ||
tag == nsHTMLAtoms::u ||
tag == nsHTMLAtoms::a ||
tag == nsHTMLAtoms::tt ||
tag == nsHTMLAtoms::s ||
tag == nsHTMLAtoms::big ||
tag == nsHTMLAtoms::small ||
tag == nsHTMLAtoms::strike ||
tag == nsHTMLAtoms::em ||
tag == nsHTMLAtoms::strong ||
tag == nsHTMLAtoms::dfn ||
tag == nsHTMLAtoms::code ||
tag == nsHTMLAtoms::cite ||
tag == nsHTMLAtoms::variable ||
tag == nsHTMLAtoms::abbr ||
tag == nsHTMLAtoms::font ||
tag == nsHTMLAtoms::script ||
tag == nsHTMLAtoms::span ||
tag == nsHTMLAtoms::pre ||
tag == nsHTMLAtoms::h1 ||
tag == nsHTMLAtoms::h2 ||
tag == nsHTMLAtoms::h3 ||
tag == nsHTMLAtoms::h4 ||
tag == nsHTMLAtoms::h5 ||
tag == nsHTMLAtoms::h6);
return (tag == nsGkAtoms::b ||
tag == nsGkAtoms::i ||
tag == nsGkAtoms::u ||
tag == nsGkAtoms::a ||
tag == nsGkAtoms::tt ||
tag == nsGkAtoms::s ||
tag == nsGkAtoms::big ||
tag == nsGkAtoms::small ||
tag == nsGkAtoms::strike ||
tag == nsGkAtoms::em ||
tag == nsGkAtoms::strong ||
tag == nsGkAtoms::dfn ||
tag == nsGkAtoms::code ||
tag == nsGkAtoms::cite ||
tag == nsGkAtoms::variable ||
tag == nsGkAtoms::abbr ||
tag == nsGkAtoms::font ||
tag == nsGkAtoms::script ||
tag == nsGkAtoms::span ||
tag == nsGkAtoms::pre ||
tag == nsGkAtoms::h1 ||
tag == nsGkAtoms::h2 ||
tag == nsGkAtoms::h3 ||
tag == nsGkAtoms::h4 ||
tag == nsGkAtoms::h5 ||
tag == nsGkAtoms::h6);
}
@ -1582,7 +1582,7 @@ nsHTMLCopyEncoder::GetChildAt(nsIDOMNode *aParent, PRInt32 aOffset)
PRBool
nsHTMLCopyEncoder::IsMozBR(nsIDOMNode* aNode)
{
if (IsTag(aNode, nsHTMLAtoms::br))
if (IsTag(aNode, nsGkAtoms::br))
{
nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(aNode);
if (elem)
@ -1628,11 +1628,11 @@ nsHTMLCopyEncoder::IsRoot(nsIDOMNode* aNode)
if (aNode)
{
if (mIsTextWidget)
return (IsTag(aNode, nsHTMLAtoms::div));
return (IsTag(aNode, nsGkAtoms::div));
else
return (IsTag(aNode, nsHTMLAtoms::body) ||
IsTag(aNode, nsHTMLAtoms::td) ||
IsTag(aNode, nsHTMLAtoms::th));
return (IsTag(aNode, nsGkAtoms::body) ||
IsTag(aNode, nsGkAtoms::td) ||
IsTag(aNode, nsGkAtoms::th));
}
return PR_FALSE;
}

2
content/base/src/nsDocumentFragment.cpp
Просмотреть файл

@ -166,7 +166,7 @@ NS_NewDocumentFragment(nsIDOMDocumentFragment** aInstancePtrResult,
nsCOMPtr<nsINodeInfo> nodeInfo;
nsresult rv =
aNodeInfoManager->GetNodeInfo(nsLayoutAtoms::documentFragmentNodeName,
aNodeInfoManager->GetNodeInfo(nsGkAtoms::documentFragmentNodeName,
nsnull, kNameSpaceID_None,
getter_AddRefs(nodeInfo));
NS_ENSURE_SUCCESS(rv, rv);

16
content/base/src/nsFrameLoader.cpp
Просмотреть файл

@ -70,7 +70,7 @@
#include "nsIURL.h"
#include "nsNetUtil.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsINameSpaceManager.h"
// Bug 136580: Limit to the number of nested content frames that can have the
@ -314,13 +314,13 @@ nsFrameLoader::EnsureDocShell()
PRInt32 namespaceID = mOwnerContent->GetNameSpaceID();
if (namespaceID == kNameSpaceID_XHTML) {
mOwnerContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::id, frameName);
mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::id, frameName);
} else {
mOwnerContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::name, frameName);
mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::name, frameName);
// XXX if no NAME then use ID, after a transition period this will be
// changed so that XUL only uses ID too (bug 254284).
if (frameName.IsEmpty() && namespaceID == kNameSpaceID_XUL) {
mOwnerContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::id, frameName);
mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::id, frameName);
}
}
@ -347,7 +347,7 @@ nsFrameLoader::EnsureDocShell()
PRBool isContent = PR_FALSE;
if (mOwnerContent->IsNodeOfType(nsINode::eXUL)) {
mOwnerContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::type, value);
mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::type, value);
}
// we accept "content" and "content-xxx" values.
@ -449,10 +449,10 @@ nsFrameLoader::GetURL(nsString& aURI)
{
aURI.Truncate();
if (mOwnerContent->Tag() == nsHTMLAtoms::object) {
mOwnerContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::data, aURI);
if (mOwnerContent->Tag() == nsGkAtoms::object) {
mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::data, aURI);
} else {
mOwnerContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::src, aURI);
mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::src, aURI);
}
}

15
content/base/src/nsGenericElement.cpp
Просмотреть файл

@ -95,7 +95,6 @@
#include "nsIDOMNSDocument.h"
#include "nsLayoutAtoms.h"
#include "nsHTMLAtoms.h"
#include "nsContentUtils.h"
#include "nsIJSContextStack.h"
@ -412,7 +411,7 @@ nsNode3Tearoff::AreNodesEqual(nsIContent* aContent1,
return PR_FALSE;
}
if (aContent1->Tag() == nsLayoutAtoms::documentTypeNodeName) {
if (aContent1->Tag() == nsGkAtoms::documentTypeNodeName) {
nsCOMPtr<nsIDOMDocumentType> docType1 = do_QueryInterface(aContent1);
nsCOMPtr<nsIDOMDocumentType> docType2 = do_QueryInterface(aContent2);
@ -580,7 +579,7 @@ nsNode3Tearoff::LookupPrefix(const nsAString& aNamespaceURI,
aNamespaceURI, eCaseMatters)) {
// If the localName is "xmlns", the prefix we output should be
// null.
if (name->LocalName() != nsLayoutAtoms::xmlns) {
if (name->LocalName() != nsGkAtoms::xmlns) {
name->LocalName()->ToString(aPrefix);
}
@ -1860,7 +1859,7 @@ nsGenericElement::UnbindFromTree(PRBool aDeep, PRBool aNullParent)
// anonymous content that the document is changing.
document->BindingManager()->ChangeDocumentFor(this, document, nsnull);
if (HasAttr(kNameSpaceID_XLink, nsHTMLAtoms::href)) {
if (HasAttr(kNameSpaceID_XLink, nsGkAtoms::href)) {
document->ForgetLink(this);
}
@ -2105,7 +2104,7 @@ nsGenericElement::GetBaseURI() const
// Now check for an xml:base attr
nsAutoString value;
GetAttr(kNameSpaceID_XML, nsHTMLAtoms::base, value);
GetAttr(kNameSpaceID_XML, nsGkAtoms::base, value);
if (value.IsEmpty()) {
// No xml:base, so we just use the parent's base URL
nsIURI *base = nsnull;
@ -3153,7 +3152,7 @@ nsGenericElement::SetAttr(PRInt32 aNamespaceID, nsIAtom* aName,
"Don't call SetAttr with unknown namespace");
nsIDocument* doc = GetCurrentDoc();
if (kNameSpaceID_XLink == aNamespaceID && nsHTMLAtoms::href == aName) {
if (kNameSpaceID_XLink == aNamespaceID && nsGkAtoms::href == aName) {
// XLink URI(s) might be changing. Drop the link from the map. If it
// is still style relevant it will be re-added by
// nsStyleUtil::IsSimpleXlink. Make sure to keep the style system
@ -3288,7 +3287,7 @@ nsGenericElement::SetAttrAndNotify(PRInt32 aNamespaceID,
}
if (aNamespaceID == kNameSpaceID_XMLEvents &&
aName == nsHTMLAtoms::event && mNodeInfo->GetDocument()) {
aName == nsGkAtoms::event && mNodeInfo->GetDocument()) {
mNodeInfo->GetDocument()->AddXMLEventsContent(this);
}
@ -3448,7 +3447,7 @@ nsGenericElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
nsIDocument *document = GetCurrentDoc();
mozAutoDocUpdate updateBatch(document, UPDATE_CONTENT_MODEL, aNotify);
if (document) {
if (kNameSpaceID_XLink == aNameSpaceID && nsHTMLAtoms::href == aName) {
if (kNameSpaceID_XLink == aNameSpaceID && nsGkAtoms::href == aName) {
// XLink URI might be changing.
document->ForgetLink(this);
}

245
content/base/src/nsHTMLContentSerializer.cpp
Просмотреть файл

@ -56,7 +56,6 @@
#include "nsIServiceManager.h"
#include "nsIDocumentEncoder.h"
#include "nsLayoutAtoms.h"
#include "nsHTMLAtoms.h"
#include "nsIURI.h"
#include "nsNetUtil.h"
#include "nsEscape.h"
@ -440,8 +439,8 @@ nsHTMLContentSerializer::AppendDocumentStart(nsIDOMDocument *aDocument,
PRBool
nsHTMLContentSerializer::IsJavaScript(nsIAtom* aAttrNameAtom, const nsAString& aValueString)
{
if (aAttrNameAtom == nsHTMLAtoms::href ||
aAttrNameAtom == nsHTMLAtoms::src) {
if (aAttrNameAtom == nsGkAtoms::href ||
aAttrNameAtom == nsGkAtoms::src) {
static const char kJavaScript[] = "javascript";
PRInt32 pos = aValueString.FindChar(':');
if (pos < (PRInt32)(sizeof kJavaScript - 1))
@ -456,24 +455,24 @@ nsHTMLContentSerializer::IsJavaScript(nsIAtom* aAttrNameAtom, const nsAString& a
}
PRBool result =
(aAttrNameAtom == nsLayoutAtoms::onblur) || (aAttrNameAtom == nsLayoutAtoms::onchange)
|| (aAttrNameAtom == nsLayoutAtoms::onclick) || (aAttrNameAtom == nsLayoutAtoms::ondblclick)
|| (aAttrNameAtom == nsLayoutAtoms::onfocus) || (aAttrNameAtom == nsLayoutAtoms::onkeydown)
|| (aAttrNameAtom == nsLayoutAtoms::onkeypress) || (aAttrNameAtom == nsLayoutAtoms::onkeyup)
|| (aAttrNameAtom == nsLayoutAtoms::onload) || (aAttrNameAtom == nsLayoutAtoms::onmousedown)
|| (aAttrNameAtom == nsLayoutAtoms::onpageshow) || (aAttrNameAtom == nsLayoutAtoms::onpagehide)
|| (aAttrNameAtom == nsLayoutAtoms::onmousemove) || (aAttrNameAtom == nsLayoutAtoms::onmouseout)
|| (aAttrNameAtom == nsLayoutAtoms::onmouseover) || (aAttrNameAtom == nsLayoutAtoms::onmouseup)
|| (aAttrNameAtom == nsLayoutAtoms::onreset) || (aAttrNameAtom == nsLayoutAtoms::onselect)
|| (aAttrNameAtom == nsLayoutAtoms::onsubmit) || (aAttrNameAtom == nsLayoutAtoms::onunload)
|| (aAttrNameAtom == nsLayoutAtoms::onabort) || (aAttrNameAtom == nsLayoutAtoms::onerror)
|| (aAttrNameAtom == nsLayoutAtoms::onpaint) || (aAttrNameAtom == nsLayoutAtoms::onresize)
|| (aAttrNameAtom == nsLayoutAtoms::onscroll) || (aAttrNameAtom == nsLayoutAtoms::onbroadcast)
|| (aAttrNameAtom == nsLayoutAtoms::onclose) || (aAttrNameAtom == nsLayoutAtoms::oncontextmenu)
|| (aAttrNameAtom == nsLayoutAtoms::oncommand) || (aAttrNameAtom == nsLayoutAtoms::oncommandupdate)
|| (aAttrNameAtom == nsLayoutAtoms::ondragdrop) || (aAttrNameAtom == nsLayoutAtoms::ondragenter)
|| (aAttrNameAtom == nsLayoutAtoms::ondragexit) || (aAttrNameAtom == nsLayoutAtoms::ondraggesture)
|| (aAttrNameAtom == nsLayoutAtoms::ondragover) || (aAttrNameAtom == nsLayoutAtoms::oninput);
(aAttrNameAtom == nsGkAtoms::onblur) || (aAttrNameAtom == nsGkAtoms::onchange)
|| (aAttrNameAtom == nsGkAtoms::onclick) || (aAttrNameAtom == nsGkAtoms::ondblclick)
|| (aAttrNameAtom == nsGkAtoms::onfocus) || (aAttrNameAtom == nsGkAtoms::onkeydown)
|| (aAttrNameAtom == nsGkAtoms::onkeypress) || (aAttrNameAtom == nsGkAtoms::onkeyup)
|| (aAttrNameAtom == nsGkAtoms::onload) || (aAttrNameAtom == nsGkAtoms::onmousedown)
|| (aAttrNameAtom == nsGkAtoms::onpageshow) || (aAttrNameAtom == nsGkAtoms::onpagehide)
|| (aAttrNameAtom == nsGkAtoms::onmousemove) || (aAttrNameAtom == nsGkAtoms::onmouseout)
|| (aAttrNameAtom == nsGkAtoms::onmouseover) || (aAttrNameAtom == nsGkAtoms::onmouseup)
|| (aAttrNameAtom == nsGkAtoms::onreset) || (aAttrNameAtom == nsGkAtoms::onselect)
|| (aAttrNameAtom == nsGkAtoms::onsubmit) || (aAttrNameAtom == nsGkAtoms::onunload)
|| (aAttrNameAtom == nsGkAtoms::onabort) || (aAttrNameAtom == nsGkAtoms::onerror)
|| (aAttrNameAtom == nsGkAtoms::onpaint) || (aAttrNameAtom == nsGkAtoms::onresize)
|| (aAttrNameAtom == nsGkAtoms::onscroll) || (aAttrNameAtom == nsGkAtoms::onbroadcast)
|| (aAttrNameAtom == nsGkAtoms::onclose) || (aAttrNameAtom == nsGkAtoms::oncontextmenu)
|| (aAttrNameAtom == nsGkAtoms::oncommand) || (aAttrNameAtom == nsGkAtoms::oncommandupdate)
|| (aAttrNameAtom == nsGkAtoms::ondragdrop) || (aAttrNameAtom == nsGkAtoms::ondragenter)
|| (aAttrNameAtom == nsGkAtoms::ondragexit) || (aAttrNameAtom == nsGkAtoms::ondraggesture)
|| (aAttrNameAtom == nsGkAtoms::ondragover) || (aAttrNameAtom == nsGkAtoms::oninput);
return result;
}
@ -482,7 +481,7 @@ nsHTMLContentSerializer::EscapeURI(const nsAString& aURI, nsAString& aEscapedURI
{
// URL escape %xx cannot be used in JS.
// No escaping if the scheme is 'javascript'.
if (IsJavaScript(nsHTMLAtoms::href, aURI)) {
if (IsJavaScript(nsGkAtoms::href, aURI)) {
aEscapedURI = aURI;
return NS_OK;
}
@ -576,20 +575,20 @@ nsHTMLContentSerializer::SerializeAttributes(nsIContent* aContent,
// Filter out special case of <br type="_moz"> or <br _moz*>,
// used by the editor. Bug 16988. Yuck.
//
if (aTagName == nsHTMLAtoms::br && attrName == nsHTMLAtoms::type &&
if (aTagName == nsGkAtoms::br && attrName == nsGkAtoms::type &&
StringBeginsWith(valueStr, _mozStr)) {
continue;
}
if (mIsCopying && mIsFirstChildOfOL && (aTagName == nsHTMLAtoms::li) &&
(attrName == nsHTMLAtoms::value)){
if (mIsCopying && mIsFirstChildOfOL && (aTagName == nsGkAtoms::li) &&
(attrName == nsGkAtoms::value)){
// This is handled separately in SerializeLIValueAttribute()
continue;
}
PRBool isJS = IsJavaScript(attrName, valueStr);
if (((attrName == nsHTMLAtoms::href) ||
(attrName == nsHTMLAtoms::src))) {
if (((attrName == nsGkAtoms::href) ||
(attrName == nsGkAtoms::src))) {
// Make all links absolute when converting only the selection:
if (mFlags & nsIDocumentEncoder::OutputAbsoluteLinks) {
// Would be nice to handle OBJECT and APPLET tags,
@ -648,11 +647,11 @@ nsHTMLContentSerializer::AppendElementStart(nsIDOMElement *aElement,
// indicate that this element should be pretty printed
// even if we're not in pretty printing mode
PRBool hasDirtyAttr = content->HasAttr(kNameSpaceID_None,
nsLayoutAtoms::mozdirty);
nsGkAtoms::mozdirty);
nsIAtom *name = content->Tag();
if (name == nsHTMLAtoms::br && mPreLevel > 0
if (name == nsGkAtoms::br && mPreLevel > 0
&& (mFlags & nsIDocumentEncoder::OutputNoFormattingInPre)) {
AppendToString(mLineBreak, aStr);
mMayIgnoreLineBreakSequence = PR_TRUE;
@ -660,7 +659,7 @@ nsHTMLContentSerializer::AppendElementStart(nsIDOMElement *aElement,
return NS_OK;
}
if (name == nsHTMLAtoms::body) {
if (name == nsGkAtoms::body) {
mInBody = PR_TRUE;
}
@ -683,9 +682,9 @@ nsHTMLContentSerializer::AppendElementStart(nsIDOMElement *aElement,
StartIndentation(name, hasDirtyAttr, aStr);
if (name == nsHTMLAtoms::pre ||
name == nsHTMLAtoms::script ||
name == nsHTMLAtoms::style) {
if (name == nsGkAtoms::pre ||
name == nsGkAtoms::script ||
name == nsGkAtoms::style) {
mPreLevel++;
}
@ -697,7 +696,7 @@ nsHTMLContentSerializer::AppendElementStart(nsIDOMElement *aElement,
// Need to keep track of OL and LI elements in order to get ordinal number
// for the LI.
if (mIsCopying && name == nsHTMLAtoms::ol){
if (mIsCopying && name == nsGkAtoms::ol){
// We are copying and current node is an OL;
// Store it's start attribute value in olState->startVal.
nsAutoString start;
@ -719,7 +718,7 @@ nsHTMLContentSerializer::AppendElementStart(nsIDOMElement *aElement,
mOLStateStack.AppendElement(state);
}
if (mIsCopying && name == nsHTMLAtoms::li) {
if (mIsCopying && name == nsGkAtoms::li) {
mIsFirstChildOfOL = IsFirstChildOfOL(aOriginalElement);
if (mIsFirstChildOfOL){
// If OL is parent of this LI, serialize attributes in different manner.
@ -739,10 +738,10 @@ nsHTMLContentSerializer::AppendElementStart(nsIDOMElement *aElement,
mColPos = 0;
}
if (name == nsHTMLAtoms::script ||
name == nsHTMLAtoms::style ||
name == nsHTMLAtoms::noscript ||
name == nsHTMLAtoms::noframes) {
if (name == nsGkAtoms::script ||
name == nsGkAtoms::style ||
name == nsGkAtoms::noscript ||
name == nsGkAtoms::noframes) {
mInCDATA = PR_TRUE;
}
@ -759,11 +758,11 @@ nsHTMLContentSerializer::AppendElementEnd(nsIDOMElement *aElement,
if (!content) return NS_ERROR_FAILURE;
PRBool hasDirtyAttr = content->HasAttr(kNameSpaceID_None,
nsLayoutAtoms::mozdirty);
nsGkAtoms::mozdirty);
nsIAtom *name = content->Tag();
if (name == nsHTMLAtoms::script) {
if (name == nsGkAtoms::script) {
nsCOMPtr<nsIScriptElement> script = do_QueryInterface(aElement);
NS_ASSERTION(script, "What kind of weird script element is this?");
@ -775,13 +774,13 @@ nsHTMLContentSerializer::AppendElementEnd(nsIDOMElement *aElement,
}
}
if (name == nsHTMLAtoms::pre ||
name == nsHTMLAtoms::script ||
name == nsHTMLAtoms::style) {
if (name == nsGkAtoms::pre ||
name == nsGkAtoms::script ||
name == nsGkAtoms::style) {
mPreLevel--;
}
if (mIsCopying && (name == nsHTMLAtoms::ol)){
if (mIsCopying && (name == nsGkAtoms::ol)){
NS_ASSERTION((mOLStateStack.Count() > 0), "Cannot have an empty OL Stack");
/* Though at this point we must always have an state to be deleted as all
the OL opening tags are supposed to push an olState object to the stack*/
@ -794,7 +793,7 @@ nsHTMLContentSerializer::AppendElementEnd(nsIDOMElement *aElement,
nsIParserService* parserService = nsContentUtils::GetParserService();
if (parserService && (name != nsHTMLAtoms::style)) {
if (parserService && (name != nsGkAtoms::style)) {
PRBool isContainer;
parserService->IsContainer(parserService->HTMLAtomTagToId(name),
@ -1043,14 +1042,14 @@ nsHTMLContentSerializer::LineBreakBeforeOpen(nsIAtom* aName,
return PR_FALSE;
}
if (aName == nsHTMLAtoms::title ||
aName == nsHTMLAtoms::meta ||
aName == nsHTMLAtoms::link ||
aName == nsHTMLAtoms::style ||
aName == nsHTMLAtoms::select ||
aName == nsHTMLAtoms::option ||
aName == nsHTMLAtoms::script ||
aName == nsHTMLAtoms::html) {
if (aName == nsGkAtoms::title ||
aName == nsGkAtoms::meta ||
aName == nsGkAtoms::link ||
aName == nsGkAtoms::style ||
aName == nsGkAtoms::select ||
aName == nsGkAtoms::option ||
aName == nsGkAtoms::script ||
aName == nsGkAtoms::html) {
return PR_TRUE;
}
else {
@ -1075,23 +1074,23 @@ nsHTMLContentSerializer::LineBreakAfterOpen(nsIAtom* aName,
return PR_FALSE;
}
if ((aName == nsHTMLAtoms::html) ||
(aName == nsHTMLAtoms::head) ||
(aName == nsHTMLAtoms::body) ||
(aName == nsHTMLAtoms::ul) ||
(aName == nsHTMLAtoms::ol) ||
(aName == nsHTMLAtoms::dl) ||
(aName == nsHTMLAtoms::table) ||
(aName == nsHTMLAtoms::tbody) ||
(aName == nsHTMLAtoms::tr) ||
(aName == nsHTMLAtoms::br) ||
(aName == nsHTMLAtoms::meta) ||
(aName == nsHTMLAtoms::link) ||
(aName == nsHTMLAtoms::script) ||
(aName == nsHTMLAtoms::select) ||
(aName == nsHTMLAtoms::map) ||
(aName == nsHTMLAtoms::area) ||
(aName == nsHTMLAtoms::style)) {
if ((aName == nsGkAtoms::html) ||
(aName == nsGkAtoms::head) ||
(aName == nsGkAtoms::body) ||
(aName == nsGkAtoms::ul) ||
(aName == nsGkAtoms::ol) ||
(aName == nsGkAtoms::dl) ||
(aName == nsGkAtoms::table) ||
(aName == nsGkAtoms::tbody) ||
(aName == nsGkAtoms::tr) ||
(aName == nsGkAtoms::br) ||
(aName == nsGkAtoms::meta) ||
(aName == nsGkAtoms::link) ||
(aName == nsGkAtoms::script) ||
(aName == nsGkAtoms::select) ||
(aName == nsGkAtoms::map) ||
(aName == nsGkAtoms::area) ||
(aName == nsGkAtoms::style)) {
return PR_TRUE;
}
@ -1107,15 +1106,15 @@ nsHTMLContentSerializer::LineBreakBeforeClose(nsIAtom* aName,
return PR_FALSE;
}
if ((aName == nsHTMLAtoms::html) ||
(aName == nsHTMLAtoms::head) ||
(aName == nsHTMLAtoms::body) ||
(aName == nsHTMLAtoms::ul) ||
(aName == nsHTMLAtoms::ol) ||
(aName == nsHTMLAtoms::dl) ||
(aName == nsHTMLAtoms::select) ||
(aName == nsHTMLAtoms::table) ||
(aName == nsHTMLAtoms::tbody)) {
if ((aName == nsGkAtoms::html) ||
(aName == nsGkAtoms::head) ||
(aName == nsGkAtoms::body) ||
(aName == nsGkAtoms::ul) ||
(aName == nsGkAtoms::ol) ||
(aName == nsGkAtoms::dl) ||
(aName == nsGkAtoms::select) ||
(aName == nsGkAtoms::table) ||
(aName == nsGkAtoms::tbody)) {
return PR_TRUE;
}
@ -1131,23 +1130,23 @@ nsHTMLContentSerializer::LineBreakAfterClose(nsIAtom* aName,
return PR_FALSE;
}
if ((aName == nsHTMLAtoms::html) ||
(aName == nsHTMLAtoms::head) ||
(aName == nsHTMLAtoms::body) ||
(aName == nsHTMLAtoms::tr) ||
(aName == nsHTMLAtoms::th) ||
(aName == nsHTMLAtoms::td) ||
(aName == nsHTMLAtoms::pre) ||
(aName == nsHTMLAtoms::title) ||
(aName == nsHTMLAtoms::li) ||
(aName == nsHTMLAtoms::dt) ||
(aName == nsHTMLAtoms::dd) ||
(aName == nsHTMLAtoms::blockquote) ||
(aName == nsHTMLAtoms::select) ||
(aName == nsHTMLAtoms::option) ||
(aName == nsHTMLAtoms::p) ||
(aName == nsHTMLAtoms::map) ||
(aName == nsHTMLAtoms::div)) {
if ((aName == nsGkAtoms::html) ||
(aName == nsGkAtoms::head) ||
(aName == nsGkAtoms::body) ||
(aName == nsGkAtoms::tr) ||
(aName == nsGkAtoms::th) ||
(aName == nsGkAtoms::td) ||
(aName == nsGkAtoms::pre) ||
(aName == nsGkAtoms::title) ||
(aName == nsGkAtoms::li) ||
(aName == nsGkAtoms::dt) ||
(aName == nsGkAtoms::dd) ||
(aName == nsGkAtoms::blockquote) ||
(aName == nsGkAtoms::select) ||
(aName == nsGkAtoms::option) ||
(aName == nsGkAtoms::p) ||
(aName == nsGkAtoms::map) ||
(aName == nsGkAtoms::div)) {
return PR_TRUE;
}
else {
@ -1174,19 +1173,19 @@ nsHTMLContentSerializer::StartIndentation(nsIAtom* aName,
}
}
if ((aName == nsHTMLAtoms::head) ||
(aName == nsHTMLAtoms::table) ||
(aName == nsHTMLAtoms::tr) ||
(aName == nsHTMLAtoms::ul) ||
(aName == nsHTMLAtoms::ol) ||
(aName == nsHTMLAtoms::dl) ||
(aName == nsHTMLAtoms::tbody) ||
(aName == nsHTMLAtoms::form) ||
(aName == nsHTMLAtoms::frameset) ||
(aName == nsHTMLAtoms::blockquote) ||
(aName == nsHTMLAtoms::li) ||
(aName == nsHTMLAtoms::dt) ||
(aName == nsHTMLAtoms::dd)) {
if ((aName == nsGkAtoms::head) ||
(aName == nsGkAtoms::table) ||
(aName == nsGkAtoms::tr) ||
(aName == nsGkAtoms::ul) ||
(aName == nsGkAtoms::ol) ||
(aName == nsGkAtoms::dl) ||
(aName == nsGkAtoms::tbody) ||
(aName == nsGkAtoms::form) ||
(aName == nsGkAtoms::frameset) ||
(aName == nsGkAtoms::blockquote) ||
(aName == nsGkAtoms::li) ||
(aName == nsGkAtoms::dt) ||
(aName == nsGkAtoms::dd)) {
mIndent++;
}
}
@ -1196,19 +1195,19 @@ nsHTMLContentSerializer::EndIndentation(nsIAtom* aName,
PRBool aHasDirtyAttr,
nsAString& aStr)
{
if ((aName == nsHTMLAtoms::head) ||
(aName == nsHTMLAtoms::table) ||
(aName == nsHTMLAtoms::tr) ||
(aName == nsHTMLAtoms::ul) ||
(aName == nsHTMLAtoms::ol) ||
(aName == nsHTMLAtoms::dl) ||
(aName == nsHTMLAtoms::li) ||
(aName == nsHTMLAtoms::tbody) ||
(aName == nsHTMLAtoms::form) ||
(aName == nsHTMLAtoms::blockquote) ||
(aName == nsHTMLAtoms::dt) ||
(aName == nsHTMLAtoms::dd) ||
(aName == nsHTMLAtoms::frameset)) {
if ((aName == nsGkAtoms::head) ||
(aName == nsGkAtoms::table) ||
(aName == nsGkAtoms::tr) ||
(aName == nsGkAtoms::ul) ||
(aName == nsGkAtoms::ol) ||
(aName == nsGkAtoms::dl) ||
(aName == nsGkAtoms::li) ||
(aName == nsGkAtoms::tbody) ||
(aName == nsGkAtoms::form) ||
(aName == nsGkAtoms::blockquote) ||
(aName == nsGkAtoms::dt) ||
(aName == nsGkAtoms::dd) ||
(aName == nsGkAtoms::frameset)) {
mIndent--;
}

6
content/base/src/nsNodeInfoManager.cpp
Просмотреть файл

@ -268,7 +268,7 @@ already_AddRefed<nsINodeInfo>
nsNodeInfoManager::GetTextNodeInfo()
{
if (!mTextNodeInfo) {
GetNodeInfo(nsLayoutAtoms::textTagName, nsnull, kNameSpaceID_None,
GetNodeInfo(nsGkAtoms::textTagName, nsnull, kNameSpaceID_None,
&mTextNodeInfo);
}
else {
@ -282,7 +282,7 @@ already_AddRefed<nsINodeInfo>
nsNodeInfoManager::GetCommentNodeInfo()
{
if (!mCommentNodeInfo) {
GetNodeInfo(nsLayoutAtoms::commentTagName, nsnull, kNameSpaceID_None,
GetNodeInfo(nsGkAtoms::commentTagName, nsnull, kNameSpaceID_None,
&mCommentNodeInfo);
}
else {
@ -296,7 +296,7 @@ already_AddRefed<nsINodeInfo>
nsNodeInfoManager::GetDocumentNodeInfo()
{
if (!mDocumentNodeInfo) {
GetNodeInfo(nsLayoutAtoms::documentNodeName, nsnull, kNameSpaceID_None,
GetNodeInfo(nsGkAtoms::documentNodeName, nsnull, kNameSpaceID_None,
&mDocumentNodeInfo);
}
else {

13
content/base/src/nsObjectLoadingContent.cpp
Просмотреть файл

@ -71,7 +71,6 @@
#include "nsContentPolicyUtils.h"
#include "nsContentUtils.h"
#include "nsDocShellCID.h"
#include "nsHTMLAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsThreadUtils.h"
#include "nsNetUtil.h"
@ -898,7 +897,7 @@ nsObjectLoadingContent::LoadObject(nsIURI* aURI,
PRBool hasID = PR_FALSE;
if (caps & eSupportClassID) {
nsAutoString classid;
thisContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::classid, classid);
thisContent->GetAttr(kNameSpaceID_None, nsGkAtoms::classid, classid);
if (!classid.IsEmpty()) {
hasID = PR_TRUE;
isSupportedClassID = NS_SUCCEEDED(TypeForClassID(classid, typeForID));
@ -1270,7 +1269,7 @@ nsObjectLoadingContent::GetObjectBaseURI(nsIContent* thisContent, nsIURI** aURI)
// For plugins, the codebase attribute is the base URI
nsCOMPtr<nsIURI> baseURI = thisContent->GetBaseURI();
nsAutoString codebase;
thisContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::codebase,
thisContent->GetAttr(kNameSpaceID_None, nsGkAtoms::codebase,
codebase);
if (!codebase.IsEmpty()) {
nsContentUtils::NewURIWithDocumentCharset(aURI, codebase,
@ -1380,8 +1379,8 @@ nsObjectLoadingContent::GetPluginSupportState(nsIContent* aContent,
return ePluginOtherState;
}
if (aContent->Tag() == nsHTMLAtoms::embed ||
aContent->Tag() == nsHTMLAtoms::applet) {
if (aContent->Tag() == nsGkAtoms::embed ||
aContent->Tag() == nsGkAtoms::applet) {
return GetPluginDisabledState(aContentType);
}
@ -1392,8 +1391,8 @@ nsObjectLoadingContent::GetPluginSupportState(nsIContent* aContent,
NS_ASSERTION(child, "GetChildCount lied!");
if (child->IsNodeOfType(nsINode::eHTML) &&
child->Tag() == nsHTMLAtoms::param &&
child->AttrValueIs(kNameSpaceID_None, nsHTMLAtoms::name,
child->Tag() == nsGkAtoms::param &&
child->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name,
NS_LITERAL_STRING("pluginurl"), eIgnoreCase)) {
return GetPluginDisabledState(aContentType);
}

20
content/base/src/nsPlainTextSerializer.cpp
Просмотреть файл

@ -46,7 +46,7 @@
#include "nsPlainTextSerializer.h"
#include "nsLWBrkCIID.h"
#include "nsIServiceManager.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDOMText.h"
#include "nsIDOMCDATASection.h"
#include "nsIDOMElement.h"
@ -567,7 +567,7 @@ nsPlainTextSerializer::DoOpenContainer(const nsIParserNode* aNode, PRInt32 aTag)
// newlines before the text.
if (aTag == eHTMLTag_blockquote) {
nsAutoString value;
nsresult rv = GetAttributeValue(aNode, nsHTMLAtoms::type, value);
nsresult rv = GetAttributeValue(aNode, nsGkAtoms::type, value);
isInCiteBlockquote = NS_SUCCEEDED(rv) && value.EqualsIgnoreCase("cite");
}
@ -596,7 +596,7 @@ nsPlainTextSerializer::DoOpenContainer(const nsIParserNode* aNode, PRInt32 aTag)
// (which arguably we should only do if told to do so).
nsAutoString style;
PRInt32 whitespace;
if(NS_SUCCEEDED(GetAttributeValue(aNode, nsHTMLAtoms::style, style)) &&
if(NS_SUCCEEDED(GetAttributeValue(aNode, nsGkAtoms::style, style)) &&
(kNotFound != (whitespace = style.Find("white-space:")))) {
if (kNotFound != style.Find("-moz-pre-wrap", PR_TRUE, whitespace)) {
@ -694,7 +694,7 @@ nsPlainTextSerializer::DoOpenContainer(const nsIParserNode* aNode, PRInt32 aTag)
if (mOLStackIndex < OLStackSize) {
nsAutoString startAttr;
PRInt32 startVal = 1;
if(NS_SUCCEEDED(GetAttributeValue(aNode, nsHTMLAtoms::start, startAttr))){
if(NS_SUCCEEDED(GetAttributeValue(aNode, nsGkAtoms::start, startAttr))){
PRInt32 rv = 0;
startVal = startAttr.ToInteger(&rv);
if (NS_FAILED(rv))
@ -708,7 +708,7 @@ nsPlainTextSerializer::DoOpenContainer(const nsIParserNode* aNode, PRInt32 aTag)
if (mTagStackIndex > 1 && IsInOL()) {
if (mOLStackIndex > 0) {
nsAutoString valueAttr;
if(NS_SUCCEEDED(GetAttributeValue(aNode, nsHTMLAtoms::value, valueAttr))){
if(NS_SUCCEEDED(GetAttributeValue(aNode, nsGkAtoms::value, valueAttr))){
PRInt32 rv = 0;
PRInt32 valueAttrVal = valueAttr.ToInteger(&rv);
if (NS_SUCCEEDED(rv))
@ -815,7 +815,7 @@ nsPlainTextSerializer::DoOpenContainer(const nsIParserNode* aNode, PRInt32 aTag)
}
else if (type == eHTMLTag_a && !currentNodeIsConverted) {
nsAutoString url;
if (NS_SUCCEEDED(GetAttributeValue(aNode, nsHTMLAtoms::href, url))
if (NS_SUCCEEDED(GetAttributeValue(aNode, nsGkAtoms::href, url))
&& !url.IsEmpty()) {
mURL = url;
}
@ -1101,7 +1101,7 @@ nsPlainTextSerializer::DoAddLeaf(const nsIParserNode *aNode, PRInt32 aTag,
// Another egregious editor workaround, see bug 38194:
// ignore the bogus br tags that the editor sticks here and there.
nsAutoString typeAttr;
if (NS_FAILED(GetAttributeValue(aNode, nsHTMLAtoms::type, typeAttr))
if (NS_FAILED(GetAttributeValue(aNode, nsGkAtoms::type, typeAttr))
|| !typeAttr.EqualsLiteral("_moz")) {
EnsureVerticalSpace(mEmptyLines+1);
}
@ -1159,12 +1159,12 @@ nsPlainTextSerializer::DoAddLeaf(const nsIParserNode *aNode, PRInt32 aTag,
// See <http://www.w3.org/TR/REC-html40/struct/objects.html#edef-IMG>
nsAutoString imageDescription;
if (NS_SUCCEEDED(GetAttributeValue(aNode,
nsHTMLAtoms::alt,
nsGkAtoms::alt,
imageDescription))) {
// If the alt attribute has an empty value (|alt=""|), output nothing
}
else if (NS_SUCCEEDED(GetAttributeValue(aNode,
nsHTMLAtoms::title,
nsGkAtoms::title,
imageDescription))
&& !imageDescription.IsEmpty()) {
imageDescription = NS_LITERAL_STRING(" [") +
@ -1797,7 +1797,7 @@ PRBool
nsPlainTextSerializer::IsCurrentNodeConverted(const nsIParserNode* aNode)
{
nsAutoString value;
nsresult rv = GetAttributeValue(aNode, nsHTMLAtoms::_class, value);
nsresult rv = GetAttributeValue(aNode, nsGkAtoms::_class, value);
return (NS_SUCCEEDED(rv) &&
(value.EqualsIgnoreCase("moz-txt", 7) ||
value.EqualsIgnoreCase("\"moz-txt", 8)));

6
content/base/src/nsScriptLoader.cpp
Просмотреть файл

@ -48,7 +48,7 @@
#include "nsICharsetConverterManager.h"
#include "nsIUnicodeDecoder.h"
#include "nsIContent.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsNetUtil.h"
#include "nsIScriptGlobalObject.h"
#include "nsIScriptContext.h"
@ -190,8 +190,8 @@ IsScriptEventHandler(nsIScriptElement *aScriptElement)
NS_ASSERTION(contElement, "nsIScriptElement isn't nsIContent");
nsAutoString forAttr, eventAttr;
if (!contElement->GetAttr(kNameSpaceID_None, nsHTMLAtoms::_for, forAttr) ||
!contElement->GetAttr(kNameSpaceID_None, nsHTMLAtoms::event, eventAttr)) {
if (!contElement->GetAttr(kNameSpaceID_None, nsGkAtoms::_for, forAttr) ||
!contElement->GetAttr(kNameSpaceID_None, nsGkAtoms::event, eventAttr)) {
return PR_FALSE;
}

77
content/base/src/nsXMLContentSerializer.cpp
Просмотреть файл

@ -43,7 +43,7 @@
#include "nsXMLContentSerializer.h"
#include "nsHTMLAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsIDOMText.h"
#include "nsIDOMCDATASection.h"
#include "nsIDOMProcessingInstruction.h"
@ -60,7 +60,6 @@
#include "nsUnicharUtils.h"
#include "nsCRT.h"
#include "nsContentUtils.h"
#include "nsLayoutAtoms.h"
#include "nsAttrName.h"
typedef struct {
@ -619,7 +618,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::xmlns)) {
attrName == nsGkAtoms::xmlns)) {
content->GetAttr(namespaceID, attrName, uriStr);
if (!name->GetPrefix()) {
@ -875,86 +874,86 @@ nsXMLContentSerializer::IsShorthandAttr(const nsIAtom* aAttrName,
const nsIAtom* aElementName)
{
// checked
if ((aAttrName == nsHTMLAtoms::checked) &&
(aElementName == nsHTMLAtoms::input)) {
if ((aAttrName == nsGkAtoms::checked) &&
(aElementName == nsGkAtoms::input)) {
return PR_TRUE;
}
// compact
if ((aAttrName == nsHTMLAtoms::compact) &&
(aElementName == nsHTMLAtoms::dir ||
aElementName == nsHTMLAtoms::dl ||
aElementName == nsHTMLAtoms::menu ||
aElementName == nsHTMLAtoms::ol ||
aElementName == nsHTMLAtoms::ul)) {
if ((aAttrName == nsGkAtoms::compact) &&
(aElementName == nsGkAtoms::dir ||
aElementName == nsGkAtoms::dl ||
aElementName == nsGkAtoms::menu ||
aElementName == nsGkAtoms::ol ||
aElementName == nsGkAtoms::ul)) {
return PR_TRUE;
}
// declare
if ((aAttrName == nsHTMLAtoms::declare) &&
(aElementName == nsHTMLAtoms::object)) {
if ((aAttrName == nsGkAtoms::declare) &&
(aElementName == nsGkAtoms::object)) {
return PR_TRUE;
}
// defer
if ((aAttrName == nsHTMLAtoms::defer) &&
(aElementName == nsHTMLAtoms::script)) {
if ((aAttrName == nsGkAtoms::defer) &&
(aElementName == nsGkAtoms::script)) {
return PR_TRUE;
}
// disabled
if ((aAttrName == nsHTMLAtoms::disabled) &&
(aElementName == nsHTMLAtoms::button ||
aElementName == nsHTMLAtoms::input ||
aElementName == nsHTMLAtoms::optgroup ||
aElementName == nsHTMLAtoms::option ||
aElementName == nsHTMLAtoms::select ||
aElementName == nsHTMLAtoms::textarea)) {
if ((aAttrName == nsGkAtoms::disabled) &&
(aElementName == nsGkAtoms::button ||
aElementName == nsGkAtoms::input ||
aElementName == nsGkAtoms::optgroup ||
aElementName == nsGkAtoms::option ||
aElementName == nsGkAtoms::select ||
aElementName == nsGkAtoms::textarea)) {
return PR_TRUE;
}
// ismap
if ((aAttrName == nsHTMLAtoms::ismap) &&
(aElementName == nsHTMLAtoms::img ||
aElementName == nsHTMLAtoms::input)) {
if ((aAttrName == nsGkAtoms::ismap) &&
(aElementName == nsGkAtoms::img ||
aElementName == nsGkAtoms::input)) {
return PR_TRUE;
}
// multiple
if ((aAttrName == nsHTMLAtoms::multiple) &&
(aElementName == nsHTMLAtoms::select)) {
if ((aAttrName == nsGkAtoms::multiple) &&
(aElementName == nsGkAtoms::select)) {
return PR_TRUE;
}
// noresize
if ((aAttrName == nsHTMLAtoms::noresize) &&
(aElementName == nsHTMLAtoms::frame)) {
if ((aAttrName == nsGkAtoms::noresize) &&
(aElementName == nsGkAtoms::frame)) {
return PR_TRUE;
}
// noshade
if ((aAttrName == nsHTMLAtoms::noshade) &&
(aElementName == nsHTMLAtoms::hr)) {
if ((aAttrName == nsGkAtoms::noshade) &&
(aElementName == nsGkAtoms::hr)) {
return PR_TRUE;
}
// nowrap
if ((aAttrName == nsHTMLAtoms::nowrap) &&
(aElementName == nsHTMLAtoms::td ||
aElementName == nsHTMLAtoms::th)) {
if ((aAttrName == nsGkAtoms::nowrap) &&
(aElementName == nsGkAtoms::td ||
aElementName == nsGkAtoms::th)) {
return PR_TRUE;
}
// readonly
if ((aAttrName == nsHTMLAtoms::readonly) &&
(aElementName == nsHTMLAtoms::input ||
aElementName == nsHTMLAtoms::textarea)) {
if ((aAttrName == nsGkAtoms::readonly) &&
(aElementName == nsGkAtoms::input ||
aElementName == nsGkAtoms::textarea)) {
return PR_TRUE;
}
// selected
if ((aAttrName == nsHTMLAtoms::selected) &&
(aElementName == nsHTMLAtoms::option)) {
if ((aAttrName == nsGkAtoms::selected) &&
(aElementName == nsGkAtoms::option)) {
return PR_TRUE;
}

4
content/base/src/nsXMLNameSpaceMap.cpp
Просмотреть файл

@ -62,9 +62,9 @@ nsXMLNameSpaceMap::Create()
nsXMLNameSpaceMap *map = new nsXMLNameSpaceMap();
NS_ENSURE_TRUE(map, nsnull);
nsresult rv = map->AddPrefix(nsLayoutAtoms::xmlns,
nsresult rv = map->AddPrefix(nsGkAtoms::xmlns,
kNameSpaceID_XMLNS);
rv |= map->AddPrefix(nsLayoutAtoms::xml, kNameSpaceID_XML);
rv |= map->AddPrefix(nsGkAtoms::xml, kNameSpaceID_XML);
if (NS_FAILED(rv)) {
delete map;

86
content/events/src/nsDOMEvent.cpp
Просмотреть файл

@ -377,101 +377,101 @@ nsDOMEvent::SetEventType(const nsAString& aEventTypeArg)
mEvent->message = NS_USER_DEFINED_EVENT;
if (mEvent->eventStructType == NS_MOUSE_EVENT) {
if (atom == nsLayoutAtoms::onmousedown)
if (atom == nsGkAtoms::onmousedown)
mEvent->message = NS_MOUSE_BUTTON_DOWN;
else if (atom == nsLayoutAtoms::onmouseup)
else if (atom == nsGkAtoms::onmouseup)
mEvent->message = NS_MOUSE_BUTTON_UP;
else if (atom == nsLayoutAtoms::onclick)
else if (atom == nsGkAtoms::onclick)
mEvent->message = NS_MOUSE_CLICK;
else if (atom == nsLayoutAtoms::ondblclick)
else if (atom == nsGkAtoms::ondblclick)
mEvent->message = NS_MOUSE_DOUBLECLICK;
else if (atom == nsLayoutAtoms::onmouseover)
else if (atom == nsGkAtoms::onmouseover)
mEvent->message = NS_MOUSE_ENTER_SYNTH;
else if (atom == nsLayoutAtoms::onmouseout)
else if (atom == nsGkAtoms::onmouseout)
mEvent->message = NS_MOUSE_EXIT_SYNTH;
else if (atom == nsLayoutAtoms::onmousemove)
else if (atom == nsGkAtoms::onmousemove)
mEvent->message = NS_MOUSE_MOVE;
else if (atom == nsLayoutAtoms::oncontextmenu)
else if (atom == nsGkAtoms::oncontextmenu)
mEvent->message = NS_CONTEXTMENU;
} else if (mEvent->eventStructType == NS_KEY_EVENT) {
if (atom == nsLayoutAtoms::onkeydown)
if (atom == nsGkAtoms::onkeydown)
mEvent->message = NS_KEY_DOWN;
else if (atom == nsLayoutAtoms::onkeyup)
else if (atom == nsGkAtoms::onkeyup)
mEvent->message = NS_KEY_UP;
else if (atom == nsLayoutAtoms::onkeypress)
else if (atom == nsGkAtoms::onkeypress)
mEvent->message = NS_KEY_PRESS;
} else if (mEvent->eventStructType == NS_COMPOSITION_EVENT) {
if (atom == nsLayoutAtoms::oncompositionstart)
if (atom == nsGkAtoms::oncompositionstart)
mEvent->message = NS_COMPOSITION_START;
else if (atom == nsLayoutAtoms::oncompositionend)
else if (atom == nsGkAtoms::oncompositionend)
mEvent->message = NS_COMPOSITION_END;
} else if (mEvent->eventStructType == NS_EVENT) {
if (atom == nsLayoutAtoms::onfocus)
if (atom == nsGkAtoms::onfocus)
mEvent->message = NS_FOCUS_CONTENT;
else if (atom == nsLayoutAtoms::onblur)
else if (atom == nsGkAtoms::onblur)
mEvent->message = NS_BLUR_CONTENT;
else if (atom == nsLayoutAtoms::onsubmit)
else if (atom == nsGkAtoms::onsubmit)
mEvent->message = NS_FORM_SUBMIT;
else if (atom == nsLayoutAtoms::onreset)
else if (atom == nsGkAtoms::onreset)
mEvent->message = NS_FORM_RESET;
else if (atom == nsLayoutAtoms::onchange)
else if (atom == nsGkAtoms::onchange)
mEvent->message = NS_FORM_CHANGE;
else if (atom == nsLayoutAtoms::onselect)
else if (atom == nsGkAtoms::onselect)
mEvent->message = NS_FORM_SELECTED;
else if (atom == nsLayoutAtoms::onload)
else if (atom == nsGkAtoms::onload)
mEvent->message = NS_LOAD;
else if (atom == nsLayoutAtoms::onunload)
else if (atom == nsGkAtoms::onunload)
mEvent->message = NS_PAGE_UNLOAD;
else if (atom == nsLayoutAtoms::onabort)
else if (atom == nsGkAtoms::onabort)
mEvent->message = NS_IMAGE_ABORT;
else if (atom == nsLayoutAtoms::onerror)
else if (atom == nsGkAtoms::onerror)
mEvent->message = NS_LOAD_ERROR;
} else if (mEvent->eventStructType == NS_MUTATION_EVENT) {
if (atom == nsLayoutAtoms::onDOMAttrModified)
if (atom == nsGkAtoms::onDOMAttrModified)
mEvent->message = NS_MUTATION_ATTRMODIFIED;
else if (atom == nsLayoutAtoms::onDOMCharacterDataModified)
else if (atom == nsGkAtoms::onDOMCharacterDataModified)
mEvent->message = NS_MUTATION_CHARACTERDATAMODIFIED;
else if (atom == nsLayoutAtoms::onDOMNodeInserted)
else if (atom == nsGkAtoms::onDOMNodeInserted)
mEvent->message = NS_MUTATION_NODEINSERTED;
else if (atom == nsLayoutAtoms::onDOMNodeRemoved)
else if (atom == nsGkAtoms::onDOMNodeRemoved)
mEvent->message = NS_MUTATION_NODEREMOVED;
else if (atom == nsLayoutAtoms::onDOMNodeInsertedIntoDocument)
else if (atom == nsGkAtoms::onDOMNodeInsertedIntoDocument)
mEvent->message = NS_MUTATION_NODEINSERTEDINTODOCUMENT;
else if (atom == nsLayoutAtoms::onDOMNodeRemovedFromDocument)
else if (atom == nsGkAtoms::onDOMNodeRemovedFromDocument)
mEvent->message = NS_MUTATION_NODEREMOVEDFROMDOCUMENT;
else if (atom == nsLayoutAtoms::onDOMSubtreeModified)
else if (atom == nsGkAtoms::onDOMSubtreeModified)
mEvent->message = NS_MUTATION_SUBTREEMODIFIED;
} else if (mEvent->eventStructType == NS_UI_EVENT) {
if (atom == nsLayoutAtoms::onDOMActivate)
if (atom == nsGkAtoms::onDOMActivate)
mEvent->message = NS_UI_ACTIVATE;
else if (atom == nsLayoutAtoms::onDOMFocusIn)
else if (atom == nsGkAtoms::onDOMFocusIn)
mEvent->message = NS_UI_FOCUSIN;
else if (atom == nsLayoutAtoms::onDOMFocusOut)
else if (atom == nsGkAtoms::onDOMFocusOut)
mEvent->message = NS_UI_FOCUSOUT;
else if (atom == nsLayoutAtoms::oninput)
else if (atom == nsGkAtoms::oninput)
mEvent->message = NS_FORM_INPUT;
} else if (mEvent->eventStructType == NS_PAGETRANSITION_EVENT) {
if (atom == nsLayoutAtoms::onpageshow)
if (atom == nsGkAtoms::onpageshow)
mEvent->message = NS_PAGE_SHOW;
else if (atom == nsLayoutAtoms::onpagehide)
else if (atom == nsGkAtoms::onpagehide)
mEvent->message = NS_PAGE_HIDE;
}
#ifdef MOZ_SVG
else if (mEvent->eventStructType == NS_SVG_EVENT) {
if (atom == nsLayoutAtoms::onSVGLoad)
if (atom == nsGkAtoms::onSVGLoad)
mEvent->message = NS_SVG_LOAD;
else if (atom == nsLayoutAtoms::onSVGUnload)
else if (atom == nsGkAtoms::onSVGUnload)
mEvent->message = NS_SVG_UNLOAD;
else if (atom == nsLayoutAtoms::onSVGAbort)
else if (atom == nsGkAtoms::onSVGAbort)
mEvent->message = NS_SVG_ABORT;
else if (atom == nsLayoutAtoms::onSVGError)
else if (atom == nsGkAtoms::onSVGError)
mEvent->message = NS_SVG_ERROR;
else if (atom == nsLayoutAtoms::onSVGResize)
else if (atom == nsGkAtoms::onSVGResize)
mEvent->message = NS_SVG_RESIZE;
else if (atom == nsLayoutAtoms::onSVGScroll)
else if (atom == nsGkAtoms::onSVGScroll)
mEvent->message = NS_SVG_SCROLL;
} else if (mEvent->eventStructType == NS_SVGZOOM_EVENT) {
if (atom == nsLayoutAtoms::onSVGZoom)
if (atom == nsGkAtoms::onSVGZoom)
mEvent->message = NS_SVG_ZOOM;
}
#endif // MOZ_SVG

31
content/events/src/nsEventListenerManager.cpp
Просмотреть файл

@ -62,7 +62,7 @@
#ifdef MOZ_SVG
#include "nsIDOMSVGListener.h"
#include "nsIDOMSVGZoomListener.h"
#include "nsSVGAtoms.h"
#include "nsLayoutAtoms.h"
#endif // MOZ_SVG
#include "nsIEventStateManager.h"
#include "nsPIDOMWindow.h"
@ -71,7 +71,6 @@
#include "prmem.h"
#include "nsIScriptGlobalObject.h"
#include "nsIScriptRuntime.h"
#include "nsLayoutAtoms.h"
#include "nsLayoutUtils.h"
#ifdef MOZ_XUL
// XXXbz the fact that this is ifdef MOZ_XUL is good indication that
@ -1160,20 +1159,20 @@ nsEventListenerManager::CompileEventHandlerInternal(nsIScriptContext *aContext,
nsAutoString handlerBody;
nsIAtom* attrName = aName;
#ifdef MOZ_SVG
if (aName == nsLayoutAtoms::onSVGLoad)
attrName = nsSVGAtoms::onload;
else if (aName == nsLayoutAtoms::onSVGUnload)
attrName = nsSVGAtoms::onunload;
else if (aName == nsLayoutAtoms::onSVGAbort)
attrName = nsSVGAtoms::onabort;
else if (aName == nsLayoutAtoms::onSVGError)
attrName = nsSVGAtoms::onerror;
else if (aName == nsLayoutAtoms::onSVGResize)
attrName = nsSVGAtoms::onresize;
else if (aName == nsLayoutAtoms::onSVGScroll)
attrName = nsSVGAtoms::onscroll;
else if (aName == nsLayoutAtoms::onSVGZoom)
attrName = nsSVGAtoms::onzoom;
if (aName == nsGkAtoms::onSVGLoad)
attrName = nsGkAtoms::onload;
else if (aName == nsGkAtoms::onSVGUnload)
attrName = nsGkAtoms::onunload;
else if (aName == nsGkAtoms::onSVGAbort)
attrName = nsGkAtoms::onabort;
else if (aName == nsGkAtoms::onSVGError)
attrName = nsGkAtoms::onerror;
else if (aName == nsGkAtoms::onSVGResize)
attrName = nsGkAtoms::onresize;
else if (aName == nsGkAtoms::onSVGScroll)
attrName = nsGkAtoms::onscroll;
else if (aName == nsGkAtoms::onSVGZoom)
attrName = nsGkAtoms::onzoom;
#endif // MOZ_SVG
content->GetAttr(kNameSpaceID_None, attrName, handlerBody);

74
content/events/src/nsEventStateManager.cpp
Просмотреть файл

@ -55,7 +55,7 @@
#include "nsPresContext.h"
#include "nsIPresShell.h"
#include "nsDOMEvent.h"
#include "nsHTMLAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsIEditorDocShell.h"
#include "nsIFormControl.h"
#include "nsIComboboxControlFrame.h"
@ -98,7 +98,6 @@
#include "nsIChromeEventHandler.h"
#include "nsIFocusController.h"
#include "nsXULAtoms.h"
#include "nsIDOMXULElement.h"
#include "nsIDOMDocument.h"
#include "nsIDOMKeyEvent.h"
@ -121,7 +120,6 @@
#include "nsIFrameFrame.h"
#include "nsIFrameTraversal.h"
#include "nsLayoutAtoms.h"
#include "nsLayoutCID.h"
#include "nsLayoutUtils.h"
#include "nsIInterfaceRequestorUtils.h"
@ -1190,12 +1188,12 @@ nsEventStateManager::HandleAccessKey(nsPresContext* aPresContext,
// if it's a XUL element...
if (content->IsNodeOfType(nsINode::eXUL)) {
// find out what type of content node this is
if (content->Tag() == nsXULAtoms::label) {
if (content->Tag() == nsGkAtoms::label) {
// If anything fails, this will be null ...
nsCOMPtr<nsIDOMElement> element;
nsAutoString control;
content->GetAttr(kNameSpaceID_None, nsXULAtoms::control, control);
content->GetAttr(kNameSpaceID_None, nsGkAtoms::control, control);
if (!control.IsEmpty()) {
nsCOMPtr<nsIDOMDocument> domDocument =
do_QueryInterface(content->GetDocument());
@ -1229,10 +1227,10 @@ nsEventStateManager::HandleAccessKey(nsPresContext* aPresContext,
nsIAtom *atom = content->Tag();
// define behavior for each type of XUL element:
if (atom == nsXULAtoms::textbox || atom == nsXULAtoms::menulist) {
if (atom == nsGkAtoms::textbox || atom == nsGkAtoms::menulist) {
// if it's a text box or menulist, give it focus
element->Focus();
} else if (atom == nsXULAtoms::toolbarbutton) {
} else if (atom == nsGkAtoms::toolbarbutton) {
// if it's a toolbar button, just click
element->Click();
} else {
@ -1246,7 +1244,7 @@ nsEventStateManager::HandleAccessKey(nsPresContext* aPresContext,
// It's hard to say what HTML4 wants us to do in all cases.
// So for now we'll settle for A) Set focus (except for <label>s
// which focus their control in nsHTMLLabelElement::PostHandleEvent)
if (content->Tag() != nsHTMLAtoms::label || !sKeyCausesActivation) {
if (content->Tag() != nsGkAtoms::label || !sKeyCausesActivation) {
ChangeFocusWith(content, eEventFocusedByKey);
}
if (sKeyCausesActivation) {
@ -1383,11 +1381,11 @@ nsEventStateManager::CreateClickHoldTimer(nsPresContext* inPresContext,
if (mGestureDownContent) {
// check for the |popup| attribute
if (nsContentUtils::HasNonEmptyAttr(mGestureDownContent, kNameSpaceID_None,
nsXULAtoms::popup))
nsGkAtoms::popup))
return;
// check for a <menubutton> like bookmarks
if (mGestureDownContent->Tag() == nsXULAtoms::menubutton)
if (mGestureDownContent->Tag() == nsGkAtoms::menubutton)
return;
}
@ -1482,21 +1480,21 @@ nsEventStateManager::FireContextClick()
PRBool allowedToDispatch = PR_TRUE;
if (mGestureDownContent->IsNodeOfType(nsINode::eXUL)) {
if (tag == nsXULAtoms::scrollbar ||
tag == nsXULAtoms::scrollbarbutton ||
tag == nsXULAtoms::button)
if (tag == nsGkAtoms::scrollbar ||
tag == nsGkAtoms::scrollbarbutton ||
tag == nsGkAtoms::button)
allowedToDispatch = PR_FALSE;
else if (tag == nsXULAtoms::toolbarbutton) {
else if (tag == nsGkAtoms::toolbarbutton) {
// a <toolbarbutton> that has the container attribute set
// will already have its own dropdown.
if (nsContentUtils::HasNonEmptyAttr(mGestureDownContent,
kNameSpaceID_None, nsXULAtoms::container)) {
kNameSpaceID_None, nsGkAtoms::container)) {
allowedToDispatch = PR_FALSE;
} else {
// If the toolbar button has an open menu, don't attempt to open
// a second menu
if (mGestureDownContent->AttrValueIs(kNameSpaceID_None, nsXULAtoms::open,
nsXULAtoms::_true, eCaseMatters)) {
if (mGestureDownContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
nsGkAtoms::_true, eCaseMatters)) {
allowedToDispatch = PR_FALSE;
}
}
@ -1515,9 +1513,9 @@ nsEventStateManager::FireContextClick()
type == NS_FORM_INPUT_FILE ||
type == NS_FORM_TEXTAREA);
}
else if (tag == nsHTMLAtoms::applet ||
tag == nsHTMLAtoms::embed ||
tag == nsHTMLAtoms::object) {
else if (tag == nsGkAtoms::applet ||
tag == nsGkAtoms::embed ||
tag == nsGkAtoms::object) {
allowedToDispatch = PR_FALSE;
}
}
@ -3345,7 +3343,7 @@ nsEventStateManager::ShiftFocusInternal(PRBool aForward, nsIContent* aStart)
// point was given.
if (!aStart && itemType != nsIDocShellTreeItem::typeChrome) {
// We're going to tab from the selection position
if (!mCurrentFocus || (mLastFocusedWith != eEventFocusedByMouse && mCurrentFocus->Tag() != nsHTMLAtoms::area)) {
if (!mCurrentFocus || (mLastFocusedWith != eEventFocusedByMouse && mCurrentFocus->Tag() != nsGkAtoms::area)) {
nsCOMPtr<nsIContent> selectionContent, endSelectionContent; // We won't be using this, need arg for method call
PRUint32 selectionOffset; // We won't be using this either, need arg for method call
GetDocSelectionLocation(getter_AddRefs(selectionContent), getter_AddRefs(endSelectionContent), &selectionFrame, &selectionOffset);
@ -3387,7 +3385,7 @@ nsEventStateManager::ShiftFocusInternal(PRBool aForward, nsIContent* aStart)
}
if (aStart) {
if (aStart->HasAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex)) {
if (aStart->HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex)) {
aStart->IsFocusable(&mCurrentTabIndex);
} else {
ignoreTabIndex = PR_TRUE; // ignore current tabindex, bug 81481
@ -3646,7 +3644,7 @@ nsEventStateManager::GetNextTabbableContent(nsIContent* aRootContent,
PR_TRUE // aFollowOOFs
);
NS_ENSURE_SUCCESS(rv, rv);
if (!aStartContent || aStartContent->Tag() != nsHTMLAtoms::area ||
if (!aStartContent || aStartContent->Tag() != nsGkAtoms::area ||
!aStartContent->IsNodeOfType(nsINode::eHTML)) {
// Need to do special check in case we're in an imagemap which has multiple
// content per frame, so don't skip over the starting frame.
@ -3674,8 +3672,8 @@ nsEventStateManager::GetNextTabbableContent(nsIContent* aRootContent,
nsIContent* currentContent = (*aResultFrame)->GetContent();
(*aResultFrame)->IsFocusable(&tabIndex);
if (tabIndex >= 0) {
if (currentContent->Tag() == nsHTMLAtoms::img &&
currentContent->HasAttr(kNameSpaceID_None, nsHTMLAtoms::usemap)) {
if (currentContent->Tag() == nsGkAtoms::img &&
currentContent->HasAttr(kNameSpaceID_None, nsGkAtoms::usemap)) {
// Must be an image w/ a map -- it's tabbable but no tabindex is specified
// Special case for image maps: they don't get walked by nsIFrameTraversal
nsIContent *areaContent = GetNextTabbableMapArea(forward, currentContent);
@ -3712,7 +3710,7 @@ nsEventStateManager::GetNextTabbableMapArea(PRBool aForward,
nsIContent *aImageContent)
{
nsAutoString useMap;
aImageContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::usemap, useMap);
aImageContent->GetAttr(kNameSpaceID_None, nsGkAtoms::usemap, useMap);
nsCOMPtr<nsIDocument> doc = aImageContent->GetDocument();
if (doc) {
@ -3761,7 +3759,7 @@ nsEventStateManager::GetNextTabIndex(nsIContent* aParent, PRBool forward)
}
nsAutoString tabIndexStr;
child->GetAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex, tabIndexStr);
child->GetAttr(kNameSpaceID_None, nsGkAtoms::tabindex, tabIndexStr);
PRInt32 ec, val = tabIndexStr.ToInteger(&ec);
if (NS_SUCCEEDED (ec) && val > mCurrentTabIndex && val != tabIndex) {
tabIndex = (tabIndex == 0 || val < tabIndex) ? val : tabIndex;
@ -3779,7 +3777,7 @@ nsEventStateManager::GetNextTabIndex(nsIContent* aParent, PRBool forward)
}
nsAutoString tabIndexStr;
child->GetAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex, tabIndexStr);
child->GetAttr(kNameSpaceID_None, nsGkAtoms::tabindex, tabIndexStr);
PRInt32 ec, val = tabIndexStr.ToInteger(&ec);
if (NS_SUCCEEDED (ec)) {
if ((mCurrentTabIndex == 0 && val > tabIndex) ||
@ -4212,7 +4210,7 @@ IsFocusable(nsIPresShell* aPresShell, nsIContent* aContent)
return focusFrame->AreAncestorViewsVisible();
}
if (aContent->Tag() != nsHTMLAtoms::area) {
if (aContent->Tag() != nsGkAtoms::area) {
return focusFrame->IsFocusable();
}
// HTML areas do not have their own frame, and the img frame we get from
@ -4460,7 +4458,7 @@ nsEventStateManager::SendFocusBlur(nsPresContext* aPresContext,
}
nsAutoString tabIndex;
aContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex, tabIndex);
aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::tabindex, tabIndex);
PRInt32 ec, val = tabIndex.ToInteger(&ec);
if (NS_SUCCEEDED (ec)) {
mCurrentTabIndex = val;
@ -4785,7 +4783,7 @@ nsEventStateManager::GetDocSelectionLocation(nsIContent **aStartContent,
// points to (the current focus), not relative to the label itself.
nsIContent *parentContent = startContent;
while ((parentContent = parentContent->GetParent()) != nsnull) {
if (parentContent->Tag() == nsHTMLAtoms::label) {
if (parentContent->Tag() == nsGkAtoms::label) {
return NS_OK; // Don't return selection location, we're on a label
}
}
@ -4963,16 +4961,16 @@ nsEventStateManager::MoveFocusToCaret(PRBool aCanFocusDoc,
nsIAtom *tag = testContent->Tag();
// Add better focusable test here later if necessary ...
if (tag == nsHTMLAtoms::a &&
if (tag == nsGkAtoms::a &&
testContent->IsNodeOfType(nsINode::eHTML)) {
*aIsSelectionWithFocus = PR_TRUE;
}
else {
// Xlink must be type="simple"
*aIsSelectionWithFocus =
testContent->HasAttr(kNameSpaceID_XLink, nsHTMLAtoms::href) &&
testContent->AttrValueIs(kNameSpaceID_XLink, nsHTMLAtoms::type,
nsHTMLAtoms::simple, eCaseMatters);
testContent->HasAttr(kNameSpaceID_XLink, nsGkAtoms::href) &&
testContent->AttrValueIs(kNameSpaceID_XLink, nsGkAtoms::type,
nsGkAtoms::simple, eCaseMatters);
}
if (*aIsSelectionWithFocus) {
@ -5006,7 +5004,7 @@ nsEventStateManager::MoveFocusToCaret(PRBool aCanFocusDoc,
// Right now we only look for elements with the <a> tag.
// Add better focusable test here later if necessary ...
if (testContent) {
if (testContent->Tag() == nsHTMLAtoms::a &&
if (testContent->Tag() == nsGkAtoms::a &&
testContent->IsNodeOfType(nsINode::eHTML)) {
*aIsSelectionWithFocus = PR_TRUE;
FocusElementButNotDocument(testContent);
@ -5256,7 +5254,7 @@ nsEventStateManager::IsFrameSetDoc(nsIDocShell* aDocShell)
nsINodeInfo *ni = childContent->NodeInfo();
if (childContent->IsNodeOfType(nsINode::eHTML) &&
ni->Equals(nsHTMLAtoms::frameset)) {
ni->Equals(nsGkAtoms::frameset)) {
isFrameSet = PR_TRUE;
break;
}
@ -5289,7 +5287,7 @@ nsEventStateManager::IsIFrameDoc(nsIDocShell* aDocShell)
return PR_FALSE;
}
return docContent->Tag() == nsHTMLAtoms::iframe;
return docContent->Tag() == nsGkAtoms::iframe;
}
//-------------------------------------------------------

10
content/events/src/nsXMLEventsElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsXMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDocument.h"
class nsXMLEventsElement : public nsXMLElement {
@ -65,8 +65,8 @@ nsXMLEventsElement::~nsXMLEventsElement()
nsIAtom *
nsXMLEventsElement::GetIDAttributeName() const
{
if (mNodeInfo->Equals(nsHTMLAtoms::listener))
return nsHTMLAtoms::id;
if (mNodeInfo->Equals(nsGkAtoms::listener))
return nsGkAtoms::id;
return nsXMLElement::GetIDAttributeName();
}
@ -74,9 +74,9 @@ nsresult
nsXMLEventsElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsIAtom* aPrefix,
const nsAString& aValue, PRBool aNotify)
{
if (mNodeInfo->Equals(nsHTMLAtoms::listener) &&
if (mNodeInfo->Equals(nsGkAtoms::listener) &&
mNodeInfo->GetDocument() && aNameSpaceID == kNameSpaceID_None &&
aName == nsHTMLAtoms::event)
aName == nsGkAtoms::event)
mNodeInfo->GetDocument()->AddXMLEventsContent(this);
return nsXMLElement::SetAttr(aNameSpaceID, aName, aPrefix, aValue,
aNotify);

39
content/events/src/nsXMLEventsManager.cpp
Просмотреть файл

@ -38,7 +38,7 @@
#include "nsIDOMMutationEvent.h"
#include "nsXMLEventsManager.h"
#include "nsHTMLAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsIDOMElement.h"
#include "nsIDOMDocument.h"
#include "nsIDOMEventReceiver.h"
@ -47,7 +47,6 @@
#include "nsIDOMEventListener.h"
#include "nsINameSpaceManager.h"
#include "nsINodeInfo.h"
#include "nsLayoutAtoms.h"
PRBool nsXMLEventsListener::InitXMLEventsListener(nsIDocument * aDocument,
nsXMLEventsManager * aManager,
@ -57,13 +56,13 @@ PRBool nsXMLEventsListener::InitXMLEventsListener(nsIDocument * aDocument,
PRInt32 nameSpaceID;
if (aContent->GetDocument() != aDocument)
return PR_FALSE;
if (aContent->NodeInfo()->Equals(nsHTMLAtoms::listener,
if (aContent->NodeInfo()->Equals(nsGkAtoms::listener,
kNameSpaceID_XMLEvents))
nameSpaceID = kNameSpaceID_None;
else
nameSpaceID = kNameSpaceID_XMLEvents;
nsAutoString eventType;
aContent->GetAttr(nameSpaceID, nsHTMLAtoms::event, eventType);
aContent->GetAttr(nameSpaceID, nsGkAtoms::event, eventType);
if (eventType.IsEmpty())
return PR_FALSE;
nsAutoString handlerURIStr;
@ -72,7 +71,7 @@ PRBool nsXMLEventsListener::InitXMLEventsListener(nsIDocument * aDocument,
nsAutoString observerID;
nsAutoString targetIdref;
if (aContent->GetAttr(nameSpaceID, nsHTMLAtoms::handler, handlerURIStr)) {
if (aContent->GetAttr(nameSpaceID, nsGkAtoms::handler, handlerURIStr)) {
hasHandlerURI = PR_TRUE;
nsCAutoString handlerRef;
nsCOMPtr<nsIURI> handlerURI;
@ -104,22 +103,22 @@ PRBool nsXMLEventsListener::InitXMLEventsListener(nsIDocument * aDocument,
if (!handler)
return PR_FALSE;
aContent->GetAttr(nameSpaceID, nsHTMLAtoms::target, targetIdref);
aContent->GetAttr(nameSpaceID, nsGkAtoms::target, targetIdref);
PRBool hasObserver =
aContent->GetAttr(nameSpaceID, nsHTMLAtoms::observer, observerID);
aContent->GetAttr(nameSpaceID, nsGkAtoms::observer, observerID);
PRBool capture =
aContent->AttrValueIs(nameSpaceID, nsHTMLAtoms::phase,
nsLayoutAtoms::capture, eCaseMatters);
aContent->AttrValueIs(nameSpaceID, nsGkAtoms::phase,
nsGkAtoms::capture, eCaseMatters);
PRBool stopPropagation =
aContent->AttrValueIs(nameSpaceID, nsHTMLAtoms::propagate,
nsLayoutAtoms::stop, eCaseMatters);
aContent->AttrValueIs(nameSpaceID, nsGkAtoms::propagate,
nsGkAtoms::stop, eCaseMatters);
PRBool cancelDefault =
aContent->AttrValueIs(nameSpaceID, nsHTMLAtoms::defaultAction,
nsLayoutAtoms::cancel, eCaseMatters);
aContent->AttrValueIs(nameSpaceID, nsGkAtoms::defaultAction,
nsGkAtoms::cancel, eCaseMatters);
nsCOMPtr<nsIContent> observer;
if (!hasObserver) {
@ -360,18 +359,18 @@ nsXMLEventsManager::AttributeChanged(nsIDocument* aDocument,
PRInt32 aModType)
{
if (aNameSpaceID == kNameSpaceID_XMLEvents &&
(aAttribute == nsHTMLAtoms::event ||
aAttribute == nsHTMLAtoms::handler ||
aAttribute == nsHTMLAtoms::target ||
aAttribute == nsHTMLAtoms::observer ||
aAttribute == nsHTMLAtoms::phase ||
aAttribute == nsHTMLAtoms::propagate)) {
(aAttribute == nsGkAtoms::event ||
aAttribute == nsGkAtoms::handler ||
aAttribute == nsGkAtoms::target ||
aAttribute == nsGkAtoms::observer ||
aAttribute == nsGkAtoms::phase ||
aAttribute == nsGkAtoms::propagate)) {
RemoveListener(aContent);
AddXMLEventsContent(aContent);
nsXMLEventsListener::InitXMLEventsListener(aDocument, this, aContent);
}
else {
if (aContent->NodeInfo()->Equals(nsHTMLAtoms::listener,
if (aContent->NodeInfo()->Equals(nsGkAtoms::listener,
kNameSpaceID_XMLEvents)) {
RemoveListener(aContent);
AddXMLEventsContent(aContent);

12
content/html/content/src/nsFormSubmission.cpp
Просмотреть файл

@ -43,7 +43,7 @@
#include "nsIForm.h"
#include "nsILinkHandler.h"
#include "nsIDocument.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsIHTMLDocument.h"
#include "nsIFormControl.h"
#include "nsIDOMHTMLFormElement.h"
@ -199,7 +199,7 @@ public:
/**
* Get an attribute of a form as int, provided that it is an enumerated value.
* @param aForm the form in question
* @param aAtom the attribute (for example, nsHTMLAtoms::enctype) to get
* @param aAtom the attribute (for example, nsGkAtoms::enctype) to get
* @param aValue the result (will not be set at all if the attribute does not
* exist on the form, so *make sure you provide a default value*.)
* [OUT]
@ -1147,11 +1147,11 @@ GetSubmissionFromForm(nsGenericHTMLElement* aForm,
// Get encoding type (default: urlencoded)
PRInt32 enctype = NS_FORM_ENCTYPE_URLENCODED;
nsFormSubmission::GetEnumAttr(aForm, nsHTMLAtoms::enctype, &enctype);
nsFormSubmission::GetEnumAttr(aForm, nsGkAtoms::enctype, &enctype);
// Get method (default: GET)
PRInt32 method = NS_FORM_METHOD_GET;
nsFormSubmission::GetEnumAttr(aForm, nsHTMLAtoms::method, &method);
nsFormSubmission::GetEnumAttr(aForm, nsGkAtoms::method, &method);
// Get charset
nsCAutoString charset;
@ -1185,7 +1185,7 @@ GetSubmissionFromForm(nsGenericHTMLElement* aForm,
if (enctype == NS_FORM_ENCTYPE_MULTIPART ||
enctype == NS_FORM_ENCTYPE_TEXTPLAIN) {
nsAutoString enctypeStr;
aForm->GetAttr(kNameSpaceID_None, nsHTMLAtoms::enctype, enctypeStr);
aForm->GetAttr(kNameSpaceID_None, nsGkAtoms::enctype, enctypeStr);
SendJSWarning(aForm, "ForgotPostWarning", PromiseFlatString(enctypeStr));
}
*aFormSubmission = new nsFSURLEncoded(charset, encoder,
@ -1239,7 +1239,7 @@ nsFormSubmission::GetSubmitCharset(nsGenericHTMLElement* aForm,
nsresult rv = NS_OK;
nsAutoString acceptCharsetValue;
aForm->GetAttr(kNameSpaceID_None, nsHTMLAtoms::acceptcharset,
aForm->GetAttr(kNameSpaceID_None, nsGkAtoms::acceptcharset,
acceptCharsetValue);
PRInt32 charsetLen = acceptCharsetValue.Length();

268
content/html/content/src/nsGenericHTMLElement.cpp
Просмотреть файл

@ -99,7 +99,6 @@
#include "nsReadableUtils.h"
#include "nsUnicharUtils.h"
#include "nsLayoutAtoms.h"
#include "nsHTMLAtoms.h"
#include "nsIEventStateManager.h"
#include "nsIDOMEvent.h"
#include "nsIDOMNSEvent.h"
@ -125,7 +124,6 @@
#include "nsRuleWalker.h"
#include "nsIObjectFrame.h"
#include "nsLayoutAtoms.h"
#include "xptinfo.h"
#include "nsIInterfaceInfoManager.h"
#include "nsIServiceManager.h"
@ -284,7 +282,7 @@ nsGenericHTMLElement::CopyInnerTo(nsGenericElement* aDst) const
for (i = 0; i < count; ++i) {
const nsAttrName *name = mAttrsAndChildren.AttrNameAt(i);
const nsAttrValue *value = mAttrsAndChildren.AttrAt(i);
if (name->Equals(nsHTMLAtoms::style, kNameSpaceID_None) &&
if (name->Equals(nsGkAtoms::style, kNameSpaceID_None) &&
value->Type() == nsAttrValue::eCSSStyleRule) {
// We can't just set this as a string, because that will fail
// to reparse the string into style data until the node is
@ -311,15 +309,15 @@ nsGenericHTMLElement::CopyInnerTo(nsGenericElement* aDst) const
// Copy the baseuri and basetarget
void* prop;
if ((prop = GetProperty(nsHTMLAtoms::htmlBaseHref))) {
rv = aDst->SetProperty(nsHTMLAtoms::htmlBaseHref, prop,
if ((prop = GetProperty(nsGkAtoms::htmlBaseHref))) {
rv = aDst->SetProperty(nsGkAtoms::htmlBaseHref, prop,
nsPropertyTable::SupportsDtorFunc, PR_TRUE);
if (NS_SUCCEEDED(rv)) {
NS_ADDREF(NS_STATIC_CAST(nsIURI*, prop));
}
}
if ((prop = GetProperty(nsHTMLAtoms::htmlBaseTarget))) {
rv = aDst->SetProperty(nsHTMLAtoms::htmlBaseTarget, prop,
if ((prop = GetProperty(nsGkAtoms::htmlBaseTarget))) {
rv = aDst->SetProperty(nsGkAtoms::htmlBaseTarget, prop,
nsPropertyTable::SupportsDtorFunc, PR_TRUE);
if (NS_SUCCEEDED(rv)) {
NS_ADDREF(NS_STATIC_CAST(nsIAtom*, prop));
@ -423,42 +421,42 @@ nsGenericHTMLElement::GetElementsByTagNameNS(const nsAString& aNamespaceURI,
nsresult
nsGenericHTMLElement::GetId(nsAString& aId)
{
GetAttr(kNameSpaceID_None, nsHTMLAtoms::id, aId);
GetAttr(kNameSpaceID_None, nsGkAtoms::id, aId);
return NS_OK;
}
nsresult
nsGenericHTMLElement::SetId(const nsAString& aId)
{
SetAttr(kNameSpaceID_None, nsHTMLAtoms::id, aId, PR_TRUE);
SetAttr(kNameSpaceID_None, nsGkAtoms::id, aId, PR_TRUE);
return NS_OK;
}
nsresult
nsGenericHTMLElement::GetTitle(nsAString& aTitle)
{
GetAttr(kNameSpaceID_None, nsHTMLAtoms::title, aTitle);
GetAttr(kNameSpaceID_None, nsGkAtoms::title, aTitle);
return NS_OK;
}
nsresult
nsGenericHTMLElement::SetTitle(const nsAString& aTitle)
{
SetAttr(kNameSpaceID_None, nsHTMLAtoms::title, aTitle, PR_TRUE);
SetAttr(kNameSpaceID_None, nsGkAtoms::title, aTitle, PR_TRUE);
return NS_OK;
}
nsresult
nsGenericHTMLElement::GetLang(nsAString& aLang)
{
GetAttr(kNameSpaceID_None, nsHTMLAtoms::lang, aLang);
GetAttr(kNameSpaceID_None, nsGkAtoms::lang, aLang);
return NS_OK;
}
nsresult
nsGenericHTMLElement::SetLang(const nsAString& aLang)
{
SetAttr(kNameSpaceID_None, nsHTMLAtoms::lang, aLang, PR_TRUE);
SetAttr(kNameSpaceID_None, nsGkAtoms::lang, aLang, PR_TRUE);
return NS_OK;
}
@ -471,7 +469,7 @@ static const nsAttrValue::EnumTable kDirTable[] = {
nsresult
nsGenericHTMLElement::GetDir(nsAString& aDir)
{
const nsAttrValue* attr = mAttrsAndChildren.GetAttr(nsHTMLAtoms::dir);
const nsAttrValue* attr = mAttrsAndChildren.GetAttr(nsGkAtoms::dir);
if (attr && attr->Type() == nsAttrValue::eEnum) {
attr->ToString(aDir);
@ -486,21 +484,21 @@ nsGenericHTMLElement::GetDir(nsAString& aDir)
nsresult
nsGenericHTMLElement::SetDir(const nsAString& aDir)
{
SetAttr(kNameSpaceID_None, nsHTMLAtoms::dir, aDir, PR_TRUE);
SetAttr(kNameSpaceID_None, nsGkAtoms::dir, aDir, PR_TRUE);
return NS_OK;
}
nsresult
nsGenericHTMLElement::GetClassName(nsAString& aClassName)
{
GetAttr(kNameSpaceID_None, nsHTMLAtoms::_class, aClassName);
GetAttr(kNameSpaceID_None, nsGkAtoms::_class, aClassName);
return NS_OK;
}
nsresult
nsGenericHTMLElement::SetClassName(const nsAString& aClassName)
{
SetAttr(kNameSpaceID_None, nsHTMLAtoms::_class, aClassName, PR_TRUE);
SetAttr(kNameSpaceID_None, nsGkAtoms::_class, aClassName, PR_TRUE);
return NS_OK;
}
@ -557,7 +555,7 @@ nsGenericHTMLElement::RecreateFrames()
static PRBool
IsBody(nsIContent *aContent)
{
return (aContent->NodeInfo()->Equals(nsHTMLAtoms::body) &&
return (aContent->NodeInfo()->Equals(nsGkAtoms::body) &&
aContent->IsNodeOfType(nsINode::eHTML));
}
@ -566,9 +564,9 @@ IsOffsetParent(nsIContent *aContent)
{
nsINodeInfo *ni = aContent->NodeInfo();
return ((ni->Equals(nsHTMLAtoms::td) ||
ni->Equals(nsHTMLAtoms::table) ||
ni->Equals(nsHTMLAtoms::th)) &&
return ((ni->Equals(nsGkAtoms::td) ||
ni->Equals(nsGkAtoms::table) ||
ni->Equals(nsGkAtoms::th)) &&
aContent->IsNodeOfType(nsINode::eHTML));
}
@ -975,8 +973,8 @@ nsGenericHTMLElement::GetScrollInfo(nsIScrollableView **aScrollableView,
}
PRBool quirksMode = InNavQuirksMode(document);
if ((quirksMode && mNodeInfo->Equals(nsHTMLAtoms::body)) ||
(!quirksMode && mNodeInfo->Equals(nsHTMLAtoms::html))) {
if ((quirksMode && mNodeInfo->Equals(nsGkAtoms::body)) ||
(!quirksMode && mNodeInfo->Equals(nsGkAtoms::html))) {
// In quirks mode, the scroll info for the body element should map to the
// scroll info for the nearest scrollable frame above the body element
// (i.e. the root scrollable frame). This is what IE6 does in quirks
@ -1254,9 +1252,9 @@ nsGenericHTMLElement::GetSpellcheck(PRBool* aSpellcheck)
for (node = this; node; node = node->GetNodeParent()) {
if (node->IsNodeOfType(nsINode::eHTML)) {
static nsIContent::AttrValuesArray strings[] =
{&nsHTMLAtoms::_true, &nsHTMLAtoms::_false, nsnull};
{&nsGkAtoms::_true, &nsGkAtoms::_false, nsnull};
switch (NS_STATIC_CAST(nsIContent*, node)->
FindAttrValueIn(kNameSpaceID_None, nsHTMLAtoms::spellcheck,
FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::spellcheck,
strings, eCaseMatters)) {
case 0: // spellcheck = "true"
*aSpellcheck = PR_TRUE;
@ -1322,10 +1320,10 @@ NS_IMETHODIMP
nsGenericHTMLElement::SetSpellcheck(PRBool aSpellcheck)
{
if (aSpellcheck) {
return SetAttrHelper(nsHTMLAtoms::spellcheck, NS_LITERAL_STRING("true"));
return SetAttrHelper(nsGkAtoms::spellcheck, NS_LITERAL_STRING("true"));
}
return SetAttrHelper(nsHTMLAtoms::spellcheck, NS_LITERAL_STRING("false"));
return SetAttrHelper(nsGkAtoms::spellcheck, NS_LITERAL_STRING("false"));
}
PRBool
@ -1366,7 +1364,7 @@ nsGenericHTMLElement::FindForm(nsIForm* aCurrentForm)
nsIContent* content = this;
while (content) {
// If the current ancestor is a form, return it as our form
if (content->Tag() == nsHTMLAtoms::form &&
if (content->Tag() == nsGkAtoms::form &&
content->IsNodeOfType(nsINode::eHTML)) {
nsIDOMHTMLFormElement* form;
CallQueryInterface(content, &form);
@ -1419,7 +1417,7 @@ nsGenericHTMLElement::FindForm(nsIForm* aCurrentForm)
static PRBool
IsArea(nsIContent *aContent)
{
return (aContent->Tag() == nsHTMLAtoms::area &&
return (aContent->Tag() == nsGkAtoms::area &&
aContent->IsNodeOfType(nsINode::eHTML));
}
@ -1528,7 +1526,7 @@ nsGenericHTMLElement::PostHandleEventForAnchors(nsEventChainPostVisitor& aVisito
case NS_UI_ACTIVATE:
{
nsAutoString target;
GetAttr(kNameSpaceID_None, nsHTMLAtoms::target, target);
GetAttr(kNameSpaceID_None, nsGkAtoms::target, target);
if (target.IsEmpty()) {
GetBaseTarget(target);
}
@ -1558,7 +1556,7 @@ nsGenericHTMLElement::PostHandleEventForAnchors(nsEventChainPostVisitor& aVisito
case NS_FOCUS_CONTENT:
{
nsAutoString target;
GetAttr(kNameSpaceID_None, nsHTMLAtoms::target, target);
GetAttr(kNameSpaceID_None, nsGkAtoms::target, target);
if (target.IsEmpty()) {
GetBaseTarget(target);
}
@ -1593,7 +1591,7 @@ nsGenericHTMLElement::GetHrefURIForAnchors(nsIURI** aURI)
// Get href= attribute (relative URI).
// We use the nsAttrValue's copy of the URI string to avoid copying.
const nsAttrValue* attr = mAttrsAndChildren.GetAttr(nsHTMLAtoms::href);
const nsAttrValue* attr = mAttrsAndChildren.GetAttr(nsGkAtoms::href);
if (attr) {
// Get base URI.
nsCOMPtr<nsIURI> baseURI = GetBaseURI();
@ -1624,44 +1622,44 @@ PRBool nsGenericHTMLElement::IsEventName(nsIAtom* aName)
return PR_FALSE;
}
return (aName == nsLayoutAtoms::onclick ||
aName == nsLayoutAtoms::ondblclick ||
aName == nsLayoutAtoms::onmousedown ||
aName == nsLayoutAtoms::onmouseup ||
aName == nsLayoutAtoms::onmouseover ||
aName == nsLayoutAtoms::onmouseout ||
aName == nsLayoutAtoms::onkeydown ||
aName == nsLayoutAtoms::onkeyup ||
aName == nsLayoutAtoms::onkeypress ||
aName == nsLayoutAtoms::onmousemove ||
aName == nsLayoutAtoms::onload ||
aName == nsLayoutAtoms::onunload ||
aName == nsLayoutAtoms::onbeforeunload ||
aName == nsLayoutAtoms::onpageshow ||
aName == nsLayoutAtoms::onpagehide ||
aName == nsLayoutAtoms::onabort ||
aName == nsLayoutAtoms::onerror ||
aName == nsLayoutAtoms::onfocus ||
aName == nsLayoutAtoms::onblur ||
aName == nsLayoutAtoms::onsubmit ||
aName == nsLayoutAtoms::onreset ||
aName == nsLayoutAtoms::onchange ||
aName == nsLayoutAtoms::onselect ||
aName == nsLayoutAtoms::onpaint ||
aName == nsLayoutAtoms::onresize ||
aName == nsLayoutAtoms::onscroll ||
aName == nsLayoutAtoms::oninput ||
aName == nsLayoutAtoms::oncontextmenu ||
aName == nsLayoutAtoms::onDOMAttrModified ||
aName == nsLayoutAtoms::onDOMCharacterDataModified ||
aName == nsLayoutAtoms::onDOMSubtreeModified ||
aName == nsLayoutAtoms::onDOMNodeInsertedIntoDocument ||
aName == nsLayoutAtoms::onDOMNodeRemovedFromDocument ||
aName == nsLayoutAtoms::onDOMNodeInserted ||
aName == nsLayoutAtoms::onDOMNodeRemoved ||
aName == nsLayoutAtoms::onDOMActivate ||
aName == nsLayoutAtoms::onDOMFocusIn ||
aName == nsLayoutAtoms::onDOMFocusOut);
return (aName == nsGkAtoms::onclick ||
aName == nsGkAtoms::ondblclick ||
aName == nsGkAtoms::onmousedown ||
aName == nsGkAtoms::onmouseup ||
aName == nsGkAtoms::onmouseover ||
aName == nsGkAtoms::onmouseout ||
aName == nsGkAtoms::onkeydown ||
aName == nsGkAtoms::onkeyup ||
aName == nsGkAtoms::onkeypress ||
aName == nsGkAtoms::onmousemove ||
aName == nsGkAtoms::onload ||
aName == nsGkAtoms::onunload ||
aName == nsGkAtoms::onbeforeunload ||
aName == nsGkAtoms::onpageshow ||
aName == nsGkAtoms::onpagehide ||
aName == nsGkAtoms::onabort ||
aName == nsGkAtoms::onerror ||
aName == nsGkAtoms::onfocus ||
aName == nsGkAtoms::onblur ||
aName == nsGkAtoms::onsubmit ||
aName == nsGkAtoms::onreset ||
aName == nsGkAtoms::onchange ||
aName == nsGkAtoms::onselect ||
aName == nsGkAtoms::onpaint ||
aName == nsGkAtoms::onresize ||
aName == nsGkAtoms::onscroll ||
aName == nsGkAtoms::oninput ||
aName == nsGkAtoms::oncontextmenu ||
aName == nsGkAtoms::onDOMAttrModified ||
aName == nsGkAtoms::onDOMCharacterDataModified ||
aName == nsGkAtoms::onDOMSubtreeModified ||
aName == nsGkAtoms::onDOMNodeInsertedIntoDocument ||
aName == nsGkAtoms::onDOMNodeRemovedFromDocument ||
aName == nsGkAtoms::onDOMNodeInserted ||
aName == nsGkAtoms::onDOMNodeRemoved ||
aName == nsGkAtoms::onDOMActivate ||
aName == nsGkAtoms::onDOMFocusIn ||
aName == nsGkAtoms::onDOMFocusOut);
}
nsresult
@ -1673,7 +1671,7 @@ nsGenericHTMLElement::AfterSetAttr(PRInt32 aNamespaceID, nsIAtom* aName,
nsresult rv = AddScriptEventListener(aName, *aValue);
NS_ENSURE_SUCCESS(rv, rv);
}
else if (aNotify && aName == nsHTMLAtoms::spellcheck) {
else if (aNotify && aName == nsGkAtoms::spellcheck) {
SyncEditorsOnSubtree(this);
}
}
@ -1688,8 +1686,8 @@ nsGenericHTMLElement::GetEventListenerManagerForAttr(nsIEventListenerManager** a
PRBool* aDefer)
{
// Attributes on the body and frameset tags get set on the global object
if (mNodeInfo->Equals(nsHTMLAtoms::body) ||
mNodeInfo->Equals(nsHTMLAtoms::frameset)) {
if (mNodeInfo->Equals(nsGkAtoms::body) ||
mNodeInfo->Equals(nsGkAtoms::frameset)) {
nsPIDOMWindow *win;
// If we have a document, and it has a window, add the event
@ -1743,19 +1741,19 @@ nsGenericHTMLElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
const nsAttrValue*
nsGenericHTMLElement::GetClasses() const
{
return mAttrsAndChildren.GetAttr(nsHTMLAtoms::_class);
return mAttrsAndChildren.GetAttr(nsGkAtoms::_class);
}
nsIAtom *
nsGenericHTMLElement::GetIDAttributeName() const
{
return nsHTMLAtoms::id;
return nsGkAtoms::id;
}
nsIAtom *
nsGenericHTMLElement::GetClassAttributeName() const
{
return nsHTMLAtoms::_class;
return nsGkAtoms::_class;
}
nsresult
@ -1768,12 +1766,12 @@ nsGenericHTMLElement::WalkContentStyleRules(nsRuleWalker* aRuleWalker)
nsICSSStyleRule*
nsGenericHTMLElement::GetInlineStyleRule()
{
const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);
const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(nsGkAtoms::style);
if (attrVal) {
if (attrVal->Type() != nsAttrValue::eCSSStyleRule) {
ReparseStyleAttribute();
attrVal = mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);
attrVal = mAttrsAndChildren.GetAttr(nsGkAtoms::style);
// hopefully attrVal->Type() is now nsAttrValue::eCSSStyleRule
}
@ -1804,16 +1802,16 @@ nsGenericHTMLElement::SetInlineStyleRule(nsICSSStyleRule* aStyleRule,
// save the old attribute so we can set up the mutation event properly
// XXXbz if the old rule points to the same declaration as the new one,
// this is getting the new attr value, not the old one....
modification = GetAttr(kNameSpaceID_None, nsHTMLAtoms::style,
modification = GetAttr(kNameSpaceID_None, nsGkAtoms::style,
oldValueStr);
}
else if (aNotify && IsInDoc()) {
modification = !!mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);
modification = !!mAttrsAndChildren.GetAttr(nsGkAtoms::style);
}
nsAttrValue attrValue(aStyleRule);
return SetAttrAndNotify(kNameSpaceID_None, nsHTMLAtoms::style, nsnull, oldValueStr,
return SetAttrAndNotify(kNameSpaceID_None, nsGkAtoms::style, nsnull, oldValueStr,
attrValue, modification, hasListeners, aNotify);
}
@ -1823,7 +1821,7 @@ nsGenericHTMLElement::GetBaseURI() const
nsIDocument* doc = GetOwnerDoc();
void* prop;
if (HasFlag(NODE_HAS_PROPERTIES) && (prop = GetProperty(nsHTMLAtoms::htmlBaseHref))) {
if (HasFlag(NODE_HAS_PROPERTIES) && (prop = GetProperty(nsGkAtoms::htmlBaseHref))) {
nsIURI* uri = NS_STATIC_CAST(nsIURI*, prop);
NS_ADDREF(uri);
@ -1850,7 +1848,7 @@ void
nsGenericHTMLElement::GetBaseTarget(nsAString& aBaseTarget) const
{
void* prop;
if (HasFlag(NODE_HAS_PROPERTIES) && (prop = GetProperty(nsHTMLAtoms::htmlBaseTarget))) {
if (HasFlag(NODE_HAS_PROPERTIES) && (prop = GetProperty(nsGkAtoms::htmlBaseTarget))) {
NS_STATIC_CAST(nsIAtom*, prop)->ToString(aBaseTarget);
return;
@ -1970,25 +1968,25 @@ nsGenericHTMLElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::dir) {
if (aAttribute == nsGkAtoms::dir) {
return aResult.ParseEnumValue(aValue, kDirTable);
}
if (aAttribute == nsHTMLAtoms::style) {
if (aAttribute == nsGkAtoms::style) {
ParseStyleAttribute(this, mNodeInfo->NamespaceEquals(kNameSpaceID_XHTML),
aValue, aResult);
return PR_TRUE;
}
if (aAttribute == nsHTMLAtoms::_class) {
if (aAttribute == nsGkAtoms::_class) {
aResult.ParseAtomArray(aValue);
return PR_TRUE;
}
if (aAttribute == nsHTMLAtoms::tabindex) {
if (aAttribute == nsGkAtoms::tabindex) {
return aResult.ParseIntWithBounds(aValue, -32768, 32767);
}
if (aAttribute == nsHTMLAtoms::name && !aValue.IsEmpty()) {
if (aAttribute == nsGkAtoms::name && !aValue.IsEmpty()) {
// Store name as an atom. name="" means that the element has no name,
// not that it has an emptystring as the name.
aResult.ParseAtom(aValue);
@ -2334,13 +2332,13 @@ nsGenericHTMLElement::ParseImageAttribute(nsIAtom* aAttribute,
const nsAString& aString,
nsAttrValue& aResult)
{
if ((aAttribute == nsHTMLAtoms::width) ||
(aAttribute == nsHTMLAtoms::height)) {
if ((aAttribute == nsGkAtoms::width) ||
(aAttribute == nsGkAtoms::height)) {
return aResult.ParseSpecialIntValue(aString, PR_TRUE, PR_FALSE);
}
else if ((aAttribute == nsHTMLAtoms::hspace) ||
(aAttribute == nsHTMLAtoms::vspace) ||
(aAttribute == nsHTMLAtoms::border)) {
else if ((aAttribute == nsGkAtoms::hspace) ||
(aAttribute == nsGkAtoms::vspace) ||
(aAttribute == nsGkAtoms::border)) {
return aResult.ParseIntWithBounds(aString, 0);
}
return PR_FALSE;
@ -2363,7 +2361,7 @@ nsGenericHTMLElement::ParseScrollingValue(const nsAString& aString,
nsresult
nsGenericHTMLElement::ReparseStyleAttribute()
{
const nsAttrValue* oldVal = mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);
const nsAttrValue* oldVal = mAttrsAndChildren.GetAttr(nsGkAtoms::style);
if (oldVal && oldVal->Type() != nsAttrValue::eCSSStyleRule) {
nsAttrValue attrValue;
@ -2373,7 +2371,7 @@ nsGenericHTMLElement::ReparseStyleAttribute()
stringValue, attrValue);
// Don't bother going through SetInlineStyleRule, we don't want to fire off
// mutation events or document notifications anyway
nsresult rv = mAttrsAndChildren.SetAndTakeAttr(nsHTMLAtoms::style, attrValue);
nsresult rv = mAttrsAndChildren.SetAndTakeAttr(nsGkAtoms::style, attrValue);
NS_ENSURE_SUCCESS(rv, rv);
}
@ -2395,7 +2393,7 @@ nsGenericHTMLElement::ParseStyleAttribute(nsIContent* aContent,
if (!aContent->IsNativeAnonymous()) { // native anonymous content
// always assumes CSS
nsAutoString styleType;
doc->GetHeaderData(nsHTMLAtoms::headerContentStyleType, styleType);
doc->GetHeaderData(nsGkAtoms::headerContentStyleType, styleType);
if (!styleType.IsEmpty()) {
static const char textCssStr[] = "text/css";
isCSS = (styleType.EqualsIgnoreCase(textCssStr, sizeof(textCssStr) - 1));
@ -2435,7 +2433,7 @@ nsGenericHTMLElement::MapCommonAttributesInto(const nsMappedAttributes* aAttribu
nsRuleData* aData)
{
if (aData->mSID == eStyleStruct_Visibility) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::lang);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::lang);
if (value && value->Type() == nsAttrValue::eString) {
aData->mDisplayData->mLang.SetStringValue(value->GetStringValue(),
eCSSUnit_String);
@ -2447,53 +2445,53 @@ nsGenericHTMLElement::MapCommonAttributesInto(const nsMappedAttributes* aAttribu
/* static */ const nsGenericHTMLElement::MappedAttributeEntry
nsGenericHTMLElement::sCommonAttributeMap[] = {
{ &nsHTMLAtoms::lang },
{ &nsGkAtoms::lang },
{ nsnull }
};
/* static */ const nsGenericElement::MappedAttributeEntry
nsGenericHTMLElement::sImageMarginSizeAttributeMap[] = {
{ &nsHTMLAtoms::width },
{ &nsHTMLAtoms::height },
{ &nsHTMLAtoms::hspace },
{ &nsHTMLAtoms::vspace },
{ &nsGkAtoms::width },
{ &nsGkAtoms::height },
{ &nsGkAtoms::hspace },
{ &nsGkAtoms::vspace },
{ nsnull }
};
/* static */ const nsGenericElement::MappedAttributeEntry
nsGenericHTMLElement::sImageAlignAttributeMap[] = {
{ &nsHTMLAtoms::align },
{ &nsGkAtoms::align },
{ nsnull }
};
/* static */ const nsGenericElement::MappedAttributeEntry
nsGenericHTMLElement::sDivAlignAttributeMap[] = {
{ &nsHTMLAtoms::align },
{ &nsGkAtoms::align },
{ nsnull }
};
/* static */ const nsGenericElement::MappedAttributeEntry
nsGenericHTMLElement::sImageBorderAttributeMap[] = {
{ &nsHTMLAtoms::border },
{ &nsGkAtoms::border },
{ nsnull }
};
/* static */ const nsGenericElement::MappedAttributeEntry
nsGenericHTMLElement::sBackgroundAttributeMap[] = {
{ &nsHTMLAtoms::background },
{ &nsHTMLAtoms::bgcolor },
{ &nsGkAtoms::background },
{ &nsGkAtoms::bgcolor },
{ nsnull }
};
/* static */ const nsGenericElement::MappedAttributeEntry
nsGenericHTMLElement::sBackgroundColorAttributeMap[] = {
{ &nsHTMLAtoms::bgcolor },
{ &nsGkAtoms::bgcolor },
{ nsnull }
};
/* static */ const nsGenericElement::MappedAttributeEntry
nsGenericHTMLElement::sScrollingAttributeMap[] = {
{ &nsHTMLAtoms::scrolling },
{ &nsGkAtoms::scrolling },
{ nsnull }
};
@ -2502,7 +2500,7 @@ nsGenericHTMLElement::MapImageAlignAttributeInto(const nsMappedAttributes* aAttr
nsRuleData* aRuleData)
{
if (aRuleData->mSID == eStyleStruct_Display || aRuleData->mSID == eStyleStruct_TextReset) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum) {
PRInt32 align = value->GetEnumValue();
if (aRuleData->mSID == eStyleStruct_Display && aRuleData->mDisplayData->mFloat.GetUnit() == eCSSUnit_Null) {
@ -2532,7 +2530,7 @@ nsGenericHTMLElement::MapDivAlignAttributeInto(const nsMappedAttributes* aAttrib
if (aRuleData->mSID == eStyleStruct_Text) {
if (aRuleData->mTextData->mTextAlign.GetUnit() == eCSSUnit_Null) {
// align: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum)
aRuleData->mTextData->mTextAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -2550,7 +2548,7 @@ nsGenericHTMLElement::MapImageMarginAttributeInto(const nsMappedAttributes* aAtt
const nsAttrValue* value;
// hspace: value
value = aAttributes->GetAttr(nsHTMLAtoms::hspace);
value = aAttributes->GetAttr(nsGkAtoms::hspace);
if (value) {
nsCSSValue hval;
if (value->Type() == nsAttrValue::eInteger)
@ -2568,7 +2566,7 @@ nsGenericHTMLElement::MapImageMarginAttributeInto(const nsMappedAttributes* aAtt
}
// vspace: value
value = aAttributes->GetAttr(nsHTMLAtoms::vspace);
value = aAttributes->GetAttr(nsGkAtoms::vspace);
if (value) {
nsCSSValue vval;
if (value->Type() == nsAttrValue::eInteger)
@ -2595,7 +2593,7 @@ nsGenericHTMLElement::MapImageSizeAttributesInto(const nsMappedAttributes* aAttr
// width: value
if (aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mPositionData->mWidth.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
else if (value && value->Type() == nsAttrValue::ePercent)
@ -2604,7 +2602,7 @@ nsGenericHTMLElement::MapImageSizeAttributesInto(const nsMappedAttributes* aAttr
// height: value
if (aData->mPositionData->mHeight.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::height);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::height);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mPositionData->mHeight.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
else if (value && value->Type() == nsAttrValue::ePercent)
@ -2620,7 +2618,7 @@ nsGenericHTMLElement::MapImageBorderAttributeInto(const nsMappedAttributes* aAtt
return;
// border: pixels
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::border);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::border);
if (!value)
return;
@ -2668,7 +2666,7 @@ nsGenericHTMLElement::MapBackgroundInto(const nsMappedAttributes* aAttributes,
if (aData->mColorData->mBackImage.GetUnit() == eCSSUnit_Null) {
// background
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::background);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::background);
if (value && value->Type() == nsAttrValue::eString) {
const nsString& spec = value->GetStringValue();
if (!spec.IsEmpty()) {
@ -2716,7 +2714,7 @@ nsGenericHTMLElement::MapBGColorInto(const nsMappedAttributes* aAttributes,
return;
if (aData->mColorData->mBackColor.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::bgcolor);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::bgcolor);
nscolor color;
if (value && value->GetColorValue(color)) {
aData->mColorData->mBackColor.SetColorValue(color);
@ -2746,7 +2744,7 @@ nsGenericHTMLElement::MapScrollingAttributeInto(const nsMappedAttributes* aAttri
};
for (PRUint32 i = 0; i < NS_ARRAY_LENGTH(overflowValues); ++i) {
if (overflowValues[i]->GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::scrolling);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::scrolling);
if (value && value->Type() == nsAttrValue::eEnum) {
PRInt32 mappedValue;
switch (value->GetEnumValue()) {
@ -2979,8 +2977,8 @@ nsGenericHTMLFormElement::SetForm(nsIDOMHTMLFormElement* aForm,
nsAutoString nameVal, idVal;
if (aForm || (mForm && aRemoveFromForm)) {
GetAttr(kNameSpaceID_None, nsHTMLAtoms::name, nameVal);
GetAttr(kNameSpaceID_None, nsHTMLAtoms::id, idVal);
GetAttr(kNameSpaceID_None, nsGkAtoms::name, nameVal);
GetAttr(kNameSpaceID_None, nsGkAtoms::id, idVal);
}
if (mForm && aRemoveFromForm) {
@ -3146,7 +3144,7 @@ nsGenericHTMLFormElement::BeforeSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
// remove the control from the hashtable as needed
if (mForm && (aName == nsHTMLAtoms::name || aName == nsHTMLAtoms::id)) {
if (mForm && (aName == nsGkAtoms::name || aName == nsGkAtoms::id)) {
GetAttr(kNameSpaceID_None, aName, tmp);
if (!tmp.IsEmpty()) {
@ -3154,14 +3152,14 @@ nsGenericHTMLFormElement::BeforeSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
}
}
if (mForm && aName == nsHTMLAtoms::type) {
GetAttr(kNameSpaceID_None, nsHTMLAtoms::name, tmp);
if (mForm && aName == nsGkAtoms::type) {
GetAttr(kNameSpaceID_None, nsGkAtoms::name, tmp);
if (!tmp.IsEmpty()) {
mForm->RemoveElementFromTable(this, tmp);
}
GetAttr(kNameSpaceID_None, nsHTMLAtoms::id, tmp);
GetAttr(kNameSpaceID_None, nsGkAtoms::id, tmp);
if (!tmp.IsEmpty()) {
mForm->RemoveElementFromTable(this, tmp);
@ -3182,23 +3180,23 @@ nsGenericHTMLFormElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
if (aNameSpaceID == kNameSpaceID_None) {
// add the control to the hashtable as needed
if (mForm && (aName == nsHTMLAtoms::name || aName == nsHTMLAtoms::id) &&
if (mForm && (aName == nsGkAtoms::name || aName == nsGkAtoms::id) &&
aValue) {
if (!aValue->IsEmpty()) {
mForm->AddElementToTable(this, *aValue);
}
}
if (mForm && aName == nsHTMLAtoms::type) {
if (mForm && aName == nsGkAtoms::type) {
nsAutoString tmp;
GetAttr(kNameSpaceID_None, nsHTMLAtoms::name, tmp);
GetAttr(kNameSpaceID_None, nsGkAtoms::name, tmp);
if (!tmp.IsEmpty()) {
mForm->AddElementToTable(this, tmp);
}
GetAttr(kNameSpaceID_None, nsHTMLAtoms::id, tmp);
GetAttr(kNameSpaceID_None, nsGkAtoms::id, tmp);
if (!tmp.IsEmpty()) {
mForm->AddElementToTable(this, tmp);
@ -3209,7 +3207,7 @@ nsGenericHTMLFormElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
// And notify on content state changes, if any
if (aNotify && aName == nsHTMLAtoms::disabled && CanBeDisabled()) {
if (aNotify && aName == nsGkAtoms::disabled && CanBeDisabled()) {
nsIDocument* document = GetCurrentDoc();
if (document) {
mozAutoDocUpdate upd(document, UPDATE_CONTENT_STATE, PR_TRUE);
@ -3274,7 +3272,7 @@ nsGenericHTMLFormElement::IntrinsicState() const
if (CanBeDisabled()) {
// :enabled/:disabled
PRBool disabled;
GetBoolAttr(nsHTMLAtoms::disabled, &disabled);
GetBoolAttr(nsGkAtoms::disabled, &disabled);
if (disabled) {
state |= NS_EVENT_STATE_DISABLED;
state &= ~NS_EVENT_STATE_ENABLED;
@ -3450,7 +3448,7 @@ nsGenericHTMLFrameElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
aValue, aNotify);
if (NS_SUCCEEDED(rv) && aNameSpaceID == kNameSpaceID_None &&
aName == nsHTMLAtoms::src) {
aName == nsGkAtoms::src) {
return LoadSrc();
}
@ -3542,7 +3540,7 @@ nsGenericHTMLElement::IsFocusable(PRInt32 *aTabIndex)
GetTabIndex(&tabIndex);
// Just check for disabled attribute on all HTML elements
PRBool disabled = HasAttr(kNameSpaceID_None, nsHTMLAtoms::disabled);
PRBool disabled = HasAttr(kNameSpaceID_None, nsGkAtoms::disabled);
if (disabled) {
tabIndex = -1;
}
@ -3552,7 +3550,7 @@ nsGenericHTMLElement::IsFocusable(PRInt32 *aTabIndex)
}
// If a tabindex is specified at all, or the default tabindex is 0, we're focusable
return tabIndex >= 0 || (!disabled && HasAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex));
return tabIndex >= 0 || (!disabled && HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex));
}
void
@ -3560,7 +3558,7 @@ nsGenericHTMLElement::RegUnRegAccessKey(PRBool aDoReg)
{
// first check to see if we have an access key
nsAutoString accessKey;
GetAttr(kNameSpaceID_None, nsHTMLAtoms::accesskey, accessKey);
GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accessKey);
if (accessKey.IsEmpty()) {
return;
}

28
content/html/content/src/nsGenericHTMLElement.h
Просмотреть файл

@ -929,12 +929,12 @@ NS_NewHTML##_elementName##Element(nsINodeInfo *aNodeInfo, PRBool aFromParser)\
NS_IMETHODIMP \
_class::Get##_method(nsAString& aValue) \
{ \
return GetAttrHelper(nsHTMLAtoms::_atom, aValue); \
return GetAttrHelper(nsGkAtoms::_atom, aValue); \
} \
NS_IMETHODIMP \
_class::Set##_method(const nsAString& aValue) \
{ \
return SetAttrHelper(nsHTMLAtoms::_atom, aValue); \
return SetAttrHelper(nsGkAtoms::_atom, aValue); \
}
/**
@ -946,12 +946,12 @@ NS_NewHTML##_elementName##Element(nsINodeInfo *aNodeInfo, PRBool aFromParser)\
NS_IMETHODIMP \
_class::Get##_method(nsAString& aValue) \
{ \
return GetStringAttrWithDefault(nsHTMLAtoms::_atom, _default, aValue);\
return GetStringAttrWithDefault(nsGkAtoms::_atom, _default, aValue);\
} \
NS_IMETHODIMP \
_class::Set##_method(const nsAString& aValue) \
{ \
return SetAttrHelper(nsHTMLAtoms::_atom, aValue); \
return SetAttrHelper(nsGkAtoms::_atom, aValue); \
}
/**
@ -963,12 +963,12 @@ NS_NewHTML##_elementName##Element(nsINodeInfo *aNodeInfo, PRBool aFromParser)\
NS_IMETHODIMP \
_class::Get##_method(PRBool* aValue) \
{ \
return GetBoolAttr(nsHTMLAtoms::_atom, aValue); \
return GetBoolAttr(nsGkAtoms::_atom, aValue); \
} \
NS_IMETHODIMP \
_class::Set##_method(PRBool aValue) \
{ \
return SetBoolAttr(nsHTMLAtoms::_atom, aValue); \
return SetBoolAttr(nsGkAtoms::_atom, aValue); \
}
/**
@ -983,12 +983,12 @@ NS_NewHTML##_elementName##Element(nsINodeInfo *aNodeInfo, PRBool aFromParser)\
NS_IMETHODIMP \
_class::Get##_method(PRInt32* aValue) \
{ \
return GetIntAttr(nsHTMLAtoms::_atom, _default, aValue); \
return GetIntAttr(nsGkAtoms::_atom, _default, aValue); \
} \
NS_IMETHODIMP \
_class::Set##_method(PRInt32 aValue) \
{ \
return SetIntAttr(nsHTMLAtoms::_atom, aValue); \
return SetIntAttr(nsGkAtoms::_atom, aValue); \
}
/**
@ -1002,24 +1002,24 @@ NS_NewHTML##_elementName##Element(nsINodeInfo *aNodeInfo, PRBool aFromParser)\
NS_IMETHODIMP \
_class::Get##_method(nsAString& aValue) \
{ \
return GetURIAttr(nsHTMLAtoms::_atom, nsnull, aValue); \
return GetURIAttr(nsGkAtoms::_atom, nsnull, aValue); \
} \
NS_IMETHODIMP \
_class::Set##_method(const nsAString& aValue) \
{ \
return SetAttrHelper(nsHTMLAtoms::_atom, aValue); \
return SetAttrHelper(nsGkAtoms::_atom, aValue); \
}
#define NS_IMPL_URI_ATTR_WITH_BASE(_class, _method, _atom, _base_atom) \
NS_IMETHODIMP \
_class::Get##_method(nsAString& aValue) \
{ \
return GetURIAttr(nsHTMLAtoms::_atom, nsHTMLAtoms::_base_atom, aValue); \
return GetURIAttr(nsGkAtoms::_atom, nsGkAtoms::_base_atom, aValue); \
} \
NS_IMETHODIMP \
_class::Set##_method(const nsAString& aValue) \
{ \
return SetAttrHelper(nsHTMLAtoms::_atom, aValue); \
return SetAttrHelper(nsGkAtoms::_atom, aValue); \
}
/**
@ -1069,11 +1069,11 @@ NS_NewHTML##_elementName##Element(nsINodeInfo *aNodeInfo, PRBool aFromParser)\
#define NS_INTERFACE_MAP_ENTRY_IF_TAG(_interface, _tag) \
NS_INTERFACE_MAP_ENTRY_CONDITIONAL(_interface, \
mNodeInfo->Equals(nsHTMLAtoms::_tag))
mNodeInfo->Equals(nsGkAtoms::_tag))
#define NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO_IF_TAG(_class, _tag) \
if (mNodeInfo->Equals(nsHTMLAtoms::_tag) && \
if (mNodeInfo->Equals(nsGkAtoms::_tag) && \
aIID.Equals(NS_GET_IID(nsIClassInfo))) { \
foundInterface = \
nsContentUtils::GetClassInfoInstance(eDOMClassInfo_##_class##_id); \

22
content/html/content/src/nsHTMLAnchorElement.cpp
Просмотреть файл

@ -45,7 +45,7 @@
#include "nsIHTMLDocument.h"
#include "nsGenericHTMLElement.h"
#include "nsILink.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIEventStateManager.h"
@ -263,7 +263,7 @@ nsHTMLAnchorElement::IsFocusable(PRInt32 *aTabIndex)
return PR_FALSE;
}
if (!HasAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex)) {
if (!HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex)) {
// check whether we're actually a link
nsCOMPtr<nsIURI> linkURI = nsContentUtils::GetLinkURI(this);
if (!linkURI) {
@ -292,7 +292,7 @@ nsHTMLAnchorElement::PostHandleEvent(nsEventChainPostVisitor& aVisitor)
NS_IMETHODIMP
nsHTMLAnchorElement::GetTarget(nsAString& aValue)
{
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::target, aValue)) {
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::target, aValue)) {
GetBaseTarget(aValue);
}
return NS_OK;
@ -301,7 +301,7 @@ nsHTMLAnchorElement::GetTarget(nsAString& aValue)
NS_IMETHODIMP
nsHTMLAnchorElement::SetTarget(const nsAString& aValue)
{
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::target, aValue, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::target, aValue, PR_TRUE);
}
NS_IMETHODIMP
@ -549,13 +549,13 @@ nsHTMLAnchorElement::ToString(nsAString& aSource)
NS_IMETHODIMP
nsHTMLAnchorElement::GetPing(nsAString& aValue)
{
return GetURIListAttr(nsHTMLAtoms::ping, aValue);
return GetURIListAttr(nsGkAtoms::ping, aValue);
}
NS_IMETHODIMP
nsHTMLAnchorElement::SetPing(const nsAString& aValue)
{
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::ping, aValue, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::ping, aValue, PR_TRUE);
}
NS_IMETHODIMP
@ -583,7 +583,7 @@ nsHTMLAnchorElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
nsIAtom* aPrefix, const nsAString& aValue,
PRBool aNotify)
{
if (aName == nsHTMLAtoms::href && kNameSpaceID_None == aNameSpaceID) {
if (aName == nsGkAtoms::href && kNameSpaceID_None == aNameSpaceID) {
nsAutoString val;
GetHref(val);
if (!val.Equals(aValue)) {
@ -598,14 +598,14 @@ nsHTMLAnchorElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
}
}
if (aName == nsHTMLAtoms::accesskey && kNameSpaceID_None == aNameSpaceID) {
if (aName == nsGkAtoms::accesskey && kNameSpaceID_None == aNameSpaceID) {
RegUnRegAccessKey(PR_FALSE);
}
nsresult rv = nsGenericHTMLElement::SetAttr(aNameSpaceID, aName, aPrefix,
aValue, aNotify);
if (aName == nsHTMLAtoms::accesskey && kNameSpaceID_None == aNameSpaceID &&
if (aName == nsGkAtoms::accesskey && kNameSpaceID_None == aNameSpaceID &&
!aValue.IsEmpty()) {
RegUnRegAccessKey(PR_TRUE);
}
@ -617,11 +617,11 @@ nsresult
nsHTMLAnchorElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
PRBool aNotify)
{
if (aAttribute == nsHTMLAtoms::href && kNameSpaceID_None == aNameSpaceID) {
if (aAttribute == nsGkAtoms::href && kNameSpaceID_None == aNameSpaceID) {
SetLinkState(eLinkState_Unknown);
}
if (aAttribute == nsHTMLAtoms::accesskey &&
if (aAttribute == nsGkAtoms::accesskey &&
kNameSpaceID_None == aNameSpaceID) {
RegUnRegAccessKey(PR_FALSE);
}

18
content/html/content/src/nsHTMLAreaElement.cpp
Просмотреть файл

@ -41,7 +41,7 @@
#include "nsGenericHTMLElement.h"
#include "nsILink.h"
#include "nsIPresShell.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIEventStateManager.h"
@ -156,7 +156,7 @@ NS_IMPL_INT_ATTR_DEFAULT_VALUE(nsHTMLAreaElement, TabIndex, tabindex, 0)
NS_IMETHODIMP
nsHTMLAreaElement::GetTarget(nsAString& aValue)
{
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::target, aValue)) {
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::target, aValue)) {
GetBaseTarget(aValue);
}
return NS_OK;
@ -165,7 +165,7 @@ nsHTMLAreaElement::GetTarget(nsAString& aValue)
NS_IMETHODIMP
nsHTMLAreaElement::SetTarget(const nsAString& aValue)
{
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::target, aValue, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::target, aValue, PR_TRUE);
}
nsresult
@ -236,11 +236,11 @@ nsHTMLAreaElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
nsIAtom* aPrefix, const nsAString& aValue,
PRBool aNotify)
{
if (aName == nsHTMLAtoms::accesskey && aNameSpaceID == kNameSpaceID_None) {
if (aName == nsGkAtoms::accesskey && aNameSpaceID == kNameSpaceID_None) {
RegUnRegAccessKey(PR_FALSE);
}
if (aName == nsHTMLAtoms::href && aNameSpaceID == kNameSpaceID_None) {
if (aName == nsGkAtoms::href && aNameSpaceID == kNameSpaceID_None) {
nsIDocument* doc = GetCurrentDoc();
if (doc) {
doc->ForgetLink(this);
@ -254,7 +254,7 @@ nsHTMLAreaElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
nsresult rv =
nsGenericHTMLElement::SetAttr(aNameSpaceID, aName, aPrefix, aValue, aNotify);
if (aName == nsHTMLAtoms::accesskey && aNameSpaceID == kNameSpaceID_None &&
if (aName == nsGkAtoms::accesskey && aNameSpaceID == kNameSpaceID_None &&
!aValue.IsEmpty()) {
RegUnRegAccessKey(PR_TRUE);
}
@ -266,7 +266,7 @@ nsresult
nsHTMLAreaElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
PRBool aNotify)
{
if (aAttribute == nsHTMLAtoms::accesskey &&
if (aAttribute == nsGkAtoms::accesskey &&
aNameSpaceID == kNameSpaceID_None) {
RegUnRegAccessKey(PR_FALSE);
}
@ -482,13 +482,13 @@ nsHTMLAreaElement::ToString(nsAString& aSource)
NS_IMETHODIMP
nsHTMLAreaElement::GetPing(nsAString& aValue)
{
return GetURIListAttr(nsHTMLAtoms::ping, aValue);
return GetURIListAttr(nsGkAtoms::ping, aValue);
}
NS_IMETHODIMP
nsHTMLAreaElement::SetPing(const nsAString& aValue)
{
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::ping, aValue, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::ping, aValue, PR_TRUE);
}
NS_IMETHODIMP

1
content/html/content/src/nsHTMLAtoms.h
Просмотреть файл

@ -38,6 +38,5 @@
#define nsHTMLAtoms_h___
#include "nsGkAtoms.h"
typedef class nsGkAtoms nsHTMLAtoms;
#endif /* nsHTMLAtoms_h___ */

8
content/html/content/src/nsHTMLBRElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLBRElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -117,7 +117,7 @@ nsHTMLBRElement::ParseAttribute(PRInt32 aNamespaceID,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aAttribute == nsHTMLAtoms::clear && aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::clear && aNamespaceID == kNameSpaceID_None) {
return aResult.ParseEnumValue(aValue, kClearTable);
}
@ -131,7 +131,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
{
if (aData->mSID == eStyleStruct_Display) {
if (aData->mDisplayData->mClear.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::clear);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::clear);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mDisplayData->mClear.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -144,7 +144,7 @@ NS_IMETHODIMP_(PRBool)
nsHTMLBRElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::clear },
{ &nsGkAtoms::clear },
{ nsnull }
};

65
content/html/content/src/nsHTMLBodyElement.cpp
Просмотреть файл

@ -40,7 +40,7 @@
#include "nsIDOMHTMLBodyElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
@ -59,7 +59,6 @@
#include "nsIEditorDocShell.h"
#include "nsCOMPtr.h"
#include "nsIView.h"
#include "nsLayoutAtoms.h"
#include "nsRuleWalker.h"
#include "nsIViewManager.h"
@ -157,7 +156,7 @@ BodyRule::MapRuleInfoInto(nsRuleData* aData)
const nsAttrValue* value;
if (mPart->GetAttrCount() > 0) {
// if marginwidth/marginheight are set, reflect them as 'margin'
value = mPart->GetParsedAttr(nsHTMLAtoms::marginwidth);
value = mPart->GetParsedAttr(nsGkAtoms::marginwidth);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyMarginWidth = value->GetIntegerValue();
if (bodyMarginWidth < 0) bodyMarginWidth = 0;
@ -168,7 +167,7 @@ BodyRule::MapRuleInfoInto(nsRuleData* aData)
margin.mRight.SetFloatValue((float)bodyMarginWidth, eCSSUnit_Pixel);
}
value = mPart->GetParsedAttr(nsHTMLAtoms::marginheight);
value = mPart->GetParsedAttr(nsGkAtoms::marginheight);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyMarginHeight = value->GetIntegerValue();
if (bodyMarginHeight < 0) bodyMarginHeight = 0;
@ -181,7 +180,7 @@ BodyRule::MapRuleInfoInto(nsRuleData* aData)
if (eCompatibility_NavQuirks == mode){
// topmargin (IE-attribute)
value = mPart->GetParsedAttr(nsHTMLAtoms::topmargin);
value = mPart->GetParsedAttr(nsGkAtoms::topmargin);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyTopMargin = value->GetIntegerValue();
if (bodyTopMargin < 0) bodyTopMargin = 0;
@ -191,7 +190,7 @@ BodyRule::MapRuleInfoInto(nsRuleData* aData)
}
// bottommargin (IE-attribute)
value = mPart->GetParsedAttr(nsHTMLAtoms::bottommargin);
value = mPart->GetParsedAttr(nsGkAtoms::bottommargin);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyBottomMargin = value->GetIntegerValue();
if (bodyBottomMargin < 0) bodyBottomMargin = 0;
@ -201,7 +200,7 @@ BodyRule::MapRuleInfoInto(nsRuleData* aData)
}
// leftmargin (IE-attribute)
value = mPart->GetParsedAttr(nsHTMLAtoms::leftmargin);
value = mPart->GetParsedAttr(nsGkAtoms::leftmargin);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyLeftMargin = value->GetIntegerValue();
if (bodyLeftMargin < 0) bodyLeftMargin = 0;
@ -211,7 +210,7 @@ BodyRule::MapRuleInfoInto(nsRuleData* aData)
}
// rightmargin (IE-attribute)
value = mPart->GetParsedAttr(nsHTMLAtoms::rightmargin);
value = mPart->GetParsedAttr(nsGkAtoms::rightmargin);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyRightMargin = value->GetIntegerValue();
if (bodyRightMargin < 0) bodyRightMargin = 0;
@ -319,7 +318,7 @@ nsHTMLBodyElement::Get##func_(nsAString& aColor) \
aColor.Truncate(); \
nsAutoString color; \
nscolor attrColor; \
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::attr_, color)) { \
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::attr_, color)) { \
\
nsPresContext *presContext = GetPresContext(); \
if (presContext) { \
@ -336,7 +335,7 @@ nsHTMLBodyElement::Get##func_(nsAString& aColor) \
NS_IMETHODIMP \
nsHTMLBodyElement::Set##func_(const nsAString& aColor) \
{ \
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::attr_, aColor, \
return SetAttr(kNameSpaceID_None, nsGkAtoms::attr_, aColor, \
PR_TRUE); \
}
@ -357,7 +356,7 @@ nsHTMLBodyElement::GetBgColor(nsAString& aBgColor)
// If we don't have an attribute, find the actual color used for
// (generally from the user agent style sheet) for compatibility
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::bgcolor, attr)) {
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::bgcolor, attr)) {
// Make sure the style is up-to-date, since we need it
nsIFrame* frame = GetPrimaryFrame(Flush_Style);
@ -382,7 +381,7 @@ nsHTMLBodyElement::GetBgColor(nsAString& aBgColor)
NS_IMETHODIMP
nsHTMLBodyElement::SetBgColor(const nsAString& aBgColor)
{
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::bgcolor, aBgColor, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::bgcolor, aBgColor, PR_TRUE);
}
PRBool
@ -392,19 +391,19 @@ nsHTMLBodyElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::bgcolor ||
aAttribute == nsHTMLAtoms::text ||
aAttribute == nsHTMLAtoms::link ||
aAttribute == nsHTMLAtoms::alink ||
aAttribute == nsHTMLAtoms::vlink) {
if (aAttribute == nsGkAtoms::bgcolor ||
aAttribute == nsGkAtoms::text ||
aAttribute == nsGkAtoms::link ||
aAttribute == nsGkAtoms::alink ||
aAttribute == nsGkAtoms::vlink) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if (aAttribute == nsHTMLAtoms::marginwidth ||
aAttribute == nsHTMLAtoms::marginheight ||
aAttribute == nsHTMLAtoms::topmargin ||
aAttribute == nsHTMLAtoms::bottommargin ||
aAttribute == nsHTMLAtoms::leftmargin ||
aAttribute == nsHTMLAtoms::rightmargin) {
if (aAttribute == nsGkAtoms::marginwidth ||
aAttribute == nsGkAtoms::marginheight ||
aAttribute == nsGkAtoms::topmargin ||
aAttribute == nsGkAtoms::bottommargin ||
aAttribute == nsGkAtoms::leftmargin ||
aAttribute == nsGkAtoms::rightmargin) {
return aResult.ParseIntWithBounds(aValue, 0);
}
}
@ -439,17 +438,17 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
if (styleSheet) {
const nsAttrValue* value;
nscolor color;
value = aAttributes->GetAttr(nsHTMLAtoms::link);
value = aAttributes->GetAttr(nsGkAtoms::link);
if (value && value->GetColorValue(color)) {
styleSheet->SetLinkColor(color);
}
value = aAttributes->GetAttr(nsHTMLAtoms::alink);
value = aAttributes->GetAttr(nsGkAtoms::alink);
if (value && value->GetColorValue(color)) {
styleSheet->SetActiveLinkColor(color);
}
value = aAttributes->GetAttr(nsHTMLAtoms::vlink);
value = aAttributes->GetAttr(nsGkAtoms::vlink);
if (value && value->GetColorValue(color)) {
styleSheet->SetVisitedLinkColor(color);
}
@ -462,7 +461,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
if (aData->mColorData->mColor.GetUnit() == eCSSUnit_Null) {
// color: color
nscolor color;
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::text);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::text);
if (value && value->GetColorValue(color))
aData->mColorData->mColor.SetColorValue(color);
}
@ -499,16 +498,16 @@ NS_IMETHODIMP_(PRBool)
nsHTMLBodyElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::link },
{ &nsHTMLAtoms::vlink },
{ &nsHTMLAtoms::alink },
{ &nsHTMLAtoms::text },
{ &nsGkAtoms::link },
{ &nsGkAtoms::vlink },
{ &nsGkAtoms::alink },
{ &nsGkAtoms::text },
// These aren't mapped through attribute mapping, but they are
// mapped through a style rule, so it is attribute dependent style.
// XXXldb But we don't actually replace the body rule when we have
// dynamic changes...
{ &nsHTMLAtoms::marginwidth },
{ &nsHTMLAtoms::marginheight },
{ &nsGkAtoms::marginwidth },
{ &nsGkAtoms::marginheight },
{ nsnull },
};

14
content/html/content/src/nsHTMLButtonElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsIDOMHTMLFormElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsIPresShell.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
@ -259,7 +259,7 @@ nsHTMLButtonElement::SetFocus(nsPresContext* aPresContext)
return;
// first see if we are disabled or not. If disabled then do nothing.
if (HasAttr(kNameSpaceID_None, nsHTMLAtoms::disabled)) {
if (HasAttr(kNameSpaceID_None, nsGkAtoms::disabled)) {
return;
}
@ -286,7 +286,7 @@ nsHTMLButtonElement::ParseAttribute(PRInt32 aNamespaceID,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aAttribute == nsHTMLAtoms::type && kNameSpaceID_None == aNamespaceID) {
if (aAttribute == nsGkAtoms::type && kNameSpaceID_None == aNamespaceID) {
// XXX ARG!! This is major evilness. ParseAttribute
// shouldn't set members. Override SetAttr instead
PRBool res = aResult.ParseEnumValue(aValue, kButtonTypeTable);
@ -516,14 +516,14 @@ nsHTMLButtonElement::PostHandleEvent(nsEventChainPostVisitor& aVisitor)
nsresult
nsHTMLButtonElement::GetDefaultValue(nsAString& aDefaultValue)
{
GetAttr(kNameSpaceID_None, nsHTMLAtoms::value, aDefaultValue);
GetAttr(kNameSpaceID_None, nsGkAtoms::value, aDefaultValue);
return NS_OK;
}
nsresult
nsHTMLButtonElement::SetDefaultValue(const nsAString& aDefaultValue)
{
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::value, aDefaultValue, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::value, aDefaultValue, PR_TRUE);
}
NS_IMETHODIMP
@ -558,7 +558,7 @@ nsHTMLButtonElement::SubmitNamesValues(nsIFormSubmission* aFormSubmission,
// Get the name (if no name, no submit)
//
nsAutoString name;
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::name, name)) {
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::name, name)) {
return NS_OK;
}
@ -590,7 +590,7 @@ nsresult
nsHTMLButtonElement::BeforeSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
const nsAString* aValue, PRBool aNotify)
{
if (aNotify && aName == nsHTMLAtoms::disabled &&
if (aNotify && aName == nsGkAtoms::disabled &&
aNameSpaceID == kNameSpaceID_None) {
mDisabledChanged = PR_TRUE;
}

20
content/html/content/src/nsHTMLCanvasElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsGenericHTMLElement.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsSize.h"
#include "nsIFrame.h"
#include "nsIDocument.h"
@ -168,13 +168,13 @@ nsHTMLCanvasElement::GetWidthHeight()
nsIntSize size(0,0);
const nsAttrValue* value;
if ((value = GetParsedAttr(nsHTMLAtoms::width)) &&
if ((value = GetParsedAttr(nsGkAtoms::width)) &&
value->Type() == nsAttrValue::eInteger)
{
size.width = value->GetIntegerValue();
}
if ((value = GetParsedAttr(nsHTMLAtoms::height)) &&
if ((value = GetParsedAttr(nsGkAtoms::height)) &&
value->Type() == nsAttrValue::eInteger)
{
size.height = value->GetIntegerValue();
@ -199,7 +199,7 @@ nsHTMLCanvasElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
nsresult rv = nsGenericHTMLElement::SetAttr(aNameSpaceID, aName, aPrefix, aValue,
aNotify);
if (NS_SUCCEEDED(rv) && mCurrentContext &&
(aName == nsHTMLAtoms::width || aName == nsHTMLAtoms::height))
(aName == nsGkAtoms::width || aName == nsGkAtoms::height))
{
rv = UpdateContext();
NS_ENSURE_SUCCESS(rv, rv);
@ -214,8 +214,8 @@ nsHTMLCanvasElement::GetAttributeChangeHint(const nsIAtom* aAttribute,
{
nsChangeHint retval =
nsGenericHTMLElement::GetAttributeChangeHint(aAttribute, aModType);
if (aAttribute == nsHTMLAtoms::width ||
aAttribute == nsHTMLAtoms::height)
if (aAttribute == nsGkAtoms::width ||
aAttribute == nsGkAtoms::height)
{
NS_UpdateHint(retval, NS_STYLE_HINT_REFLOW);
}
@ -238,8 +238,8 @@ nsHTMLCanvasElement::GetAttributeMappingFunction() const
static const nsGenericElement::MappedAttributeEntry
sImageMarginAttributeMap[] = {
{ &nsHTMLAtoms::hspace },
{ &nsHTMLAtoms::vspace },
{ &nsGkAtoms::hspace },
{ &nsGkAtoms::vspace },
{ nsnull }
};
@ -262,8 +262,8 @@ nsHTMLCanvasElement::ParseAttribute(PRInt32 aNamespaceID,
{
if (aNamespaceID == kNameSpaceID_None)
{
if ((aAttribute == nsHTMLAtoms::width) ||
(aAttribute == nsHTMLAtoms::height))
if ((aAttribute == nsGkAtoms::width) ||
(aAttribute == nsGkAtoms::height))
{
return aResult.ParseIntWithBounds(aValue, 0);
}

26
content/html/content/src/nsHTMLDivElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLDivElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -112,22 +112,22 @@ nsHTMLDivElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (mNodeInfo->Equals(nsHTMLAtoms::marquee)) {
if ((aAttribute == nsHTMLAtoms::width) ||
(aAttribute == nsHTMLAtoms::height)) {
if (mNodeInfo->Equals(nsGkAtoms::marquee)) {
if ((aAttribute == nsGkAtoms::width) ||
(aAttribute == nsGkAtoms::height)) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::bgcolor) {
if (aAttribute == nsGkAtoms::bgcolor) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if ((aAttribute == nsHTMLAtoms::hspace) ||
(aAttribute == nsHTMLAtoms::vspace)) {
if ((aAttribute == nsGkAtoms::hspace) ||
(aAttribute == nsGkAtoms::vspace)) {
return aResult.ParseIntWithBounds(aValue, 0);
}
}
if (mNodeInfo->Equals(nsHTMLAtoms::div) &&
aAttribute == nsHTMLAtoms::align) {
if (mNodeInfo->Equals(nsGkAtoms::div) &&
aAttribute == nsGkAtoms::align) {
return ParseDivAlignValue(aValue, aResult);
}
}
@ -155,14 +155,14 @@ MapMarqueeAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData*
NS_IMETHODIMP_(PRBool)
nsHTMLDivElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
if (mNodeInfo->Equals(nsHTMLAtoms::div)) {
if (mNodeInfo->Equals(nsGkAtoms::div)) {
static const MappedAttributeEntry* const map[] = {
sDivAlignAttributeMap,
sCommonAttributeMap
};
return FindAttributeDependence(aAttribute, map, NS_ARRAY_LENGTH(map));
}
if (mNodeInfo->Equals(nsHTMLAtoms::marquee)) {
if (mNodeInfo->Equals(nsGkAtoms::marquee)) {
static const MappedAttributeEntry* const map[] = {
sImageMarginSizeAttributeMap,
sBackgroundColorAttributeMap,
@ -177,10 +177,10 @@ nsHTMLDivElement::IsAttributeMapped(const nsIAtom* aAttribute) const
nsMapRuleToAttributesFunc
nsHTMLDivElement::GetAttributeMappingFunction() const
{
if (mNodeInfo->Equals(nsHTMLAtoms::div)) {
if (mNodeInfo->Equals(nsGkAtoms::div)) {
return &MapAttributesIntoRule;
}
if (mNodeInfo->Equals(nsHTMLAtoms::marquee)) {
if (mNodeInfo->Equals(nsGkAtoms::marquee)) {
return &MapMarqueeAttributesIntoRule;
}
return nsGenericHTMLElement::GetAttributeMappingFunction();

32
content/html/content/src/nsHTMLFontElement.cpp
Просмотреть файл

@ -38,7 +38,7 @@
#include "nsIDOMHTMLFontElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDeviceContext.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
@ -143,7 +143,7 @@ nsHTMLFontElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::size) {
if (aAttribute == nsGkAtoms::size) {
nsAutoString tmp(aValue);
tmp.CompressWhitespace(PR_TRUE, PR_TRUE);
PRUnichar ch = tmp.IsEmpty() ? 0 : tmp.First();
@ -154,11 +154,11 @@ nsHTMLFontElement::ParseAttribute(PRInt32 aNamespaceID,
return aResult.ParseIntValue(aValue);
}
if (aAttribute == nsHTMLAtoms::pointSize ||
aAttribute == nsHTMLAtoms::fontWeight) {
if (aAttribute == nsGkAtoms::pointSize ||
aAttribute == nsGkAtoms::fontWeight) {
return aResult.ParseIntValue(aValue);
}
if (aAttribute == nsHTMLAtoms::color) {
if (aAttribute == nsGkAtoms::color) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
}
@ -176,7 +176,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// face: string list
if (font.mFamily.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::face);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::face);
if (value && value->Type() == nsAttrValue::eString &&
!value->IsEmptyString()) {
font.mFamily.SetStringValue(value->GetStringValue(), eCSSUnit_String);
@ -186,12 +186,12 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// pointSize: int
if (font.mSize.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::pointSize);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::pointSize);
if (value && value->Type() == nsAttrValue::eInteger)
font.mSize.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Point);
else {
// size: int, enum ,
value = aAttributes->GetAttr(nsHTMLAtoms::size);
value = aAttributes->GetAttr(nsGkAtoms::size);
if (value) {
nsAttrValue::ValueType unit = value->Type();
if (unit == nsAttrValue::eInteger || unit == nsAttrValue::eEnum) {
@ -210,7 +210,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// fontWeight: int
if (font.mWeight.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::fontWeight);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::fontWeight);
if (value && value->Type() == nsAttrValue::eInteger) // +/-
font.mWeight.SetIntValue(value->GetIntegerValue(), eCSSUnit_Integer);
}
@ -218,7 +218,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
else if (aData->mSID == eStyleStruct_Color) {
if (aData->mColorData->mColor.GetUnit() == eCSSUnit_Null) {
// color: color
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::color);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::color);
nscolor color;
if (value && value->GetColorValue(color)) {
aData->mColorData->mColor.SetColorValue(color);
@ -229,7 +229,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// Make <a><font color="red">text</font></a> give the text a red underline
// in quirks mode. The NS_STYLE_TEXT_DECORATION_OVERRIDE_ALL flag only
// affects quirks mode rendering.
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::color);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::color);
nscolor color;
if (value && value->GetColorValue(color)) {
nsCSSValue& decoration = aData->mTextData->mDecoration;
@ -248,11 +248,11 @@ NS_IMETHODIMP_(PRBool)
nsHTMLFontElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::face },
{ &nsHTMLAtoms::pointSize },
{ &nsHTMLAtoms::size },
{ &nsHTMLAtoms::fontWeight },
{ &nsHTMLAtoms::color },
{ &nsGkAtoms::face },
{ &nsGkAtoms::pointSize },
{ &nsGkAtoms::size },
{ &nsGkAtoms::fontWeight },
{ &nsGkAtoms::color },
{ nsnull }
};

20
content/html/content/src/nsHTMLFormElement.cpp
Просмотреть файл

@ -45,7 +45,7 @@
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsEventStateManager.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIDocument.h"
@ -586,7 +586,7 @@ nsHTMLFormElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
nsIAtom* aPrefix, const nsAString& aValue,
PRBool aNotify)
{
if ((aName == nsHTMLAtoms::action || aName == nsHTMLAtoms::target) &&
if ((aName == nsGkAtoms::action || aName == nsGkAtoms::target) &&
aNameSpaceID == kNameSpaceID_None) {
if (mPendingSubmission) {
// aha, there is a pending submission that means we're in
@ -613,24 +613,24 @@ NS_IMPL_STRING_ATTR(nsHTMLFormElement, Name, name)
NS_IMETHODIMP
nsHTMLFormElement::GetAction(nsAString& aValue)
{
GetAttr(kNameSpaceID_None, nsHTMLAtoms::action, aValue);
GetAttr(kNameSpaceID_None, nsGkAtoms::action, aValue);
if (aValue.IsEmpty()) {
// Avoid resolving action="" to the base uri, bug 297761.
return NS_OK;
}
return GetURIAttr(nsHTMLAtoms::action, nsnull, aValue);
return GetURIAttr(nsGkAtoms::action, nsnull, aValue);
}
NS_IMETHODIMP
nsHTMLFormElement::SetAction(const nsAString& aValue)
{
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::action, aValue, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::action, aValue, PR_TRUE);
}
NS_IMETHODIMP
nsHTMLFormElement::GetTarget(nsAString& aValue)
{
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::target, aValue)) {
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::target, aValue)) {
GetBaseTarget(aValue);
}
return NS_OK;
@ -639,7 +639,7 @@ nsHTMLFormElement::GetTarget(nsAString& aValue)
NS_IMETHODIMP
nsHTMLFormElement::SetTarget(const nsAString& aValue)
{
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::target, aValue, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::target, aValue, PR_TRUE);
}
NS_IMETHODIMP
@ -689,10 +689,10 @@ nsHTMLFormElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::method) {
if (aAttribute == nsGkAtoms::method) {
return aResult.ParseEnumValue(aValue, kFormMethodTable);
}
if (aAttribute == nsHTMLAtoms::enctype) {
if (aAttribute == nsGkAtoms::enctype) {
return aResult.ParseEnumValue(aValue, kFormEnctypeTable);
}
}
@ -1816,7 +1816,7 @@ nsHTMLFormElement::WalkRadioGroup(const nsAString& aName,
if (control->GetType() == NS_FORM_INPUT_RADIO) {
nsCOMPtr<nsIContent> controlContent(do_QueryInterface(control));
if (controlContent) {
if (controlContent->AttrValueIs(kNameSpaceID_None, nsHTMLAtoms::name,
if (controlContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name,
EmptyString(), eCaseMatters)) {
aVisitor->Visit(control, &stopIterating);
if (stopIterating) {

12
content/html/content/src/nsHTMLFrameElement.cpp
Просмотреть файл

@ -36,7 +36,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsIDOMHTMLFrameElement.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsIPresShell.h"
#include "nsIDocument.h"
#include "nsIDOMDocument.h"
@ -127,19 +127,19 @@ nsHTMLFrameElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::bordercolor) {
if (aAttribute == nsGkAtoms::bordercolor) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if (aAttribute == nsHTMLAtoms::frameborder) {
if (aAttribute == nsGkAtoms::frameborder) {
return ParseFrameborderValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::marginwidth) {
if (aAttribute == nsGkAtoms::marginwidth) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::marginheight) {
if (aAttribute == nsGkAtoms::marginheight) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::scrolling) {
if (aAttribute == nsGkAtoms::scrolling) {
return ParseScrollingValue(aValue, aResult);
}
}

20
content/html/content/src/nsHTMLFrameSetElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLFrameSetElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIFrameSetElement.h"
@ -168,14 +168,14 @@ nsHTMLFrameSetElement::SetAttr(PRInt32 aNameSpaceID,
* Once nsGenericHTMLElement::SetAttr returns, we want to go back to our
* normal hint, which is NS_STYLE_HINT_REFLOW.
*/
if (aAttribute == nsHTMLAtoms::rows && aNameSpaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::rows && aNameSpaceID == kNameSpaceID_None) {
PRInt32 oldRows = mNumRows;
ParseRowCol(aValue, mNumRows, getter_Transfers(mRowSpecs));
if (mNumRows != oldRows) {
mCurrentRowColHint = NS_STYLE_HINT_FRAMECHANGE;
}
} else if (aAttribute == nsHTMLAtoms::cols &&
} else if (aAttribute == nsGkAtoms::cols &&
aNameSpaceID == kNameSpaceID_None) {
PRInt32 oldCols = mNumCols;
ParseRowCol(aValue, mNumCols, getter_Transfers(mColSpecs));
@ -202,7 +202,7 @@ nsHTMLFrameSetElement::GetRowSpec(PRInt32 *aNumValues,
*aSpecs = nsnull;
if (!mRowSpecs) {
const nsAttrValue* value = GetParsedAttr(nsHTMLAtoms::rows);
const nsAttrValue* value = GetParsedAttr(nsGkAtoms::rows);
if (value && value->Type() == nsAttrValue::eString) {
nsresult rv = ParseRowCol(value->GetStringValue(), mNumRows,
getter_Transfers(mRowSpecs));
@ -236,7 +236,7 @@ nsHTMLFrameSetElement::GetColSpec(PRInt32 *aNumValues,
*aSpecs = nsnull;
if (!mColSpecs) {
const nsAttrValue* value = GetParsedAttr(nsHTMLAtoms::cols);
const nsAttrValue* value = GetParsedAttr(nsGkAtoms::cols);
if (value && value->Type() == nsAttrValue::eString) {
nsresult rv = ParseRowCol(value->GetStringValue(), mNumCols,
getter_Transfers(mColSpecs));
@ -268,13 +268,13 @@ nsHTMLFrameSetElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::bordercolor) {
if (aAttribute == nsGkAtoms::bordercolor) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if (aAttribute == nsHTMLAtoms::frameborder) {
if (aAttribute == nsGkAtoms::frameborder) {
return nsGenericHTMLElement::ParseFrameborderValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::border) {
if (aAttribute == nsGkAtoms::border) {
return aResult.ParseIntWithBounds(aValue, 0, 100);
}
}
@ -289,8 +289,8 @@ nsHTMLFrameSetElement::GetAttributeChangeHint(const nsIAtom* aAttribute,
{
nsChangeHint retval =
nsGenericHTMLElement::GetAttributeChangeHint(aAttribute, aModType);
if (aAttribute == nsHTMLAtoms::rows ||
aAttribute == nsHTMLAtoms::cols) {
if (aAttribute == nsGkAtoms::rows ||
aAttribute == nsGkAtoms::cols) {
NS_UpdateHint(retval, mCurrentRowColHint);
}
return retval;

32
content/html/content/src/nsHTMLHRElement.cpp
Просмотреть файл

@ -38,7 +38,7 @@
#include "nsIDOMNSHTMLHRElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -128,16 +128,16 @@ nsHTMLHRElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::width) {
if (aAttribute == nsGkAtoms::width) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::size) {
if (aAttribute == nsGkAtoms::size) {
return aResult.ParseIntWithBounds(aValue, 1, 1000);
}
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return aResult.ParseEnumValue(aValue, kAlignTable);
}
if (aAttribute == nsHTMLAtoms::color) {
if (aAttribute == nsGkAtoms::color) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
}
@ -152,7 +152,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
{
PRBool noshade = PR_FALSE;
const nsAttrValue* colorValue = aAttributes->GetAttr(nsHTMLAtoms::color);
const nsAttrValue* colorValue = aAttributes->GetAttr(nsGkAtoms::color);
nscolor color;
PRBool colorIsSet = colorValue && colorValue->GetColorValue(color);
@ -161,13 +161,13 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
if (colorIsSet) {
noshade = PR_TRUE;
} else {
noshade = !!aAttributes->GetAttr(nsHTMLAtoms::noshade);
noshade = !!aAttributes->GetAttr(nsGkAtoms::noshade);
}
}
if (aData->mSID == eStyleStruct_Margin) {
// align: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum) {
// Map align attribute into auto side margins
nsCSSRect& margin = aData->mMarginData->mMargin;
@ -196,7 +196,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
else if (aData->mSID == eStyleStruct_Position) {
// width: integer, percent
if (aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
if (value && value->Type() == nsAttrValue::eInteger) {
aData->mPositionData->mWidth.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
} else if (value && value->Type() == nsAttrValue::ePercent) {
@ -214,7 +214,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// the height includes the top and bottom borders that are initially 1px.
// for size=1, html.css has a special case rule that makes this work by
// removing all but the top border.
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::size);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::size);
if (value && value->Type() == nsAttrValue::eInteger) {
aData->mPositionData->mHeight.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
} // else use default value from html.css
@ -226,7 +226,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// if a size is set, use half of it per side, otherwise, use 1px per side
float sizePerSide;
PRBool allSides = PR_TRUE;
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::size);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::size);
if (value && value->Type() == nsAttrValue::eInteger) {
sizePerSide = (float)value->GetIntegerValue() / 2.0f;
if (sizePerSide < 1.0f) {
@ -309,11 +309,11 @@ NS_IMETHODIMP_(PRBool)
nsHTMLHRElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::align },
{ &nsHTMLAtoms::width },
{ &nsHTMLAtoms::size },
{ &nsHTMLAtoms::color },
{ &nsHTMLAtoms::noshade },
{ &nsGkAtoms::align },
{ &nsGkAtoms::width },
{ &nsGkAtoms::size },
{ &nsGkAtoms::color },
{ &nsGkAtoms::noshade },
{ nsnull },
};

4
content/html/content/src/nsHTMLHeadingElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLHeadingElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -111,7 +111,7 @@ nsHTMLHeadingElement::ParseAttribute(PRInt32 aNamespaceID,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aAttribute == nsHTMLAtoms::align && aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::align && aNamespaceID == kNameSpaceID_None) {
return ParseDivAlignValue(aValue, aResult);
}

28
content/html/content/src/nsHTMLIFrameElement.cpp
Просмотреть файл

@ -36,7 +36,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsIDOMHTMLIFrameElement.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
#include "nsIDocument.h"
@ -128,25 +128,25 @@ nsHTMLIFrameElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::marginwidth) {
if (aAttribute == nsGkAtoms::marginwidth) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::marginheight) {
if (aAttribute == nsGkAtoms::marginheight) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::width) {
if (aAttribute == nsGkAtoms::width) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::height) {
if (aAttribute == nsGkAtoms::height) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::frameborder) {
if (aAttribute == nsGkAtoms::frameborder) {
return ParseFrameborderValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::scrolling) {
if (aAttribute == nsGkAtoms::scrolling) {
return ParseScrollingValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return ParseAlignValue(aValue, aResult);
}
}
@ -163,7 +163,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// frameborder: 0 | 1 (| NO | YES in quirks mode)
// If frameborder is 0 or No, set border to 0
// else leave it as the value set in html.css
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::frameborder);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::frameborder);
if (value && value->Type() == nsAttrValue::eEnum) {
PRInt32 frameborder = value->GetEnumValue();
if (NS_STYLE_FRAME_0 == frameborder ||
@ -183,7 +183,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
else if (aData->mSID == eStyleStruct_Position) {
// width: value
if (aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mPositionData->mWidth.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
else if (value && value->Type() == nsAttrValue::ePercent)
@ -192,7 +192,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// height: value
if (aData->mPositionData->mHeight.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::height);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::height);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mPositionData->mHeight.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
else if (value && value->Type() == nsAttrValue::ePercent)
@ -209,9 +209,9 @@ NS_IMETHODIMP_(PRBool)
nsHTMLIFrameElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::width },
{ &nsHTMLAtoms::height },
{ &nsHTMLAtoms::frameborder },
{ &nsGkAtoms::width },
{ &nsGkAtoms::height },
{ &nsGkAtoms::frameborder },
{ nsnull },
};

29
content/html/content/src/nsHTMLImageElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsImageLoadingContent.h"
#include "nsHTMLAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
@ -58,7 +58,6 @@
#include "nsContentUtils.h"
#include "nsIFrame.h"
#include "nsIImageFrame.h"
#include "nsLayoutAtoms.h"
#include "nsNodeInfoManager.h"
#include "nsGUIEvent.h"
#include "nsContentPolicyUtils.h"
@ -169,7 +168,7 @@ NS_NewHTMLImageElement(nsINodeInfo *aNodeInfo, PRBool aFromParser)
do_QueryInterface(nsContentUtils::GetDocumentFromCaller());
NS_ENSURE_TRUE(doc, nsnull);
rv = doc->NodeInfoManager()->GetNodeInfo(nsHTMLAtoms::img, nsnull,
rv = doc->NodeInfoManager()->GetNodeInfo(nsGkAtoms::img, nsnull,
kNameSpaceID_None,
getter_AddRefs(nodeInfo));
NS_ENSURE_SUCCESS(rv, nsnull);
@ -363,14 +362,14 @@ nsHTMLImageElement::GetWidthHeight()
mCurrentRequest->GetImage(getter_AddRefs(image));
}
if ((value = GetParsedAttr(nsHTMLAtoms::width)) &&
if ((value = GetParsedAttr(nsGkAtoms::width)) &&
value->Type() == nsAttrValue::eInteger) {
size.width = value->GetIntegerValue();
} else if (image) {
image->GetWidth(&size.width);
}
if ((value = GetParsedAttr(nsHTMLAtoms::height)) &&
if ((value = GetParsedAttr(nsGkAtoms::height)) &&
value->Type() == nsAttrValue::eInteger) {
size.height = value->GetIntegerValue();
} else if (image) {
@ -395,7 +394,7 @@ nsHTMLImageElement::SetHeight(PRInt32 aHeight)
nsAutoString val;
val.AppendInt(aHeight);
return nsGenericHTMLElement::SetAttr(kNameSpaceID_None, nsHTMLAtoms::height,
return nsGenericHTMLElement::SetAttr(kNameSpaceID_None, nsGkAtoms::height,
val, PR_TRUE);
}
@ -413,7 +412,7 @@ nsHTMLImageElement::SetWidth(PRInt32 aWidth)
nsAutoString val;
val.AppendInt(aWidth);
return nsGenericHTMLElement::SetAttr(kNameSpaceID_None, nsHTMLAtoms::width,
return nsGenericHTMLElement::SetAttr(kNameSpaceID_None, nsGkAtoms::width,
val, PR_TRUE);
}
@ -424,10 +423,10 @@ nsHTMLImageElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return ParseAlignValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::src) {
if (aAttribute == nsGkAtoms::src) {
static const char* kWhitespace = " \n\r\t\b";
aResult.SetTo(nsContentUtils::TrimCharsInSet(kWhitespace, aValue));
return PR_TRUE;
@ -458,8 +457,8 @@ nsHTMLImageElement::GetAttributeChangeHint(const nsIAtom* aAttribute,
{
nsChangeHint retval =
nsGenericHTMLElement::GetAttributeChangeHint(aAttribute, aModType);
if (aAttribute == nsHTMLAtoms::usemap ||
aAttribute == nsHTMLAtoms::ismap) {
if (aAttribute == nsGkAtoms::usemap ||
aAttribute == nsGkAtoms::ismap) {
NS_UpdateHint(retval, NS_STYLE_HINT_FRAMECHANGE);
}
return retval;
@ -550,7 +549,7 @@ nsHTMLImageElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
// get bound after all the attributes have been set, so we'll do the
// image load from BindToTree. Skip the LoadImage call in that case.
if (aNotify &&
aNameSpaceID == kNameSpaceID_None && aName == nsHTMLAtoms::src) {
aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::src) {
// If caller is not chrome and dom.disable_image_src_set is true,
// prevent setting image.src by exiting early
@ -595,7 +594,7 @@ nsHTMLImageElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
// Our base URI may have changed; claim that our URI changed, and the
// nsImageLoadingContent will decide whether a new image load is warranted.
nsAutoString uri;
if (GetAttr(kNameSpaceID_None, nsHTMLAtoms::src, uri)) {
if (GetAttr(kNameSpaceID_None, nsGkAtoms::src, uri)) {
// Note: no need to notify here; since we're just now being bound
// we don't have any frames or anything yet.
LoadImage(uri, PR_FALSE, PR_FALSE);
@ -626,7 +625,7 @@ nsHTMLImageElement::Initialize(JSContext* aContext, JSObject *aObj,
JSBool ret = JS_ValueToInt32(aContext, argv[0], &width);
NS_ENSURE_TRUE(ret, NS_ERROR_INVALID_ARG);
nsresult rv = SetIntAttr(nsHTMLAtoms::width, NS_STATIC_CAST(PRInt32, width));
nsresult rv = SetIntAttr(nsGkAtoms::width, NS_STATIC_CAST(PRInt32, width));
if (NS_SUCCEEDED(rv) && (argc > 1)) {
// The second (optional) argument is the height of the image
@ -634,7 +633,7 @@ nsHTMLImageElement::Initialize(JSContext* aContext, JSObject *aObj,
ret = JS_ValueToInt32(aContext, argv[1], &height);
NS_ENSURE_TRUE(ret, NS_ERROR_INVALID_ARG);
rv = SetIntAttr(nsHTMLAtoms::height, NS_STATIC_CAST(PRInt32, height));
rv = SetIntAttr(nsGkAtoms::height, NS_STATIC_CAST(PRInt32, height));
}
return rv;

90
content/html/content/src/nsHTMLInputElement.cpp
Просмотреть файл

@ -53,7 +53,7 @@
#include "nsIDOMHTMLFormElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -252,7 +252,7 @@ protected:
* @param true if the name existed, false if not
*/
PRBool GetNameIfExists(nsAString& aName) {
return GetAttr(kNameSpaceID_None, nsHTMLAtoms::name, aName);
return GetAttr(kNameSpaceID_None, nsGkAtoms::name, aName);
}
/**
@ -269,8 +269,8 @@ protected:
void SelectAll(nsPresContext* aPresContext);
PRBool IsImage() const
{
return AttrValueIs(kNameSpaceID_None, nsHTMLAtoms::type,
nsHTMLAtoms::image, eIgnoreCase);
return AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
nsGkAtoms::image, eIgnoreCase);
}
/**
@ -457,16 +457,16 @@ nsHTMLInputElement::BeforeSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
// (type changes are handled in the form itself currently)
// If the parser is not done creating the radio, we also should not do it.
//
if ((aName == nsHTMLAtoms::name ||
(aName == nsHTMLAtoms::type && !mForm)) &&
if ((aName == nsGkAtoms::name ||
(aName == nsGkAtoms::type && !mForm)) &&
mType == NS_FORM_INPUT_RADIO &&
(mForm || !(GET_BOOLBIT(mBitField, BF_PARSER_CREATING)))) {
WillRemoveFromRadioGroup();
} else if (aNotify && aName == nsHTMLAtoms::src &&
} else if (aNotify && aName == nsGkAtoms::src &&
aValue && mType == NS_FORM_INPUT_IMAGE) {
// Null value means the attr got unset; don't trigger on that
LoadImage(*aValue, PR_TRUE, aNotify);
} else if (aNotify && aName == nsHTMLAtoms::disabled) {
} else if (aNotify && aName == nsGkAtoms::disabled) {
SET_BOOLBIT(mBitField, BF_DISABLED_CHANGED, PR_TRUE);
}
}
@ -486,8 +486,8 @@ nsHTMLInputElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
// (type changes are handled in the form itself currently)
// If the parser is not done creating the radio, we also should not do it.
//
if ((aName == nsHTMLAtoms::name ||
(aName == nsHTMLAtoms::type && !mForm)) &&
if ((aName == nsGkAtoms::name ||
(aName == nsGkAtoms::type && !mForm)) &&
mType == NS_FORM_INPUT_RADIO &&
(mForm || !(GET_BOOLBIT(mBitField, BF_PARSER_CREATING)))) {
AddedToRadioGroup();
@ -502,7 +502,7 @@ nsHTMLInputElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
// We only really need to call reset for the value so that the text control
// knows the new value. No other reason.
//
if (aName == nsHTMLAtoms::value &&
if (aName == nsGkAtoms::value &&
!GET_BOOLBIT(mBitField, BF_VALUE_CHANGED) &&
(mType == NS_FORM_INPUT_TEXT ||
mType == NS_FORM_INPUT_PASSWORD ||
@ -512,7 +512,7 @@ nsHTMLInputElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
//
// Checked must be set no matter what type of control it is, since
// GetChecked() must reflect the new value
if (aName == nsHTMLAtoms::checked) {
if (aName == nsGkAtoms::checked) {
if (aNotify &&
(mType == NS_FORM_INPUT_RADIO || mType == NS_FORM_INPUT_CHECKBOX)) {
// the checked attribute being changed, no matter the current checked
@ -537,7 +537,7 @@ nsHTMLInputElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
}
}
if (aName == nsHTMLAtoms::type) {
if (aName == nsGkAtoms::type) {
if (!aValue) {
// We're now a text input. Note that we have to handle this manually,
// since removing an attribute (which is what happened, since aValue is
@ -551,7 +551,7 @@ nsHTMLInputElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
mType != NS_FORM_INPUT_TEXT &&
mType != NS_FORM_INPUT_PASSWORD &&
mType != NS_FORM_INPUT_FILE) {
SetAttr(kNameSpaceID_None, nsHTMLAtoms::value,
SetAttr(kNameSpaceID_None, nsGkAtoms::value,
NS_ConvertUTF8toUTF16(mValue), PR_FALSE);
if (mValue) {
nsMemory::Free(mValue);
@ -568,7 +568,7 @@ nsHTMLInputElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
// We just got switched to be an image input; we should see
// whether we have an image to load;
nsAutoString src;
if (GetAttr(kNameSpaceID_None, nsHTMLAtoms::src, src)) {
if (GetAttr(kNameSpaceID_None, nsGkAtoms::src, src)) {
LoadImage(src, PR_FALSE, aNotify);
}
}
@ -608,7 +608,7 @@ NS_IMPL_STRING_ATTR(nsHTMLInputElement, UseMap, usemap)
NS_IMETHODIMP
nsHTMLInputElement::GetDefaultValue(nsAString& aValue)
{
GetAttrHelper(nsHTMLAtoms::value, aValue);
GetAttrHelper(nsGkAtoms::value, aValue);
if (mType != NS_FORM_INPUT_HIDDEN) {
// Bug 114997: trim \n, etc. for non-hidden inputs
@ -621,13 +621,13 @@ nsHTMLInputElement::GetDefaultValue(nsAString& aValue)
NS_IMETHODIMP
nsHTMLInputElement::SetDefaultValue(const nsAString& aValue)
{
return SetAttrHelper(nsHTMLAtoms::value, aValue);
return SetAttrHelper(nsGkAtoms::value, aValue);
}
NS_IMETHODIMP
nsHTMLInputElement::GetSize(PRUint32* aValue)
{
const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(nsHTMLAtoms::size);
const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(nsGkAtoms::size);
if (attrVal && attrVal->Type() == nsAttrValue::eInteger) {
*aValue = attrVal->GetIntegerValue();
}
@ -644,7 +644,7 @@ nsHTMLInputElement::SetSize(PRUint32 aValue)
nsAutoString val;
val.AppendInt(aValue);
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::size, val, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::size, val, PR_TRUE);
}
NS_IMETHODIMP
@ -670,7 +670,7 @@ nsHTMLInputElement::GetValue(nsAString& aValue)
}
if (frameOwnsValue) {
formControlFrame->GetFormProperty(nsHTMLAtoms::value, aValue);
formControlFrame->GetFormProperty(nsGkAtoms::value, aValue);
} else {
if (!GET_BOOLBIT(mBitField, BF_VALUE_CHANGED) || !mValue) {
GetDefaultValue(aValue);
@ -694,7 +694,7 @@ nsHTMLInputElement::GetValue(nsAString& aValue)
}
// Treat value == defaultValue for other input elements
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::value, aValue) &&
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::value, aValue) &&
(mType == NS_FORM_INPUT_RADIO || mType == NS_FORM_INPUT_CHECKBOX)) {
// The default value of a radio or checkbox input is "on".
aValue.AssignLiteral("on");
@ -798,7 +798,7 @@ nsHTMLInputElement::SetValueInternal(const nsAString& aValue,
}
// If the frame owns the value, set the value in the frame
if (frameOwnsValue) {
formControlFrame->SetFormProperty(nsHTMLAtoms::value, aValue);
formControlFrame->SetFormProperty(nsGkAtoms::value, aValue);
return NS_OK;
}
@ -828,7 +828,7 @@ nsHTMLInputElement::SetValueInternal(const nsAString& aValue,
// Treat value == defaultValue for other input elements.
return nsGenericHTMLFormElement::SetAttr(kNameSpaceID_None,
nsHTMLAtoms::value, aValue,
nsGkAtoms::value, aValue,
PR_TRUE);
}
@ -1132,7 +1132,7 @@ nsHTMLInputElement::SetFocus(nsPresContext* aPresContext)
return;
// first see if we are disabled or not. If disabled then do nothing.
if (HasAttr(kNameSpaceID_None, nsHTMLAtoms::disabled)) {
if (HasAttr(kNameSpaceID_None, nsGkAtoms::disabled)) {
return;
}
@ -1174,7 +1174,7 @@ nsHTMLInputElement::Select()
return NS_OK;
// first see if we are disabled or not. If disabled then do nothing.
if (HasAttr(kNameSpaceID_None, nsHTMLAtoms::disabled)) {
if (HasAttr(kNameSpaceID_None, nsGkAtoms::disabled)) {
return NS_OK;
}
@ -1256,7 +1256,7 @@ nsHTMLInputElement::SelectAll(nsPresContext* aPresContext)
nsIFormControlFrame* formControlFrame = GetFormControlFrame(PR_TRUE);
if (formControlFrame) {
formControlFrame->SetFormProperty(nsHTMLAtoms::select, EmptyString());
formControlFrame->SetFormProperty(nsGkAtoms::select, EmptyString());
}
}
@ -1270,7 +1270,7 @@ nsHTMLInputElement::Click()
// first see if we are disabled or not. If disabled then do nothing.
nsAutoString disabled;
if (HasAttr(kNameSpaceID_None, nsHTMLAtoms::disabled)) {
if (HasAttr(kNameSpaceID_None, nsGkAtoms::disabled)) {
return NS_OK;
}
@ -1676,8 +1676,8 @@ nsHTMLInputElement::PostHandleEvent(nsEventChainPostVisitor& aVisitor)
do_QueryInterface(aVisitor.mEvent->originalTarget);
if (maybeButton) {
isButton = maybeButton->AttrValueIs(kNameSpaceID_None,
nsHTMLAtoms::type,
nsHTMLAtoms::button,
nsGkAtoms::type,
nsGkAtoms::button,
eCaseMatters);
}
}
@ -1795,7 +1795,7 @@ nsHTMLInputElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
// Our base URI may have changed; claim that our URI changed, and the
// nsImageLoadingContent will decide whether a new image load is warranted.
nsAutoString uri;
if (GetAttr(kNameSpaceID_None, nsHTMLAtoms::src, uri)) {
if (GetAttr(kNameSpaceID_None, nsGkAtoms::src, uri)) {
// Note: no need to notify here; since we're just now being bound
// we don't have any frames or anything yet.
LoadImage(uri, PR_FALSE, PR_FALSE);
@ -1847,7 +1847,7 @@ nsHTMLInputElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::type) {
if (aAttribute == nsGkAtoms::type) {
// XXX ARG!! This is major evilness. ParseAttribute
// shouldn't set members. Override SetAttr instead
if (!aResult.ParseEnumValue(aValue, kInputTypeTable)) {
@ -1874,22 +1874,22 @@ nsHTMLInputElement::ParseAttribute(PRInt32 aNamespaceID,
return PR_TRUE;
}
if (aAttribute == nsHTMLAtoms::width) {
if (aAttribute == nsGkAtoms::width) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::height) {
if (aAttribute == nsGkAtoms::height) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::maxlength) {
if (aAttribute == nsGkAtoms::maxlength) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::size) {
if (aAttribute == nsGkAtoms::size) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::border) {
if (aAttribute == nsGkAtoms::border) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return ParseAlignValue(aValue, aResult);
}
if (ParseImageAttribute(aAttribute, aValue, aResult)) {
@ -1930,14 +1930,14 @@ nsHTMLInputElement::GetType(nsAString& aValue)
NS_IMETHODIMP
nsHTMLInputElement::SetType(const nsAString& aValue)
{
return SetAttrHelper(nsHTMLAtoms::type, aValue);
return SetAttrHelper(nsGkAtoms::type, aValue);
}
static void
MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
nsRuleData* aData)
{
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::type);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::type);
if (value && value->Type() == nsAttrValue::eEnum &&
value->GetEnumValue() == NS_FORM_INPUT_IMAGE) {
nsGenericHTMLFormElement::MapImageBorderAttributeInto(aAttributes, aData);
@ -1956,11 +1956,11 @@ nsHTMLInputElement::GetAttributeChangeHint(const nsIAtom* aAttribute,
{
nsChangeHint retval =
nsGenericHTMLFormElement::GetAttributeChangeHint(aAttribute, aModType);
if (aAttribute == nsHTMLAtoms::type) {
if (aAttribute == nsGkAtoms::type) {
NS_UpdateHint(retval, NS_STYLE_HINT_FRAMECHANGE);
} else if (aAttribute == nsHTMLAtoms::value) {
} else if (aAttribute == nsGkAtoms::value) {
NS_UpdateHint(retval, NS_STYLE_HINT_REFLOW);
} else if (aAttribute == nsHTMLAtoms::size &&
} else if (aAttribute == nsGkAtoms::size &&
(mType == NS_FORM_INPUT_TEXT ||
mType == NS_FORM_INPUT_PASSWORD)) {
NS_UpdateHint(retval, NS_STYLE_HINT_REFLOW);
@ -1972,8 +1972,8 @@ NS_IMETHODIMP_(PRBool)
nsHTMLInputElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::align },
{ &nsHTMLAtoms::type },
{ &nsGkAtoms::align },
{ &nsGkAtoms::type },
{ nsnull },
};
@ -2321,7 +2321,7 @@ nsHTMLInputElement::SubmitNamesValues(nsIFormSubmission* aFormSubmission,
}
if (mType == NS_FORM_INPUT_SUBMIT && value.IsEmpty() &&
!HasAttr(kNameSpaceID_None, nsHTMLAtoms::value)) {
!HasAttr(kNameSpaceID_None, nsGkAtoms::value)) {
// Get our default value, which is the same as our default label
nsXPIDLString defaultValue;
nsContentUtils::GetLocalizedString(nsContentUtils::eFORMS_PROPERTIES,

10
content/html/content/src/nsHTMLLIElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLLIElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -130,12 +130,12 @@ nsHTMLLIElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::type) {
if (aAttribute == nsGkAtoms::type) {
return aResult.ParseEnumValue(aValue, kOrderedListItemTypeTable,
PR_TRUE) ||
aResult.ParseEnumValue(aValue, kUnorderedListItemTypeTable);
}
if (aAttribute == nsHTMLAtoms::value) {
if (aAttribute == nsGkAtoms::value) {
return aResult.ParseIntWithBounds(aValue, 0);
}
}
@ -151,7 +151,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
if (aData->mSID == eStyleStruct_List) {
if (aData->mListData->mType.GetUnit() == eCSSUnit_Null) {
// type: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::type);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::type);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mListData->mType.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -164,7 +164,7 @@ NS_IMETHODIMP_(PRBool)
nsHTMLLIElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::type },
{ &nsGkAtoms::type },
{ nsnull },
};

10
content/html/content/src/nsHTMLLabelElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsIDOMHTMLFormElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIFormControl.h"
@ -290,7 +290,7 @@ nsresult
nsHTMLLabelElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsIAtom* aPrefix,
const nsAString& aValue, PRBool aNotify)
{
if (aName == nsHTMLAtoms::accesskey && kNameSpaceID_None == aNameSpaceID) {
if (aName == nsGkAtoms::accesskey && kNameSpaceID_None == aNameSpaceID) {
RegUnRegAccessKey(PR_FALSE);
}
@ -298,7 +298,7 @@ nsHTMLLabelElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsIAtom* aPref
nsGenericHTMLElement::SetAttr(aNameSpaceID, aName, aPrefix, aValue,
aNotify);
if (aName == nsHTMLAtoms::accesskey && kNameSpaceID_None == aNameSpaceID &&
if (aName == nsGkAtoms::accesskey && kNameSpaceID_None == aNameSpaceID &&
!aValue.IsEmpty()) {
RegUnRegAccessKey(PR_TRUE);
}
@ -310,7 +310,7 @@ nsresult
nsHTMLLabelElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
PRBool aNotify)
{
if (aAttribute == nsHTMLAtoms::accesskey &&
if (aAttribute == nsGkAtoms::accesskey &&
kNameSpaceID_None == aNameSpaceID) {
RegUnRegAccessKey(PR_FALSE);
}
@ -321,7 +321,7 @@ nsHTMLLabelElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
inline PRBool IsNonLabelFormControl(nsIContent *aContent)
{
return aContent->IsNodeOfType(nsINode::eHTML_FORM_CONTROL) &&
aContent->Tag() != nsHTMLAtoms::label;
aContent->Tag() != nsGkAtoms::label;
}
already_AddRefed<nsIContent>

10
content/html/content/src/nsHTMLLegendElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsIDOMHTMLFormElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIForm.h"
@ -163,7 +163,7 @@ nsHTMLLegendElement::ParseAttribute(PRInt32 aNamespaceID,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aAttribute == nsHTMLAtoms::align && aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::align && aNamespaceID == kNameSpaceID_None) {
return aResult.ParseEnumValue(aValue, kAlignTable);
}
@ -177,7 +177,7 @@ nsHTMLLegendElement::GetAttributeChangeHint(const nsIAtom* aAttribute,
{
nsChangeHint retval =
nsGenericHTMLFormElement::GetAttributeChangeHint(aAttribute, aModType);
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
NS_UpdateHint(retval, NS_STYLE_HINT_REFLOW);
}
return retval;
@ -188,7 +188,7 @@ nsHTMLLegendElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
nsIAtom* aPrefix, const nsAString& aValue,
PRBool aNotify)
{
PRBool accesskey = (aAttribute == nsHTMLAtoms::accesskey &&
PRBool accesskey = (aAttribute == nsGkAtoms::accesskey &&
aNameSpaceID == kNameSpaceID_None);
if (accesskey) {
RegUnRegAccessKey(PR_FALSE);
@ -208,7 +208,7 @@ nsresult
nsHTMLLegendElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
PRBool aNotify)
{
if (aAttribute == nsHTMLAtoms::accesskey &&
if (aAttribute == nsGkAtoms::accesskey &&
aNameSpaceID == kNameSpaceID_None) {
RegUnRegAccessKey(PR_FALSE);
}

34
content/html/content/src/nsHTMLLinkElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsILink.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIDOMStyleSheet.h"
@ -262,11 +262,11 @@ nsHTMLLinkElement::CreateAndDispatchEvent(nsIDocument* aDoc,
// doing the "right" thing costs virtually nothing here, even if it doesn't
// make much sense.
static nsIContent::AttrValuesArray strings[] =
{&nsHTMLAtoms::_empty, &nsHTMLAtoms::stylesheet, nsnull};
{&nsGkAtoms::_empty, &nsGkAtoms::stylesheet, nsnull};
if (!nsContentUtils::HasNonEmptyAttr(this, kNameSpaceID_None,
nsHTMLAtoms::rev) &&
FindAttrValueIn(kNameSpaceID_None, nsHTMLAtoms::rel,
nsGkAtoms::rev) &&
FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::rel,
strings, eIgnoreCase) != ATTR_VALUE_NO_MATCH)
return;
@ -280,7 +280,7 @@ nsHTMLLinkElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
nsIAtom* aPrefix, const nsAString& aValue,
PRBool aNotify)
{
if (aName == nsHTMLAtoms::href && kNameSpaceID_None == aNameSpaceID) {
if (aName == nsGkAtoms::href && kNameSpaceID_None == aNameSpaceID) {
nsIDocument* doc = GetCurrentDoc();
if (doc) {
doc->ForgetLink(this);
@ -296,10 +296,10 @@ nsHTMLLinkElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
if (NS_SUCCEEDED(rv)) {
UpdateStyleSheet(nsnull, nsnull,
aNameSpaceID == kNameSpaceID_None &&
(aName == nsHTMLAtoms::rel ||
aName == nsHTMLAtoms::title ||
aName == nsHTMLAtoms::media ||
aName == nsHTMLAtoms::type));
(aName == nsGkAtoms::rel ||
aName == nsGkAtoms::title ||
aName == nsGkAtoms::media ||
aName == nsGkAtoms::type));
}
return rv;
@ -314,10 +314,10 @@ nsHTMLLinkElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
if (NS_SUCCEEDED(rv)) {
UpdateStyleSheet(nsnull, nsnull,
aNameSpaceID == kNameSpaceID_None &&
(aAttribute == nsHTMLAtoms::rel ||
aAttribute == nsHTMLAtoms::title ||
aAttribute == nsHTMLAtoms::media ||
aAttribute == nsHTMLAtoms::type));
(aAttribute == nsGkAtoms::rel ||
aAttribute == nsGkAtoms::title ||
aAttribute == nsGkAtoms::media ||
aAttribute == nsGkAtoms::type));
}
return rv;
@ -371,7 +371,7 @@ nsHTMLLinkElement::GetStyleSheetInfo(nsAString& aTitle,
nsAutoString rel;
nsStringArray linkTypes(4);
GetAttr(kNameSpaceID_None, nsHTMLAtoms::rel, rel);
GetAttr(kNameSpaceID_None, nsGkAtoms::rel, rel);
nsStyleLinkElement::ParseLinkTypes(rel, linkTypes);
// Is it a stylesheet link?
if (linkTypes.IndexOf(NS_LITERAL_STRING("stylesheet")) < 0) {
@ -379,7 +379,7 @@ nsHTMLLinkElement::GetStyleSheetInfo(nsAString& aTitle,
}
nsAutoString title;
GetAttr(kNameSpaceID_None, nsHTMLAtoms::title, title);
GetAttr(kNameSpaceID_None, nsGkAtoms::title, title);
title.CompressWhitespace();
aTitle.Assign(title);
@ -392,12 +392,12 @@ nsHTMLLinkElement::GetStyleSheetInfo(nsAString& aTitle,
}
}
GetAttr(kNameSpaceID_None, nsHTMLAtoms::media, aMedia);
GetAttr(kNameSpaceID_None, nsGkAtoms::media, aMedia);
ToLowerCase(aMedia); // HTML4.0 spec is inconsistent, make it case INSENSITIVE
nsAutoString mimeType;
nsAutoString notUsed;
GetAttr(kNameSpaceID_None, nsHTMLAtoms::type, aType);
GetAttr(kNameSpaceID_None, nsGkAtoms::type, aType);
nsParserUtils::SplitMimeType(aType, mimeType, notUsed);
if (!mimeType.IsEmpty() && !mimeType.LowerCaseEqualsLiteral("text/css")) {
return;

4
content/html/content/src/nsHTMLMapElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLMapElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsContentList.h"
@ -140,7 +140,7 @@ nsHTMLMapElement::GetAreas(nsIDOMHTMLCollection** aAreas)
if (!mAreas) {
// Not using NS_GetContentList because this should not be cached
mAreas = new nsContentList(this,
nsHTMLAtoms::area,
nsGkAtoms::area,
mNodeInfo->NamespaceID(),
PR_FALSE);

22
content/html/content/src/nsHTMLOListElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsIDOMHTMLUListElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -154,13 +154,13 @@ nsHTMLSharedListElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (mNodeInfo->Equals(nsHTMLAtoms::ol) ||
mNodeInfo->Equals(nsHTMLAtoms::ul)) {
if (aAttribute == nsHTMLAtoms::type) {
if (mNodeInfo->Equals(nsGkAtoms::ol) ||
mNodeInfo->Equals(nsGkAtoms::ul)) {
if (aAttribute == nsGkAtoms::type) {
return aResult.ParseEnumValue(aValue, kListTypeTable) ||
aResult.ParseEnumValue(aValue, kOldListTypeTable, PR_TRUE);
}
if (aAttribute == nsHTMLAtoms::start) {
if (aAttribute == nsGkAtoms::start) {
return aResult.ParseIntValue(aValue);
}
}
@ -176,7 +176,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aData)
if (aData->mSID == eStyleStruct_List) {
if (aData->mListData->mType.GetUnit() == eCSSUnit_Null) {
// type: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::type);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::type);
if (value) {
if (value->Type() == nsAttrValue::eEnum)
aData->mListData->mType.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
@ -192,10 +192,10 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aData)
NS_IMETHODIMP_(PRBool)
nsHTMLSharedListElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
if (mNodeInfo->Equals(nsHTMLAtoms::ol) ||
mNodeInfo->Equals(nsHTMLAtoms::ul)) {
if (mNodeInfo->Equals(nsGkAtoms::ol) ||
mNodeInfo->Equals(nsGkAtoms::ul)) {
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::type },
{ &nsGkAtoms::type },
{ nsnull }
};
@ -213,8 +213,8 @@ nsHTMLSharedListElement::IsAttributeMapped(const nsIAtom* aAttribute) const
nsMapRuleToAttributesFunc
nsHTMLSharedListElement::GetAttributeMappingFunction() const
{
if (mNodeInfo->Equals(nsHTMLAtoms::ol) ||
mNodeInfo->Equals(nsHTMLAtoms::ul)) {
if (mNodeInfo->Equals(nsGkAtoms::ol) ||
mNodeInfo->Equals(nsGkAtoms::ul)) {
return &MapAttributesIntoRule;
}

10
content/html/content/src/nsHTMLOptGroupElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLOptGroupElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIFrame.h"
@ -173,10 +173,10 @@ nsHTMLOptGroupElement::GetSelect()
nsIContent* parent = this;
while ((parent = parent->GetParent()) &&
parent->IsNodeOfType(eHTML)) {
if (parent->Tag() == nsHTMLAtoms::select) {
if (parent->Tag() == nsGkAtoms::select) {
return parent;
}
if (parent->Tag() != nsHTMLAtoms::optgroup) {
if (parent->Tag() != nsGkAtoms::optgroup) {
break;
}
}
@ -189,7 +189,7 @@ nsHTMLOptGroupElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
const nsAString* aValue, PRBool aNotify)
{
if (aNotify && aNameSpaceID == kNameSpaceID_None &&
aName == nsHTMLAtoms::disabled) {
aName == nsGkAtoms::disabled) {
nsIDocument* document = GetCurrentDoc();
if (document) {
mozAutoDocUpdate upd(document, UPDATE_CONTENT_STATE, PR_TRUE);
@ -231,7 +231,7 @@ nsHTMLOptGroupElement::IntrinsicState() const
{
PRInt32 state = nsGenericHTMLElement::IntrinsicState();
PRBool disabled;
GetBoolAttr(nsHTMLAtoms::disabled, &disabled);
GetBoolAttr(nsGkAtoms::disabled, &disabled);
if (disabled) {
state |= NS_EVENT_STATE_DISABLED;
state &= ~NS_EVENT_STATE_ENABLED;

27
content/html/content/src/nsHTMLOptionElement.cpp
Просмотреть файл

@ -43,7 +43,7 @@
#include "nsIDOMHTMLFormElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIFormControl.h"
@ -64,7 +64,6 @@
#include "nsIDOMHTMLSelectElement.h"
#include "nsNodeInfoManager.h"
#include "nsCOMPtr.h"
#include "nsLayoutAtoms.h"
#include "nsIEventStateManager.h"
#include "nsIDocument.h"
#include "nsIDOMDocument.h"
@ -158,7 +157,7 @@ NS_NewHTMLOptionElement(nsINodeInfo *aNodeInfo, PRBool aFromParser)
do_QueryInterface(nsContentUtils::GetDocumentFromCaller());
NS_ENSURE_TRUE(doc, nsnull);
rv = doc->NodeInfoManager()->GetNodeInfo(nsHTMLAtoms::option, nsnull,
rv = doc->NodeInfoManager()->GetNodeInfo(nsGkAtoms::option, nsnull,
kNameSpaceID_None,
getter_AddRefs(nodeInfo));
NS_ENSURE_SUCCESS(rv, nsnull);
@ -233,7 +232,7 @@ nsHTMLOptionElement::SetSelectedInternal(PRBool aValue, PRBool aNotify)
NS_IMETHODIMP
nsHTMLOptionElement::SetValue(const nsAString& aValue)
{
SetAttr(kNameSpaceID_None, nsHTMLAtoms::value, aValue, PR_TRUE);
SetAttr(kNameSpaceID_None, nsGkAtoms::value, aValue, PR_TRUE);
return NS_OK;
}
@ -242,7 +241,7 @@ nsHTMLOptionElement::GetValue(nsAString& aValue)
{
// If the value attr is there, that is *exactly* what we use. If it is
// not, we compress whitespace .text.
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::value, aValue)) {
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::value, aValue)) {
GetText(aValue);
}
@ -344,8 +343,8 @@ nsHTMLOptionElement::GetAttributeChangeHint(const nsIAtom* aAttribute,
nsChangeHint retval =
nsGenericHTMLElement::GetAttributeChangeHint(aAttribute, aModType);
if (aAttribute == nsHTMLAtoms::label ||
aAttribute == nsHTMLAtoms::text) {
if (aAttribute == nsGkAtoms::label ||
aAttribute == nsGkAtoms::text) {
NS_UpdateHint(retval, NS_STYLE_HINT_REFLOW);
}
return retval;
@ -390,7 +389,7 @@ nsHTMLOptionElement::IntrinsicState() const
}
PRBool disabled;
GetBoolAttr(nsHTMLAtoms::disabled, &disabled);
GetBoolAttr(nsGkAtoms::disabled, &disabled);
if (disabled) {
state |= NS_EVENT_STATE_DISABLED;
state &= ~NS_EVENT_STATE_ENABLED;
@ -409,10 +408,10 @@ nsHTMLOptionElement::GetSelect()
nsIContent* parent = this;
while ((parent = parent->GetParent()) &&
parent->IsNodeOfType(eHTML)) {
if (parent->Tag() == nsHTMLAtoms::select) {
if (parent->Tag() == nsGkAtoms::select) {
return parent;
}
if (parent->Tag() != nsHTMLAtoms::optgroup) {
if (parent->Tag() != nsGkAtoms::optgroup) {
break;
}
}
@ -425,9 +424,9 @@ nsHTMLOptionElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
const nsAString* aValue, PRBool aNotify)
{
if (aNotify && aNameSpaceID == kNameSpaceID_None &&
(aName == nsHTMLAtoms::disabled || aName == nsHTMLAtoms::selected)) {
(aName == nsGkAtoms::disabled || aName == nsGkAtoms::selected)) {
PRInt32 states;
if (aName == nsHTMLAtoms::disabled) {
if (aName == nsGkAtoms::disabled) {
states = NS_EVENT_STATE_DISABLED | NS_EVENT_STATE_ENABLED;
} else {
states = NS_EVENT_STATE_DEFAULT;
@ -483,7 +482,7 @@ nsHTMLOptionElement::Initialize(JSContext* aContext,
nsAutoString value(NS_REINTERPRET_CAST(const PRUnichar*,
JS_GetStringChars(jsstr)));
result = SetAttr(kNameSpaceID_None, nsHTMLAtoms::value, value,
result = SetAttr(kNameSpaceID_None, nsGkAtoms::value, value,
PR_FALSE);
if (NS_FAILED(result)) {
return result;
@ -497,7 +496,7 @@ nsHTMLOptionElement::Initialize(JSContext* aContext,
argv[2],
&defaultSelected)) &&
(JS_TRUE == defaultSelected)) {
result = SetAttr(kNameSpaceID_None, nsHTMLAtoms::selected,
result = SetAttr(kNameSpaceID_None, nsGkAtoms::selected,
EmptyString(), PR_FALSE);
NS_ENSURE_SUCCESS(result, result);
}

4
content/html/content/src/nsHTMLParagraphElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLParagraphElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -116,7 +116,7 @@ nsHTMLParagraphElement::ParseAttribute(PRInt32 aNamespaceID,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aAttribute == nsHTMLAtoms::align && aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::align && aNamespaceID == kNameSpaceID_None) {
return ParseDivAlignValue(aValue, aResult);
}

26
content/html/content/src/nsHTMLPreElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLPreElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -118,10 +118,10 @@ nsHTMLPreElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::cols) {
if (aAttribute == nsGkAtoms::cols) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::width) {
if (aAttribute == nsGkAtoms::width) {
return aResult.ParseIntWithBounds(aValue, 0);
}
}
@ -136,17 +136,17 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
{
if (aData->mSID == eStyleStruct_Font) {
// variable
if (aAttributes->GetAttr(nsHTMLAtoms::variable))
if (aAttributes->GetAttr(nsGkAtoms::variable))
aData->mFontData->mFamily.SetStringValue(NS_LITERAL_STRING("serif"),
eCSSUnit_String);
}
else if (aData->mSID == eStyleStruct_Position) {
if (aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {
// width: int (html4 attribute == nav4 cols)
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
if (!value || value->Type() != nsAttrValue::eInteger) {
// cols: int (nav4 attribute)
value = aAttributes->GetAttr(nsHTMLAtoms::cols);
value = aAttributes->GetAttr(nsGkAtoms::cols);
}
if (value && value->Type() == nsAttrValue::eInteger)
@ -156,14 +156,14 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
else if (aData->mSID == eStyleStruct_Text) {
if (aData->mTextData->mWhiteSpace.GetUnit() == eCSSUnit_Null) {
// wrap: empty
if (aAttributes->GetAttr(nsHTMLAtoms::wrap))
if (aAttributes->GetAttr(nsGkAtoms::wrap))
aData->mTextData->mWhiteSpace.SetIntValue(NS_STYLE_WHITESPACE_MOZ_PRE_WRAP, eCSSUnit_Enumerated);
// width: int (html4 attribute == nav4 cols)
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
if (!value || value->Type() != nsAttrValue::eInteger) {
// cols: int (nav4 attribute)
value = aAttributes->GetAttr(nsHTMLAtoms::cols);
value = aAttributes->GetAttr(nsGkAtoms::cols);
}
if (value && value->Type() == nsAttrValue::eInteger) {
@ -181,10 +181,10 @@ NS_IMETHODIMP_(PRBool)
nsHTMLPreElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::variable },
{ &nsHTMLAtoms::wrap },
{ &nsHTMLAtoms::cols },
{ &nsHTMLAtoms::width },
{ &nsGkAtoms::variable },
{ &nsGkAtoms::wrap },
{ &nsGkAtoms::cols },
{ &nsGkAtoms::width },
{ nsnull },
};

4
content/html/content/src/nsHTMLScriptElement.cpp
Просмотреть файл

@ -38,7 +38,7 @@
#include "nsIDOMHTMLScriptElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsIDocument.h"
#include "nsScriptElement.h"
@ -545,7 +545,7 @@ nsHTMLScriptElement::MaybeProcessScript()
NS_ENSURE_TRUE(mScriptEventHandler, NS_ERROR_OUT_OF_MEMORY);
nsAutoString event_val;
GetAttr(kNameSpaceID_None, nsHTMLAtoms::event, event_val);
GetAttr(kNameSpaceID_None, nsGkAtoms::event, event_val);
mScriptEventHandler->ParseEventString(event_val);
}

26
content/html/content/src/nsHTMLSelectElement.cpp
Просмотреть файл

@ -45,7 +45,7 @@
#include "nsIDOMEventReceiver.h"
#include "nsContentCreatorFunctions.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsLayoutUtils.h"
@ -722,7 +722,7 @@ nsHTMLSelectElement::RemoveOptionsFromList(nsIContent* aOptions,
static PRBool IsOptGroup(nsIContent *aContent)
{
return (aContent->NodeInfo()->Equals(nsHTMLAtoms::optgroup) &&
return (aContent->NodeInfo()->Equals(nsGkAtoms::optgroup) &&
aContent->IsNodeOfType(nsINode::eHTML));
}
@ -1107,7 +1107,7 @@ nsHTMLSelectElement::SetLength(PRUint32 aLength)
// This violates the W3C DOM but we do this for backwards compatibility
nsCOMPtr<nsINodeInfo> nodeInfo;
nsContentUtils::NameChanged(mNodeInfo, nsHTMLAtoms::option,
nsContentUtils::NameChanged(mNodeInfo, nsGkAtoms::option,
getter_AddRefs(nodeInfo));
nsCOMPtr<nsIContent> element = NS_NewHTMLOptionElement(nodeInfo);
@ -1612,7 +1612,7 @@ nsHTMLSelectElement::SetFocus(nsPresContext* aPresContext)
return;
// first see if we are disabled or not. If disabled then do nothing.
if (HasAttr(kNameSpaceID_None, nsHTMLAtoms::disabled)) {
if (HasAttr(kNameSpaceID_None, nsGkAtoms::disabled)) {
return;
}
@ -1690,7 +1690,7 @@ nsresult
nsHTMLSelectElement::BeforeSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
const nsAString* aValue, PRBool aNotify)
{
if (aNotify && aName == nsHTMLAtoms::disabled &&
if (aNotify && aName == nsGkAtoms::disabled &&
aNameSpaceID == kNameSpaceID_None) {
mDisabledChanged = PR_TRUE;
}
@ -1704,7 +1704,7 @@ nsHTMLSelectElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
PRBool aNotify)
{
if (aNotify && aNameSpaceID == kNameSpaceID_None &&
aAttribute == nsHTMLAtoms::multiple) {
aAttribute == nsGkAtoms::multiple) {
// We're changing from being a multi-select to a single-select.
// Make sure we only have one option selected before we do that.
// Note that this needs to come before we really unset the attr,
@ -1721,7 +1721,7 @@ nsHTMLSelectElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
NS_ENSURE_SUCCESS(rv, rv);
if (aNotify && aNameSpaceID == kNameSpaceID_None &&
aAttribute == nsHTMLAtoms::multiple) {
aAttribute == nsGkAtoms::multiple) {
// We might have become a combobox; make sure _something_ gets
// selected in that case
CheckSelectSomething();
@ -1771,7 +1771,7 @@ nsHTMLSelectElement::ParseAttribute(PRInt32 aNamespaceID,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aAttribute == nsHTMLAtoms::size && kNameSpaceID_None == aNamespaceID) {
if (aAttribute == nsGkAtoms::size && kNameSpaceID_None == aNamespaceID) {
return aResult.ParseIntWithBounds(aValue, 0);
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
@ -1792,8 +1792,8 @@ nsHTMLSelectElement::GetAttributeChangeHint(const nsIAtom* aAttribute,
{
nsChangeHint retval =
nsGenericHTMLFormElement::GetAttributeChangeHint(aAttribute, aModType);
if (aAttribute == nsHTMLAtoms::multiple ||
aAttribute == nsHTMLAtoms::size) {
if (aAttribute == nsGkAtoms::multiple ||
aAttribute == nsGkAtoms::size) {
NS_UpdateHint(retval, NS_STYLE_HINT_FRAMECHANGE);
}
return retval;
@ -2045,7 +2045,7 @@ nsHTMLSelectElement::SubmitNamesValues(nsIFormSubmission* aFormSubmission,
// Get the name (if no name, no submit)
//
nsAutoString name;
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::name, name)) {
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::name, name)) {
return NS_OK;
}
@ -2354,9 +2354,9 @@ nsHTMLOptionCollection::NamedItem(const nsAString& aName,
nsCOMPtr<nsIContent> content = do_QueryInterface(mElements.ObjectAt(i));
if (content) {
if (content->AttrValueIs(kNameSpaceID_None, nsHTMLAtoms::name, aName,
if (content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name, aName,
eCaseMatters) ||
content->AttrValueIs(kNameSpaceID_None, nsHTMLAtoms::id, aName,
content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::id, aName,
eCaseMatters)) {
rv = CallQueryInterface(content, aReturn);

56
content/html/content/src/nsHTMLSharedElement.cpp
Просмотреть файл

@ -42,7 +42,7 @@
#include "nsIDOMHTMLQuoteElement.h"
#include "nsIDOMHTMLBaseFontElement.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsRuleData.h"
@ -197,29 +197,29 @@ nsHTMLSharedElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (mNodeInfo->Equals(nsHTMLAtoms::spacer)) {
if (aAttribute == nsHTMLAtoms::size) {
if (mNodeInfo->Equals(nsGkAtoms::spacer)) {
if (aAttribute == nsGkAtoms::size) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return ParseAlignValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::width ||
aAttribute == nsHTMLAtoms::height) {
if (aAttribute == nsGkAtoms::width ||
aAttribute == nsGkAtoms::height) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
}
else if (mNodeInfo->Equals(nsHTMLAtoms::dir) ||
mNodeInfo->Equals(nsHTMLAtoms::menu)) {
if (aAttribute == nsHTMLAtoms::type) {
else if (mNodeInfo->Equals(nsGkAtoms::dir) ||
mNodeInfo->Equals(nsGkAtoms::menu)) {
if (aAttribute == nsGkAtoms::type) {
return aResult.ParseEnumValue(aValue, kListTypeTable);
}
if (aAttribute == nsHTMLAtoms::start) {
if (aAttribute == nsGkAtoms::start) {
return aResult.ParseIntWithBounds(aValue, 1);
}
}
else if (mNodeInfo->Equals(nsHTMLAtoms::basefont)) {
if (aAttribute == nsHTMLAtoms::size) {
else if (mNodeInfo->Equals(nsGkAtoms::basefont)) {
if (aAttribute == nsGkAtoms::size) {
return aResult.ParseIntValue(aValue);
}
}
@ -246,7 +246,7 @@ SpacerMapAttributesIntoRule(const nsMappedAttributes* aAttributes,
if (typeIsBlock) {
// width: value
if (aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
if (value && value->Type() == nsAttrValue::eInteger) {
aData->mPositionData->
mWidth.SetFloatValue((float)value->GetIntegerValue(),
@ -259,7 +259,7 @@ SpacerMapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// height: value
if (aData->mPositionData->mHeight.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::height);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::height);
if (value && value->Type() == nsAttrValue::eInteger) {
aData->mPositionData->
mHeight.SetFloatValue((float)value->GetIntegerValue(),
@ -272,7 +272,7 @@ SpacerMapAttributesIntoRule(const nsMappedAttributes* aAttributes,
} else {
// size: value
if (aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::size);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::size);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mPositionData->
mWidth.SetFloatValue((float)value->GetIntegerValue(),
@ -280,7 +280,7 @@ SpacerMapAttributesIntoRule(const nsMappedAttributes* aAttributes,
}
}
} else if (aData->mSID == eStyleStruct_Display) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum) {
PRInt32 align = value->GetEnumValue();
if (aData->mDisplayData->mFloat.GetUnit() == eCSSUnit_Null) {
@ -294,7 +294,7 @@ SpacerMapAttributesIntoRule(const nsMappedAttributes* aAttributes,
}
if (aData->mDisplayData->mDisplay.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::type);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::type);
if (value && value->Type() == nsAttrValue::eString) {
nsAutoString tmp(value->GetStringValue());
if (tmp.LowerCaseEqualsLiteral("line") ||
@ -320,7 +320,7 @@ DirectoryMenuMapAttributesIntoRule(const nsMappedAttributes* aAttributes,
if (aData->mSID == eStyleStruct_List) {
if (aData->mListData->mType.GetUnit() == eCSSUnit_Null) {
// type: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::type);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::type);
if (value) {
if (value->Type() == nsAttrValue::eEnum) {
aData->mListData->mType.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
@ -337,12 +337,12 @@ DirectoryMenuMapAttributesIntoRule(const nsMappedAttributes* aAttributes,
NS_IMETHODIMP_(PRBool)
nsHTMLSharedElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
if (mNodeInfo->Equals(nsHTMLAtoms::spacer)) {
if (mNodeInfo->Equals(nsGkAtoms::spacer)) {
static const MappedAttributeEntry attributes[] = {
// XXXldb This is just wrong.
{ &nsHTMLAtoms::usemap },
{ &nsHTMLAtoms::ismap },
{ &nsHTMLAtoms::align },
{ &nsGkAtoms::usemap },
{ &nsGkAtoms::ismap },
{ &nsGkAtoms::align },
{ nsnull }
};
@ -356,10 +356,10 @@ nsHTMLSharedElement::IsAttributeMapped(const nsIAtom* aAttribute) const
return FindAttributeDependence(aAttribute, map, NS_ARRAY_LENGTH(map));
}
if (mNodeInfo->Equals(nsHTMLAtoms::dir)) {
if (mNodeInfo->Equals(nsGkAtoms::dir)) {
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::type },
// { &nsHTMLAtoms::compact }, // XXX
{ &nsGkAtoms::type },
// { &nsGkAtoms::compact }, // XXX
{ nsnull}
};
@ -377,11 +377,11 @@ nsHTMLSharedElement::IsAttributeMapped(const nsIAtom* aAttribute) const
nsMapRuleToAttributesFunc
nsHTMLSharedElement::GetAttributeMappingFunction() const
{
if (mNodeInfo->Equals(nsHTMLAtoms::spacer)) {
if (mNodeInfo->Equals(nsGkAtoms::spacer)) {
return &SpacerMapAttributesIntoRule;
}
else if (mNodeInfo->Equals(nsHTMLAtoms::dir) ||
mNodeInfo->Equals(nsHTMLAtoms::menu)) {
else if (mNodeInfo->Equals(nsGkAtoms::dir) ||
mNodeInfo->Equals(nsGkAtoms::menu)) {
return &DirectoryMenuMapAttributesIntoRule;
}

10
content/html/content/src/nsHTMLSpanElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLElement.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIAtom.h"
@ -98,8 +98,8 @@ NS_IMPL_ELEMENT_CLONE(nsHTMLSpanElement)
nsresult
nsHTMLSpanElement::GetInnerHTML(nsAString& aInnerHTML)
{
if (mNodeInfo->Equals(nsHTMLAtoms::xmp) ||
mNodeInfo->Equals(nsHTMLAtoms::plaintext)) {
if (mNodeInfo->Equals(nsGkAtoms::xmp) ||
mNodeInfo->Equals(nsGkAtoms::plaintext)) {
nsContentUtils::GetNodeTextContent(this, PR_FALSE, aInnerHTML);
return NS_OK;
}
@ -110,8 +110,8 @@ nsHTMLSpanElement::GetInnerHTML(nsAString& aInnerHTML)
nsresult
nsHTMLSpanElement::SetInnerHTML(const nsAString& aInnerHTML)
{
if (mNodeInfo->Equals(nsHTMLAtoms::xmp) ||
mNodeInfo->Equals(nsHTMLAtoms::plaintext)) {
if (mNodeInfo->Equals(nsGkAtoms::xmp) ||
mNodeInfo->Equals(nsGkAtoms::plaintext)) {
return nsContentUtils::SetNodeTextContent(this, aInnerHTML, PR_TRUE);
}

22
content/html/content/src/nsHTMLStyleElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsIDOMLinkStyle.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsIDOMStyleSheet.h"
@ -232,9 +232,9 @@ nsHTMLStyleElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
if (NS_SUCCEEDED(rv)) {
UpdateStyleSheet(nsnull, nsnull,
aNameSpaceID == kNameSpaceID_None &&
(aName == nsHTMLAtoms::title ||
aName == nsHTMLAtoms::media ||
aName == nsHTMLAtoms::type));
(aName == nsGkAtoms::title ||
aName == nsGkAtoms::media ||
aName == nsGkAtoms::type));
}
return rv;
@ -249,9 +249,9 @@ nsHTMLStyleElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
if (NS_SUCCEEDED(rv)) {
UpdateStyleSheet(nsnull, nsnull,
aNameSpaceID == kNameSpaceID_None &&
(aAttribute == nsHTMLAtoms::title ||
aAttribute == nsHTMLAtoms::media ||
aAttribute == nsHTMLAtoms::type));
(aAttribute == nsGkAtoms::title ||
aAttribute == nsGkAtoms::media ||
aAttribute == nsGkAtoms::type));
}
return rv;
@ -282,7 +282,7 @@ nsHTMLStyleElement::GetStyleSheetURL(PRBool* aIsInline,
nsIURI** aURI)
{
*aURI = nsnull;
*aIsInline = !HasAttr(kNameSpaceID_None, nsHTMLAtoms::src);
*aIsInline = !HasAttr(kNameSpaceID_None, nsGkAtoms::src);
if (*aIsInline) {
return;
}
@ -309,14 +309,14 @@ nsHTMLStyleElement::GetStyleSheetInfo(nsAString& aTitle,
*aIsAlternate = PR_FALSE;
nsAutoString title;
GetAttr(kNameSpaceID_None, nsHTMLAtoms::title, title);
GetAttr(kNameSpaceID_None, nsGkAtoms::title, title);
title.CompressWhitespace();
aTitle.Assign(title);
GetAttr(kNameSpaceID_None, nsHTMLAtoms::media, aMedia);
GetAttr(kNameSpaceID_None, nsGkAtoms::media, aMedia);
ToLowerCase(aMedia); // HTML4.0 spec is inconsistent, make it case INSENSITIVE
GetAttr(kNameSpaceID_None, nsHTMLAtoms::type, aType);
GetAttr(kNameSpaceID_None, nsGkAtoms::type, aType);
nsAutoString mimeType;
nsAutoString notUsed;

8
content/html/content/src/nsHTMLTableCaptionElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsIDOMHTMLTableCaptionElem.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -121,7 +121,7 @@ nsHTMLTableCaptionElement::ParseAttribute(PRInt32 aNamespaceID,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aAttribute == nsHTMLAtoms::align && aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::align && aNamespaceID == kNameSpaceID_None) {
return aResult.ParseEnumValue(aValue, kCaptionAlignTable);
}
@ -134,7 +134,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
{
if (aData->mSID == eStyleStruct_TableBorder) {
if (aData->mTableData->mCaptionSide.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTableData->mCaptionSide.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -147,7 +147,7 @@ NS_IMETHODIMP_(PRBool)
nsHTMLTableCaptionElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::align },
{ &nsGkAtoms::align },
{ nsnull }
};

56
content/html/content/src/nsHTMLTableCellElement.cpp
Просмотреть файл

@ -40,7 +40,7 @@
#include "nsIDOMEventReceiver.h"
#include "nsMappedAttributes.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsRuleData.h"
@ -138,7 +138,7 @@ nsHTMLTableCellElement::GetTable()
nsIContent* section = parent->GetParent();
if (section) {
if (section->IsNodeOfType(eHTML) &&
section->NodeInfo()->Equals(nsHTMLAtoms::table)) {
section->NodeInfo()->Equals(nsGkAtoms::table)) {
// XHTML, without a row group
result = section;
} else {
@ -231,7 +231,7 @@ NS_IMPL_STRING_ATTR(nsHTMLTableCellElement, Width, width)
NS_IMETHODIMP
nsHTMLTableCellElement::GetAlign(nsAString& aValue)
{
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::align, aValue)) {
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::align, aValue)) {
// There's no align attribute, ask the row for the alignment.
nsCOMPtr<nsIDOMHTMLTableRowElement> row;
@ -248,7 +248,7 @@ nsHTMLTableCellElement::GetAlign(nsAString& aValue)
NS_IMETHODIMP
nsHTMLTableCellElement::SetAlign(const nsAString& aValue)
{
return SetAttr(kNameSpaceID_None, nsHTMLAtoms::align, aValue, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::align, aValue, PR_TRUE);
}
@ -273,11 +273,11 @@ nsHTMLTableCellElement::ParseAttribute(PRInt32 aNamespaceID,
/* ignore these attributes, stored simply as strings
abbr, axis, ch, headers
*/
if (aAttribute == nsHTMLAtoms::charoff) {
if (aAttribute == nsGkAtoms::charoff) {
/* attributes that resolve to integers with a min of 0 */
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::colspan) {
if (aAttribute == nsGkAtoms::colspan) {
PRBool res = aResult.ParseIntWithBounds(aValue, -1);
if (res) {
PRInt32 val = aResult.GetIntegerValue();
@ -290,7 +290,7 @@ nsHTMLTableCellElement::ParseAttribute(PRInt32 aNamespaceID,
}
return res;
}
if (aAttribute == nsHTMLAtoms::rowspan) {
if (aAttribute == nsGkAtoms::rowspan) {
PRBool res = aResult.ParseIntWithBounds(aValue, -1, MAX_ROWSPAN);
if (res) {
PRInt32 val = aResult.GetIntegerValue();
@ -301,22 +301,22 @@ nsHTMLTableCellElement::ParseAttribute(PRInt32 aNamespaceID,
}
return res;
}
if (aAttribute == nsHTMLAtoms::height) {
if (aAttribute == nsGkAtoms::height) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::width) {
if (aAttribute == nsGkAtoms::width) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return ParseTableCellHAlignValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::bgcolor) {
if (aAttribute == nsGkAtoms::bgcolor) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if (aAttribute == nsHTMLAtoms::scope) {
if (aAttribute == nsGkAtoms::scope) {
return aResult.ParseEnumValue(aValue, kCellScopeTable);
}
if (aAttribute == nsHTMLAtoms::valign) {
if (aAttribute == nsGkAtoms::valign) {
return ParseTableVAlignValue(aValue, aResult);
}
}
@ -332,7 +332,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
if (aData->mSID == eStyleStruct_Position) {
// width: value
if (aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
if (value && value->Type() == nsAttrValue::eInteger) {
if (value->GetIntegerValue() > 0)
aData->mPositionData->mWidth.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
@ -347,7 +347,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// height: value
if (aData->mPositionData->mHeight.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::height);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::height);
if (value && value->Type() == nsAttrValue::eInteger) {
if (value->GetIntegerValue() > 0)
aData->mPositionData->mHeight.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
@ -363,16 +363,16 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
else if (aData->mSID == eStyleStruct_Text) {
if (aData->mTextData->mTextAlign.GetUnit() == eCSSUnit_Null) {
// align: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTextData->mTextAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
if (aData->mTextData->mWhiteSpace.GetUnit() == eCSSUnit_Null) {
// nowrap: enum
if (aAttributes->GetAttr(nsHTMLAtoms::nowrap)) {
if (aAttributes->GetAttr(nsGkAtoms::nowrap)) {
// See if our width is not a integer width.
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
nsCompatibility mode = aData->mPresContext->CompatibilityMode();
if (!value || value->Type() != nsAttrValue::eInteger || eCompatibility_NavQuirks != mode)
aData->mTextData->mWhiteSpace.SetIntValue(NS_STYLE_WHITESPACE_NOWRAP, eCSSUnit_Enumerated);
@ -382,7 +382,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
else if (aData->mSID == eStyleStruct_TextReset) {
if (aData->mTextData->mVerticalAlign.GetUnit() == eCSSUnit_Null) {
// valign: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::valign);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::valign);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTextData->mVerticalAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -396,19 +396,19 @@ NS_IMETHODIMP_(PRBool)
nsHTMLTableCellElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::align },
{ &nsHTMLAtoms::valign },
{ &nsHTMLAtoms::nowrap },
{ &nsGkAtoms::align },
{ &nsGkAtoms::valign },
{ &nsGkAtoms::nowrap },
#if 0
// XXXldb If these are implemented, they might need to move to
// GetAttributeChangeHint (depending on how, and preferably not).
{ &nsHTMLAtoms::abbr },
{ &nsHTMLAtoms::axis },
{ &nsHTMLAtoms::headers },
{ &nsHTMLAtoms::scope },
{ &nsGkAtoms::abbr },
{ &nsGkAtoms::axis },
{ &nsGkAtoms::headers },
{ &nsGkAtoms::scope },
#endif
{ &nsHTMLAtoms::width },
{ &nsHTMLAtoms::height },
{ &nsGkAtoms::width },
{ &nsGkAtoms::height },
{ nsnull }
};

32
content/html/content/src/nsHTMLTableColElement.cpp
Просмотреть файл

@ -38,7 +38,7 @@
#include "nsIDOMEventReceiver.h"
#include "nsMappedAttributes.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsRuleData.h"
@ -124,20 +124,20 @@ nsHTMLTableColElement::ParseAttribute(PRInt32 aNamespaceID,
{
if (aNamespaceID == kNameSpaceID_None) {
/* ignore these attributes, stored simply as strings ch */
if (aAttribute == nsHTMLAtoms::charoff) {
if (aAttribute == nsGkAtoms::charoff) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::span) {
if (aAttribute == nsGkAtoms::span) {
/* protection from unrealistic large colspan values */
return aResult.ParseIntWithBounds(aValue, 1, MAX_COLSPAN);
}
if (aAttribute == nsHTMLAtoms::width) {
if (aAttribute == nsGkAtoms::width) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return ParseTableCellHAlignValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::valign) {
if (aAttribute == nsGkAtoms::valign) {
return ParseTableVAlignValue(aValue, aResult);
}
}
@ -152,7 +152,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
if (aData->mSID == eStyleStruct_Position &&
aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {
// width
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
if (value) {
switch (value->Type()) {
case nsAttrValue::ePercent: {
@ -175,7 +175,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
else if (aData->mSID == eStyleStruct_Text) {
if (aData->mTextData->mTextAlign.GetUnit() == eCSSUnit_Null) {
// align: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTextData->mTextAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -183,7 +183,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
else if (aData->mSID == eStyleStruct_TextReset) {
if (aData->mTextData->mVerticalAlign.GetUnit() == eCSSUnit_Null) {
// valign: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::valign);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::valign);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTextData->mVerticalAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -199,7 +199,7 @@ void ColMapAttributesIntoRule(const nsMappedAttributes* aAttributes,
if (aData->mSID == eStyleStruct_Table &&
aData->mTableData->mSpan.GetUnit() == eCSSUnit_Null) {
// span: int
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::span);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::span);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mTableData->mSpan.SetIntValue(value->GetIntegerValue(),
eCSSUnit_Integer);
@ -212,14 +212,14 @@ NS_IMETHODIMP_(PRBool)
nsHTMLTableColElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::width },
{ &nsHTMLAtoms::align },
{ &nsHTMLAtoms::valign },
{ &nsGkAtoms::width },
{ &nsGkAtoms::align },
{ &nsGkAtoms::valign },
{ nsnull }
};
static const MappedAttributeEntry span_attribute[] = {
{ &nsHTMLAtoms::span },
{ &nsGkAtoms::span },
{ nsnull }
};
@ -235,7 +235,7 @@ nsHTMLTableColElement::IsAttributeMapped(const nsIAtom* aAttribute) const
};
// we only match "span" if we're a <col>
if (mNodeInfo->Equals(nsHTMLAtoms::col))
if (mNodeInfo->Equals(nsGkAtoms::col))
return FindAttributeDependence(aAttribute, col_map,
NS_ARRAY_LENGTH(col_map));
return FindAttributeDependence(aAttribute, colspan_map,
@ -246,7 +246,7 @@ nsHTMLTableColElement::IsAttributeMapped(const nsIAtom* aAttribute) const
nsMapRuleToAttributesFunc
nsHTMLTableColElement::GetAttributeMappingFunction() const
{
if (mNodeInfo->Equals(nsHTMLAtoms::col)) {
if (mNodeInfo->Equals(nsGkAtoms::col)) {
return &ColMapAttributesIntoRule;
}

120
content/html/content/src/nsHTMLTableElement.cpp
Просмотреть файл

@ -44,7 +44,7 @@
#include "nsGenericDOMHTMLCollection.h"
#include "nsMappedAttributes.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsHTMLParts.h"
@ -143,7 +143,7 @@ nsresult
TableRowsCollection::Init()
{
mOrphanRows = new nsContentList(mParent,
nsHTMLAtoms::tr,
nsGkAtoms::tr,
mParent->NodeInfo()->NamespaceID(),
PR_FALSE);
return mOrphanRows ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
@ -427,7 +427,7 @@ nsHTMLTableElement::GetSection(nsIAtom *aTag)
NS_IMETHODIMP
nsHTMLTableElement::GetTHead(nsIDOMHTMLTableSectionElement** aValue)
{
*aValue = GetSection(nsHTMLAtoms::thead).get();
*aValue = GetSection(nsGkAtoms::thead).get();
return NS_OK;
}
@ -438,7 +438,7 @@ nsHTMLTableElement::SetTHead(nsIDOMHTMLTableSectionElement* aValue)
nsCOMPtr<nsIContent> content(do_QueryInterface(aValue));
NS_ENSURE_TRUE(content, NS_ERROR_DOM_HIERARCHY_REQUEST_ERR);
if (!content->NodeInfo()->Equals(nsHTMLAtoms::thead)) {
if (!content->NodeInfo()->Equals(nsGkAtoms::thead)) {
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
}
@ -464,7 +464,7 @@ nsHTMLTableElement::SetTHead(nsIDOMHTMLTableSectionElement* aValue)
NS_IMETHODIMP
nsHTMLTableElement::GetTFoot(nsIDOMHTMLTableSectionElement** aValue)
{
*aValue = GetSection(nsHTMLAtoms::tfoot).get();
*aValue = GetSection(nsGkAtoms::tfoot).get();
return NS_OK;
}
@ -475,7 +475,7 @@ nsHTMLTableElement::SetTFoot(nsIDOMHTMLTableSectionElement* aValue)
nsCOMPtr<nsIContent> content(do_QueryInterface(aValue));
NS_ENSURE_TRUE(content, NS_ERROR_DOM_HIERARCHY_REQUEST_ERR);
if (!content->NodeInfo()->Equals(nsHTMLAtoms::tfoot)) {
if (!content->NodeInfo()->Equals(nsGkAtoms::tfoot)) {
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
}
@ -494,7 +494,7 @@ NS_IMETHODIMP
nsHTMLTableElement::GetRows(nsIDOMHTMLCollection** aValue)
{
if (!mRows) {
// XXX why was this here NS_ADDREF(nsHTMLAtoms::tr);
// XXX why was this here NS_ADDREF(nsGkAtoms::tr);
mRows = new TableRowsCollection(this);
NS_ENSURE_TRUE(mRows, NS_ERROR_OUT_OF_MEMORY);
@ -517,7 +517,7 @@ nsHTMLTableElement::GetTBodies(nsIDOMHTMLCollection** aValue)
if (!mTBodies) {
// Not using NS_GetContentList because this should not be cached
mTBodies = new nsContentList(this,
nsHTMLAtoms::tbody,
nsGkAtoms::tbody,
mNodeInfo->NamespaceID(),
PR_FALSE);
@ -546,7 +546,7 @@ nsHTMLTableElement::CreateTHead(nsIDOMHTMLElement** aValue)
{ // create a new head rowgroup
nsCOMPtr<nsINodeInfo> nodeInfo;
nsContentUtils::NameChanged(mNodeInfo, nsHTMLAtoms::thead,
nsContentUtils::NameChanged(mNodeInfo, nsGkAtoms::thead,
getter_AddRefs(nodeInfo));
nsCOMPtr<nsIContent> newHead = NS_NewHTMLTableSectionElement(nodeInfo);
@ -602,7 +602,7 @@ nsHTMLTableElement::CreateTFoot(nsIDOMHTMLElement** aValue)
else
{ // create a new foot rowgroup
nsCOMPtr<nsINodeInfo> nodeInfo;
nsContentUtils::NameChanged(mNodeInfo, nsHTMLAtoms::tfoot,
nsContentUtils::NameChanged(mNodeInfo, nsGkAtoms::tfoot,
getter_AddRefs(nodeInfo));
nsCOMPtr<nsIContent> newFoot = NS_NewHTMLTableSectionElement(nodeInfo);
@ -648,7 +648,7 @@ nsHTMLTableElement::CreateCaption(nsIDOMHTMLElement** aValue)
else
{ // create a new head rowgroup
nsCOMPtr<nsINodeInfo> nodeInfo;
nsContentUtils::NameChanged(mNodeInfo, nsHTMLAtoms::caption,
nsContentUtils::NameChanged(mNodeInfo, nsGkAtoms::caption,
getter_AddRefs(nodeInfo));
nsCOMPtr<nsIContent> newCaption = NS_NewHTMLTableCaptionElement(nodeInfo);
@ -724,7 +724,7 @@ nsHTMLTableElement::InsertRow(PRInt32 aIndex, nsIDOMHTMLElement** aValue)
refRow->GetParentNode(getter_AddRefs(parent));
// create the row
nsCOMPtr<nsINodeInfo> nodeInfo;
nsContentUtils::NameChanged(mNodeInfo, nsHTMLAtoms::tr,
nsContentUtils::NameChanged(mNodeInfo, nsGkAtoms::tr,
getter_AddRefs(nodeInfo));
nsCOMPtr<nsIContent> newRow = NS_NewHTMLTableRowElement(nodeInfo);
@ -762,9 +762,9 @@ nsHTMLTableElement::InsertRow(PRInt32 aIndex, nsIDOMHTMLElement** aValue)
nsINodeInfo *childInfo = child->NodeInfo();
nsIAtom *localName = childInfo->NameAtom();
if (childInfo->NamespaceID() == namespaceID &&
(localName == nsHTMLAtoms::thead ||
localName == nsHTMLAtoms::tbody ||
localName == nsHTMLAtoms::tfoot)) {
(localName == nsGkAtoms::thead ||
localName == nsGkAtoms::tbody ||
localName == nsGkAtoms::tfoot)) {
rowGroup = do_QueryInterface(child);
NS_ASSERTION(rowGroup, "HTML node did not QI to nsIDOMNode");
break;
@ -773,7 +773,7 @@ nsHTMLTableElement::InsertRow(PRInt32 aIndex, nsIDOMHTMLElement** aValue)
if (!rowGroup) { // need to create a TBODY
nsCOMPtr<nsINodeInfo> nodeInfo;
nsContentUtils::NameChanged(mNodeInfo, nsHTMLAtoms::tbody,
nsContentUtils::NameChanged(mNodeInfo, nsGkAtoms::tbody,
getter_AddRefs(nodeInfo));
nsCOMPtr<nsIContent> newRowGroup =
@ -788,7 +788,7 @@ nsHTMLTableElement::InsertRow(PRInt32 aIndex, nsIDOMHTMLElement** aValue)
if (rowGroup) {
nsCOMPtr<nsINodeInfo> nodeInfo;
nsContentUtils::NameChanged(mNodeInfo, nsHTMLAtoms::tr,
nsContentUtils::NameChanged(mNodeInfo, nsGkAtoms::tr,
getter_AddRefs(nodeInfo));
nsCOMPtr<nsIContent> newRow = NS_NewHTMLTableRowElement(nodeInfo);
@ -899,14 +899,14 @@ nsHTMLTableElement::ParseAttribute(PRInt32 aNamespaceID,
{
/* ignore summary, just a string */
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::cellspacing ||
aAttribute == nsHTMLAtoms::cellpadding) {
if (aAttribute == nsGkAtoms::cellspacing ||
aAttribute == nsGkAtoms::cellpadding) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::cols) {
if (aAttribute == nsGkAtoms::cols) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::border) {
if (aAttribute == nsGkAtoms::border) {
if (!aResult.ParseIntWithBounds(aValue, 0)) {
// XXX this should really be NavQuirks only to allow non numeric value
aResult.SetTo(1);
@ -914,10 +914,10 @@ nsHTMLTableElement::ParseAttribute(PRInt32 aNamespaceID,
return PR_TRUE;
}
if (aAttribute == nsHTMLAtoms::height) {
if (aAttribute == nsGkAtoms::height) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::width) {
if (aAttribute == nsGkAtoms::width) {
if (aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE)) {
// treat 0 width as auto
nsAttrValue::ValueType type = aResult.Type();
@ -931,24 +931,24 @@ nsHTMLTableElement::ParseAttribute(PRInt32 aNamespaceID,
return PR_TRUE;
}
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return ParseTableHAlignValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::bgcolor ||
aAttribute == nsHTMLAtoms::bordercolor) {
if (aAttribute == nsGkAtoms::bgcolor ||
aAttribute == nsGkAtoms::bordercolor) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if (aAttribute == nsHTMLAtoms::frame) {
if (aAttribute == nsGkAtoms::frame) {
return aResult.ParseEnumValue(aValue, kFrameTable);
}
if (aAttribute == nsHTMLAtoms::layout) {
if (aAttribute == nsGkAtoms::layout) {
return aResult.ParseEnumValue(aValue, kLayoutTable);
}
if (aAttribute == nsHTMLAtoms::rules) {
if (aAttribute == nsGkAtoms::rules) {
return aResult.ParseEnumValue(aValue, kRulesTable);
}
if (aAttribute == nsHTMLAtoms::hspace ||
aAttribute == nsHTMLAtoms::vspace) {
if (aAttribute == nsGkAtoms::hspace ||
aAttribute == nsGkAtoms::vspace) {
return aResult.ParseIntWithBounds(aValue, 0);
}
}
@ -965,7 +965,7 @@ MapTableFrameInto(const nsMappedAttributes* aAttributes,
return;
// 0 out the sides that we want to hide based on the frame attribute
const nsAttrValue* frameValue = aAttributes->GetAttr(nsHTMLAtoms::frame);
const nsAttrValue* frameValue = aAttributes->GetAttr(nsGkAtoms::frame);
if (frameValue && frameValue->Type() == nsAttrValue::eEnum) {
// adjust the border style based on the value of frame
@ -1049,8 +1049,8 @@ static void
MapTableBorderInto(const nsMappedAttributes* aAttributes,
nsRuleData* aData, PRUint8 aBorderStyle)
{
const nsAttrValue* borderValue = aAttributes->GetAttr(nsHTMLAtoms::border);
if (!borderValue && !aAttributes->GetAttr(nsHTMLAtoms::frame))
const nsAttrValue* borderValue = aAttributes->GetAttr(nsGkAtoms::border);
if (!borderValue && !aAttributes->GetAttr(nsGkAtoms::frame))
return;
// the absence of "border" with the presence of "frame" implies
@ -1109,7 +1109,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
const nsStyleDisplay* readDisplay = aData->mStyleContext->GetStyleDisplay();
if (readDisplay->mDisplay != NS_STYLE_DISPLAY_TABLE_CELL) {
// cellspacing
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::cellspacing);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::cellspacing);
if (value && value->Type() == nsAttrValue::eInteger) {
if (aData->mTableData->mBorderSpacing.mXValue.GetUnit() == eCSSUnit_Null)
aData->mTableData->mBorderSpacing.mXValue.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
@ -1133,13 +1133,13 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
const nsAttrValue* value;
// layout
if (aData->mTableData->mLayout.GetUnit() == eCSSUnit_Null) {
value = aAttributes->GetAttr(nsHTMLAtoms::layout);
value = aAttributes->GetAttr(nsGkAtoms::layout);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTableData->mLayout.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
// cols
value = aAttributes->GetAttr(nsHTMLAtoms::cols);
value = aAttributes->GetAttr(nsGkAtoms::cols);
if (value) {
if (value->Type() == nsAttrValue::eInteger)
aData->mTableData->mCols.SetIntValue(value->GetIntegerValue(), eCSSUnit_Integer);
@ -1148,7 +1148,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
}
// rules
value = aAttributes->GetAttr(nsHTMLAtoms::rules);
value = aAttributes->GetAttr(nsGkAtoms::rules);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTableData->mRules.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -1159,7 +1159,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
if (readDisplay->mDisplay != NS_STYLE_DISPLAY_TABLE_CELL) {
// align; Check for enumerated type (it may be another type if
// illegal)
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum) {
if (value->GetEnumValue() == NS_STYLE_TEXT_ALIGN_CENTER ||
@ -1176,7 +1176,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// vspace is mapped into top and bottom margins
// - *** Quirks Mode only ***
if (eCompatibility_NavQuirks == mode) {
value = aAttributes->GetAttr(nsHTMLAtoms::hspace);
value = aAttributes->GetAttr(nsGkAtoms::hspace);
if (value && value->Type() == nsAttrValue::eInteger) {
nsCSSRect& margin = aData->mMarginData->mMargin;
@ -1186,7 +1186,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
margin.mRight.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
}
value = aAttributes->GetAttr(nsHTMLAtoms::vspace);
value = aAttributes->GetAttr(nsGkAtoms::vspace);
if (value && value->Type() == nsAttrValue::eInteger) {
nsCSSRect& margin = aData->mMarginData->mMargin;
@ -1201,7 +1201,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
else if (aData->mSID == eStyleStruct_Padding) {
const nsStyleDisplay* readDisplay = aData->mStyleContext->GetStyleDisplay();
if (readDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_CELL) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::cellpadding);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::cellpadding);
if (value) {
nsAttrValue::ValueType valueType = value->Type();
if (valueType == nsAttrValue::eInteger || valueType == nsAttrValue::ePercent) {
@ -1239,7 +1239,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
if (readDisplay->mDisplay != NS_STYLE_DISPLAY_TABLE_CELL) {
// width: value
if (aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mPositionData->mWidth.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
else if (value && value->Type() == nsAttrValue::ePercent)
@ -1248,7 +1248,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// height: value
if (aData->mPositionData->mHeight.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::height);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::height);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mPositionData->mHeight.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
else if (value && value->Type() == nsAttrValue::ePercent)
@ -1271,8 +1271,8 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
// model. If there is a border on the table, then the mapping to
// rules=all will take care of borders in the collapsing model.
// But if rules="none", we don't want to do this.
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::border);
const nsAttrValue* rulesValue = aAttributes->GetAttr(nsHTMLAtoms::rules);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::border);
const nsAttrValue* rulesValue = aAttributes->GetAttr(nsGkAtoms::rules);
if ((!rulesValue || rulesValue->Type() != nsAttrValue::eEnum ||
rulesValue->GetEnumValue() != NS_STYLE_TABLE_RULES_NONE) &&
value &&
@ -1316,7 +1316,7 @@ MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
? NS_STYLE_BORDER_STYLE_BG_OUTSET :
NS_STYLE_BORDER_STYLE_OUTSET;
// bordercolor
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::bordercolor);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::bordercolor);
nscolor color;
if (value && value->GetColorValue(color)) {
if (aData->mMarginData->mBorderColor.mLeft.GetUnit() == eCSSUnit_Null)
@ -1359,21 +1359,21 @@ NS_IMETHODIMP_(PRBool)
nsHTMLTableElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::layout },
{ &nsHTMLAtoms::cellpadding },
{ &nsHTMLAtoms::cellspacing },
{ &nsHTMLAtoms::cols },
{ &nsHTMLAtoms::border },
{ &nsHTMLAtoms::frame },
{ &nsHTMLAtoms::width },
{ &nsHTMLAtoms::height },
{ &nsHTMLAtoms::hspace },
{ &nsHTMLAtoms::vspace },
{ &nsGkAtoms::layout },
{ &nsGkAtoms::cellpadding },
{ &nsGkAtoms::cellspacing },
{ &nsGkAtoms::cols },
{ &nsGkAtoms::border },
{ &nsGkAtoms::frame },
{ &nsGkAtoms::width },
{ &nsGkAtoms::height },
{ &nsGkAtoms::hspace },
{ &nsGkAtoms::vspace },
{ &nsHTMLAtoms::bordercolor },
{ &nsGkAtoms::bordercolor },
{ &nsHTMLAtoms::align },
{ &nsHTMLAtoms::rules },
{ &nsGkAtoms::align },
{ &nsGkAtoms::rules },
{ nsnull }
};

30
content/html/content/src/nsHTMLTableRowElement.cpp
Просмотреть файл

@ -43,7 +43,7 @@
#include "nsMappedAttributes.h"
#include "nsGenericHTMLElement.h"
#include "nsContentList.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsHTMLParts.h"
@ -255,7 +255,7 @@ IsCell(nsIContent *aContent, PRInt32 aNamespaceID,
{
nsIAtom* tag = aContent->Tag();
return ((tag == nsHTMLAtoms::td || tag == nsHTMLAtoms::th) &&
return ((tag == nsGkAtoms::td || tag == nsGkAtoms::th) &&
aContent->IsNodeOfType(nsINode::eHTML));
}
@ -301,7 +301,7 @@ nsHTMLTableRowElement::InsertCell(PRInt32 aIndex, nsIDOMHTMLElement** aValue)
// create the cell
nsCOMPtr<nsINodeInfo> nodeInfo;
nsContentUtils::NameChanged(mNodeInfo, nsHTMLAtoms::td,
nsContentUtils::NameChanged(mNodeInfo, nsGkAtoms::td,
getter_AddRefs(nodeInfo));
nsCOMPtr<nsIContent> cellContent = NS_NewHTMLTableCellElement(nodeInfo);
@ -390,22 +390,22 @@ nsHTMLTableRowElement::ParseAttribute(PRInt32 aNamespaceID,
*/
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::charoff) {
if (aAttribute == nsGkAtoms::charoff) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::height) {
if (aAttribute == nsGkAtoms::height) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::width) {
if (aAttribute == nsGkAtoms::width) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return ParseTableCellHAlignValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::bgcolor) {
if (aAttribute == nsGkAtoms::bgcolor) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if (aAttribute == nsHTMLAtoms::valign) {
if (aAttribute == nsGkAtoms::valign) {
return ParseTableVAlignValue(aValue, aResult);
}
}
@ -420,7 +420,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
if (aData->mSID == eStyleStruct_Position) {
// height: value
if (aData->mPositionData->mHeight.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::height);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::height);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mPositionData->mHeight.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
else if (value && value->Type() == nsAttrValue::ePercent)
@ -430,7 +430,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
else if (aData->mSID == eStyleStruct_Text) {
if (aData->mTextData->mTextAlign.GetUnit() == eCSSUnit_Null) {
// align: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTextData->mTextAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -438,7 +438,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
else if (aData->mSID == eStyleStruct_TextReset) {
if (aData->mTextData->mVerticalAlign.GetUnit() == eCSSUnit_Null) {
// valign: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::valign);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::valign);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTextData->mVerticalAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -452,9 +452,9 @@ NS_IMETHODIMP_(PRBool)
nsHTMLTableRowElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::align },
{ &nsHTMLAtoms::valign },
{ &nsHTMLAtoms::height },
{ &nsGkAtoms::align },
{ &nsGkAtoms::valign },
{ &nsGkAtoms::height },
{ nsnull }
};

28
content/html/content/src/nsHTMLTableSectionElement.cpp
Просмотреть файл

@ -38,7 +38,7 @@
#include "nsIDOMEventReceiver.h"
#include "nsMappedAttributes.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsHTMLParts.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
@ -120,7 +120,7 @@ nsHTMLTableSectionElement::GetRows(nsIDOMHTMLCollection** aValue)
if (!mRows) {
mRows = new nsContentList(this,
nsHTMLAtoms::tr,
nsGkAtoms::tr,
mNodeInfo->NamespaceID(),
PR_FALSE);
@ -156,7 +156,7 @@ nsHTMLTableSectionElement::InsertRow(PRInt32 aIndex,
// create the row
nsCOMPtr<nsINodeInfo> nodeInfo;
nsContentUtils::NameChanged(mNodeInfo, nsHTMLAtoms::tr,
nsContentUtils::NameChanged(mNodeInfo, nsGkAtoms::tr,
getter_AddRefs(nodeInfo));
nsCOMPtr<nsIContent> rowContent = NS_NewHTMLTableRowElement(nodeInfo);
@ -234,19 +234,19 @@ nsHTMLTableSectionElement::ParseAttribute(PRInt32 aNamespaceID,
/* ignore these attributes, stored simply as strings
ch
*/
if (aAttribute == nsHTMLAtoms::charoff) {
if (aAttribute == nsGkAtoms::charoff) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::height) {
if (aAttribute == nsGkAtoms::height) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE, PR_FALSE);
}
if (aAttribute == nsHTMLAtoms::align) {
if (aAttribute == nsGkAtoms::align) {
return ParseTableCellHAlignValue(aValue, aResult);
}
if (aAttribute == nsHTMLAtoms::bgcolor) {
if (aAttribute == nsGkAtoms::bgcolor) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if (aAttribute == nsHTMLAtoms::valign) {
if (aAttribute == nsGkAtoms::valign) {
return ParseTableVAlignValue(aValue, aResult);
}
}
@ -261,7 +261,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
if (aData->mSID == eStyleStruct_Position) {
// height: value
if (aData->mPositionData->mHeight.GetUnit() == eCSSUnit_Null) {
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::height);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::height);
if (value && value->Type() == nsAttrValue::eInteger)
aData->mPositionData->mHeight.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
}
@ -269,7 +269,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
else if (aData->mSID == eStyleStruct_Text) {
if (aData->mTextData->mTextAlign.GetUnit() == eCSSUnit_Null) {
// align: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTextData->mTextAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -277,7 +277,7 @@ void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aD
else if (aData->mSID == eStyleStruct_TextReset) {
if (aData->mTextData->mVerticalAlign.GetUnit() == eCSSUnit_Null) {
// valign: enum
const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::valign);
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::valign);
if (value && value->Type() == nsAttrValue::eEnum)
aData->mTextData->mVerticalAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
}
@ -291,9 +291,9 @@ NS_IMETHODIMP_(PRBool)
nsHTMLTableSectionElement::IsAttributeMapped(const nsIAtom* aAttribute) const
{
static const MappedAttributeEntry attributes[] = {
{ &nsHTMLAtoms::align },
{ &nsHTMLAtoms::valign },
{ &nsHTMLAtoms::height },
{ &nsGkAtoms::align },
{ &nsGkAtoms::valign },
{ &nsGkAtoms::height },
{ nsnull }
};

22
content/html/content/src/nsHTMLTextAreaElement.cpp
Просмотреть файл

@ -52,7 +52,7 @@
#include "nsIFormSubmission.h"
#include "nsIDOMEventReceiver.h"
#include "nsGenericHTMLElement.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsMappedAttributes.h"
@ -258,7 +258,7 @@ nsHTMLTextAreaElement::SetFocus(nsPresContext* aPresContext)
return;
// first see if we are disabled or not. If disabled then do nothing.
if (HasAttr(kNameSpaceID_None, nsHTMLAtoms::disabled)) {
if (HasAttr(kNameSpaceID_None, nsGkAtoms::disabled)) {
return;
}
@ -299,7 +299,7 @@ nsHTMLTextAreaElement::Select()
nsresult rv = NS_OK;
// first see if we are disabled or not. If disabled then do nothing.
if (HasAttr(kNameSpaceID_None, nsHTMLAtoms::disabled)) {
if (HasAttr(kNameSpaceID_None, nsGkAtoms::disabled)) {
return rv;
}
@ -367,7 +367,7 @@ nsHTMLTextAreaElement::SelectAll(nsPresContext* aPresContext)
nsIFormControlFrame* formControlFrame = GetFormControlFrame(PR_TRUE);
if (formControlFrame) {
formControlFrame->SetFormProperty(nsHTMLAtoms::select, EmptyString());
formControlFrame->SetFormProperty(nsGkAtoms::select, EmptyString());
}
return NS_OK;
@ -459,7 +459,7 @@ nsHTMLTextAreaElement::SetValueInternal(const nsAString& aValue,
textControlFrame->OwnsValue(&frameOwnsValue);
}
if (frameOwnsValue) {
formControlFrame->SetFormProperty(nsHTMLAtoms::value, aValue);
formControlFrame->SetFormProperty(nsGkAtoms::value, aValue);
}
else {
if (mValue) {
@ -541,10 +541,10 @@ nsHTMLTextAreaElement::ParseAttribute(PRInt32 aNamespaceID,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsHTMLAtoms::cols) {
if (aAttribute == nsGkAtoms::cols) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsHTMLAtoms::rows) {
if (aAttribute == nsGkAtoms::rows) {
return aResult.ParseIntWithBounds(aValue, 0);
}
}
@ -566,8 +566,8 @@ nsHTMLTextAreaElement::GetAttributeChangeHint(const nsIAtom* aAttribute,
{
nsChangeHint retval =
nsGenericHTMLFormElement::GetAttributeChangeHint(aAttribute, aModType);
if (aAttribute == nsHTMLAtoms::rows ||
aAttribute == nsHTMLAtoms::cols) {
if (aAttribute == nsGkAtoms::rows ||
aAttribute == nsGkAtoms::cols) {
NS_UpdateHint(retval, NS_STYLE_HINT_REFLOW);
}
return retval;
@ -836,7 +836,7 @@ nsHTMLTextAreaElement::SubmitNamesValues(nsIFormSubmission* aFormSubmission,
// Get the name (if no name, no submit)
//
nsAutoString name;
if (!GetAttr(kNameSpaceID_None, nsHTMLAtoms::name, name)) {
if (!GetAttr(kNameSpaceID_None, nsGkAtoms::name, name)) {
return NS_OK;
}
@ -921,7 +921,7 @@ nsresult
nsHTMLTextAreaElement::BeforeSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
const nsAString* aValue, PRBool aNotify)
{
if (aNotify && aName == nsHTMLAtoms::disabled &&
if (aNotify && aName == nsGkAtoms::disabled &&
aNameSpaceID == kNameSpaceID_None) {
mDisabledChanged = PR_TRUE;
}

24
content/html/document/src/nsHTMLContentSink.cpp
Просмотреть файл

@ -86,7 +86,7 @@
#include "nsIComponentManager.h"
#include "nsIServiceManager.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsContentUtils.h"
#include "nsIFrame.h"
#include "nsIChannel.h"
@ -717,10 +717,10 @@ HTMLContentSink::AddAttributes(const nsIParserNode& aNode,
const nsAString& v =
nsContentUtils::TrimCharsInSet(
(nodeType == eHTMLTag_input &&
keyAtom == nsHTMLAtoms::value) ?
keyAtom == nsGkAtoms::value) ?
"" : kWhitespace, aNode.GetValueAt(i));
if (nodeType == eHTMLTag_a && keyAtom == nsHTMLAtoms::name) {
if (nodeType == eHTMLTag_a && keyAtom == nsGkAtoms::name) {
NS_ConvertUTF16toUTF8 cname(v);
NS_ConvertUTF8toUTF16 uv(nsUnescape(cname.BeginWriting()));
@ -1983,7 +1983,7 @@ HTMLContentSink::Init(nsIDocument* aDoc,
mMaxTextRun = nsContentUtils::GetIntPref("content.maxtextrun", 8191);
nsCOMPtr<nsINodeInfo> nodeInfo;
rv = mNodeInfoManager->GetNodeInfo(nsHTMLAtoms::html, nsnull,
rv = mNodeInfoManager->GetNodeInfo(nsGkAtoms::html, nsnull,
kNameSpaceID_None,
getter_AddRefs(nodeInfo));
NS_ENSURE_SUCCESS(rv, rv);
@ -2012,7 +2012,7 @@ HTMLContentSink::Init(nsIDocument* aDoc,
}
// Make head part
rv = mNodeInfoManager->GetNodeInfo(nsHTMLAtoms::head,
rv = mNodeInfoManager->GetNodeInfo(nsGkAtoms::head,
nsnull, kNameSpaceID_None,
getter_AddRefs(nodeInfo));
NS_ENSURE_SUCCESS(rv, rv);
@ -3394,7 +3394,7 @@ HTMLContentSink::AddBaseTagInfo(nsIContent* aContent)
{
nsresult rv;
if (mBaseHref) {
rv = aContent->SetProperty(nsHTMLAtoms::htmlBaseHref, mBaseHref,
rv = aContent->SetProperty(nsGkAtoms::htmlBaseHref, mBaseHref,
nsPropertyTable::SupportsDtorFunc, PR_TRUE);
if (NS_SUCCEEDED(rv)) {
// circumvent nsDerivedSafe
@ -3402,7 +3402,7 @@ HTMLContentSink::AddBaseTagInfo(nsIContent* aContent)
}
}
if (mBaseTarget) {
rv = aContent->SetProperty(nsHTMLAtoms::htmlBaseTarget, mBaseTarget,
rv = aContent->SetProperty(nsGkAtoms::htmlBaseTarget, mBaseTarget,
nsPropertyTable::SupportsDtorFunc, PR_TRUE);
if (NS_SUCCEEDED(rv)) {
// circumvent nsDerivedSafe
@ -3465,7 +3465,7 @@ HTMLContentSink::ProcessBASEElement(nsGenericHTMLElement* aElement)
{
// href attribute
nsAutoString attrValue;
if (aElement->GetAttr(kNameSpaceID_None, nsHTMLAtoms::href, attrValue)) {
if (aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::href, attrValue)) {
//-- Make sure this page is allowed to load this URI
nsresult rv;
nsCOMPtr<nsIURI> baseHrefURI;
@ -3499,7 +3499,7 @@ HTMLContentSink::ProcessBASEElement(nsGenericHTMLElement* aElement)
}
// target attribute
if (aElement->GetAttr(kNameSpaceID_None, nsHTMLAtoms::target, attrValue)) {
if (aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::target, attrValue)) {
if (!mBody) {
// still in real HEAD
mDocument->SetBaseTarget(attrValue);
@ -3524,7 +3524,7 @@ HTMLContentSink::ProcessLINKTag(const nsIParserNode& aNode)
// Create content object
nsCOMPtr<nsIContent> element;
nsCOMPtr<nsINodeInfo> nodeInfo;
mNodeInfoManager->GetNodeInfo(nsHTMLAtoms::link, nsnull, kNameSpaceID_None,
mNodeInfoManager->GetNodeInfo(nsGkAtoms::link, nsnull, kNameSpaceID_None,
getter_AddRefs(nodeInfo));
result = NS_NewHTMLElement(getter_AddRefs(element), nodeInfo);
@ -3557,7 +3557,7 @@ HTMLContentSink::ProcessLINKTag(const nsIParserNode& aNode)
// look for <link rel="next" href="url">
nsAutoString relVal;
element->GetAttr(kNameSpaceID_None, nsHTMLAtoms::rel, relVal);
element->GetAttr(kNameSpaceID_None, nsGkAtoms::rel, relVal);
if (!relVal.IsEmpty()) {
// XXX seems overkill to generate this string array
nsStringArray linkTypes;
@ -3565,7 +3565,7 @@ HTMLContentSink::ProcessLINKTag(const nsIParserNode& aNode)
PRBool hasPrefetch = (linkTypes.IndexOf(NS_LITERAL_STRING("prefetch")) != -1);
if (hasPrefetch || linkTypes.IndexOf(NS_LITERAL_STRING("next")) != -1) {
nsAutoString hrefVal;
element->GetAttr(kNameSpaceID_None, nsHTMLAtoms::href, hrefVal);
element->GetAttr(kNameSpaceID_None, nsGkAtoms::href, hrefVal);
if (!hrefVal.IsEmpty()) {
PrefetchHref(hrefVal, hasPrefetch);
}

49
content/html/document/src/nsHTMLDocument.cpp
Просмотреть файл

@ -50,7 +50,6 @@
#include "nsIXMLContentSink.h"
#include "nsHTMLParts.h"
#include "nsHTMLStyleSheet.h"
#include "nsHTMLAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsIPresShell.h"
#include "nsPresContext.h"
@ -1233,7 +1232,7 @@ nsHTMLDocument::AttributeWillChange(nsIContent* aContent, PRInt32 aNameSpaceID,
NS_ABORT_IF_FALSE(aContent, "Null content!");
NS_PRECONDITION(aAttribute, "Must have an attribute that's changing!");
if (!IsXHTML() && aAttribute == nsHTMLAtoms::name &&
if (!IsXHTML() && aAttribute == nsGkAtoms::name &&
aNameSpaceID == kNameSpaceID_None) {
nsIAtom* name = IsNamedItem(aContent);
if (name) {
@ -1265,7 +1264,7 @@ nsHTMLDocument::AttributeChanged(nsIDocument* aDocument,
NS_ABORT_IF_FALSE(aContent, "Null content!");
NS_PRECONDITION(aAttribute, "Must have an attribute that's changing!");
if (!IsXHTML() && aAttribute == nsHTMLAtoms::name &&
if (!IsXHTML() && aAttribute == nsGkAtoms::name &&
aNameSpaceID == kNameSpaceID_None) {
nsIAtom* name = IsNamedItem(aContent);
@ -1685,8 +1684,8 @@ nsHTMLDocument::SetBody(nsIDOMHTMLElement* aBody)
nsCOMPtr<nsIDOMElement> root(do_QueryInterface(mRootContent));
// The body element must be either a body tag or a frameset tag.
if (!body || !root || !(body->Tag() == nsHTMLAtoms::body ||
body->Tag() == nsHTMLAtoms::frameset)) {
if (!body || !root || !(body->Tag() == nsGkAtoms::body ||
body->Tag() == nsGkAtoms::frameset)) {
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
}
@ -1707,7 +1706,7 @@ NS_IMETHODIMP
nsHTMLDocument::GetImages(nsIDOMHTMLCollection** aImages)
{
if (!mImages) {
mImages = new nsContentList(this, nsHTMLAtoms::img, mDefaultNamespaceID);
mImages = new nsContentList(this, nsGkAtoms::img, mDefaultNamespaceID);
if (!mImages) {
return NS_ERROR_OUT_OF_MEMORY;
}
@ -1723,7 +1722,7 @@ NS_IMETHODIMP
nsHTMLDocument::GetApplets(nsIDOMHTMLCollection** aApplets)
{
if (!mApplets) {
mApplets = new nsContentList(this, nsHTMLAtoms::applet,
mApplets = new nsContentList(this, nsGkAtoms::applet,
mDefaultNamespaceID);
if (!mApplets) {
return NS_ERROR_OUT_OF_MEMORY;
@ -1761,8 +1760,8 @@ nsHTMLDocument::MatchLinks(nsIContent *aContent, PRInt32 aNamespaceID,
nsIAtom *localName = ni->NameAtom();
if (ni->NamespaceID() == namespaceID &&
(localName == nsHTMLAtoms::a || localName == nsHTMLAtoms::area)) {
return aContent->HasAttr(kNameSpaceID_None, nsHTMLAtoms::href);
(localName == nsGkAtoms::a || localName == nsGkAtoms::area)) {
return aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::href);
}
}
@ -1803,8 +1802,8 @@ nsHTMLDocument::MatchAnchors(nsIContent *aContent, PRInt32 aNamespaceID,
#endif
PRInt32 namespaceID = aContent->GetCurrentDoc()->GetDefaultNamespaceID();
if (aContent->NodeInfo()->Equals(nsHTMLAtoms::a, namespaceID)) {
return aContent->HasAttr(kNameSpaceID_None, nsHTMLAtoms::name);
if (aContent->NodeInfo()->Equals(nsGkAtoms::a, namespaceID)) {
return aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::name);
}
return PR_FALSE;
@ -2538,7 +2537,7 @@ nsHTMLDocument::MatchNameAttribute(nsIContent* aContent, PRInt32 aNamespaceID,
{
NS_PRECONDITION(aContent, "Must have content node to work with!");
return aContent->AttrValueIs(kNameSpaceID_None, nsHTMLAtoms::name, aData,
return aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name, aData,
eCaseMatters);
}
@ -2884,7 +2883,7 @@ NS_IMETHODIMP
nsHTMLDocument::GetEmbeds(nsIDOMHTMLCollection** aEmbeds)
{
if (!mEmbeds) {
mEmbeds = new nsContentList(this, nsHTMLAtoms::embed, mDefaultNamespaceID);
mEmbeds = new nsContentList(this, nsGkAtoms::embed, mDefaultNamespaceID);
if (!mEmbeds) {
return NS_ERROR_OUT_OF_MEMORY;
}
@ -3075,15 +3074,15 @@ IsNamedItem(nsIContent* aContent)
}
nsIAtom* tag = elm->Tag();
if (tag != nsHTMLAtoms::img &&
tag != nsHTMLAtoms::form &&
tag != nsHTMLAtoms::applet &&
tag != nsHTMLAtoms::embed &&
tag != nsHTMLAtoms::object) {
if (tag != nsGkAtoms::img &&
tag != nsGkAtoms::form &&
tag != nsGkAtoms::applet &&
tag != nsGkAtoms::embed &&
tag != nsGkAtoms::object) {
return nsnull;
}
const nsAttrValue* val = elm->GetParsedAttr(nsHTMLAtoms::name);
const nsAttrValue* val = elm->GetParsedAttr(nsGkAtoms::name);
if (val && val->Type() == nsAttrValue::eAtom) {
return val->GetAtomValue();
}
@ -3440,10 +3439,10 @@ nsHTMLDocument::ResolveName(const nsAString& aName,
if (e && e != ID_NOT_IN_DOCUMENT && e->IsNodeOfType(nsINode::eHTML)) {
nsIAtom *tag = e->Tag();
if ((tag == nsHTMLAtoms::embed ||
tag == nsHTMLAtoms::img ||
tag == nsHTMLAtoms::object ||
tag == nsHTMLAtoms::applet) &&
if ((tag == nsGkAtoms::embed ||
tag == nsGkAtoms::img ||
tag == nsGkAtoms::object ||
tag == nsGkAtoms::applet) &&
(!aForm || nsContentUtils::BelongsInForm(aForm, e))) {
NS_ADDREF(*aResult = e);
}
@ -3467,7 +3466,7 @@ nsHTMLDocument::GetBodyContent()
nsIContent *child = mRootContent->GetChildAt(i);
NS_ENSURE_TRUE(child, NS_ERROR_UNEXPECTED);
if (child->NodeInfo()->Equals(nsHTMLAtoms::body, mDefaultNamespaceID) &&
if (child->NodeInfo()->Equals(nsGkAtoms::body, mDefaultNamespaceID) &&
child->IsNodeOfType(nsINode::eHTML)) {
mBodyContent = do_QueryInterface(child);
@ -3509,7 +3508,7 @@ nsContentList*
nsHTMLDocument::GetForms()
{
if (!mForms)
mForms = new nsContentList(this, nsHTMLAtoms::form, mDefaultNamespaceID);
mForms = new nsContentList(this, nsGkAtoms::form, mDefaultNamespaceID);
return mForms;
}

18
content/html/document/src/nsHTMLFragmentContentSink.cpp
Просмотреть файл

@ -42,7 +42,7 @@
#include "nsIHTMLContentSink.h"
#include "nsIParser.h"
#include "nsIParserService.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsHTMLTokens.h"
#include "nsGenericHTMLElement.h"
#include "nsIDOMText.h"
@ -306,7 +306,7 @@ void
nsHTMLFragmentContentSink::ProcessBaseTag(nsIContent* aContent)
{
nsAutoString value;
if (aContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::href, value)) {
if (aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::href, value)) {
nsCOMPtr<nsIURI> baseHrefURI;
nsresult rv =
nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(baseHrefURI),
@ -328,7 +328,7 @@ nsHTMLFragmentContentSink::ProcessBaseTag(nsIContent* aContent)
mBaseHref = baseHrefURI;
}
}
if (aContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::target, value)) {
if (aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::target, value)) {
mBaseTarget = do_GetAtom(value);
}
}
@ -342,7 +342,7 @@ nsHTMLFragmentContentSink::AddBaseTagInfo(nsIContent* aContent)
nsresult rv;
if (mBaseHref) {
rv = aContent->SetProperty(nsHTMLAtoms::htmlBaseHref, mBaseHref,
rv = aContent->SetProperty(nsGkAtoms::htmlBaseHref, mBaseHref,
nsPropertyTable::SupportsDtorFunc, PR_TRUE);
if (NS_SUCCEEDED(rv)) {
// circumvent nsDerivedSafe
@ -350,7 +350,7 @@ nsHTMLFragmentContentSink::AddBaseTagInfo(nsIContent* aContent)
}
}
if (mBaseTarget) {
rv = aContent->SetProperty(nsHTMLAtoms::htmlBaseTarget, mBaseTarget,
rv = aContent->SetProperty(nsGkAtoms::htmlBaseTarget, mBaseTarget,
nsPropertyTable::SupportsDtorFunc, PR_TRUE);
if (NS_SUCCEEDED(rv)) {
// circumvent nsDerivedSafe
@ -822,7 +822,7 @@ nsHTMLFragmentContentSink::AddAttributes(const nsIParserNode& aNode,
const nsAString& v =
nsContentUtils::TrimCharsInSet(kWhitespace, aNode.GetValueAt(i));
if (nodeType == eHTMLTag_a && keyAtom == nsHTMLAtoms::name) {
if (nodeType == eHTMLTag_a && keyAtom == nsGkAtoms::name) {
NS_ConvertUTF16toUTF8 cname(v);
NS_ConvertUTF8toUTF16 uv(nsUnescape(cname.BeginWriting()));
@ -1054,7 +1054,7 @@ nsHTMLParanoidFragmentSink::AddAttributes(const nsIParserNode& aNode,
continue;
}
if (nodeType == eHTMLTag_a && keyAtom == nsHTMLAtoms::name) {
if (nodeType == eHTMLTag_a && keyAtom == nsGkAtoms::name) {
NS_ConvertUTF16toUTF8 cname(v);
NS_ConvertUTF8toUTF16 uv(nsUnescape(cname.BeginWriting()));
// Add attribute to content
@ -1144,7 +1144,7 @@ nsHTMLParanoidFragmentSink::AddLeaf(const nsIParserNode& aNode)
#ifdef MOZILLA_1_8_BRANCH
// we have to do this on the branch for some late 90s reason
if (name == nsHTMLAtoms::script || name == nsHTMLAtoms::style) {
if (name == nsGkAtoms::script || name == nsGkAtoms::style) {
nsCOMPtr<nsIDTD> dtd;
mParser->GetDTD(getter_AddRefs(dtd));
NS_ENSURE_TRUE(dtd, NS_ERROR_FAILURE);
@ -1157,7 +1157,7 @@ nsHTMLParanoidFragmentSink::AddLeaf(const nsIParserNode& aNode)
// We will process base tags, but we won't include them
// in the output
if (name == nsHTMLAtoms::base) {
if (name == nsGkAtoms::base) {
nsCOMPtr<nsIContent> content;
nsCOMPtr<nsINodeInfo> nodeInfo;
nsIParserService* parserService = nsContentUtils::GetParserService();

20
content/html/document/src/nsImageDocument.cpp
Просмотреть файл

@ -48,7 +48,7 @@
#include "nsIDOMKeyEvent.h"
#include "nsIDOMMouseEvent.h"
#include "nsIDOMEventListener.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "imgIRequest.h"
#include "imgILoader.h"
#include "imgIContainer.h"
@ -239,7 +239,7 @@ ImageListener::OnStopRequest(nsIRequest* request, nsISupports *ctxt,
imgDoc->mStringBundle->FormatStringFromName(str.get(), formatString, 1,
getter_Copies(errorMsg));
imgDoc->mImageContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::alt, errorMsg, PR_FALSE);
imgDoc->mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::alt, errorMsg, PR_FALSE);
}
return nsMediaDocumentStreamListener::OnStopRequest(request, ctxt, status);
@ -409,7 +409,7 @@ nsImageDocument::ShrinkToFit()
image->SetWidth(PR_MAX(1, NSToCoordFloor(GetRatio() * mImageWidth)));
image->SetHeight(PR_MAX(1, NSToCoordFloor(GetRatio() * mImageHeight)));
mImageContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::style,
mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::style,
NS_LITERAL_STRING("cursor: -moz-zoom-in"), PR_TRUE);
mImageIsResized = PR_TRUE;
@ -458,15 +458,15 @@ nsImageDocument::RestoreImageTo(PRInt32 aX, PRInt32 aY)
NS_IMETHODIMP
nsImageDocument::RestoreImage()
{
mImageContent->UnsetAttr(kNameSpaceID_None, nsHTMLAtoms::width, PR_TRUE);
mImageContent->UnsetAttr(kNameSpaceID_None, nsHTMLAtoms::height, PR_TRUE);
mImageContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::width, PR_TRUE);
mImageContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::height, PR_TRUE);
if (mImageIsOverflowing) {
mImageContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::style,
mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::style,
NS_LITERAL_STRING("cursor: -moz-zoom-out"), PR_TRUE);
}
else {
mImageContent->UnsetAttr(kNameSpaceID_None, nsHTMLAtoms::style, PR_TRUE);
mImageContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::style, PR_TRUE);
}
mImageIsResized = PR_FALSE;
@ -569,7 +569,7 @@ nsImageDocument::CreateSyntheticDocument()
}
nsCOMPtr<nsINodeInfo> nodeInfo;
rv = mNodeInfoManager->GetNodeInfo(nsHTMLAtoms::img, nsnull,
rv = mNodeInfoManager->GetNodeInfo(nsGkAtoms::img, nsnull,
kNameSpaceID_None,
getter_AddRefs(nodeInfo));
NS_ENSURE_SUCCESS(rv, rv);
@ -587,8 +587,8 @@ nsImageDocument::CreateSyntheticDocument()
NS_ConvertUTF8toUTF16 srcString(src);
// Make sure not to start the image load from here...
imageLoader->SetLoadingEnabled(PR_FALSE);
mImageContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::src, srcString, PR_FALSE);
mImageContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::alt, srcString, PR_FALSE);
mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::src, srcString, PR_FALSE);
mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::alt, srcString, PR_FALSE);
body->AppendChildTo(mImageContent, PR_FALSE);
imageLoader->SetLoadingEnabled(PR_TRUE);

6
content/html/document/src/nsMediaDocument.cpp
Просмотреть файл

@ -37,7 +37,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsMediaDocument.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsRect.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
@ -233,7 +233,7 @@ nsMediaDocument::CreateSyntheticDocument()
nsresult rv;
nsCOMPtr<nsINodeInfo> nodeInfo;
rv = mNodeInfoManager->GetNodeInfo(nsHTMLAtoms::html, nsnull,
rv = mNodeInfoManager->GetNodeInfo(nsGkAtoms::html, nsnull,
kNameSpaceID_None,
getter_AddRefs(nodeInfo));
NS_ENSURE_SUCCESS(rv, rv);
@ -247,7 +247,7 @@ nsMediaDocument::CreateSyntheticDocument()
rv = AppendChildTo(root, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
rv = mNodeInfoManager->GetNodeInfo(nsHTMLAtoms::body, nsnull,
rv = mNodeInfoManager->GetNodeInfo(nsGkAtoms::body, nsnull,
kNameSpaceID_None,
getter_AddRefs(nodeInfo));
NS_ENSURE_SUCCESS(rv, rv);

18
content/html/document/src/nsPluginDocument.cpp
Просмотреть файл

@ -37,7 +37,7 @@
#include "nsMediaDocument.h"
#include "nsIPluginDocument.h"
#include "nsHTMLAtoms.h"
#include "nsGkAtoms.h"
#include "nsIPresShell.h"
#include "nsIObjectFrame.h"
#include "nsIPluginInstance.h"
@ -231,13 +231,13 @@ nsPluginDocument::CreateSyntheticPluginDocument()
// remove margins from body
NS_NAMED_LITERAL_STRING(zero, "0");
body->SetAttr(kNameSpaceID_None, nsHTMLAtoms::marginwidth, zero, PR_FALSE);
body->SetAttr(kNameSpaceID_None, nsHTMLAtoms::marginheight, zero, PR_FALSE);
body->SetAttr(kNameSpaceID_None, nsGkAtoms::marginwidth, zero, PR_FALSE);
body->SetAttr(kNameSpaceID_None, nsGkAtoms::marginheight, zero, PR_FALSE);
// make plugin content
nsCOMPtr<nsINodeInfo> nodeInfo;
rv = mNodeInfoManager->GetNodeInfo(nsHTMLAtoms::embed, nsnull,
rv = mNodeInfoManager->GetNodeInfo(nsGkAtoms::embed, nsnull,
kNameSpaceID_None,
getter_AddRefs(nodeInfo));
NS_ENSURE_SUCCESS(rv, rv);
@ -245,24 +245,24 @@ nsPluginDocument::CreateSyntheticPluginDocument()
NS_ENSURE_SUCCESS(rv, rv);
// make it a named element
mPluginContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::name,
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::name,
NS_LITERAL_STRING("plugin"), PR_FALSE);
// fill viewport and auto-resize
NS_NAMED_LITERAL_STRING(percent100, "100%");
mPluginContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::width, percent100,
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::width, percent100,
PR_FALSE);
mPluginContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::height, percent100,
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::height, percent100,
PR_FALSE);
// set URL
nsCAutoString src;
mDocumentURI->GetSpec(src);
mPluginContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::src,
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::src,
NS_ConvertUTF8toUTF16(src), PR_FALSE);
// set mime type
mPluginContent->SetAttr(kNameSpaceID_None, nsHTMLAtoms::type,
mPluginContent->SetAttr(kNameSpaceID_None, nsGkAtoms::type,
NS_ConvertUTF8toUTF16(mMimeType), PR_FALSE);
// This will not start the load because nsObjectLoadingContent checks whether

14
content/svg/content/src/nsSVGAngle.cpp
Просмотреть файл

@ -36,7 +36,7 @@
#include "nsSVGAngle.h"
#include "prdtoa.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGValue.h"
#include "nsReadableUtils.h"
#include "nsTextFormatter.h"
@ -376,13 +376,13 @@ void nsSVGAngle::GetUnitString(nsAString& unit)
UnitAtom = nsnull;
break;
case SVG_ANGLETYPE_DEG:
UnitAtom = nsSVGAtoms::deg;
UnitAtom = nsGkAtoms::deg;
break;
case SVG_ANGLETYPE_GRAD:
UnitAtom = nsSVGAtoms::grad;
UnitAtom = nsGkAtoms::grad;
break;
case SVG_ANGLETYPE_RAD:
UnitAtom = nsSVGAtoms::rad;
UnitAtom = nsGkAtoms::rad;
break;
default:
NS_ASSERTION(PR_FALSE, "unknown unit");
@ -399,11 +399,11 @@ PRUint16 nsSVGAngle::GetUnitTypeForString(const char* unitStr)
nsCOMPtr<nsIAtom> unitAtom = do_GetAtom(unitStr);
if (unitAtom == nsSVGAtoms::deg)
if (unitAtom == nsGkAtoms::deg)
return SVG_ANGLETYPE_DEG;
else if (unitAtom == nsSVGAtoms::grad)
else if (unitAtom == nsGkAtoms::grad)
return SVG_ANGLETYPE_GRAD;
else if (unitAtom == nsSVGAtoms::rad)
else if (unitAtom == nsGkAtoms::rad)
return SVG_ANGLETYPE_RAD;
return SVG_ANGLETYPE_UNKNOWN;

1
content/svg/content/src/nsSVGAtoms.h
Просмотреть файл

@ -39,7 +39,6 @@
#define nsSVGAtoms_h___
#include "nsGkAtoms.h"
typedef class nsGkAtoms nsSVGAtoms;
#endif /* nsSVGAtoms_h___ */

8
content/svg/content/src/nsSVGClipPathElement.cpp
Просмотреть файл

@ -36,7 +36,7 @@
#include "nsSVGGraphicElement.h"
#include "nsIDOMSVGClipPathElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGAnimatedEnumeration.h"
#include "nsSVGEnum.h"
@ -109,8 +109,8 @@ nsSVGClipPathElement::Init()
// Define enumeration mappings
static struct nsSVGEnumMapping gUnitMap[] = {
{&nsSVGAtoms::objectBoundingBox, nsIDOMSVGClipPathElement::SVG_CPUNITS_OBJECTBOUNDINGBOX},
{&nsSVGAtoms::userSpaceOnUse, nsIDOMSVGClipPathElement::SVG_CPUNITS_USERSPACEONUSE},
{&nsGkAtoms::objectBoundingBox, nsIDOMSVGClipPathElement::SVG_CPUNITS_OBJECTBOUNDINGBOX},
{&nsGkAtoms::userSpaceOnUse, nsIDOMSVGClipPathElement::SVG_CPUNITS_USERSPACEONUSE},
{nsnull, 0}
};
@ -123,7 +123,7 @@ nsSVGClipPathElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mClipPathUnits), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::clipPathUnits, mClipPathUnits);
rv = AddMappedSVGValue(nsGkAtoms::clipPathUnits, mClipPathUnits);
NS_ENSURE_SUCCESS(rv,rv);
}

166
content/svg/content/src/nsSVGElement.cpp
Просмотреть файл

@ -52,9 +52,7 @@
#include "nsIDOMCSSStyleDeclaration.h"
#include "nsIServiceManager.h"
#include "nsIXBLService.h"
#include "nsSVGAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsHTMLAtoms.h"
#include "nsICSSStyleRule.h"
#include "nsISVGSVGElement.h"
#include "nsRuleWalker.h"
@ -157,13 +155,13 @@ nsSVGElement::UnbindFromTree(PRBool aDeep, PRBool aNullParent)
nsIAtom *
nsSVGElement::GetIDAttributeName() const
{
return nsSVGAtoms::id;
return nsGkAtoms::id;
}
nsIAtom *
nsSVGElement::GetClassAttributeName() const
{
return nsSVGAtoms::_class;
return nsGkAtoms::_class;
}
nsresult
@ -247,7 +245,7 @@ nsSVGElement::ParseAttribute(PRInt32 aNamespaceID,
}
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsSVGAtoms::style) {
if (aAttribute == nsGkAtoms::style) {
nsGenericHTMLElement::ParseStyleAttribute(this, PR_TRUE,
aValue, aResult);
return PR_TRUE;
@ -375,23 +373,23 @@ nsSVGElement::SetInlineStyleRule(nsICSSStyleRule* aStyleRule, PRBool aNotify)
// save the old attribute so we can set up the mutation event properly
// XXXbz if the old rule points to the same declaration as the new one,
// this is getting the new attr value, not the old one....
modification = GetAttr(kNameSpaceID_None, nsHTMLAtoms::style,
modification = GetAttr(kNameSpaceID_None, nsGkAtoms::style,
oldValueStr);
}
else if (aNotify && IsInDoc()) {
modification = !!mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);
modification = !!mAttrsAndChildren.GetAttr(nsGkAtoms::style);
}
nsAttrValue attrValue(aStyleRule);
return SetAttrAndNotify(kNameSpaceID_None, nsHTMLAtoms::style, nsnull, oldValueStr,
return SetAttrAndNotify(kNameSpaceID_None, nsGkAtoms::style, nsnull, oldValueStr,
attrValue, modification, hasListeners, aNotify);
}
nsICSSStyleRule*
nsSVGElement::GetInlineStyleRule()
{
const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(nsSVGAtoms::style);
const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(nsGkAtoms::style);
if (attrVal && attrVal->Type() == nsAttrValue::eCSSStyleRule) {
return attrVal->GetCSSStyleRuleValue();
@ -403,98 +401,98 @@ nsSVGElement::GetInlineStyleRule()
// PresentationAttributes-FillStroke
/* static */ const nsGenericElement::MappedAttributeEntry
nsSVGElement::sFillStrokeMap[] = {
{ &nsSVGAtoms::fill },
{ &nsSVGAtoms::fill_opacity },
{ &nsSVGAtoms::fill_rule },
{ &nsSVGAtoms::stroke },
{ &nsSVGAtoms::stroke_dasharray },
{ &nsSVGAtoms::stroke_dashoffset },
{ &nsSVGAtoms::stroke_linecap },
{ &nsSVGAtoms::stroke_linejoin },
{ &nsSVGAtoms::stroke_miterlimit },
{ &nsSVGAtoms::stroke_opacity },
{ &nsSVGAtoms::stroke_width },
{ &nsGkAtoms::fill },
{ &nsGkAtoms::fill_opacity },
{ &nsGkAtoms::fill_rule },
{ &nsGkAtoms::stroke },
{ &nsGkAtoms::stroke_dasharray },
{ &nsGkAtoms::stroke_dashoffset },
{ &nsGkAtoms::stroke_linecap },
{ &nsGkAtoms::stroke_linejoin },
{ &nsGkAtoms::stroke_miterlimit },
{ &nsGkAtoms::stroke_opacity },
{ &nsGkAtoms::stroke_width },
{ nsnull }
};
// PresentationAttributes-Graphics
/* static */ const nsGenericElement::MappedAttributeEntry
nsSVGElement::sGraphicsMap[] = {
{ &nsSVGAtoms::clip_path },
{ &nsSVGAtoms::clip_rule },
{ &nsSVGAtoms::cursor },
{ &nsSVGAtoms::display },
{ &nsSVGAtoms::filter },
{ &nsSVGAtoms::image_rendering },
{ &nsSVGAtoms::mask },
{ &nsSVGAtoms::opacity },
{ &nsSVGAtoms::pointer_events },
{ &nsSVGAtoms::shape_rendering },
{ &nsSVGAtoms::text_rendering },
{ &nsSVGAtoms::visibility },
{ &nsGkAtoms::clip_path },
{ &nsGkAtoms::clip_rule },
{ &nsGkAtoms::cursor },
{ &nsGkAtoms::display },
{ &nsGkAtoms::filter },
{ &nsGkAtoms::image_rendering },
{ &nsGkAtoms::mask },
{ &nsGkAtoms::opacity },
{ &nsGkAtoms::pointer_events },
{ &nsGkAtoms::shape_rendering },
{ &nsGkAtoms::text_rendering },
{ &nsGkAtoms::visibility },
{ nsnull }
};
// PresentationAttributes-TextContentElements
/* static */ const nsGenericElement::MappedAttributeEntry
nsSVGElement::sTextContentElementsMap[] = {
{ &nsSVGAtoms::alignment_baseline },
{ &nsSVGAtoms::baseline_shift },
{ &nsSVGAtoms::direction },
{ &nsSVGAtoms::dominant_baseline },
{ &nsSVGAtoms::glyph_orientation_horizontal },
{ &nsSVGAtoms::glyph_orientation_vertical },
{ &nsSVGAtoms::kerning },
{ &nsSVGAtoms::letter_spacing },
{ &nsSVGAtoms::text_anchor },
{ &nsSVGAtoms::text_decoration },
{ &nsSVGAtoms::unicode_bidi },
{ &nsSVGAtoms::word_spacing },
{ &nsGkAtoms::alignment_baseline },
{ &nsGkAtoms::baseline_shift },
{ &nsGkAtoms::direction },
{ &nsGkAtoms::dominant_baseline },
{ &nsGkAtoms::glyph_orientation_horizontal },
{ &nsGkAtoms::glyph_orientation_vertical },
{ &nsGkAtoms::kerning },
{ &nsGkAtoms::letter_spacing },
{ &nsGkAtoms::text_anchor },
{ &nsGkAtoms::text_decoration },
{ &nsGkAtoms::unicode_bidi },
{ &nsGkAtoms::word_spacing },
{ nsnull }
};
// PresentationAttributes-FontSpecification
/* static */ const nsGenericElement::MappedAttributeEntry
nsSVGElement::sFontSpecificationMap[] = {
{ &nsSVGAtoms::font_family },
{ &nsSVGAtoms::font_size },
{ &nsSVGAtoms::font_size_adjust },
{ &nsSVGAtoms::font_stretch },
{ &nsSVGAtoms::font_style },
{ &nsSVGAtoms::font_variant },
{ &nsSVGAtoms::fontWeight },
{ &nsGkAtoms::font_family },
{ &nsGkAtoms::font_size },
{ &nsGkAtoms::font_size_adjust },
{ &nsGkAtoms::font_stretch },
{ &nsGkAtoms::font_style },
{ &nsGkAtoms::font_variant },
{ &nsGkAtoms::fontWeight },
{ nsnull }
};
// PresentationAttributes-GradientStop
/* static */ const nsGenericElement::MappedAttributeEntry
nsSVGElement::sGradientStopMap[] = {
{ &nsSVGAtoms::stop_color },
{ &nsSVGAtoms::stop_opacity },
{ &nsGkAtoms::stop_color },
{ &nsGkAtoms::stop_opacity },
{ nsnull }
};
// PresentationAttributes-Viewports
/* static */ const nsGenericElement::MappedAttributeEntry
nsSVGElement::sViewportsMap[] = {
{ &nsSVGAtoms::overflow },
{ &nsSVGAtoms::clip },
{ &nsGkAtoms::overflow },
{ &nsGkAtoms::clip },
{ nsnull }
};
// PresentationAttributes-Makers
/* static */ const nsGenericElement::MappedAttributeEntry
nsSVGElement::sMarkersMap[] = {
{ &nsSVGAtoms::marker_end },
{ &nsSVGAtoms::marker_mid },
{ &nsSVGAtoms::marker_start },
{ &nsGkAtoms::marker_end },
{ &nsGkAtoms::marker_mid },
{ &nsGkAtoms::marker_start },
{ nsnull }
};
// PresentationAttributes-Color
/* static */ const nsGenericElement::MappedAttributeEntry
nsSVGElement::sColorMap[] = {
{ &nsSVGAtoms::color },
{ &nsGkAtoms::color },
{ nsnull }
};
@ -521,14 +519,14 @@ nsSVGElement::IsSupported(const nsAString& aFeature, const nsAString& aVersion,
/* attribute DOMString id; */
NS_IMETHODIMP nsSVGElement::GetId(nsAString & aId)
{
GetAttr(kNameSpaceID_None, nsSVGAtoms::id, aId);
GetAttr(kNameSpaceID_None, nsGkAtoms::id, aId);
return NS_OK;
}
NS_IMETHODIMP nsSVGElement::SetId(const nsAString & aId)
{
return SetAttr(kNameSpaceID_None, nsSVGAtoms::id, aId, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::id, aId, PR_TRUE);
}
/* readonly attribute nsIDOMSVGSVGElement ownerSVGElement; */
@ -838,34 +836,34 @@ nsSVGElement::IsGraphicElementEventName(nsIAtom* aName)
return PR_FALSE;
}
return (aName == nsSVGAtoms::onabort ||
aName == nsSVGAtoms::onclick ||
aName == nsSVGAtoms::onerror ||
aName == nsSVGAtoms::onload ||
aName == nsSVGAtoms::onmousedown ||
aName == nsSVGAtoms::onmouseup ||
aName == nsSVGAtoms::onmouseover ||
aName == nsSVGAtoms::onmousemove ||
aName == nsSVGAtoms::onmouseout);
return (aName == nsGkAtoms::onabort ||
aName == nsGkAtoms::onclick ||
aName == nsGkAtoms::onerror ||
aName == nsGkAtoms::onload ||
aName == nsGkAtoms::onmousedown ||
aName == nsGkAtoms::onmouseup ||
aName == nsGkAtoms::onmouseover ||
aName == nsGkAtoms::onmousemove ||
aName == nsGkAtoms::onmouseout);
}
/* static */
nsIAtom* nsSVGElement::GetEventNameForAttr(nsIAtom* aAttr)
{
if (aAttr == nsSVGAtoms::onload)
return nsLayoutAtoms::onSVGLoad;
if (aAttr == nsSVGAtoms::onunload)
return nsLayoutAtoms::onSVGUnload;
if (aAttr == nsSVGAtoms::onabort)
return nsLayoutAtoms::onSVGAbort;
if (aAttr == nsSVGAtoms::onerror)
return nsLayoutAtoms::onSVGError;
if (aAttr == nsSVGAtoms::onresize)
return nsLayoutAtoms::onSVGResize;
if (aAttr == nsSVGAtoms::onscroll)
return nsLayoutAtoms::onSVGScroll;
if (aAttr == nsSVGAtoms::onzoom)
return nsLayoutAtoms::onSVGZoom;
if (aAttr == nsGkAtoms::onload)
return nsGkAtoms::onSVGLoad;
if (aAttr == nsGkAtoms::onunload)
return nsGkAtoms::onSVGUnload;
if (aAttr == nsGkAtoms::onabort)
return nsGkAtoms::onSVGAbort;
if (aAttr == nsGkAtoms::onerror)
return nsGkAtoms::onSVGError;
if (aAttr == nsGkAtoms::onresize)
return nsGkAtoms::onSVGResize;
if (aAttr == nsGkAtoms::onscroll)
return nsGkAtoms::onSVGScroll;
if (aAttr == nsGkAtoms::onzoom)
return nsGkAtoms::onSVGZoom;
return aAttr;
}

104
content/svg/content/src/nsSVGElementFactory.cpp
Просмотреть файл

@ -40,7 +40,7 @@
#include "nsContentCreatorFunctions.h"
#include "nsIAtom.h"
#include "nsINodeInfo.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsContentDLF.h"
#include "nsContentUtils.h"
#include "nsSVGUtils.h"
@ -150,101 +150,101 @@ NS_NewSVGElement(nsIContent** aResult, nsINodeInfo *aNodeInfo)
nsIAtom *name = aNodeInfo->NameAtom();
if (name == nsSVGAtoms::polyline)
if (name == nsGkAtoms::polyline)
return NS_NewSVGPolylineElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::polygon)
if (name == nsGkAtoms::polygon)
return NS_NewSVGPolygonElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::circle)
if (name == nsGkAtoms::circle)
return NS_NewSVGCircleElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::ellipse)
if (name == nsGkAtoms::ellipse)
return NS_NewSVGEllipseElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::line)
if (name == nsGkAtoms::line)
return NS_NewSVGLineElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::rect)
if (name == nsGkAtoms::rect)
return NS_NewSVGRectElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::svg)
if (name == nsGkAtoms::svg)
return NS_NewSVGSVGElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::g)
if (name == nsGkAtoms::g)
return NS_NewSVGGElement(aResult, aNodeInfo);
#ifdef MOZ_SVG_FOREIGNOBJECT
if (name == nsSVGAtoms::foreignObject)
if (name == nsGkAtoms::foreignObject)
return NS_NewSVGForeignObjectElement(aResult, aNodeInfo);
#endif
if (name == nsSVGAtoms::path)
if (name == nsGkAtoms::path)
return NS_NewSVGPathElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::text)
if (name == nsGkAtoms::text)
return NS_NewSVGTextElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::tspan)
if (name == nsGkAtoms::tspan)
return NS_NewSVGTSpanElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::image)
if (name == nsGkAtoms::image)
return NS_NewSVGImageElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::style)
if (name == nsGkAtoms::style)
return NS_NewSVGStyleElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::linearGradient)
if (name == nsGkAtoms::linearGradient)
return NS_NewSVGLinearGradientElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::metadata)
if (name == nsGkAtoms::metadata)
return NS_NewSVGMetadataElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::radialGradient)
if (name == nsGkAtoms::radialGradient)
return NS_NewSVGRadialGradientElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::stop)
if (name == nsGkAtoms::stop)
return NS_NewSVGStopElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::defs)
if (name == nsGkAtoms::defs)
return NS_NewSVGDefsElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::desc)
if (name == nsGkAtoms::desc)
return NS_NewSVGDescElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::script)
if (name == nsGkAtoms::script)
return NS_NewSVGScriptElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::use)
if (name == nsGkAtoms::use)
return NS_NewSVGUseElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::symbol)
if (name == nsGkAtoms::symbol)
return NS_NewSVGSymbolElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::marker)
if (name == nsGkAtoms::marker)
return NS_NewSVGMarkerElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::title)
if (name == nsGkAtoms::title)
return NS_NewSVGTitleElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::clipPath)
if (name == nsGkAtoms::clipPath)
return NS_NewSVGClipPathElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::textPath)
if (name == nsGkAtoms::textPath)
return NS_NewSVGTextPathElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::filter)
if (name == nsGkAtoms::filter)
return NS_NewSVGFilterElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feBlend)
if (name == nsGkAtoms::feBlend)
return NS_NewSVGFEBlendElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feComponentTransfer)
if (name == nsGkAtoms::feComponentTransfer)
return NS_NewSVGFEComponentTransferElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feComposite)
if (name == nsGkAtoms::feComposite)
return NS_NewSVGFECompositeElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feFuncR)
if (name == nsGkAtoms::feFuncR)
return NS_NewSVGFEFuncRElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feFuncG)
if (name == nsGkAtoms::feFuncG)
return NS_NewSVGFEFuncGElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feFuncB)
if (name == nsGkAtoms::feFuncB)
return NS_NewSVGFEFuncBElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feFuncA)
if (name == nsGkAtoms::feFuncA)
return NS_NewSVGFEFuncAElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feGaussianBlur)
if (name == nsGkAtoms::feGaussianBlur)
return NS_NewSVGFEGaussianBlurElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feMerge)
if (name == nsGkAtoms::feMerge)
return NS_NewSVGFEMergeElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feMergeNode)
if (name == nsGkAtoms::feMergeNode)
return NS_NewSVGFEMergeNodeElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feMorphology)
if (name == nsGkAtoms::feMorphology)
return NS_NewSVGFEMorphologyElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feOffset)
if (name == nsGkAtoms::feOffset)
return NS_NewSVGFEOffsetElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::feColorMatrix ||
name == nsSVGAtoms::feConvolveMatrix ||
name == nsSVGAtoms::feDiffuseLighting ||
name == nsSVGAtoms::feDisplacementMap ||
name == nsSVGAtoms::feFlood ||
name == nsSVGAtoms::feImage ||
name == nsSVGAtoms::feSpecularLighting ||
name == nsSVGAtoms::feTile ||
name == nsSVGAtoms::feTurbulence)
if (name == nsGkAtoms::feColorMatrix ||
name == nsGkAtoms::feConvolveMatrix ||
name == nsGkAtoms::feDiffuseLighting ||
name == nsGkAtoms::feDisplacementMap ||
name == nsGkAtoms::feFlood ||
name == nsGkAtoms::feImage ||
name == nsGkAtoms::feSpecularLighting ||
name == nsGkAtoms::feTile ||
name == nsGkAtoms::feTurbulence)
return NS_NewSVGFEUnimplementedMOZElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::pattern)
if (name == nsGkAtoms::pattern)
return NS_NewSVGPatternElement(aResult, aNodeInfo);
if (name == nsSVGAtoms::mask)
if (name == nsGkAtoms::mask)
return NS_NewSVGMaskElement(aResult, aNodeInfo);
// if we don't know what to create, just create a standard xml element:

4
content/svg/content/src/nsSVGFeatures.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsString.h"
#include "nsSVGUtils.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
// Test to see if a feature is implemented
PRBool
@ -87,7 +87,7 @@ NS_SVG_TestFeatures(const nsAString& fstr) {
static PRBool
NS_SVG_Conditional(const nsIAtom *atom, PRUint16 cond) {
#define SVG_ELEMENT(_atom, _supports) if (atom == nsSVGAtoms::_atom) return (_supports & cond) != 0;
#define SVG_ELEMENT(_atom, _supports) if (atom == nsGkAtoms::_atom) return (_supports & cond) != 0;
#include "nsSVGElementList.h"
#undef SVG_ELEMENT
return PR_FALSE;

12
content/svg/content/src/nsSVGFilterElement.cpp
Просмотреть файл

@ -34,7 +34,7 @@
*
* ***** END LICENSE BLOCK ***** */
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGLength.h"
#include "nsCOMPtr.h"
#include "nsISVGSVGElement.h"
@ -85,8 +85,8 @@ nsSVGFilterElement::Init()
// Define enumeration mappings
static struct nsSVGEnumMapping gUnitMap[] = {
{&nsSVGAtoms::objectBoundingBox, nsIDOMSVGFilterElement::SVG_FUNITS_OBJECTBOUNDINGBOX},
{&nsSVGAtoms::userSpaceOnUse, nsIDOMSVGFilterElement::SVG_FUNITS_USERSPACEONUSE},
{&nsGkAtoms::objectBoundingBox, nsIDOMSVGFilterElement::SVG_FUNITS_OBJECTBOUNDINGBOX},
{&nsGkAtoms::userSpaceOnUse, nsIDOMSVGFilterElement::SVG_FUNITS_USERSPACEONUSE},
{nsnull, 0}
};
@ -100,7 +100,7 @@ nsSVGFilterElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mFilterUnits), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::filterUnits, mFilterUnits);
rv = AddMappedSVGValue(nsGkAtoms::filterUnits, mFilterUnits);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -112,7 +112,7 @@ nsSVGFilterElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mPrimitiveUnits), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::primitiveUnits, mPrimitiveUnits);
rv = AddMappedSVGValue(nsGkAtoms::primitiveUnits, mPrimitiveUnits);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -239,7 +239,7 @@ nsSVGFilterElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
nsresult rv = nsSVGFilterElementBase::SetAttr(aNameSpaceID, aName, aPrefix,
aValue, aNotify);
if (aName == nsSVGAtoms::filterRes && aNameSpaceID == kNameSpaceID_None) {
if (aName == nsGkAtoms::filterRes && aNameSpaceID == kNameSpaceID_None) {
PRUint32 resX, resY;
char *str;
str = ToNewCString(aValue);

73
content/svg/content/src/nsSVGFilters.cpp
Просмотреть файл

@ -37,9 +37,8 @@
#include "nsSVGElement.h"
#include "nsSVGAnimatedString.h"
#include "nsSVGLength.h"
#include "nsSVGAtoms.h"
#include "nsSVGNumber2.h"
#include "nsGkAtoms.h"
#include "nsSVGNumber2.h"
#include "nsIDOMSVGFilters.h"
#include "nsCOMPtr.h"
#include "nsISVGFilter.h"
@ -91,7 +90,7 @@ nsSVGFE::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mResult));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::result, mResult);
rv = AddMappedSVGValue(nsGkAtoms::result, mResult);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -539,7 +538,7 @@ nsSVGFEGaussianBlurElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mIn1));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::in, mIn1);
rv = AddMappedSVGValue(nsGkAtoms::in, mIn1);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -589,7 +588,7 @@ nsSVGFEGaussianBlurElement::ParseAttribute(PRInt32 aNameSpaceID, nsIAtom* aName,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aName == nsSVGAtoms::stdDeviation && aNameSpaceID == kNameSpaceID_None) {
if (aName == nsGkAtoms::stdDeviation && aNameSpaceID == kNameSpaceID_None) {
return ScanDualValueAttribute(aValue, nsGkAtoms::stdDeviation,
&mNumberAttributes[STD_DEV_X],
&mNumberAttributes[STD_DEV_Y],
@ -885,11 +884,11 @@ nsSVGFEBlendElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
static struct nsSVGEnumMapping gModeTypes[] = {
{&nsSVGAtoms::normal, nsSVGFEBlendElement::SVG_MODE_NORMAL},
{&nsSVGAtoms::multiply, nsSVGFEBlendElement::SVG_MODE_MULTIPLY},
{&nsSVGAtoms::screen, nsSVGFEBlendElement::SVG_MODE_SCREEN},
{&nsSVGAtoms::darken, nsSVGFEBlendElement::SVG_MODE_DARKEN},
{&nsSVGAtoms::lighten, nsSVGFEBlendElement::SVG_MODE_LIGHTEN},
{&nsGkAtoms::normal, nsSVGFEBlendElement::SVG_MODE_NORMAL},
{&nsGkAtoms::multiply, nsSVGFEBlendElement::SVG_MODE_MULTIPLY},
{&nsGkAtoms::screen, nsSVGFEBlendElement::SVG_MODE_SCREEN},
{&nsGkAtoms::darken, nsSVGFEBlendElement::SVG_MODE_DARKEN},
{&nsGkAtoms::lighten, nsSVGFEBlendElement::SVG_MODE_LIGHTEN},
{nsnull, 0}
};
@ -903,7 +902,7 @@ nsSVGFEBlendElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mMode), modes);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::mode, mMode);
rv = AddMappedSVGValue(nsGkAtoms::mode, mMode);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -911,7 +910,7 @@ nsSVGFEBlendElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mIn1));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::in, mIn1);
rv = AddMappedSVGValue(nsGkAtoms::in, mIn1);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -919,7 +918,7 @@ nsSVGFEBlendElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mIn2));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::in2, mIn2);
rv = AddMappedSVGValue(nsGkAtoms::in2, mIn2);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -1123,12 +1122,12 @@ nsSVGFECompositeElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
static struct nsSVGEnumMapping gOperatorTypes[] = {
{&nsSVGAtoms::over, nsSVGFECompositeElement::SVG_OPERATOR_OVER},
{&nsSVGAtoms::in, nsSVGFECompositeElement::SVG_OPERATOR_IN},
{&nsSVGAtoms::out, nsSVGFECompositeElement::SVG_OPERATOR_OUT},
{&nsSVGAtoms::atop, nsSVGFECompositeElement::SVG_OPERATOR_ATOP},
{&nsSVGAtoms::xor_, nsSVGFECompositeElement::SVG_OPERATOR_XOR},
{&nsSVGAtoms::arithmetic, nsSVGFECompositeElement::SVG_OPERATOR_ARITHMETIC},
{&nsGkAtoms::over, nsSVGFECompositeElement::SVG_OPERATOR_OVER},
{&nsGkAtoms::in, nsSVGFECompositeElement::SVG_OPERATOR_IN},
{&nsGkAtoms::out, nsSVGFECompositeElement::SVG_OPERATOR_OUT},
{&nsGkAtoms::atop, nsSVGFECompositeElement::SVG_OPERATOR_ATOP},
{&nsGkAtoms::xor_, nsSVGFECompositeElement::SVG_OPERATOR_XOR},
{&nsGkAtoms::arithmetic, nsSVGFECompositeElement::SVG_OPERATOR_ARITHMETIC},
{nsnull, 0}
};
@ -1142,7 +1141,7 @@ nsSVGFECompositeElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mOperator), operators);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::_operator, mOperator);
rv = AddMappedSVGValue(nsGkAtoms::_operator, mOperator);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -1150,7 +1149,7 @@ nsSVGFECompositeElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mIn1));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::in, mIn1);
rv = AddMappedSVGValue(nsGkAtoms::in, mIn1);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -1158,7 +1157,7 @@ nsSVGFECompositeElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mIn2));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::in2, mIn2);
rv = AddMappedSVGValue(nsGkAtoms::in2, mIn2);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -1418,7 +1417,7 @@ nsSVGFEComponentTransferElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mIn1));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::in, mIn1);
rv = AddMappedSVGValue(nsGkAtoms::in, mIn1);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -1614,15 +1613,15 @@ nsSVGComponentTransferFunctionElement::Init()
// enumeration mappings
static struct nsSVGEnumMapping gComponentTransferTypes[] = {
{&nsSVGAtoms::identity,
{&nsGkAtoms::identity,
nsIDOMSVGComponentTransferFunctionElement::SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY},
{&nsSVGAtoms::table,
{&nsGkAtoms::table,
nsIDOMSVGComponentTransferFunctionElement::SVG_FECOMPONENTTRANSFER_TYPE_TABLE},
{&nsSVGAtoms::discrete,
{&nsGkAtoms::discrete,
nsIDOMSVGComponentTransferFunctionElement::SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE},
{&nsSVGAtoms::linear,
{&nsGkAtoms::linear,
nsIDOMSVGComponentTransferFunctionElement::SVG_FECOMPONENTTRANSFER_TYPE_LINEAR},
{&nsSVGAtoms::gamma,
{&nsGkAtoms::gamma,
nsIDOMSVGComponentTransferFunctionElement::SVG_FECOMPONENTTRANSFER_TYPE_GAMMA},
{nsnull, 0}
};
@ -1638,7 +1637,7 @@ nsSVGComponentTransferFunctionElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mType), types);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::type, mType);
rv = AddMappedSVGValue(nsGkAtoms::type, mType);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -1649,7 +1648,7 @@ nsSVGComponentTransferFunctionElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedNumberList(getter_AddRefs(mTableValues), values);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::tableValues, mTableValues);
rv = AddMappedSVGValue(nsGkAtoms::tableValues, mTableValues);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -2236,7 +2235,7 @@ nsSVGFEMergeNodeElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mIn1));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::in, mIn1);
rv = AddMappedSVGValue(nsGkAtoms::in, mIn1);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -2378,7 +2377,7 @@ nsSVGFEOffsetElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mIn1));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::in, mIn1);
rv = AddMappedSVGValue(nsGkAtoms::in, mIn1);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -2568,8 +2567,8 @@ nsSVGFEMorphologyElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
static struct nsSVGEnumMapping gOperatorTypes[] = {
{&nsSVGAtoms::erode, nsSVGFEMorphologyElement::SVG_OPERATOR_ERODE},
{&nsSVGAtoms::dilate, nsSVGFEMorphologyElement::SVG_OPERATOR_DILATE},
{&nsGkAtoms::erode, nsSVGFEMorphologyElement::SVG_OPERATOR_ERODE},
{&nsGkAtoms::dilate, nsSVGFEMorphologyElement::SVG_OPERATOR_DILATE},
{nsnull, 0}
};
@ -2583,7 +2582,7 @@ nsSVGFEMorphologyElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mOperator), operators);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::_operator, mOperator);
rv = AddMappedSVGValue(nsGkAtoms::_operator, mOperator);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -2591,7 +2590,7 @@ nsSVGFEMorphologyElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mIn1));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::in, mIn1);
rv = AddMappedSVGValue(nsGkAtoms::in, mIn1);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -2649,7 +2648,7 @@ nsSVGFEMorphologyElement::ParseAttribute(PRInt32 aNameSpaceID, nsIAtom* aName,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aName == nsSVGAtoms::radius && aNameSpaceID == kNameSpaceID_None) {
if (aName == nsGkAtoms::radius && aNameSpaceID == kNameSpaceID_None) {
return ScanDualValueAttribute(aValue, nsGkAtoms::radius,
&mNumberAttributes[RADIUS_X],
&mNumberAttributes[RADIUS_Y],

20
content/svg/content/src/nsSVGGradientElement.cpp
Просмотреть файл

@ -47,7 +47,7 @@
#include "nsCOMPtr.h"
#include "nsISVGSVGElement.h"
#include "nsSVGStylableElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGGradientElement.h"
//--------------------- Gradients------------------------
@ -78,15 +78,15 @@ nsSVGGradientElement::Init()
// Define enumeration mappings
static struct nsSVGEnumMapping gUnitMap[] = {
{&nsSVGAtoms::objectBoundingBox, nsIDOMSVGGradientElement::SVG_GRUNITS_OBJECTBOUNDINGBOX},
{&nsSVGAtoms::userSpaceOnUse, nsIDOMSVGGradientElement::SVG_GRUNITS_USERSPACEONUSE},
{&nsGkAtoms::objectBoundingBox, nsIDOMSVGGradientElement::SVG_GRUNITS_OBJECTBOUNDINGBOX},
{&nsGkAtoms::userSpaceOnUse, nsIDOMSVGGradientElement::SVG_GRUNITS_USERSPACEONUSE},
{nsnull, 0}
};
static struct nsSVGEnumMapping gSpreadMap[] = {
{&nsSVGAtoms::pad, nsIDOMSVGGradientElement::SVG_SPREADMETHOD_PAD},
{&nsSVGAtoms::reflect, nsIDOMSVGGradientElement::SVG_SPREADMETHOD_REFLECT},
{&nsSVGAtoms::repeat, nsIDOMSVGGradientElement::SVG_SPREADMETHOD_REPEAT},
{&nsGkAtoms::pad, nsIDOMSVGGradientElement::SVG_SPREADMETHOD_PAD},
{&nsGkAtoms::reflect, nsIDOMSVGGradientElement::SVG_SPREADMETHOD_REFLECT},
{&nsGkAtoms::repeat, nsIDOMSVGGradientElement::SVG_SPREADMETHOD_REPEAT},
{nsnull, 0}
};
@ -100,7 +100,7 @@ nsSVGGradientElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mGradientUnits), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::gradientUnits, mGradientUnits);
rv = AddMappedSVGValue(nsGkAtoms::gradientUnits, mGradientUnits);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -112,7 +112,7 @@ nsSVGGradientElement::Init()
rv = NS_NewSVGAnimatedTransformList(getter_AddRefs(mGradientTransform),
transformList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::gradientTransform, mGradientTransform);
rv = AddMappedSVGValue(nsGkAtoms::gradientTransform, mGradientTransform);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -124,7 +124,7 @@ nsSVGGradientElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mSpreadMethod), spread);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::spreadMethod, mSpreadMethod);
rv = AddMappedSVGValue(nsGkAtoms::spreadMethod, mSpreadMethod);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -134,7 +134,7 @@ nsSVGGradientElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mHref));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::href, mHref, kNameSpaceID_XLink);
rv = AddMappedSVGValue(nsGkAtoms::href, mHref, kNameSpaceID_XLink);
NS_ENSURE_SUCCESS(rv,rv);
}

4
content/svg/content/src/nsSVGGraphicElement.cpp
Просмотреть файл

@ -40,7 +40,7 @@
#include "nsSVGGraphicElement.h"
#include "nsSVGTransformList.h"
#include "nsSVGAnimatedTransformList.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGMatrix.h"
#include "nsISVGSVGElement.h"
#include "nsIDOMEventTarget.h"
@ -328,7 +328,7 @@ nsSVGGraphicElement::CreateTransformList()
rv = NS_NewSVGAnimatedTransformList(getter_AddRefs(mTransforms),
transformList);
NS_ENSURE_SUCCESS(rv, rv);
rv = AddMappedSVGValue(nsSVGAtoms::transform, mTransforms);
rv = AddMappedSVGValue(nsGkAtoms::transform, mTransforms);
if (NS_FAILED(rv)) {
mTransforms = nsnull;
return rv;

8
content/svg/content/src/nsSVGImageElement.cpp
Просмотреть файл

@ -36,7 +36,7 @@
*
* ***** END LICENSE BLOCK ***** */
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGLength.h"
#include "nsSVGAnimatedString.h"
#include "nsCOMPtr.h"
@ -170,7 +170,7 @@ nsSVGImageElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mHref));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::href, mHref, kNameSpaceID_XLink);
rv = AddMappedSVGValue(nsGkAtoms::href, mHref, kNameSpaceID_XLink);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -183,7 +183,7 @@ nsSVGImageElement::Init()
getter_AddRefs(mPreserveAspectRatio),
preserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::preserveAspectRatio,
rv = AddMappedSVGValue(nsGkAtoms::preserveAspectRatio,
mPreserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -321,7 +321,7 @@ nsSVGImageElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
// Our base URI may have changed; claim that our URI changed, and the
// nsImageLoadingContent will decide whether a new image load is warranted.
nsAutoString href;
if (GetAttr(kNameSpaceID_XLink, nsSVGAtoms::href, href)) {
if (GetAttr(kNameSpaceID_XLink, nsGkAtoms::href, href)) {
// Note: no need to notify here; since we're just now being bound
// we don't have any frames or anything yet.
LoadImage(href, PR_FALSE, PR_FALSE);

38
content/svg/content/src/nsSVGLength.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsSVGLength.h"
#include "nsIDOMSVGMatrix.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGValue.h"
#include "nsTextFormatter.h"
#include "prdtoa.h"
@ -338,31 +338,31 @@ nsSVGLength::GetValueAsString(nsAString & aValueAsString)
case SVG_LENGTHTYPE_NUMBER:
return NS_OK;
case SVG_LENGTHTYPE_PX:
UnitAtom = nsSVGAtoms::px;
UnitAtom = nsGkAtoms::px;
break;
case SVG_LENGTHTYPE_MM:
UnitAtom = nsSVGAtoms::mm;
UnitAtom = nsGkAtoms::mm;
break;
case SVG_LENGTHTYPE_CM:
UnitAtom = nsSVGAtoms::cm;
UnitAtom = nsGkAtoms::cm;
break;
case SVG_LENGTHTYPE_IN:
UnitAtom = nsSVGAtoms::in;
UnitAtom = nsGkAtoms::in;
break;
case SVG_LENGTHTYPE_PT:
UnitAtom = nsSVGAtoms::pt;
UnitAtom = nsGkAtoms::pt;
break;
case SVG_LENGTHTYPE_PC:
UnitAtom = nsSVGAtoms::pc;
UnitAtom = nsGkAtoms::pc;
break;
case SVG_LENGTHTYPE_EMS:
UnitAtom = nsSVGAtoms::em;
UnitAtom = nsGkAtoms::em;
break;
case SVG_LENGTHTYPE_EXS:
UnitAtom = nsSVGAtoms::ex;
UnitAtom = nsGkAtoms::ex;
break;
case SVG_LENGTHTYPE_PERCENTAGE:
UnitAtom = nsSVGAtoms::percentage;
UnitAtom = nsGkAtoms::percentage;
break;
default:
NS_NOTREACHED("Unknown unit");
@ -398,23 +398,23 @@ nsSVGLength::SetValueAsString(const nsAString & aValueAsString)
}
else {
nsCOMPtr<nsIAtom> unitAtom = do_GetAtom(unitStr);
if (unitAtom == nsSVGAtoms::px)
if (unitAtom == nsGkAtoms::px)
unitType = SVG_LENGTHTYPE_PX;
else if (unitAtom == nsSVGAtoms::mm)
else if (unitAtom == nsGkAtoms::mm)
unitType = SVG_LENGTHTYPE_MM;
else if (unitAtom == nsSVGAtoms::cm)
else if (unitAtom == nsGkAtoms::cm)
unitType = SVG_LENGTHTYPE_CM;
else if (unitAtom == nsSVGAtoms::in)
else if (unitAtom == nsGkAtoms::in)
unitType = SVG_LENGTHTYPE_IN;
else if (unitAtom == nsSVGAtoms::pt)
else if (unitAtom == nsGkAtoms::pt)
unitType = SVG_LENGTHTYPE_PT;
else if (unitAtom == nsSVGAtoms::pc)
else if (unitAtom == nsGkAtoms::pc)
unitType = SVG_LENGTHTYPE_PC;
else if (unitAtom == nsSVGAtoms::em)
else if (unitAtom == nsGkAtoms::em)
unitType = SVG_LENGTHTYPE_EMS;
else if (unitAtom == nsSVGAtoms::ex)
else if (unitAtom == nsGkAtoms::ex)
unitType = SVG_LENGTHTYPE_EXS;
else if (unitAtom == nsSVGAtoms::percentage)
else if (unitAtom == nsGkAtoms::percentage)
unitType = SVG_LENGTHTYPE_PERCENTAGE;
}
if (IsValidUnitType(unitType)){

16
content/svg/content/src/nsSVGMarkerElement.cpp
Просмотреть файл

@ -34,7 +34,7 @@
*
* ***** END LICENSE BLOCK ***** */
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGAnimatedAngle.h"
#include "nsSVGAnimatedRect.h"
#include "nsSVGLength.h"
@ -92,8 +92,8 @@ nsSVGMarkerElement::Init()
// enumeration mappings
static struct nsSVGEnumMapping gMarkerUnits[] = {
{&nsSVGAtoms::strokeWidth, SVG_MARKERUNITS_STROKEWIDTH},
{&nsSVGAtoms::userSpaceOnUse, SVG_MARKERUNITS_USERSPACEONUSE},
{&nsGkAtoms::strokeWidth, SVG_MARKERUNITS_STROKEWIDTH},
{&nsGkAtoms::userSpaceOnUse, SVG_MARKERUNITS_USERSPACEONUSE},
{nsnull, 0}
};
@ -106,7 +106,7 @@ nsSVGMarkerElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mMarkerUnits), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::markerUnits, mMarkerUnits);
rv = AddMappedSVGValue(nsGkAtoms::markerUnits, mMarkerUnits);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -117,7 +117,7 @@ nsSVGMarkerElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedAngle(getter_AddRefs(mOrient), angle);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::orient, mOrient);
rv = AddMappedSVGValue(nsGkAtoms::orient, mOrient);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -128,7 +128,7 @@ nsSVGMarkerElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedRect(getter_AddRefs(mViewBox), viewbox);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::viewBox, mViewBox);
rv = AddMappedSVGValue(nsGkAtoms::viewBox, mViewBox);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -141,7 +141,7 @@ nsSVGMarkerElement::Init()
getter_AddRefs(mPreserveAspectRatio),
preserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::preserveAspectRatio,
rv = AddMappedSVGValue(nsGkAtoms::preserveAspectRatio,
mPreserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -213,7 +213,7 @@ NS_IMETHODIMP nsSVGMarkerElement::GetMarkerHeight(nsIDOMSVGAnimatedLength * *aMa
NS_IMETHODIMP nsSVGMarkerElement::GetOrientType(nsIDOMSVGAnimatedEnumeration * *aOrientType)
{
static struct nsSVGEnumMapping gOrientType[] = {
{&nsSVGAtoms::_auto, SVG_MARKER_ORIENT_AUTO},
{&nsGkAtoms::_auto, SVG_MARKER_ORIENT_AUTO},
{nsnull, 0}
};

10
content/svg/content/src/nsSVGMaskElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsIDOMSVGAnimatedEnum.h"
#include "nsCOMPtr.h"
#include "nsISVGSVGElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGMaskElement.h"
//--------------------- Masks ------------------------
@ -84,8 +84,8 @@ nsSVGMaskElement::Init()
// Define enumeration mappings
static struct nsSVGEnumMapping pUnitMap[] = {
{&nsSVGAtoms::objectBoundingBox, nsIDOMSVGMaskElement::SVG_MUNITS_OBJECTBOUNDINGBOX},
{&nsSVGAtoms::userSpaceOnUse, nsIDOMSVGMaskElement::SVG_MUNITS_USERSPACEONUSE},
{&nsGkAtoms::objectBoundingBox, nsIDOMSVGMaskElement::SVG_MUNITS_OBJECTBOUNDINGBOX},
{&nsGkAtoms::userSpaceOnUse, nsIDOMSVGMaskElement::SVG_MUNITS_USERSPACEONUSE},
{nsnull, 0}
};
@ -99,7 +99,7 @@ nsSVGMaskElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mMaskUnits), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::maskUnits, mMaskUnits);
rv = AddMappedSVGValue(nsGkAtoms::maskUnits, mMaskUnits);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -111,7 +111,7 @@ nsSVGMaskElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mMaskContentUnits), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::maskContentUnits, mMaskContentUnits);
rv = AddMappedSVGValue(nsGkAtoms::maskContentUnits, mMaskContentUnits);
NS_ENSURE_SUCCESS(rv,rv);
}

18
content/svg/content/src/nsSVGPatternElement.cpp
Просмотреть файл

@ -44,7 +44,7 @@
#include "nsSVGAnimatedString.h"
#include "nsCOMPtr.h"
#include "nsISVGSVGElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGAnimatedRect.h"
#include "nsSVGRect.h"
#include "nsSVGMatrix.h"
@ -99,8 +99,8 @@ nsSVGPatternElement::Init()
// Define enumeration mappings
static struct nsSVGEnumMapping pUnitMap[] = {
{&nsSVGAtoms::objectBoundingBox, nsIDOMSVGPatternElement::SVG_PUNITS_OBJECTBOUNDINGBOX},
{&nsSVGAtoms::userSpaceOnUse, nsIDOMSVGPatternElement::SVG_PUNITS_USERSPACEONUSE},
{&nsGkAtoms::objectBoundingBox, nsIDOMSVGPatternElement::SVG_PUNITS_OBJECTBOUNDINGBOX},
{&nsGkAtoms::userSpaceOnUse, nsIDOMSVGPatternElement::SVG_PUNITS_USERSPACEONUSE},
{nsnull, 0}
};
@ -114,7 +114,7 @@ nsSVGPatternElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mPatternUnits), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::patternUnits, mPatternUnits);
rv = AddMappedSVGValue(nsGkAtoms::patternUnits, mPatternUnits);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -126,7 +126,7 @@ nsSVGPatternElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mPatternContentUnits), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::patternContentUnits, mPatternContentUnits);
rv = AddMappedSVGValue(nsGkAtoms::patternContentUnits, mPatternContentUnits);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -138,7 +138,7 @@ nsSVGPatternElement::Init()
rv = NS_NewSVGAnimatedTransformList(getter_AddRefs(mPatternTransform),
transformList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::patternTransform, mPatternTransform);
rv = AddMappedSVGValue(nsGkAtoms::patternTransform, mPatternTransform);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -148,7 +148,7 @@ nsSVGPatternElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mHref));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::href, mHref, kNameSpaceID_XLink);
rv = AddMappedSVGValue(nsGkAtoms::href, mHref, kNameSpaceID_XLink);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -161,7 +161,7 @@ nsSVGPatternElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedRect(getter_AddRefs(mViewBox), viewbox);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::viewBox, mViewBox);
rv = AddMappedSVGValue(nsGkAtoms::viewBox, mViewBox);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -174,7 +174,7 @@ nsSVGPatternElement::Init()
getter_AddRefs(mPreserveAspectRatio),
preserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::preserveAspectRatio,
rv = AddMappedSVGValue(nsGkAtoms::preserveAspectRatio,
mPreserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
}

2
content/svg/content/src/nsSVGPolyElement.cpp
Просмотреть файл

@ -66,7 +66,7 @@ nsSVGPolyElement::Init()
// points #IMPLIED
rv = nsSVGPointList::Create(getter_AddRefs(mPoints));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::points, mPoints);
rv = AddMappedSVGValue(nsGkAtoms::points, mPoints);
NS_ENSURE_SUCCESS(rv,rv);
return rv;

18
content/svg/content/src/nsSVGSVGElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
*
* ***** END LICENSE BLOCK ***** */
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsSVGLength.h"
#include "nsSVGAngle.h"
#include "nsCOMPtr.h"
@ -130,7 +130,7 @@ nsSVGSVGElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedRect(getter_AddRefs(mViewBox), viewbox);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::viewBox, mViewBox);
rv = AddMappedSVGValue(nsGkAtoms::viewBox, mViewBox);
NS_ENSURE_SUCCESS(rv,rv);
// initialize coordinate context with viewbox:
SetCoordCtxRect(viewbox);
@ -145,7 +145,7 @@ nsSVGSVGElement::Init()
getter_AddRefs(mPreserveAspectRatio),
preserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::preserveAspectRatio,
rv = AddMappedSVGValue(nsGkAtoms::preserveAspectRatio,
mPreserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -154,8 +154,8 @@ nsSVGSVGElement::Init()
// Define enumeration mappings
static struct nsSVGEnumMapping zoomMap[] = {
{&nsSVGAtoms::disable, nsIDOMSVGZoomAndPan::SVG_ZOOMANDPAN_DISABLE},
{&nsSVGAtoms::magnify, nsIDOMSVGZoomAndPan::SVG_ZOOMANDPAN_MAGNIFY},
{&nsGkAtoms::disable, nsIDOMSVGZoomAndPan::SVG_ZOOMANDPAN_DISABLE},
{&nsGkAtoms::magnify, nsIDOMSVGZoomAndPan::SVG_ZOOMANDPAN_MAGNIFY},
{nsnull, 0}
};
@ -164,7 +164,7 @@ nsSVGSVGElement::Init()
rv = NS_NewSVGEnum(getter_AddRefs(mZoomAndPan),
nsIDOMSVGZoomAndPan::SVG_ZOOMANDPAN_MAGNIFY, zoomMap);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::zoomAndPan, mZoomAndPan);
rv = AddMappedSVGValue(nsGkAtoms::zoomAndPan, mZoomAndPan);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -1230,9 +1230,9 @@ nsSVGSVGElement::IsEventName(nsIAtom* aName)
question will always be the outermost 'svg' element, this shouldn't cause
any real problems.
*/
aName == nsSVGAtoms::onunload ||
aName == nsSVGAtoms::onscroll ||
aName == nsSVGAtoms::onzoom;
aName == nsGkAtoms::onunload ||
aName == nsGkAtoms::onscroll ||
aName == nsGkAtoms::onzoom;
}
//----------------------------------------------------------------------

6
content/svg/content/src/nsSVGScriptElement.cpp
Просмотреть файл

@ -38,7 +38,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsSVGElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDOMSVGScriptElement.h"
#include "nsIDOMSVGURIReference.h"
#include "nsCOMPtr.h"
@ -147,7 +147,7 @@ nsSVGScriptElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mHref));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::href, mHref, kNameSpaceID_XLink);
rv = AddMappedSVGValue(nsGkAtoms::href, mHref, kNameSpaceID_XLink);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -166,7 +166,7 @@ NS_IMPL_ELEMENT_CLONE_WITH_INIT(nsSVGScriptElement)
NS_IMETHODIMP
nsSVGScriptElement::GetType(nsAString & aType)
{
GetAttr(kNameSpaceID_None, nsSVGAtoms::type, aType);
GetAttr(kNameSpaceID_None, nsGkAtoms::type, aType);
return NS_OK;
}

4
content/svg/content/src/nsSVGStylableElement.cpp
Просмотреть файл

@ -39,7 +39,7 @@
#include "nsSVGStylableElement.h"
#include "nsICSSOMFactory.h"
#include "nsSVGAnimatedString.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsDOMCSSDeclaration.h"
#include "nsIDOMClassInfo.h"
@ -76,7 +76,7 @@ nsSVGStylableElement::Init()
{
mClassName = new nsSVGClassValue;
NS_ENSURE_TRUE(mClassName, NS_ERROR_OUT_OF_MEMORY);
rv = AddMappedSVGValue(nsSVGAtoms::_class,
rv = AddMappedSVGValue(nsGkAtoms::_class,
NS_STATIC_CAST(nsIDOMSVGAnimatedString*, mClassName),
kNameSpaceID_None);
NS_ENSURE_SUCCESS(rv, rv);

36
content/svg/content/src/nsSVGStyleElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsSVGElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDOMSVGStyleElement.h"
#include "nsUnicharUtils.h"
#include "nsIDocument.h"
@ -200,9 +200,9 @@ nsSVGStyleElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
if (NS_SUCCEEDED(rv)) {
UpdateStyleSheet(nsnull, nsnull,
aNameSpaceID == kNameSpaceID_None &&
(aName == nsSVGAtoms::title ||
aName == nsSVGAtoms::media ||
aName == nsSVGAtoms::type));
(aName == nsGkAtoms::title ||
aName == nsGkAtoms::media ||
aName == nsGkAtoms::type));
}
return rv;
@ -217,9 +217,9 @@ nsSVGStyleElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
if (NS_SUCCEEDED(rv)) {
UpdateStyleSheet(nsnull, nsnull,
aNameSpaceID == kNameSpaceID_None &&
(aAttribute == nsSVGAtoms::title ||
aAttribute == nsSVGAtoms::media ||
aAttribute == nsSVGAtoms::type));
(aAttribute == nsGkAtoms::title ||
aAttribute == nsGkAtoms::media ||
aAttribute == nsGkAtoms::type));
}
return rv;
@ -231,49 +231,49 @@ nsSVGStyleElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
/* attribute DOMString xmlspace; */
NS_IMETHODIMP nsSVGStyleElement::GetXmlspace(nsAString & aXmlspace)
{
GetAttr(kNameSpaceID_XML, nsSVGAtoms::space, aXmlspace);
GetAttr(kNameSpaceID_XML, nsGkAtoms::space, aXmlspace);
return NS_OK;
}
NS_IMETHODIMP nsSVGStyleElement::SetXmlspace(const nsAString & aXmlspace)
{
return SetAttr(kNameSpaceID_XML, nsSVGAtoms::space, aXmlspace, PR_TRUE);
return SetAttr(kNameSpaceID_XML, nsGkAtoms::space, aXmlspace, PR_TRUE);
}
/* attribute DOMString type; */
NS_IMETHODIMP nsSVGStyleElement::GetType(nsAString & aType)
{
GetAttr(kNameSpaceID_None, nsSVGAtoms::type, aType);
GetAttr(kNameSpaceID_None, nsGkAtoms::type, aType);
return NS_OK;
}
NS_IMETHODIMP nsSVGStyleElement::SetType(const nsAString & aType)
{
return SetAttr(kNameSpaceID_None, nsSVGAtoms::type, aType, PR_TRUE);
return SetAttr(kNameSpaceID_None, nsGkAtoms::type, aType, PR_TRUE);
}
/* attribute DOMString media; */
NS_IMETHODIMP nsSVGStyleElement::GetMedia(nsAString & aMedia)
{
GetAttr(kNameSpaceID_None, nsSVGAtoms::media, aMedia);
GetAttr(kNameSpaceID_None, nsGkAtoms::media, aMedia);
return NS_OK;
}
NS_IMETHODIMP nsSVGStyleElement::SetMedia(const nsAString & aMedia)
{
return SetAttr(kNameSpaceID_XML, nsSVGAtoms::media, aMedia, PR_TRUE);
return SetAttr(kNameSpaceID_XML, nsGkAtoms::media, aMedia, PR_TRUE);
}
/* attribute DOMString title; */
NS_IMETHODIMP nsSVGStyleElement::GetTitle(nsAString & aTitle)
{
GetAttr(kNameSpaceID_None, nsSVGAtoms::title, aTitle);
GetAttr(kNameSpaceID_None, nsGkAtoms::title, aTitle);
return NS_OK;
}
NS_IMETHODIMP nsSVGStyleElement::SetTitle(const nsAString & aTitle)
{
return SetAttr(kNameSpaceID_XML, nsSVGAtoms::title, aTitle, PR_TRUE);
return SetAttr(kNameSpaceID_XML, nsGkAtoms::title, aTitle, PR_TRUE);
}
//----------------------------------------------------------------------
@ -298,16 +298,16 @@ nsSVGStyleElement::GetStyleSheetInfo(nsAString& aTitle,
*aIsAlternate = PR_FALSE;
nsAutoString title;
GetAttr(kNameSpaceID_None, nsSVGAtoms::title, title);
GetAttr(kNameSpaceID_None, nsGkAtoms::title, title);
title.CompressWhitespace();
aTitle.Assign(title);
GetAttr(kNameSpaceID_None, nsSVGAtoms::media, aMedia);
GetAttr(kNameSpaceID_None, nsGkAtoms::media, aMedia);
// SVG spec refers to the HTML4.0 spec which is inconsistent, make it
// case INSENSITIVE
ToLowerCase(aMedia);
GetAttr(kNameSpaceID_None, nsSVGAtoms::type, aType);
GetAttr(kNameSpaceID_None, nsGkAtoms::type, aType);
return;
}

6
content/svg/content/src/nsSVGSymbolElement.cpp
Просмотреть файл

@ -43,7 +43,7 @@
#include "nsIDOMSVGFitToViewBox.h"
#include "nsSVGRect.h"
#include "nsSVGAnimatedRect.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
typedef nsSVGStylableElement nsSVGSymbolElementBase;
@ -120,7 +120,7 @@ nsSVGSymbolElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedRect(getter_AddRefs(mViewBox), viewbox);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::viewBox, mViewBox);
rv = AddMappedSVGValue(nsGkAtoms::viewBox, mViewBox);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -133,7 +133,7 @@ nsSVGSymbolElement::Init()
getter_AddRefs(mPreserveAspectRatio),
preserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::preserveAspectRatio,
rv = AddMappedSVGValue(nsGkAtoms::preserveAspectRatio,
mPreserveAspectRatio);
NS_ENSURE_SUCCESS(rv,rv);
}

10
content/svg/content/src/nsSVGTSpanElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsSVGStylableElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDOMSVGTSpanElement.h"
#include "nsCOMPtr.h"
#include "nsSVGAnimatedLengthList.h"
@ -142,7 +142,7 @@ nsSVGTSpanElement::Init()
rv = NS_NewSVGAnimatedLengthList(getter_AddRefs(mX),
lengthList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::x, mX);
rv = AddMappedSVGValue(nsGkAtoms::x, mX);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -154,7 +154,7 @@ nsSVGTSpanElement::Init()
rv = NS_NewSVGAnimatedLengthList(getter_AddRefs(mY),
lengthList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::y, mY);
rv = AddMappedSVGValue(nsGkAtoms::y, mY);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -166,7 +166,7 @@ nsSVGTSpanElement::Init()
rv = NS_NewSVGAnimatedLengthList(getter_AddRefs(mdX),
lengthList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::dx, mdX);
rv = AddMappedSVGValue(nsGkAtoms::dx, mdX);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -178,7 +178,7 @@ nsSVGTSpanElement::Init()
rv = NS_NewSVGAnimatedLengthList(getter_AddRefs(mdY),
lengthList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::dy, mdY);
rv = AddMappedSVGValue(nsGkAtoms::dy, mdY);
NS_ENSURE_SUCCESS(rv,rv);
}

10
content/svg/content/src/nsSVGTextElement.cpp
Просмотреть файл

@ -37,7 +37,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsSVGGraphicElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDOMSVGTextElement.h"
#include "nsCOMPtr.h"
#include "nsSVGAnimatedLengthList.h"
@ -139,7 +139,7 @@ nsSVGTextElement::Init()
rv = NS_NewSVGAnimatedLengthList(getter_AddRefs(mX),
lengthList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::x, mX);
rv = AddMappedSVGValue(nsGkAtoms::x, mX);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -151,7 +151,7 @@ nsSVGTextElement::Init()
rv = NS_NewSVGAnimatedLengthList(getter_AddRefs(mY),
lengthList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::y, mY);
rv = AddMappedSVGValue(nsGkAtoms::y, mY);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -163,7 +163,7 @@ nsSVGTextElement::Init()
rv = NS_NewSVGAnimatedLengthList(getter_AddRefs(mdX),
lengthList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::dx, mdX);
rv = AddMappedSVGValue(nsGkAtoms::dx, mdX);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -175,7 +175,7 @@ nsSVGTextElement::Init()
rv = NS_NewSVGAnimatedLengthList(getter_AddRefs(mdY),
lengthList);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::dy, mdY);
rv = AddMappedSVGValue(nsGkAtoms::dy, mdY);
NS_ENSURE_SUCCESS(rv,rv);
}

16
content/svg/content/src/nsSVGTextPathElement.cpp
Просмотреть файл

@ -36,7 +36,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsSVGStylableElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDOMSVGTextPathElement.h"
#include "nsIDOMSVGURIReference.h"
#include "nsISVGTextContentMetrics.h"
@ -134,14 +134,14 @@ nsSVGTextPathElement::Init()
// enumeration mappings
static struct nsSVGEnumMapping methodMap[] = {
{&nsSVGAtoms::align, TEXTPATH_METHODTYPE_ALIGN},
{&nsSVGAtoms::stretch, TEXTPATH_METHODTYPE_STRETCH},
{&nsGkAtoms::align, TEXTPATH_METHODTYPE_ALIGN},
{&nsGkAtoms::stretch, TEXTPATH_METHODTYPE_STRETCH},
{nsnull, 0}
};
static struct nsSVGEnumMapping spacingMap[] = {
{&nsSVGAtoms::_auto, TEXTPATH_SPACINGTYPE_AUTO},
{&nsSVGAtoms::exact, TEXTPATH_SPACINGTYPE_EXACT},
{&nsGkAtoms::_auto, TEXTPATH_SPACINGTYPE_AUTO},
{&nsGkAtoms::exact, TEXTPATH_SPACINGTYPE_EXACT},
{nsnull, 0}
};
@ -155,7 +155,7 @@ nsSVGTextPathElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mMethod), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::method, mMethod);
rv = AddMappedSVGValue(nsGkAtoms::method, mMethod);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -167,7 +167,7 @@ nsSVGTextPathElement::Init()
NS_ENSURE_SUCCESS(rv,rv);
rv = NS_NewSVGAnimatedEnumeration(getter_AddRefs(mSpacing), units);
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::spacing, mSpacing);
rv = AddMappedSVGValue(nsGkAtoms::spacing, mSpacing);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -178,7 +178,7 @@ nsSVGTextPathElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mHref));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::href, mHref, kNameSpaceID_XLink);
rv = AddMappedSVGValue(nsGkAtoms::href, mHref, kNameSpaceID_XLink);
NS_ENSURE_SUCCESS(rv,rv);
}

26
content/svg/content/src/nsSVGTransformListParser.cpp
Просмотреть файл

@ -40,7 +40,7 @@
#include "nsSVGTransform.h"
#include "nsSVGMatrix.h"
#include "nsDOMError.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsReadableUtils.h"
#include "nsCRT.h"
#include "nsCOMArray.h"
@ -153,22 +153,22 @@ nsSVGTransformListParser::MatchTransform()
nsresult rv = GetTransformToken(getter_AddRefs(keyatom), PR_TRUE);
NS_ENSURE_SUCCESS(rv, rv);
if (keyatom == nsSVGAtoms::translate) {
if (keyatom == nsGkAtoms::translate) {
ENSURE_MATCHED(MatchTranslate());
}
else if (keyatom == nsSVGAtoms::scale) {
else if (keyatom == nsGkAtoms::scale) {
ENSURE_MATCHED(MatchScale());
}
else if (keyatom == nsSVGAtoms::rotate) {
else if (keyatom == nsGkAtoms::rotate) {
ENSURE_MATCHED(MatchRotate());
}
else if (keyatom == nsSVGAtoms::skewX) {
else if (keyatom == nsGkAtoms::skewX) {
ENSURE_MATCHED(MatchSkewX());
}
else if (keyatom == nsSVGAtoms::skewY) {
else if (keyatom == nsGkAtoms::skewY) {
ENSURE_MATCHED(MatchSkewY());
}
else if (keyatom == nsSVGAtoms::matrix) {
else if (keyatom == nsGkAtoms::matrix) {
ENSURE_MATCHED(MatchMatrix());
}
else {
@ -187,12 +187,12 @@ nsSVGTransformListParser::IsTokenTransformStarter()
nsresult rv = GetTransformToken(getter_AddRefs(keyatom), PR_FALSE);
NS_ENSURE_SUCCESS(rv, PR_FALSE);
if (keyatom == nsSVGAtoms::translate ||
keyatom == nsSVGAtoms::scale ||
keyatom == nsSVGAtoms::rotate ||
keyatom == nsSVGAtoms::skewX ||
keyatom == nsSVGAtoms::skewY ||
keyatom == nsSVGAtoms::matrix) {
if (keyatom == nsGkAtoms::translate ||
keyatom == nsGkAtoms::scale ||
keyatom == nsGkAtoms::rotate ||
keyatom == nsGkAtoms::skewX ||
keyatom == nsGkAtoms::skewY ||
keyatom == nsGkAtoms::matrix) {
return PR_TRUE;
}

58
content/svg/content/src/nsSVGUseElement.cpp
Просмотреть файл

@ -35,7 +35,7 @@
* ***** END LICENSE BLOCK ***** */
#include "nsIDOMSVGGElement.h"
#include "nsSVGAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDOMSVGAnimatedLength.h"
#include "nsISVGSVGElement.h"
#include "nsSVGCoordCtxProvider.h"
@ -189,7 +189,7 @@ nsSVGUseElement::Init()
{
rv = NS_NewSVGAnimatedString(getter_AddRefs(mHref));
NS_ENSURE_SUCCESS(rv,rv);
rv = AddMappedSVGValue(nsSVGAtoms::href, mHref, kNameSpaceID_XLink);
rv = AddMappedSVGValue(nsGkAtoms::href, mHref, kNameSpaceID_XLink);
NS_ENSURE_SUCCESS(rv,rv);
}
@ -362,19 +362,19 @@ nsSVGUseElement::CreateAnonymousContent(nsPresContext* aPresContext,
// make sure target is valid type for <use>
// QIable nsSVGGraphicsElement would eliminate enumerating all elements
nsIAtom *tag = targetContent->Tag();
if (tag != nsSVGAtoms::svg &&
tag != nsSVGAtoms::symbol &&
tag != nsSVGAtoms::g &&
tag != nsSVGAtoms::path &&
tag != nsSVGAtoms::text &&
tag != nsSVGAtoms::rect &&
tag != nsSVGAtoms::circle &&
tag != nsSVGAtoms::ellipse &&
tag != nsSVGAtoms::line &&
tag != nsSVGAtoms::polyline &&
tag != nsSVGAtoms::polygon &&
tag != nsSVGAtoms::image &&
tag != nsSVGAtoms::use)
if (tag != nsGkAtoms::svg &&
tag != nsGkAtoms::symbol &&
tag != nsGkAtoms::g &&
tag != nsGkAtoms::path &&
tag != nsGkAtoms::text &&
tag != nsGkAtoms::rect &&
tag != nsGkAtoms::circle &&
tag != nsGkAtoms::ellipse &&
tag != nsGkAtoms::line &&
tag != nsGkAtoms::polyline &&
tag != nsGkAtoms::polygon &&
tag != nsGkAtoms::image &&
tag != nsGkAtoms::use)
return NS_ERROR_FAILURE;
// circular loop detection
@ -424,7 +424,7 @@ nsSVGUseElement::CreateAnonymousContent(nsPresContext* aPresContext,
return NS_ERROR_FAILURE;
nsCOMPtr<nsINodeInfo> nodeInfo;
nodeInfoManager->GetNodeInfo(nsSVGAtoms::svg, nsnull, kNameSpaceID_SVG,
nodeInfoManager->GetNodeInfo(nsGkAtoms::svg, nsnull, kNameSpaceID_SVG,
getter_AddRefs(nodeInfo));
if (!nodeInfo)
return NS_ERROR_FAILURE;
@ -435,10 +435,10 @@ nsSVGUseElement::CreateAnonymousContent(nsPresContext* aPresContext,
if (!svgNode)
return NS_ERROR_FAILURE;
if (newcontent->HasAttr(kNameSpaceID_None, nsSVGAtoms::viewBox)) {
if (newcontent->HasAttr(kNameSpaceID_None, nsGkAtoms::viewBox)) {
nsAutoString viewbox;
newcontent->GetAttr(kNameSpaceID_None, nsSVGAtoms::viewBox, viewbox);
svgNode->SetAttr(kNameSpaceID_None, nsSVGAtoms::viewBox, viewbox, PR_FALSE);
newcontent->GetAttr(kNameSpaceID_None, nsGkAtoms::viewBox, viewbox);
svgNode->SetAttr(kNameSpaceID_None, nsGkAtoms::viewBox, viewbox, PR_FALSE);
}
// copy attributes
@ -465,16 +465,16 @@ nsSVGUseElement::CreateAnonymousContent(nsPresContext* aPresContext,
}
if (symbol || svg) {
if (HasAttr(kNameSpaceID_None, nsSVGAtoms::width)) {
if (HasAttr(kNameSpaceID_None, nsGkAtoms::width)) {
nsAutoString width;
GetAttr(kNameSpaceID_None, nsSVGAtoms::width, width);
newcontent->SetAttr(kNameSpaceID_None, nsSVGAtoms::width, width, PR_FALSE);
GetAttr(kNameSpaceID_None, nsGkAtoms::width, width);
newcontent->SetAttr(kNameSpaceID_None, nsGkAtoms::width, width, PR_FALSE);
}
if (HasAttr(kNameSpaceID_None, nsSVGAtoms::height)) {
if (HasAttr(kNameSpaceID_None, nsGkAtoms::height)) {
nsAutoString height;
GetAttr(kNameSpaceID_None, nsSVGAtoms::height, height);
newcontent->SetAttr(kNameSpaceID_None, nsSVGAtoms::height, height, PR_FALSE);
GetAttr(kNameSpaceID_None, nsGkAtoms::height, height);
newcontent->SetAttr(kNameSpaceID_None, nsGkAtoms::height, height, PR_FALSE);
}
}
@ -507,12 +507,12 @@ nsSVGUseElement::SyncWidthHeight(PRUint8 aAttrEnum)
if (symbol || svg) {
if (aAttrEnum == WIDTH) {
nsAutoString width;
GetAttr(kNameSpaceID_None, nsSVGAtoms::width, width);
mClone->SetAttr(kNameSpaceID_None, nsSVGAtoms::width, width, PR_FALSE);
GetAttr(kNameSpaceID_None, nsGkAtoms::width, width);
mClone->SetAttr(kNameSpaceID_None, nsGkAtoms::width, width, PR_FALSE);
} else if (aAttrEnum == HEIGHT) {
nsAutoString height;
GetAttr(kNameSpaceID_None, nsSVGAtoms::height, height);
mClone->SetAttr(kNameSpaceID_None, nsSVGAtoms::height, height, PR_FALSE);
GetAttr(kNameSpaceID_None, nsGkAtoms::height, height);
mClone->SetAttr(kNameSpaceID_None, nsGkAtoms::height, height, PR_FALSE);
}
}
}

31
content/xbl/src/nsXBLBinding.cpp
Просмотреть файл

@ -87,8 +87,7 @@
#include "nsIDOMEventGroup.h"
#include "nsAttrName.h"
#include "nsXBLAtoms.h"
#include "nsXULAtoms.h"
#include "nsGkAtoms.h"
#include "nsIDOMAttr.h"
#include "nsIDOMNamedNodeMap.h"
@ -443,7 +442,7 @@ nsXBLBinding::GenerateAnonymousContent()
{
// Fetch the content element for this binding.
nsIContent* content =
mPrototypeBinding->GetImmediateChild(nsXBLAtoms::content);
mPrototypeBinding->GetImmediateChild(nsGkAtoms::content);
if (!content) {
// We have no anonymous content.
@ -464,7 +463,7 @@ nsXBLBinding::GenerateAnonymousContent()
#ifdef DEBUG
// See if there's an includes attribute.
if (nsContentUtils::HasNonEmptyAttr(content, kNameSpaceID_None,
nsXBLAtoms::includes)) {
nsGkAtoms::includes)) {
nsCAutoString id;
mPrototypeBinding->GetID(id);
nsCAutoString message("An XBL Binding with an id of ");
@ -506,8 +505,8 @@ nsXBLBinding::GenerateAnonymousContent()
nsINodeInfo *ni = childContent->NodeInfo();
nsIAtom *localName = ni->NameAtom();
if (ni->NamespaceID() != kNameSpaceID_XUL ||
(localName != nsXULAtoms::observes &&
localName != nsXULAtoms::_template)) {
(localName != nsGkAtoms::observes &&
localName != nsGkAtoms::_template)) {
hasContent = PR_FALSE;
break;
}
@ -590,8 +589,8 @@ nsXBLBinding::GenerateAnonymousContent()
nsINodeInfo *ni = childContent->NodeInfo();
nsIAtom *localName = ni->NameAtom();
if (ni->NamespaceID() != kNameSpaceID_XUL ||
(localName != nsXULAtoms::observes &&
localName != nsXULAtoms::_template)) {
(localName != nsGkAtoms::observes &&
localName != nsGkAtoms::_template)) {
// Kill all anonymous content.
mContent = nsnull;
bindingManager->SetContentListFor(mBoundElement, nsnull);
@ -642,7 +641,7 @@ nsXBLBinding::GenerateAnonymousContent()
PRInt32 namespaceID = attrName->NamespaceID();
nsIAtom* name = attrName->LocalName();
if (name != nsXBLAtoms::includes) {
if (name != nsGkAtoms::includes) {
if (!nsContentUtils::HasNonEmptyAttr(mBoundElement, namespaceID, name)) {
nsAutoString value2;
content->GetAttr(namespaceID, name, value2);
@ -678,9 +677,9 @@ nsXBLBinding::InstallEventHandlers()
// Fetch the event type.
nsCOMPtr<nsIAtom> eventAtom = curr->GetEventName();
if (!eventAtom ||
eventAtom == nsXBLAtoms::keyup ||
eventAtom == nsXBLAtoms::keydown ||
eventAtom == nsXBLAtoms::keypress)
eventAtom == nsGkAtoms::keyup ||
eventAtom == nsGkAtoms::keydown ||
eventAtom == nsGkAtoms::keypress)
continue;
nsAutoString type;
@ -830,9 +829,9 @@ nsXBLBinding::UnhookEventHandlers()
if (handler) {
nsCOMPtr<nsIAtom> eventAtom = curr->GetEventName();
if (!eventAtom ||
eventAtom == nsXBLAtoms::keyup ||
eventAtom == nsXBLAtoms::keydown ||
eventAtom == nsXBLAtoms::keypress)
eventAtom == nsGkAtoms::keyup ||
eventAtom == nsGkAtoms::keydown ||
eventAtom == nsGkAtoms::keypress)
continue;
nsAutoString type;
@ -899,7 +898,7 @@ nsXBLBinding::ChangeDocument(nsIDocument* aOldDocument, nsIDocument* aNewDocumen
if (mIsStyleBinding) {
// Now the binding dies. Unhook our prototypes.
nsIContent* interfaceElement =
mPrototypeBinding->GetImmediateChild(nsXBLAtoms::implementation);
mPrototypeBinding->GetImmediateChild(nsGkAtoms::implementation);
if (interfaceElement) {
nsIScriptGlobalObject *global = aOldDocument->GetScriptGlobalObject();

121
content/xbl/src/nsXBLContentSink.cpp
Просмотреть файл

@ -41,17 +41,14 @@
#include "nsIBindingManager.h"
#include "nsIDOMNode.h"
#include "nsIParser.h"
#include "nsXBLAtoms.h"
#include "nsINameSpaceManager.h"
#include "nsHTMLAtoms.h"
#include "nsLayoutAtoms.h"
#include "nsINameSpaceManager.h"
#include "nsHTMLTokens.h"
#include "nsIURI.h"
#include "nsTextFragment.h"
#ifdef MOZ_XUL
#include "nsXULElement.h"
#endif
#include "nsXULAtoms.h"
#include "nsXBLProtoImplProperty.h"
#include "nsXBLProtoImplMethod.h"
#include "nsXBLProtoImplField.h"
@ -174,8 +171,8 @@ nsXBLContentSink::FlushText(PRBool aCreateTextNode,
if (content &&
(content->NodeInfo()->NamespaceEquals(kNameSpaceID_XBL) ||
(content->NodeInfo()->NamespaceEquals(kNameSpaceID_XUL) &&
content->Tag() != nsXULAtoms::label &&
content->Tag() != nsXULAtoms::description))) {
content->Tag() != nsGkAtoms::label &&
content->Tag() != nsGkAtoms::description))) {
PRBool isWS = PR_TRUE;
if (mTextLength > 0) {
@ -314,47 +311,47 @@ nsXBLContentSink::HandleEndElement(const PRUnichar *aName)
}
}
else if (mState == eXBL_InHandlers) {
if (localName == nsXBLAtoms::handlers) {
if (localName == nsGkAtoms::handlers) {
mState = eXBL_InBinding;
mHandler = nsnull;
}
else if (localName == nsXBLAtoms::handler)
else if (localName == nsGkAtoms::handler)
mSecondaryState = eXBL_None;
return NS_OK;
}
else if (mState == eXBL_InResources) {
if (localName == nsXBLAtoms::resources)
if (localName == nsGkAtoms::resources)
mState = eXBL_InBinding;
return NS_OK;
}
else if (mState == eXBL_InImplementation) {
if (localName == nsXBLAtoms::implementation)
if (localName == nsGkAtoms::implementation)
mState = eXBL_InBinding;
else if (localName == nsXBLAtoms::property) {
else if (localName == nsGkAtoms::property) {
mSecondaryState = eXBL_None;
mProperty = nsnull;
}
else if (localName == nsXBLAtoms::method) {
else if (localName == nsGkAtoms::method) {
mSecondaryState = eXBL_None;
mMethod = nsnull;
}
else if (localName == nsXBLAtoms::field) {
else if (localName == nsGkAtoms::field) {
mSecondaryState = eXBL_None;
mField = nsnull;
}
else if (localName == nsXBLAtoms::constructor ||
localName == nsXBLAtoms::destructor)
else if (localName == nsGkAtoms::constructor ||
localName == nsGkAtoms::destructor)
mSecondaryState = eXBL_None;
else if (localName == nsXBLAtoms::getter ||
localName == nsXBLAtoms::setter)
else if (localName == nsGkAtoms::getter ||
localName == nsGkAtoms::setter)
mSecondaryState = eXBL_InProperty;
else if (localName == nsXBLAtoms::parameter ||
localName == nsXBLAtoms::body)
else if (localName == nsGkAtoms::parameter ||
localName == nsGkAtoms::body)
mSecondaryState = eXBL_InMethod;
return NS_OK;
}
else if (mState == eXBL_InBindings &&
localName == nsXBLAtoms::bindings) {
localName == nsGkAtoms::bindings) {
mState = eXBL_InDocument;
}
@ -362,7 +359,7 @@ nsXBLContentSink::HandleEndElement(const PRUnichar *aName)
if (NS_FAILED(rv))
return rv;
if (mState == eXBL_InBinding && localName == nsXBLAtoms::binding) {
if (mState == eXBL_InBinding && localName == nsGkAtoms::binding) {
mState = eXBL_InBindings;
if (mBinding) { // See comment in HandleStartElement()
mBinding->Initialize();
@ -408,7 +405,7 @@ nsXBLContentSink::OnOpenContainer(const PRUnichar **aAtts,
}
PRBool ret = PR_TRUE;
if (aTagName == nsXBLAtoms::bindings) {
if (aTagName == nsGkAtoms::bindings) {
ENSURE_XBL_STATE(mState == eXBL_InDocument);
NS_NewXBLDocumentInfo(mDocument, &mDocInfo);
@ -432,40 +429,40 @@ nsXBLContentSink::OnOpenContainer(const PRUnichar **aAtts,
NS_RELEASE(info); // We keep a weak ref. We've created a cycle between doc/binding manager/doc info.
mState = eXBL_InBindings;
}
else if (aTagName == nsXBLAtoms::binding) {
else if (aTagName == nsGkAtoms::binding) {
ENSURE_XBL_STATE(mState == eXBL_InBindings);
mState = eXBL_InBinding;
}
else if (aTagName == nsXBLAtoms::handlers) {
else if (aTagName == nsGkAtoms::handlers) {
ENSURE_XBL_STATE(mState == eXBL_InBinding && mBinding);
mState = eXBL_InHandlers;
ret = PR_FALSE;
}
else if (aTagName == nsXBLAtoms::handler) {
else if (aTagName == nsGkAtoms::handler) {
ENSURE_XBL_STATE(mState == eXBL_InHandlers);
mSecondaryState = eXBL_InHandler;
ConstructHandler(aAtts, aLineNumber);
ret = PR_FALSE;
}
else if (aTagName == nsXBLAtoms::resources) {
else if (aTagName == nsGkAtoms::resources) {
ENSURE_XBL_STATE(mState == eXBL_InBinding && mBinding);
mState = eXBL_InResources;
// Note that this mState will cause us to return false, so no need
// to set ret to false.
}
else if (aTagName == nsXBLAtoms::stylesheet || aTagName == nsXBLAtoms::image) {
else if (aTagName == nsGkAtoms::stylesheet || aTagName == nsGkAtoms::image) {
ENSURE_XBL_STATE(mState == eXBL_InResources);
NS_ASSERTION(mBinding, "Must have binding here");
ConstructResource(aAtts, aTagName);
}
else if (aTagName == nsXBLAtoms::implementation) {
else if (aTagName == nsGkAtoms::implementation) {
ENSURE_XBL_STATE(mState == eXBL_InBinding && mBinding);
mState = eXBL_InImplementation;
ConstructImplementation(aAtts);
// Note that this mState will cause us to return false, so no need
// to set ret to false.
}
else if (aTagName == nsXBLAtoms::constructor) {
else if (aTagName == nsGkAtoms::constructor) {
ENSURE_XBL_STATE(mState == eXBL_InImplementation &&
mSecondaryState == eXBL_None);
NS_ASSERTION(mBinding, "Must have binding here");
@ -479,7 +476,7 @@ nsXBLContentSink::OnOpenContainer(const PRUnichar **aAtts,
AddMember(newMethod);
}
}
else if (aTagName == nsXBLAtoms::destructor) {
else if (aTagName == nsGkAtoms::destructor) {
ENSURE_XBL_STATE(mState == eXBL_InImplementation &&
mSecondaryState == eXBL_None);
NS_ASSERTION(mBinding, "Must have binding here");
@ -492,45 +489,45 @@ nsXBLContentSink::OnOpenContainer(const PRUnichar **aAtts,
AddMember(newMethod);
}
}
else if (aTagName == nsXBLAtoms::field) {
else if (aTagName == nsGkAtoms::field) {
ENSURE_XBL_STATE(mState == eXBL_InImplementation &&
mSecondaryState == eXBL_None);
NS_ASSERTION(mBinding, "Must have binding here");
mSecondaryState = eXBL_InField;
ConstructField(aAtts, aLineNumber);
}
else if (aTagName == nsXBLAtoms::property) {
else if (aTagName == nsGkAtoms::property) {
ENSURE_XBL_STATE(mState == eXBL_InImplementation &&
mSecondaryState == eXBL_None);
NS_ASSERTION(mBinding, "Must have binding here");
mSecondaryState = eXBL_InProperty;
ConstructProperty(aAtts);
}
else if (aTagName == nsXBLAtoms::getter) {
else if (aTagName == nsGkAtoms::getter) {
ENSURE_XBL_STATE(mSecondaryState == eXBL_InProperty && mProperty);
NS_ASSERTION(mState == eXBL_InImplementation, "Unexpected state");
mProperty->SetGetterLineNumber(aLineNumber);
mSecondaryState = eXBL_InGetter;
}
else if (aTagName == nsXBLAtoms::setter) {
else if (aTagName == nsGkAtoms::setter) {
ENSURE_XBL_STATE(mSecondaryState == eXBL_InProperty && mProperty);
NS_ASSERTION(mState == eXBL_InImplementation, "Unexpected state");
mProperty->SetSetterLineNumber(aLineNumber);
mSecondaryState = eXBL_InSetter;
}
else if (aTagName == nsXBLAtoms::method) {
else if (aTagName == nsGkAtoms::method) {
ENSURE_XBL_STATE(mState == eXBL_InImplementation &&
mSecondaryState == eXBL_None);
NS_ASSERTION(mBinding, "Must have binding here");
mSecondaryState = eXBL_InMethod;
ConstructMethod(aAtts);
}
else if (aTagName == nsXBLAtoms::parameter) {
else if (aTagName == nsGkAtoms::parameter) {
ENSURE_XBL_STATE(mSecondaryState == eXBL_InMethod && mMethod);
NS_ASSERTION(mState == eXBL_InImplementation, "Unexpected state");
ConstructParameter(aAtts);
}
else if (aTagName == nsXBLAtoms::body) {
else if (aTagName == nsGkAtoms::body) {
ENSURE_XBL_STATE(mSecondaryState == eXBL_InMethod && mMethod);
NS_ASSERTION(mState == eXBL_InImplementation, "Unexpected state");
// stash away the line number
@ -548,7 +545,7 @@ nsXBLContentSink::ConstructBinding()
{
nsCOMPtr<nsIContent> binding = GetCurrentContent();
nsAutoString id;
binding->GetAttr(kNameSpaceID_None, nsHTMLAtoms::id, id);
binding->GetAttr(kNameSpaceID_None, nsGkAtoms::id, id);
NS_ConvertUTF16toUTF8 cid(id);
nsresult rv = NS_OK;
@ -561,7 +558,7 @@ nsXBLContentSink::ConstructBinding()
rv = mBinding->Init(cid, mDocInfo, binding);
if (NS_SUCCEEDED(rv)) {
mDocInfo->SetPrototypeBinding(cid, mBinding);
binding->UnsetAttr(kNameSpaceID_None, nsHTMLAtoms::id, PR_FALSE);
binding->UnsetAttr(kNameSpaceID_None, nsGkAtoms::id, PR_FALSE);
} else {
delete mBinding;
mBinding = nsnull;
@ -618,29 +615,29 @@ nsXBLContentSink::ConstructHandler(const PRUnichar **aAtts, PRUint32 aLineNumber
}
// Is this attribute one of the ones we care about?
if (localName == nsXBLAtoms::event)
if (localName == nsGkAtoms::event)
event = aAtts[1];
else if (localName == nsXBLAtoms::modifiers)
else if (localName == nsGkAtoms::modifiers)
modifiers = aAtts[1];
else if (localName == nsXBLAtoms::button)
else if (localName == nsGkAtoms::button)
button = aAtts[1];
else if (localName == nsXBLAtoms::clickcount)
else if (localName == nsGkAtoms::clickcount)
clickcount = aAtts[1];
else if (localName == nsXBLAtoms::keycode)
else if (localName == nsGkAtoms::keycode)
keycode = aAtts[1];
else if (localName == nsXBLAtoms::key || localName == nsXBLAtoms::charcode)
else if (localName == nsGkAtoms::key || localName == nsGkAtoms::charcode)
charcode = aAtts[1];
else if (localName == nsXBLAtoms::phase)
else if (localName == nsGkAtoms::phase)
phase = aAtts[1];
else if (localName == nsXBLAtoms::command)
else if (localName == nsGkAtoms::command)
command = aAtts[1];
else if (localName == nsXBLAtoms::action)
else if (localName == nsGkAtoms::action)
action = aAtts[1];
else if (localName == nsXBLAtoms::group)
else if (localName == nsGkAtoms::group)
group = aAtts[1];
else if (localName == nsXBLAtoms::preventdefault)
else if (localName == nsGkAtoms::preventdefault)
preventdefault = aAtts[1];
else if (localName == nsXBLAtoms::allowuntrusted)
else if (localName == nsGkAtoms::allowuntrusted)
allowuntrusted = aAtts[1];
}
@ -694,7 +691,7 @@ nsXBLContentSink::ConstructResource(const PRUnichar **aAtts,
return;
const PRUnichar* src = nsnull;
if (FindValue(aAtts, nsHTMLAtoms::src, &src)) {
if (FindValue(aAtts, nsGkAtoms::src, &src)) {
mBinding->AddResource(aResourceType, nsDependentString(src));
}
}
@ -721,10 +718,10 @@ nsXBLContentSink::ConstructImplementation(const PRUnichar **aAtts)
}
// Is this attribute one of the ones we care about?
if (localName == nsXBLAtoms::name) {
if (localName == nsGkAtoms::name) {
name = aAtts[1];
}
else if (localName == nsXBLAtoms::implements) {
else if (localName == nsGkAtoms::implements) {
// Only allow implementation of interfaces via XBL if the principal of
// our XBL document has UniversalXPConnect privileges. No principal
// means no privs!
@ -764,10 +761,10 @@ nsXBLContentSink::ConstructField(const PRUnichar **aAtts, PRUint32 aLineNumber)
}
// Is this attribute one of the ones we care about?
if (localName == nsXBLAtoms::name) {
if (localName == nsGkAtoms::name) {
name = aAtts[1];
}
else if (localName == nsXBLAtoms::readonly) {
else if (localName == nsGkAtoms::readonly) {
readonly = aAtts[1];
}
}
@ -802,16 +799,16 @@ nsXBLContentSink::ConstructProperty(const PRUnichar **aAtts)
}
// Is this attribute one of the ones we care about?
if (localName == nsXBLAtoms::name) {
if (localName == nsGkAtoms::name) {
name = aAtts[1];
}
else if (localName == nsXBLAtoms::readonly) {
else if (localName == nsGkAtoms::readonly) {
readonly = aAtts[1];
}
else if (localName == nsXBLAtoms::onget) {
else if (localName == nsGkAtoms::onget) {
onget = aAtts[1];
}
else if (localName == nsXBLAtoms::onset) {
else if (localName == nsGkAtoms::onset) {
onset = aAtts[1];
}
}
@ -832,7 +829,7 @@ nsXBLContentSink::ConstructMethod(const PRUnichar **aAtts)
mMethod = nsnull;
const PRUnichar* name = nsnull;
if (FindValue(aAtts, nsXBLAtoms::name, &name)) {
if (FindValue(aAtts, nsGkAtoms::name, &name)) {
mMethod = new nsXBLProtoImplMethod(name);
}
@ -848,7 +845,7 @@ nsXBLContentSink::ConstructParameter(const PRUnichar **aAtts)
return;
const PRUnichar* name = nsnull;
if (FindValue(aAtts, nsXBLAtoms::name, &name)) {
if (FindValue(aAtts, nsGkAtoms::name, &name)) {
mMethod->AddParameter(nsDependentString(name));
}
}

62
content/xbl/src/nsXBLPrototypeBinding.cpp
Просмотреть файл

@ -67,9 +67,7 @@
#include "nsIInterfaceInfoManager.h"
#include "nsIPresShell.h"
#include "nsIDocumentObserver.h"
#include "nsHTMLAtoms.h"
#include "nsXULAtoms.h"
#include "nsXBLAtoms.h"
#include "nsGkAtoms.h"
#include "nsXBLProtoImpl.h"
#include "nsCRT.h"
#include "nsContentUtils.h"
@ -284,7 +282,7 @@ nsXBLPrototypeBinding::Init(const nsACString& aID,
void
nsXBLPrototypeBinding::Initialize()
{
nsIContent* content = GetImmediateChild(nsXBLAtoms::content);
nsIContent* content = GetImmediateChild(nsGkAtoms::content);
if (content) {
// Make sure to construct the attribute table first, since constructing the
// insertion point table removes some of the subtrees, which makes them
@ -335,8 +333,8 @@ void
nsXBLPrototypeBinding::SetBindingElement(nsIContent* aElement)
{
mBinding = aElement;
if (mBinding->AttrValueIs(kNameSpaceID_None, nsXBLAtoms::inheritstyle,
nsXBLAtoms::_false, eCaseMatters))
if (mBinding->AttrValueIs(kNameSpaceID_None, nsGkAtoms::inheritstyle,
nsGkAtoms::_false, eCaseMatters))
mInheritStyle = PR_FALSE;
}
@ -463,7 +461,7 @@ nsXBLPrototypeBinding::AttributeChanged(nsIAtom* aAttribute,
return;
// Iterate over the elements in the array.
nsIContent* content = GetImmediateChild(nsXBLAtoms::content);
nsIContent* content = GetImmediateChild(nsGkAtoms::content);
while (xblAttr) {
nsIContent* element = xblAttr->GetElement();
@ -481,7 +479,7 @@ nsXBLPrototypeBinding::AttributeChanged(nsIAtom* aAttribute,
nsAutoString value;
// Check to see if the src attribute is xbl:text. If so, then we need to obtain the
// children of the real element and get the text nodes' values.
if (aAttribute == nsHTMLAtoms::text && aNameSpaceID == kNameSpaceID_XBL) {
if (aAttribute == nsGkAtoms::text && aNameSpaceID == kNameSpaceID_XBL) {
nsContentUtils::GetNodeTextContent(aChangedElement, PR_FALSE, value);
value.StripChar(PRUnichar('\n'));
value.StripChar(PRUnichar('\r'));
@ -502,10 +500,10 @@ nsXBLPrototypeBinding::AttributeChanged(nsIAtom* aAttribute,
// set or unset on us. We may also be a tag that is having
// xbl:text set on us.
if ((dstAttr == nsHTMLAtoms::text && dstNs == kNameSpaceID_XBL) ||
realElement->NodeInfo()->Equals(nsHTMLAtoms::html,
if ((dstAttr == nsGkAtoms::text && dstNs == kNameSpaceID_XBL) ||
realElement->NodeInfo()->Equals(nsGkAtoms::html,
kNameSpaceID_XUL) &&
dstAttr == nsHTMLAtoms::value) {
dstAttr == nsGkAtoms::value) {
// Flush out all our kids.
PRUint32 childCount = realElement->GetChildCount();
for (PRUint32 i = 0; i < childCount; i++)
@ -557,7 +555,7 @@ PRBool PR_CALLBACK InstantiateInsertionPoint(nsHashKey* aKey, void* aData, void*
// Locate the real content.
nsIContent *instanceRoot = binding->GetAnonymousContent();
nsIContent *templRoot = proto->GetImmediateChild(nsXBLAtoms::content);
nsIContent *templRoot = proto->GetImmediateChild(nsGkAtoms::content);
nsIContent *realContent = proto->LocateInstance(nsnull, templRoot,
instanceRoot, content);
if (!realContent)
@ -616,7 +614,7 @@ nsXBLPrototypeBinding::GetInsertionPoint(nsIContent* aBoundElement,
nsISupportsKey key(aChild->Tag());
nsXBLInsertionPointEntry* entry = NS_STATIC_CAST(nsXBLInsertionPointEntry*, mInsertionPointTable->Get(&key));
if (!entry) {
nsISupportsKey key2(nsXBLAtoms::children);
nsISupportsKey key2(nsGkAtoms::children);
entry = NS_STATIC_CAST(nsXBLInsertionPointEntry*, mInsertionPointTable->Get(&key2));
}
@ -624,7 +622,7 @@ nsXBLPrototypeBinding::GetInsertionPoint(nsIContent* aBoundElement,
if (entry) {
nsIContent* content = entry->GetInsertionParent();
*aIndex = entry->GetInsertionIndex();
nsIContent* templContent = GetImmediateChild(nsXBLAtoms::content);
nsIContent* templContent = GetImmediateChild(nsGkAtoms::content);
realContent = LocateInstance(nsnull, templContent, aCopyRoot, content);
}
else {
@ -652,7 +650,7 @@ nsXBLPrototypeBinding::GetSingleInsertionPoint(nsIContent* aBoundElement,
return nsnull;
}
nsISupportsKey key(nsXBLAtoms::children);
nsISupportsKey key(nsGkAtoms::children);
nsXBLInsertionPointEntry* entry =
NS_STATIC_CAST(nsXBLInsertionPointEntry*, mInsertionPointTable->Get(&key));
@ -671,7 +669,7 @@ nsXBLPrototypeBinding::GetSingleInsertionPoint(nsIContent* aBoundElement,
*aMultipleInsertionPoints = PR_FALSE;
*aIndex = entry->GetInsertionIndex();
nsIContent* templContent = GetImmediateChild(nsXBLAtoms::content);
nsIContent* templContent = GetImmediateChild(nsGkAtoms::content);
nsIContent* content = entry->GetInsertionParent();
nsIContent *realContent = LocateInstance(nsnull, templContent, aCopyRoot,
content);
@ -757,7 +755,7 @@ nsXBLPrototypeBinding::LocateInstance(nsIContent* aBoundElement,
nsCOMPtr<nsIContent> childPoint;
if (aBoundElement) {
if (templParent->NodeInfo()->Equals(nsXBLAtoms::children,
if (templParent->NodeInfo()->Equals(nsGkAtoms::children,
kNameSpaceID_XBL)) {
childPoint = templParent;
templParent = childPoint->GetParent();
@ -850,7 +848,7 @@ PRBool PR_CALLBACK SetAttrs(nsHashKey* aKey, void* aData, void* aClosure)
nsAutoString value;
PRBool attrPresent = PR_TRUE;
if (src == nsHTMLAtoms::text && srcNs == kNameSpaceID_XBL) {
if (src == nsGkAtoms::text && srcNs == kNameSpaceID_XBL) {
nsContentUtils::GetNodeTextContent(changeData->mBoundElement, PR_FALSE,
value);
value.StripChar(PRUnichar('\n'));
@ -867,7 +865,7 @@ PRBool PR_CALLBACK SetAttrs(nsHashKey* aKey, void* aData, void* aClosure)
if (attrPresent) {
nsIContent* content =
changeData->mProto->GetImmediateChild(nsXBLAtoms::content);
changeData->mProto->GetImmediateChild(nsGkAtoms::content);
nsXBLAttributeEntry* curr = entry;
while (curr) {
@ -882,10 +880,10 @@ PRBool PR_CALLBACK SetAttrs(nsHashKey* aKey, void* aData, void* aClosure)
if (realElement) {
realElement->SetAttr(dstNs, dst, value, PR_FALSE);
if ((dst == nsHTMLAtoms::text && dstNs == kNameSpaceID_XBL) ||
(realElement->NodeInfo()->Equals(nsHTMLAtoms::html,
if ((dst == nsGkAtoms::text && dstNs == kNameSpaceID_XBL) ||
(realElement->NodeInfo()->Equals(nsGkAtoms::html,
kNameSpaceID_XUL) &&
dst == nsHTMLAtoms::value && !value.IsEmpty())) {
dst == nsGkAtoms::value && !value.IsEmpty())) {
nsCOMPtr<nsIContent> textContent;
NS_NewTextNode(getter_AddRefs(textContent),
@ -958,7 +956,7 @@ nsXBLPrototypeBinding::ShouldBuildChildFrames() const
nsObjectHashtable* xblAttributes =
NS_STATIC_CAST(nsObjectHashtable*, mAttributeTable->Get(&nskey));
if (xblAttributes) {
nsISupportsKey key(nsHTMLAtoms::text);
nsISupportsKey key(nsGkAtoms::text);
void* entry = xblAttributes->Get(&key);
return !entry;
}
@ -985,9 +983,9 @@ nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent* aElement)
{
// Don't add entries for <children> elements, since those will get
// removed from the DOM when we construct the insertion point table.
if (!aElement->NodeInfo()->Equals(nsXBLAtoms::children, kNameSpaceID_XBL)) {
if (!aElement->NodeInfo()->Equals(nsGkAtoms::children, kNameSpaceID_XBL)) {
nsAutoString inherits;
aElement->GetAttr(kNameSpaceID_XBL, nsXBLAtoms::inherits, inherits);
aElement->GetAttr(kNameSpaceID_XBL, nsGkAtoms::inherits, inherits);
if (!inherits.IsEmpty()) {
if (!mAttributeTable) {
@ -1081,7 +1079,7 @@ nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent* aElement)
// by the template only, and we don't need it anymore.
// XXXdwh Don't do this for XUL elements, since it faults them into heavyweight
// elements. Should nuke from the prototype instead.
// aElement->UnsetAttr(kNameSpaceID_XBL, nsXBLAtoms::inherits, PR_FALSE);
// aElement->UnsetAttr(kNameSpaceID_XBL, nsGkAtoms::inherits, PR_FALSE);
token = nsCRT::strtok( newStr, ", ", &newStr );
}
@ -1108,7 +1106,7 @@ void
nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent* aContent)
{
nsCOMArray<nsIContent> childrenElements;
GetNestedChildren(nsXBLAtoms::children, kNameSpaceID_XBL, aContent,
GetNestedChildren(nsGkAtoms::children, kNameSpaceID_XBL, aContent,
childrenElements);
PRInt32 count = childrenElements.Count();
@ -1130,9 +1128,9 @@ nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent* aContent)
nsXBLInsertionPointEntry* xblIns = nsXBLInsertionPointEntry::Create(parent);
nsAutoString includes;
child->GetAttr(kNameSpaceID_None, nsXBLAtoms::includes, includes);
child->GetAttr(kNameSpaceID_None, nsGkAtoms::includes, includes);
if (includes.IsEmpty()) {
nsISupportsKey key(nsXBLAtoms::children);
nsISupportsKey key(nsGkAtoms::children);
xblIns->AddRef();
mInsertionPointTable->Put(&key, xblIns);
}
@ -1309,9 +1307,9 @@ nsXBLPrototypeBinding::CreateKeyHandlers()
nsXBLPrototypeHandler* curr = mPrototypeHandler;
while (curr) {
nsCOMPtr<nsIAtom> eventAtom = curr->GetEventName();
if (eventAtom == nsXBLAtoms::keyup ||
eventAtom == nsXBLAtoms::keydown ||
eventAtom == nsXBLAtoms::keypress) {
if (eventAtom == nsGkAtoms::keyup ||
eventAtom == nsGkAtoms::keydown ||
eventAtom == nsGkAtoms::keypress) {
PRUint8 phase = curr->GetPhase();
PRUint8 type = curr->GetType();

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше