nsresult
nsHTMLSharedObjectElement::DoneAddingChildren(PRBool aHaveNotified)
{
if (!mIsDoneAddingChildren) {
mIsDoneAddingChildren = PR_TRUE;
// If we're already in a document, we need to trigger the load
// Otherwise, BindToTree takes care of that.
if (IsInDoc()) {
StartObjectLoad(aHaveNotified);
}
}
return NS_OK;
}
NS_IMETHODIMP
HTMLBodyElement::WalkContentStyleRules(nsRuleWalker* aRuleWalker)
{
nsGenericHTMLElement::WalkContentStyleRules(aRuleWalker);
if (!mContentStyleRule && IsInDoc()) {
// XXXbz should this use OwnerDoc() or GetComposedDoc()?
// sXBL/XBL2 issue!
mContentStyleRule = new BodyRule(this);
}
if (aRuleWalker && mContentStyleRule) {
aRuleWalker->Forward(mContentStyleRule);
}
return NS_OK;
}
NS_IMETHODIMP
nsSVGElement::DidModifySVGObservable(nsISVGValue* aObservable,
nsISVGValue::modificationType aModType)
{
// Return without setting DOM attributes as markup attributes if the
// attribute's element is being inserted into an SVG document fragment,
// which provides a context which percentage lengths are relative to.
// Bug 274886
if (aModType == nsISVGValue::mod_context)
return NS_OK;
// Return without setting DOM attribute
if (mSuppressNotification)
return NS_OK;
PRUint32 i, count = mMappedAttributes.AttrCount();
const nsAttrValue* attrValue = nsnull;
for (i = 0; i < count; ++i) {
attrValue = mMappedAttributes.AttrAt(i);
if (attrValue->GetSVGValue() == aObservable) {
break;
}
}
if (i == count) {
NS_NOTREACHED("unknown nsISVGValue");
return NS_ERROR_UNEXPECTED;
}
const nsAttrName* attrName = mMappedAttributes.AttrNameAt(i);
PRBool modification = PR_FALSE;
PRBool hasListeners =
nsContentUtils::HasMutationListeners(this,
NS_EVENT_BITS_MUTATION_ATTRMODIFIED,
this);
if (hasListeners || IsInDoc()) {
modification = !!mAttrsAndChildren.GetAttr(attrName->LocalName(),
attrName->NamespaceID());
}
nsAttrValue newValue(aObservable);
return SetAttrAndNotify(attrName->NamespaceID(), attrName->LocalName(),
attrName->GetPrefix(), EmptyString(), newValue,
modification, hasListeners, PR_TRUE, nsnull);
}
nsresult
HTMLObjectElement::UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
bool aNotify)
{
nsresult rv = nsGenericHTMLFormElement::UnsetAttr(aNameSpaceID,
aAttribute, aNotify);
NS_ENSURE_SUCCESS(rv, rv);
// See comment in SetAttr
if (aNotify && IsInDoc() && mIsDoneAddingChildren &&
aNameSpaceID == kNameSpaceID_None && aAttribute == nsGkAtoms::data) {
return LoadObject(aNotify, true);
}
return NS_OK;
}
void
nsXMLCDATASection::List(FILE* out, PRInt32 aIndent) const
{
NS_PRECONDITION(IsInDoc(), "bad content");
PRInt32 index;
for (index = aIndent; --index >= 0; ) fputs(" ", out);
fprintf(out, "CDATASection refcount=%d<", mRefCnt.get());
nsAutoString tmp;
ToCString(tmp, 0, mText.GetLength());
fputs(NS_LossyConvertUCS2toASCII(tmp).get(), out);
fputs(">\n", out);
}
void
nsCommentNode::List(FILE* out, PRInt32 aIndent) const
{
NS_PRECONDITION(IsInDoc(), "bad content");
PRInt32 indx;
for (indx = aIndent; --indx >= 0; ) fputs(" ", out);
fprintf(out, "Comment@%p refcount=%d<!--", this, mRefCnt.get());
nsAutoString tmp;
ToCString(tmp, 0, mText.GetLength());
fputs(NS_LossyConvertUCS2toASCII(tmp).get(), out);
fputs("-->\n", out);
}
bool
SVGMPathElement::ParseAttribute(int32_t aNamespaceID,
nsIAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult)
{
bool returnVal =
SVGMPathElementBase::ParseAttribute(aNamespaceID, aAttribute,
aValue, aResult);
if (aNamespaceID == kNameSpaceID_XLink &&
aAttribute == nsGkAtoms::href &&
IsInDoc()) {
// NOTE: If we fail the IsInDoc call, it's ok -- we'll update the target
// on next BindToTree call.
UpdateHrefTarget(GetParent(), aValue);
}
return returnVal;
}
NS_IMETHODIMP
nsStyledElementNotElementCSSInlineStyle::SetInlineStyleRule(css::StyleRule* aStyleRule,
const nsAString* aSerialized,
bool aNotify)
{
SetMayHaveStyle();
bool modification = false;
nsAttrValue oldValue;
bool hasListeners = aNotify &&
nsContentUtils::HasMutationListeners(this,
NS_EVENT_BITS_MUTATION_ATTRMODIFIED,
this);
// There's no point in comparing the stylerule pointers since we're always
// getting a new stylerule here. And we can't compare the stringvalues of
// the old and the new rules since both will point to the same declaration
// and thus will be the same.
if (hasListeners) {
// 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....
nsAutoString oldValueStr;
modification = GetAttr(kNameSpaceID_None, nsGkAtoms::style,
oldValueStr);
if (modification) {
oldValue.SetTo(oldValueStr);
}
}
else if (aNotify && IsInDoc()) {
modification = !!mAttrsAndChildren.GetAttr(nsGkAtoms::style);
}
nsAttrValue attrValue(aStyleRule, aSerialized);
// XXXbz do we ever end up with ADDITION here? I doubt it.
PRUint8 modType = modification ?
static_cast<PRUint8>(nsIDOMMutationEvent::MODIFICATION) :
static_cast<PRUint8>(nsIDOMMutationEvent::ADDITION);
return SetAttrAndNotify(kNameSpaceID_None, nsGkAtoms::style, nsnull,
oldValue, attrValue, modType, hasListeners,
aNotify, kDontCallAfterSetAttr);
}
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);
}
NS_IMETHODIMP
HTMLSharedObjectElement::GetSVGDocument(nsIDOMDocument **aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
*aResult = nullptr;
if (!IsInDoc()) {
return NS_OK;
}
// XXXbz should this use GetCurrentDoc()? sXBL/XBL2 issue!
nsIDocument *sub_doc = OwnerDoc()->GetSubDocumentFor(this);
if (!sub_doc) {
return NS_OK;
}
return CallQueryInterface(sub_doc, aResult);
}
nsresult
HTMLSharedElement::UnsetAttr(int32_t aNameSpaceID, nsIAtom* aName,
bool aNotify)
{
nsresult rv = nsGenericHTMLElement::UnsetAttr(aNameSpaceID, aName, aNotify);
NS_ENSURE_SUCCESS(rv, rv);
// If we're the first <base> with an href and our href attribute is being
// unset, then we're no longer the first <base> with an href, and we need to
// find the new one. Similar for target.
if (mNodeInfo->Equals(nsGkAtoms::base) &&
aNameSpaceID == kNameSpaceID_None &&
IsInDoc()) {
if (aName == nsGkAtoms::href) {
SetBaseURIUsingFirstBaseWithHref(GetUncomposedDoc(), nullptr);
} else if (aName == nsGkAtoms::target) {
SetBaseTargetUsingFirstBaseWithTarget(GetUncomposedDoc(), nullptr);
}
}
return NS_OK;
}
bool
HTMLImageElement::IsHTMLFocusable(bool aWithMouse,
bool *aIsFocusable, int32_t *aTabIndex)
{
int32_t tabIndex = TabIndex();
if (IsInDoc()) {
nsAutoString usemap;
GetUseMap(usemap);
// XXXbz which document should this be using? sXBL/XBL2 issue! I
// think that OwnerDoc() is right, since we don't want to
// assume stuff about the document we're bound to.
if (OwnerDoc()->FindImageMap(usemap)) {
if (aTabIndex) {
// Use tab index on individual map areas
*aTabIndex = (sTabFocusModel & eTabFocus_linksMask)? 0 : -1;
}
// Image map is not focusable itself, but flag as tabbable
// so that image map areas get walked into.
*aIsFocusable = false;
return false;
}
}
if (aTabIndex) {
// Can be in tab order if tabindex >=0 and form controls are tabbable.
*aTabIndex = (sTabFocusModel & eTabFocus_formElementsMask)? tabIndex : -1;
}
*aIsFocusable =
#ifdef XP_MACOSX
(!aWithMouse || nsFocusManager::sMouseFocusesFormControl) &&
#endif
(tabIndex >= 0 || HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex));
return false;
}
nsresult
SVGAnimationElement::AfterSetAttr(int32_t aNamespaceID, nsIAtom* aName,
const nsAttrValue* aValue, bool aNotify)
{
nsresult rv =
SVGAnimationElementBase::AfterSetAttr(aNamespaceID, aName, aValue,
aNotify);
if (aNamespaceID != kNameSpaceID_XLink || aName != nsGkAtoms::href)
return rv;
if (!aValue) {
mHrefTarget.Unlink();
AnimationTargetChanged();
} else if (IsInDoc()) {
NS_ABORT_IF_FALSE(aValue->Type() == nsAttrValue::eString,
"Expected href attribute to be string type");
UpdateHrefTarget(this, aValue->GetStringValue());
} // else: we're not yet in a document -- we'll update the target on
// next BindToTree call.
return rv;
}
nsresult
HTMLObjectElement::SetAttr(int32_t aNameSpaceID, nsIAtom *aName,
nsIAtom *aPrefix, const nsAString &aValue,
bool aNotify)
{
nsresult rv = nsGenericHTMLFormElement::SetAttr(aNameSpaceID, aName, aPrefix,
aValue, aNotify);
NS_ENSURE_SUCCESS(rv, rv);
// if aNotify is false, we are coming from the parser or some such place;
// we'll get bound after all the attributes have been set, so we'll do the
// object load from BindToTree/DoneAddingChildren.
// Skip the LoadObject call in that case.
// We also don't want to start loading the object when we're not yet in
// a document, just in case that the caller wants to set additional
// attributes before inserting the node into the document.
if (aNotify && IsInDoc() && mIsDoneAddingChildren &&
aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::data) {
return LoadObject(aNotify, true);
}
return NS_OK;
}
nsresult
nsHTMLObjectElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom *aName,
nsIAtom *aPrefix, const nsAString &aValue,
PRBool aNotify)
{
// If we plan to call LoadObject, we want to do it first so that the
// object load kicks off _before_ the reflow triggered by the SetAttr. But if
// aNotify is false, we are coming from the parser or some such place; we'll
// get bound after all the attributes have been set, so we'll do the
// object load from BindToTree/DoneAddingChildren.
// Skip the LoadObject call in that case.
// We also don't want to start loading the object when we're not yet in
// a document, just in case that the caller wants to set additional
// attributes before inserting the node into the document.
if (aNotify && IsInDoc() && mIsDoneAddingChildren &&
aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::data) {
nsAutoString type;
GetAttr(kNameSpaceID_None, nsGkAtoms::type, type);
LoadObject(aValue, aNotify, NS_ConvertUTF16toUTF8(type), PR_TRUE);
}
return nsGenericHTMLFormElement::SetAttr(aNameSpaceID, aName, aPrefix,
aValue, aNotify);
}
nsGenericDOMDataNode::~nsGenericDOMDataNode()
{
NS_PRECONDITION(!IsInDoc(),
"Please remove this from the document properly");
}
