PRBool
nsHTMLTableSectionElement::ParseAttribute(PRInt32 aNamespaceID,
nsIAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
/* ignore these attributes, stored simply as strings
ch
*/
if (aAttribute == nsGkAtoms::charoff) {
return aResult.ParseIntWithBounds(aValue, 0);
}
if (aAttribute == nsGkAtoms::height) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE);
}
if (aAttribute == nsGkAtoms::align) {
return ParseTableCellHAlignValue(aValue, aResult);
}
if (aAttribute == nsGkAtoms::bgcolor) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if (aAttribute == nsGkAtoms::valign) {
return ParseTableVAlignValue(aValue, aResult);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
aResult);
}
PRBool
nsHTMLDivElement::ParseAttribute(PRInt32 aNamespaceID,
nsIAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (mNodeInfo->Equals(nsGkAtoms::marquee)) {
if ((aAttribute == nsGkAtoms::width) ||
(aAttribute == nsGkAtoms::height)) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE);
}
if (aAttribute == nsGkAtoms::bgcolor) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
if ((aAttribute == nsGkAtoms::hspace) ||
(aAttribute == nsGkAtoms::vspace)) {
return aResult.ParseIntWithBounds(aValue, 0);
}
}
if (mNodeInfo->Equals(nsGkAtoms::div) &&
aAttribute == nsGkAtoms::align) {
return ParseDivAlignValue(aValue, aResult);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
aResult);
}
PRBool
nsHTMLFontElement::ParseAttribute(PRInt32 aNamespaceID,
nsIAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::size) {
nsAutoString tmp(aValue);
tmp.CompressWhitespace(PR_TRUE, PR_TRUE);
PRUnichar ch = tmp.IsEmpty() ? 0 : tmp.First();
if ((ch == '+' || ch == '-') &&
aResult.ParseEnumValue(aValue, kRelFontSizeTable)) {
return PR_TRUE;
}
return aResult.ParseIntValue(aValue);
}
if (aAttribute == nsGkAtoms::pointSize ||
aAttribute == nsGkAtoms::fontWeight) {
return aResult.ParseIntValue(aValue);
}
if (aAttribute == nsGkAtoms::color) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
aResult);
}
/*
* This is a utility function. It will only fail if it can't get a
* parser. This means it can return NS_OK without aURI or aCSSLoader
* being initialized.
*/
nsresult
nsDOMCSSAttributeDeclaration::GetCSSParsingEnvironment(nsIURI** aSheetURI,
nsIURI** aBaseURI,
nsIPrincipal** aSheetPrincipal,
mozilla::css::Loader** aCSSLoader)
{
NS_ASSERTION(mElement, "Something is severely broken -- there should be an Element here!");
// null out the out params since some of them may not get initialized below
*aSheetURI = nsnull;
*aBaseURI = nsnull;
*aSheetPrincipal = nsnull;
*aCSSLoader = nsnull;
nsIDocument* doc = mElement->GetOwnerDoc();
if (!doc) {
// document has been destroyed
return NS_ERROR_NOT_AVAILABLE;
}
nsCOMPtr<nsIURI> baseURI = mElement->GetBaseURI();
nsCOMPtr<nsIURI> sheetURI = doc->GetDocumentURI();
NS_ADDREF(*aCSSLoader = doc->CSSLoader());
baseURI.swap(*aBaseURI);
sheetURI.swap(*aSheetURI);
NS_ADDREF(*aSheetPrincipal = mElement->NodePrincipal());
return NS_OK;
}
nsresult
nsDOMDocumentType::BindToTree(nsIDocument *aDocument, nsIContent *aParent,
nsIContent *aBindingParent,
PRBool aCompileEventHandlers)
{
if (!HasSameOwnerDoc(NODE_FROM(aParent, aDocument))) {
NS_ASSERTION(!GetOwnerDoc(), "Need to adopt or import first!");
// DocumentType nodes are the only nodes that can have a null ownerDocument
// according to the DOM spec, so we need to give them a new nodeinfo in that
// case.
// XXX We may want to move this to nsDOMImplementation::CreateDocument if
// we want to rely on the nodeinfo and wrappers being right before
// getting into ReplaceOrInsertBefore or doInsertChildAt. That would
// break inserting DOMDocumentType nodes through other DOM methods
// though.
nsNodeInfoManager *nimgr = aParent ?
aParent->NodeInfo()->NodeInfoManager() :
aDocument->NodeInfoManager();
nsCOMPtr<nsINodeInfo> newNodeInfo;
newNodeInfo = nimgr->GetNodeInfo(mNodeInfo->NameAtom(),
mNodeInfo->GetPrefixAtom(),
mNodeInfo->NamespaceID());
NS_ENSURE_TRUE(newNodeInfo, NS_ERROR_OUT_OF_MEMORY);
mNodeInfo.swap(newNodeInfo);
JSObject *oldScope = GetWrapper();
if (oldScope) {
nsIXPConnect *xpc = nsContentUtils::XPConnect();
JSContext *cx = nsnull;
JSObject *newScope = nsnull;
nsresult rv = nsContentUtils::GetContextAndScope(nsnull,
nimgr->GetDocument(),
&cx, &newScope);
if (cx && xpc) {
nsISupports *node = NS_ISUPPORTS_CAST(nsIContent*, this);
nsCOMPtr<nsIXPConnectJSObjectHolder> oldWrapper;
rv = xpc->ReparentWrappedNativeIfFound(cx, oldScope, newScope, node,
getter_AddRefs(oldWrapper));
}
if (NS_FAILED(rv)) {
mNodeInfo.swap(newNodeInfo);
return rv;
}
}
bool
nsSVGAElement::IsLink(nsIURI** aURI) const
{
// To be a clickable XLink for styling and interaction purposes, we require:
//
// xlink:href - must be set
// xlink:type - must be unset or set to "" or set to "simple"
// xlink:show - must be unset or set to "", "new" or "replace"
// xlink:actuate - must be unset or set to "" or "onRequest"
//
// For any other values, we're either not a *clickable* XLink, or the end
// result is poorly specified. Either way, we return PR_FALSE.
static nsIContent::AttrValuesArray sTypeVals[] =
{ &nsGkAtoms::_empty, &nsGkAtoms::simple, nsnull };
static nsIContent::AttrValuesArray sShowVals[] =
{ &nsGkAtoms::_empty, &nsGkAtoms::_new, &nsGkAtoms::replace, nsnull };
static nsIContent::AttrValuesArray sActuateVals[] =
{ &nsGkAtoms::_empty, &nsGkAtoms::onRequest, nsnull };
// Optimization: check for href first for early return
const nsAttrValue* href = mAttrsAndChildren.GetAttr(nsGkAtoms::href,
kNameSpaceID_XLink);
if (href &&
FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::type,
sTypeVals, eCaseMatters) !=
nsIContent::ATTR_VALUE_NO_MATCH &&
FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::show,
sShowVals, eCaseMatters) !=
nsIContent::ATTR_VALUE_NO_MATCH &&
FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::actuate,
sActuateVals, eCaseMatters) !=
nsIContent::ATTR_VALUE_NO_MATCH) {
nsCOMPtr<nsIURI> baseURI = GetBaseURI();
// Get absolute URI
nsAutoString str;
mStringAttributes[HREF].GetAnimValue(str, this);
nsContentUtils::NewURIWithDocumentCharset(aURI, str,
GetOwnerDoc(), baseURI);
// must promise out param is non-null if we return true
return !!*aURI;
}
*aURI = nsnull;
return PR_FALSE;
}
/* nsIDOMSVGMatrix getScreenCTM (); */
NS_IMETHODIMP nsSVGGraphicElement::GetScreenCTM(nsIDOMSVGMatrix **_retval)
{
nsresult rv;
*_retval = nsnull;
nsIDocument* currentDoc = GetCurrentDoc();
if (currentDoc) {
// Flush all pending notifications so that our frames are uptodate
currentDoc->FlushPendingNotifications(Flush_Layout);
}
nsBindingManager *bindingManager = nsnull;
// XXXbz I _think_ this is right. We want to be using the binding manager
// that would have attached the binding that gives us our anonymous parent.
// That's the binding manager for the document we actually belong to, which
// is our owner doc.
nsIDocument* ownerDoc = GetOwnerDoc();
if (ownerDoc) {
bindingManager = ownerDoc->BindingManager();
}
nsIContent* parent = nsnull;
nsCOMPtr<nsIDOMSVGMatrix> parentScreenCTM;
if (bindingManager) {
// check for an anonymous parent first
parent = bindingManager->GetInsertionParent(this);
}
if (!parent) {
// if we didn't find an anonymous parent, use the explicit one
parent = GetParent();
}
nsCOMPtr<nsIDOMSVGLocatable> locatableElement = do_QueryInterface(parent);
if (!locatableElement) {
// we don't have an SVGLocatable parent so we aren't even rendered
NS_WARNING("SVGGraphicElement without an SVGLocatable parent");
return NS_ERROR_FAILURE;
}
// get our parent's "screen" CTM
rv = locatableElement->GetScreenCTM(getter_AddRefs(parentScreenCTM));
if (NS_FAILED(rv)) return rv;
return AppendLocalTransform(parentScreenCTM, _retval);
}
PRBool
nsXMLElement::IsLink(nsIURI** aURI) const
{
NS_PRECONDITION(aURI, "Must provide aURI out param");
// To be an XLink for styling and interaction purposes, we require:
//
// xlink:href - must be set
// xlink:type - must be set to "simple"
// xlink:_moz_target - must be set, OR
// xlink:show - must be unset or set to "", "new" or "replace"
// xlink:actuate - must be unset or set to "" or "onRequest"
//
// For any other values, we're either not a *clickable* XLink, or the end
// result is poorly specified. Either way, we return PR_FALSE.
static nsIContent::AttrValuesArray sShowVals[] =
{ &nsGkAtoms::_empty, &nsGkAtoms::_new, &nsGkAtoms::replace, nsnull };
static nsIContent::AttrValuesArray sActuateVals[] =
{ &nsGkAtoms::_empty, &nsGkAtoms::onRequest, nsnull };
// Optimization: check for href first for early return
const nsAttrValue* href = mAttrsAndChildren.GetAttr(nsGkAtoms::href,
kNameSpaceID_XLink);
if (href &&
AttrValueIs(kNameSpaceID_XLink, nsGkAtoms::type,
nsGkAtoms::simple, eCaseMatters) &&
(HasAttr(kNameSpaceID_XLink, nsGkAtoms::_moz_target) ||
FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::show,
sShowVals, eCaseMatters) !=
nsIContent::ATTR_VALUE_NO_MATCH) &&
FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::actuate,
sActuateVals, eCaseMatters) !=
nsIContent::ATTR_VALUE_NO_MATCH) {
// Get absolute URI
nsCOMPtr<nsIURI> baseURI = GetBaseURI();
nsContentUtils::NewURIWithDocumentCharset(aURI, href->GetStringValue(),
GetOwnerDoc(), baseURI);
return !!*aURI; // must promise out param is non-null if we return true
}
*aURI = nsnull;
return PR_FALSE;
}
PRBool
nsMathMLElement::ParseAttribute(PRInt32 aNamespaceID,
nsIAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::color ||
aAttribute == nsGkAtoms::mathcolor_ ||
aAttribute == nsGkAtoms::background ||
aAttribute == nsGkAtoms::mathbackground_) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
}
return nsMathMLElementBase::ParseAttribute(aNamespaceID, aAttribute,
aValue, aResult);
}
NS_IMETHODIMP
nsAccessNode::GetLanguage(nsAString& aLanguage)
{
aLanguage.Truncate();
if (IsDefunct())
return NS_ERROR_FAILURE;
nsCoreUtils::GetLanguageFor(mContent, nsnull, aLanguage);
if (aLanguage.IsEmpty()) { // Nothing found, so use document's language
nsIDocument *doc = mContent->GetOwnerDoc();
if (doc) {
doc->GetHeaderData(nsAccessibilityAtoms::headerContentLanguage, aLanguage);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsHTMLObjectElement::GetContentDocument(nsIDOMDocument **aContentDocument)
{
NS_ENSURE_ARG_POINTER(aContentDocument);
*aContentDocument = nsnull;
if (!IsInDoc()) {
return NS_OK;
}
// XXXbz should this use GetCurrentDoc()? sXBL/XBL2 issue!
nsIDocument *sub_doc = GetOwnerDoc()->GetSubDocumentFor(this);
if (!sub_doc) {
return NS_OK;
}
return CallQueryInterface(sub_doc, aContentDocument);
}
nsIDocument*
nsDOMCSSAttributeDeclaration::DocToUpdate()
{
// XXXbz this is a bit of a hack, especially doing it before the
// BeginUpdate(), but this is a good chokepoint where we know we
// plan to modify the CSSDeclaration, so need to notify
// AttributeWillChange if this is inline style.
#ifdef MOZ_SMIL
if (!mIsSMILOverride)
#endif
{
nsNodeUtils::AttributeWillChange(mElement, kNameSpaceID_None,
nsGkAtoms::style,
nsIDOMMutationEvent::MODIFICATION);
}
// We need GetOwnerDoc() rather than GetCurrentDoc() because it might
// be the BeginUpdate call that inserts mElement into the document.
return mElement->GetOwnerDoc();
}
void
nsSVGAElement::GetLinkTarget(nsAString& aTarget)
{
mStringAttributes[TARGET].GetAnimValue(aTarget, this);
if (aTarget.IsEmpty()) {
static nsIContent::AttrValuesArray sShowVals[] =
{ &nsGkAtoms::_new, &nsGkAtoms::replace, nsnull };
switch (FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::show,
sShowVals, eCaseMatters)) {
case 0:
aTarget.AssignLiteral("_blank");
return;
case 1:
return;
}
nsIDocument* ownerDoc = GetOwnerDoc();
if (ownerDoc) {
ownerDoc->GetBaseTarget(aTarget);
}
}
}
NS_IMETHODIMP
nsHTMLSharedElement::GetHref(nsAString& aValue)
{
nsAutoString href;
GetAttr(kNameSpaceID_None, nsGkAtoms::href, href);
nsCOMPtr<nsIURI> uri;
nsIDocument* doc = GetOwnerDoc();
if (doc) {
nsContentUtils::NewURIWithDocumentCharset(
getter_AddRefs(uri), href, doc, doc->GetDocumentURI());
}
if (!uri) {
aValue = href;
return NS_OK;
}
nsCAutoString spec;
uri->GetSpec(spec);
CopyUTF8toUTF16(spec, aValue);
return NS_OK;
}
PRBool
nsHTMLHRElement::ParseAttribute(PRInt32 aNamespaceID,
nsIAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::width) {
return aResult.ParseSpecialIntValue(aValue, PR_TRUE);
}
if (aAttribute == nsGkAtoms::size) {
return aResult.ParseIntWithBounds(aValue, 1, 1000);
}
if (aAttribute == nsGkAtoms::align) {
return aResult.ParseEnumValue(aValue, kAlignTable);
}
if (aAttribute == nsGkAtoms::color) {
return aResult.ParseColor(aValue, GetOwnerDoc());
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
aResult);
}
nsDocAccessible *
nsAccessNode::GetDocAccessible() const
{
return mContent ?
GetAccService()->GetDocAccessible(mContent->GetOwnerDoc()) : nsnull;
}
PRBool
nsSVGElement::ParseAttribute(PRInt32 aNamespaceID,
nsIAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult)
{
// Parse value
nsCOMPtr<nsISVGValue> svg_value;
const nsAttrValue* val = mAttrsAndChildren.GetAttr(aAttribute, aNamespaceID);
if (val) {
// Found the attr in the list.
if (val->Type() == nsAttrValue::eSVGValue) {
svg_value = val->GetSVGValue();
}
}
else {
// Could be a mapped attribute.
svg_value = GetMappedAttribute(aNamespaceID, aAttribute);
}
if (svg_value) {
// We want to prevent DidModifySVGObservable from running if we
// come in this route, otherwise AttributeChanged() gets called
// twice (once through DidMOdifySVGObservable, once through SetAttr).
mSuppressNotification = PR_TRUE;
if (NS_FAILED(svg_value->SetValueString(aValue))) {
// The value was rejected. This happens e.g. in a XUL template
// when trying to set a value like "?x" on a value object that
// expects a length.
// To accommodate this "erroneous" value, we'll insert a proxy
// object between ourselves and the actual value object:
ReportAttributeParseFailure(GetOwnerDoc(), aAttribute, aValue);
nsCOMPtr<nsISVGValue> proxy;
nsresult rv =
NS_CreateSVGStringProxyValue(svg_value, getter_AddRefs(proxy));
// Failure means we'll store this attr as a string, not an SVGValue, but
// that's the best we can do short of throwing outright.
NS_ENSURE_SUCCESS(rv, PR_FALSE);
svg_value->RemoveObserver(this);
ResetOldStyleBaseType(svg_value);
proxy->SetValueString(aValue);
proxy->AddObserver(this);
aResult.SetTo(proxy);
}
else {
aResult.SetTo(svg_value);
}
mSuppressNotification = PR_FALSE;
return PR_TRUE;
}
nsresult rv = NS_OK;
PRBool foundMatch = PR_FALSE;
if (aNamespaceID == kNameSpaceID_None) {
// Check for nsSVGLength2 attribute
LengthAttributesInfo lengthInfo = GetLengthInfo();
PRUint32 i;
for (i = 0; i < lengthInfo.mLengthCount; i++) {
if (aAttribute == *lengthInfo.mLengthInfo[i].mName) {
rv = lengthInfo.mLengths[i].SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
lengthInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
if (!foundMatch) {
// Check for nsSVGNumber2 attribute
NumberAttributesInfo numberInfo = GetNumberInfo();
for (i = 0; i < numberInfo.mNumberCount; i++) {
if (aAttribute == *numberInfo.mNumberInfo[i].mName) {
if (i + 1 < numberInfo.mNumberCount &&
aAttribute == *numberInfo.mNumberInfo[i + 1].mName) {
rv = ParseNumberOptionalNumber(aValue, i, i + 1);
if (NS_FAILED(rv)) {
numberInfo.Reset(i + 1);
}
} else {
rv = numberInfo.mNumbers[i].SetBaseValueString(aValue, this, PR_FALSE);
}
if (NS_FAILED(rv)) {
numberInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGInteger attribute
IntegerAttributesInfo integerInfo = GetIntegerInfo();
for (i = 0; i < integerInfo.mIntegerCount; i++) {
if (aAttribute == *integerInfo.mIntegerInfo[i].mName) {
if (i + 1 < integerInfo.mIntegerCount &&
aAttribute == *integerInfo.mIntegerInfo[i + 1].mName) {
rv = ParseIntegerOptionalInteger(aValue, i, i + 1);
if (NS_FAILED(rv)) {
integerInfo.Reset(i + 1);
}
} else {
rv = integerInfo.mIntegers[i].SetBaseValueString(aValue, this, PR_FALSE);
}
if (NS_FAILED(rv)) {
integerInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGAngle attribute
AngleAttributesInfo angleInfo = GetAngleInfo();
for (i = 0; i < angleInfo.mAngleCount; i++) {
if (aAttribute == *angleInfo.mAngleInfo[i].mName) {
rv = angleInfo.mAngles[i].SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
angleInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGBoolean attribute
BooleanAttributesInfo booleanInfo = GetBooleanInfo();
for (i = 0; i < booleanInfo.mBooleanCount; i++) {
if (aAttribute == *booleanInfo.mBooleanInfo[i].mName) {
rv = booleanInfo.mBooleans[i].SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
booleanInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGEnum attribute
EnumAttributesInfo enumInfo = GetEnumInfo();
for (i = 0; i < enumInfo.mEnumCount; i++) {
if (aAttribute == *enumInfo.mEnumInfo[i].mName) {
rv = enumInfo.mEnums[i].SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
enumInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGViewBox attribute
if (aAttribute == nsGkAtoms::viewBox) {
nsSVGViewBox* viewBox = GetViewBox();
if (viewBox) {
rv = viewBox->SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
viewBox->Init();
}
foundMatch = PR_TRUE;
}
// Check for nsSVGPreserveAspectRatio attribute
} else if (aAttribute == nsGkAtoms::preserveAspectRatio) {
nsSVGPreserveAspectRatio *preserveAspectRatio =
GetPreserveAspectRatio();
if (preserveAspectRatio) {
rv = preserveAspectRatio->SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
preserveAspectRatio->Init();
}
foundMatch = PR_TRUE;
}
}
}
}
if (!foundMatch) {
// Check for nsSVGString attribute
StringAttributesInfo stringInfo = GetStringInfo();
for (PRUint32 i = 0; i < stringInfo.mStringCount; i++) {
if (aNamespaceID == stringInfo.mStringInfo[i].mNamespaceID &&
aAttribute == *stringInfo.mStringInfo[i].mName) {
stringInfo.mStrings[i].SetBaseValue(aValue, this, PR_FALSE);
foundMatch = PR_TRUE;
break;
}
}
}
if (foundMatch) {
if (NS_FAILED(rv)) {
ReportAttributeParseFailure(GetOwnerDoc(), aAttribute, aValue);
return PR_FALSE;
}
aResult.SetTo(aValue);
return PR_TRUE;
}
return nsSVGElementBase::ParseAttribute(aNamespaceID, aAttribute, aValue,
aResult);
}
void
nsSVGElement::UpdateContentStyleRule()
{
NS_ASSERTION(!mContentStyleRule, "we already have a content style rule");
nsIDocument* doc = GetOwnerDoc();
if (!doc) {
NS_ERROR("SVG element without owner document");
return;
}
nsCOMPtr<nsIURI> baseURI = GetBaseURI();
nsIURI *docURI = doc->GetDocumentURI();
nsICSSLoader* cssLoader = doc->CSSLoader();
nsCSSDeclaration* declaration = nsnull;
nsCOMPtr<nsICSSParser> parser;
nsresult rv = NS_OK;
PRUint32 attrCount = mAttrsAndChildren.AttrCount();
for (PRUint32 i = 0; i < attrCount; ++i) {
const nsAttrName* attrName = mAttrsAndChildren.AttrNameAt(i);
if (!attrName->IsAtom() || !IsAttributeMapped(attrName->Atom()))
continue;
if (!declaration) {
// Create the nsCSSDeclaration.
declaration = new nsCSSDeclaration();
if (!declaration) {
NS_WARNING("Failed to allocate nsCSSDeclaration");
return;
}
if (!declaration->InitializeEmpty()) {
NS_WARNING("could not initialize nsCSSDeclaration");
declaration->RuleAbort(); // deletes declaration
return;
}
// Try to fetch the CSS Parser from the document.
rv = cssLoader->GetParserFor(nsnull, getter_AddRefs(parser));
if (NS_FAILED(rv)) {
NS_WARNING("failed to get a css parser");
declaration->RuleAbort(); // deletes declaration
return;
}
// SVG and CSS differ slightly in their interpretation of some of
// the attributes. SVG allows attributes of the form: font-size="5"
// (style="font-size: 5" if using a style attribute)
// where CSS requires units: font-size="5pt" (style="font-size: 5pt")
// Set a flag to pass information to the parser so that we can use
// the CSS parser to parse the font-size attribute. Note that this
// does *not* affect the use of CSS stylesheets, which will still
// require units.
parser->SetSVGMode(PR_TRUE);
}
nsAutoString name;
attrName->Atom()->ToString(name);
nsAutoString value;
mAttrsAndChildren.AttrAt(i)->ToString(value);
PRBool changed;
parser->ParseProperty(nsCSSProps::LookupProperty(name), value,
docURI, baseURI, NodePrincipal(),
declaration, &changed);
}
if (declaration) {
rv = NS_NewCSSStyleRule(getter_AddRefs(mContentStyleRule), nsnull, declaration);
if (NS_FAILED(rv)) {
NS_WARNING("could not create contentstylerule");
declaration->RuleAbort(); // deletes declaration
}
// Recycle the parser
parser->SetSVGMode(PR_FALSE);
cssLoader->RecycleParser(parser);
}
}
nsresult
nsXMLElement::MaybeTriggerAutoLink(nsIDocShell *aShell)
{
NS_ENSURE_ARG_POINTER(aShell);
// We require an xlink:href, xlink:type="simple" and xlink:actuate="onLoad"
// XXX: as of XLink 1.1, elements will be links even without xlink:type set
if (!HasAttr(kNameSpaceID_XLink, nsGkAtoms::href) ||
!AttrValueIs(kNameSpaceID_XLink, nsGkAtoms::type,
nsGkAtoms::simple, eCaseMatters) ||
!AttrValueIs(kNameSpaceID_XLink, nsGkAtoms::actuate,
nsGkAtoms::onLoad, eCaseMatters)) {
return NS_OK;
}
// Disable in Mail/News for now. We may want a pref to control
// this at some point.
nsCOMPtr<nsIDocShellTreeItem> docShellItem = do_QueryInterface(aShell);
if (docShellItem) {
nsCOMPtr<nsIDocShellTreeItem> rootItem;
docShellItem->GetRootTreeItem(getter_AddRefs(rootItem));
nsCOMPtr<nsIDocShell> docshell = do_QueryInterface(rootItem);
if (docshell) {
PRUint32 appType;
if (NS_SUCCEEDED(docshell->GetAppType(&appType)) &&
appType == nsIDocShell::APP_TYPE_MAIL) {
return NS_OK;
}
}
}
// Get absolute URI
nsCOMPtr<nsIURI> absURI;
nsAutoString href;
GetAttr(kNameSpaceID_XLink, nsGkAtoms::href, href);
nsCOMPtr<nsIURI> baseURI = GetBaseURI();
nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(absURI), href,
GetOwnerDoc(), baseURI);
if (!absURI) {
return NS_OK;
}
// Check that the link's URI isn't the same as its document's URI, or else
// we'll recursively load the document forever (possibly in new windows!)
PRBool isDocURI;
absURI->Equals(GetOwnerDoc()->GetDocumentURI(), &isDocURI);
if (isDocURI) {
return NS_OK;
}
// Get target
nsAutoString target;
nsresult special_rv = GetLinkTargetAndAutoType(target);
// Ignore this link if xlink:show has a value we don't implement
if (NS_FAILED(special_rv)) return NS_OK;
// Attempt to load the URI
nsCOMPtr<nsPresContext> pc;
nsresult rv = DocShellToPresContext(aShell, getter_AddRefs(pc));
NS_ENSURE_SUCCESS(rv, rv);
if (pc) {
nsContentUtils::TriggerLink(this, pc, absURI, target, PR_TRUE, PR_FALSE);
}
return special_rv; // return GetLinkTargetAndAutoType's special rv!
}
/**
* Translate a "rows" or "cols" spec into an array of nsFramesetSpecs
*/
nsresult
nsHTMLFrameSetElement::ParseRowCol(const nsAString & aValue,
PRInt32& aNumSpecs,
nsFramesetSpec** aSpecs)
{
if (aValue.IsEmpty()) {
aNumSpecs = 0;
*aSpecs = nsnull;
return NS_OK;
}
static const PRUnichar sAster('*');
static const PRUnichar sPercent('%');
static const PRUnichar sComma(',');
nsAutoString spec(aValue);
// remove whitespace (Bug 33699) and quotation marks (bug 224598)
// also remove leading/trailing commas (bug 31482)
spec.StripChars(" \n\r\t\"\'");
spec.Trim(",");
// Count the commas. Don't count more than X commas (bug 576447).
PR_STATIC_ASSERT(NS_MAX_FRAMESET_SPEC_COUNT * sizeof(nsFramesetSpec) < (1 << 30));
PRInt32 commaX = spec.FindChar(sComma);
PRInt32 count = 1;
while (commaX != kNotFound && count < NS_MAX_FRAMESET_SPEC_COUNT) {
count++;
commaX = spec.FindChar(sComma, commaX + 1);
}
nsFramesetSpec* specs = new nsFramesetSpec[count];
if (!specs) {
*aSpecs = nsnull;
aNumSpecs = 0;
return NS_ERROR_OUT_OF_MEMORY;
}
// Pre-grab the compat mode; we may need it later in the loop.
bool isInQuirks = InNavQuirksMode(GetOwnerDoc());
// Parse each comma separated token
PRInt32 start = 0;
PRInt32 specLen = spec.Length();
for (PRInt32 i = 0; i < count; i++) {
// Find our comma
commaX = spec.FindChar(sComma, start);
NS_ASSERTION(i == count - 1 || commaX != kNotFound,
"Failed to find comma, somehow");
PRInt32 end = (commaX == kNotFound) ? specLen : commaX;
// Note: If end == start then it means that the token has no
// data in it other than a terminating comma (or the end of the spec).
// So default to a fixed width of 0.
specs[i].mUnit = eFramesetUnit_Fixed;
specs[i].mValue = 0;
if (end > start) {
PRInt32 numberEnd = end;
PRUnichar ch = spec.CharAt(numberEnd - 1);
if (sAster == ch) {
specs[i].mUnit = eFramesetUnit_Relative;
numberEnd--;
} else if (sPercent == ch) {
specs[i].mUnit = eFramesetUnit_Percent;
numberEnd--;
// check for "*%"
if (numberEnd > start) {
ch = spec.CharAt(numberEnd - 1);
if (sAster == ch) {
specs[i].mUnit = eFramesetUnit_Relative;
numberEnd--;
}
}
}
// Translate value to an integer
nsAutoString token;
spec.Mid(token, start, numberEnd - start);
// Treat * as 1*
if ((eFramesetUnit_Relative == specs[i].mUnit) &&
(0 == token.Length())) {
specs[i].mValue = 1;
}
else {
// Otherwise just convert to integer.
PRInt32 err;
specs[i].mValue = token.ToInteger(&err);
if (err) {
specs[i].mValue = 0;
}
}
// Treat 0* as 1* in quirks mode (bug 40383)
if (isInQuirks) {
if ((eFramesetUnit_Relative == specs[i].mUnit) &&
(0 == specs[i].mValue)) {
specs[i].mValue = 1;
}
}
// Catch zero and negative frame sizes for Nav compatibility
// Nav resized absolute and relative frames to "1" and
// percent frames to an even percentage of the width
//
//if (isInQuirks && (specs[i].mValue <= 0)) {
// if (eFramesetUnit_Percent == specs[i].mUnit) {
// specs[i].mValue = 100 / count;
// } else {
// specs[i].mValue = 1;
// }
//} else {
// In standards mode, just set negative sizes to zero
if (specs[i].mValue < 0) {
specs[i].mValue = 0;
}
start = end + 1;
}
}
aNumSpecs = count;
// Transfer ownership to caller here
*aSpecs = specs;
return NS_OK;
}
