gecko-dev/dom/html/HTMLBodyElement.cpp

343 строки
12 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "HTMLBodyElement.h"
#include "mozilla/dom/BindContext.h"
#include "mozilla/dom/HTMLBodyElementBinding.h"
#include "mozilla/MappedDeclarations.h"
#include "mozilla/HTMLEditor.h"
#include "mozilla/TextEditor.h"
#include "nsAttrValueInlines.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "mozilla/dom/Document.h"
#include "DocumentInlines.h"
#include "nsDocShell.h"
#include "nsHTMLStyleSheet.h"
#include "nsMappedAttributes.h"
#include "nsIDocShell.h"
#include "nsGlobalWindow.h"
NS_IMPL_NS_NEW_HTML_ELEMENT(Body)
namespace mozilla::dom {
//----------------------------------------------------------------------
HTMLBodyElement::~HTMLBodyElement() = default;
JSObject* HTMLBodyElement::WrapNode(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) {
return HTMLBodyElement_Binding::Wrap(aCx, this, aGivenProto);
}
NS_IMPL_ELEMENT_CLONE(HTMLBodyElement)
bool HTMLBodyElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
const nsAString& aValue,
nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) {
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::bgcolor || aAttribute == nsGkAtoms::text ||
aAttribute == nsGkAtoms::link || aAttribute == nsGkAtoms::alink ||
aAttribute == nsGkAtoms::vlink) {
return aResult.ParseColor(aValue);
}
if (aAttribute == nsGkAtoms::marginwidth ||
aAttribute == nsGkAtoms::marginheight ||
aAttribute == nsGkAtoms::topmargin ||
aAttribute == nsGkAtoms::bottommargin ||
aAttribute == nsGkAtoms::leftmargin ||
aAttribute == nsGkAtoms::rightmargin) {
return aResult.ParseNonNegativeIntValue(aValue);
}
}
return nsGenericHTMLElement::ParseBackgroundAttribute(
aNamespaceID, aAttribute, aValue, aResult) ||
nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
aMaybeScriptedPrincipal, aResult);
}
void HTMLBodyElement::MapAttributesIntoRule(
const nsMappedAttributes* aAttributes, MappedDeclarations& aDecls) {
// This is the one place where we try to set the same property
// multiple times in presentation attributes. Servo does not support
// querying if a property is set (because that is O(n) behavior
// in ServoSpecifiedValues). Instead, we use the below values to keep
// track of whether we have already set a property, and if so, what value
// we set it to (which is used when handling margin
// attributes from the containing frame element)
int32_t bodyMarginWidth = -1;
int32_t bodyMarginHeight = -1;
int32_t bodyTopMargin = -1;
int32_t bodyBottomMargin = -1;
int32_t bodyLeftMargin = -1;
int32_t bodyRightMargin = -1;
const nsAttrValue* value;
// if marginwidth/marginheight are set, reflect them as 'margin'
value = aAttributes->GetAttr(nsGkAtoms::marginwidth);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyMarginWidth = value->GetIntegerValue();
if (bodyMarginWidth < 0) {
bodyMarginWidth = 0;
}
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_left,
(float)bodyMarginWidth);
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_right,
(float)bodyMarginWidth);
}
value = aAttributes->GetAttr(nsGkAtoms::marginheight);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyMarginHeight = value->GetIntegerValue();
if (bodyMarginHeight < 0) {
bodyMarginHeight = 0;
}
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_top,
(float)bodyMarginHeight);
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_bottom,
(float)bodyMarginHeight);
}
// topmargin (IE-attribute)
if (bodyMarginHeight == -1) {
value = aAttributes->GetAttr(nsGkAtoms::topmargin);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyTopMargin = value->GetIntegerValue();
if (bodyTopMargin < 0) {
bodyTopMargin = 0;
}
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_top,
(float)bodyTopMargin);
}
}
// bottommargin (IE-attribute)
if (bodyMarginHeight == -1) {
value = aAttributes->GetAttr(nsGkAtoms::bottommargin);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyBottomMargin = value->GetIntegerValue();
if (bodyBottomMargin < 0) {
bodyBottomMargin = 0;
}
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_bottom,
(float)bodyBottomMargin);
}
}
// leftmargin (IE-attribute)
if (bodyMarginWidth == -1) {
value = aAttributes->GetAttr(nsGkAtoms::leftmargin);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyLeftMargin = value->GetIntegerValue();
if (bodyLeftMargin < 0) {
bodyLeftMargin = 0;
}
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_left,
(float)bodyLeftMargin);
}
}
// rightmargin (IE-attribute)
if (bodyMarginWidth == -1) {
value = aAttributes->GetAttr(nsGkAtoms::rightmargin);
if (value && value->Type() == nsAttrValue::eInteger) {
bodyRightMargin = value->GetIntegerValue();
if (bodyRightMargin < 0) {
bodyRightMargin = 0;
}
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_right,
(float)bodyRightMargin);
}
}
// if marginwidth or marginheight is set in the <frame> and not set in the
// <body> reflect them as margin in the <body>
if (bodyMarginWidth == -1 || bodyMarginHeight == -1) {
if (nsDocShell* ds = nsDocShell::Cast(aDecls.Document()->GetDocShell())) {
CSSIntSize margins = ds->GetFrameMargins();
int32_t frameMarginWidth = margins.width;
int32_t frameMarginHeight = margins.height;
if (bodyMarginWidth == -1 && frameMarginWidth >= 0) {
if (bodyLeftMargin == -1) {
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_left,
(float)frameMarginWidth);
}
if (bodyRightMargin == -1) {
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_right,
(float)frameMarginWidth);
}
}
if (bodyMarginHeight == -1 && frameMarginHeight >= 0) {
if (bodyTopMargin == -1) {
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_top,
(float)frameMarginHeight);
}
if (bodyBottomMargin == -1) {
aDecls.SetPixelValueIfUnset(eCSSProperty_margin_bottom,
(float)frameMarginHeight);
}
}
}
}
// When display if first asked for, go ahead and get our colors set up.
if (nsHTMLStyleSheet* styleSheet =
aDecls.Document()->GetAttributeStyleSheet()) {
nscolor color;
value = aAttributes->GetAttr(nsGkAtoms::link);
if (value && value->GetColorValue(color)) {
styleSheet->SetLinkColor(color);
}
value = aAttributes->GetAttr(nsGkAtoms::alink);
if (value && value->GetColorValue(color)) {
styleSheet->SetActiveLinkColor(color);
}
value = aAttributes->GetAttr(nsGkAtoms::vlink);
if (value && value->GetColorValue(color)) {
styleSheet->SetVisitedLinkColor(color);
}
}
if (!aDecls.PropertyIsSet(eCSSProperty_color)) {
// color: color
nscolor color;
value = aAttributes->GetAttr(nsGkAtoms::text);
if (value && value->GetColorValue(color)) {
aDecls.SetColorValue(eCSSProperty_color, color);
}
}
nsGenericHTMLElement::MapBackgroundAttributesInto(aAttributes, aDecls);
nsGenericHTMLElement::MapCommonAttributesInto(aAttributes, aDecls);
}
nsMapRuleToAttributesFunc HTMLBodyElement::GetAttributeMappingFunction() const {
return &MapAttributesIntoRule;
}
NS_IMETHODIMP_(bool)
HTMLBodyElement::IsAttributeMapped(const nsAtom* aAttribute) const {
static const MappedAttributeEntry attributes[] = {
{nsGkAtoms::link},
{nsGkAtoms::vlink},
{nsGkAtoms::alink},
{nsGkAtoms::text},
{nsGkAtoms::marginwidth},
{nsGkAtoms::marginheight},
{nsGkAtoms::topmargin},
{nsGkAtoms::rightmargin},
{nsGkAtoms::bottommargin},
{nsGkAtoms::leftmargin},
{nullptr},
};
static const MappedAttributeEntry* const map[] = {
attributes,
sCommonAttributeMap,
sBackgroundAttributeMap,
};
return FindAttributeDependence(aAttribute, map);
}
already_AddRefed<TextEditor> HTMLBodyElement::GetAssociatedEditor() {
RefPtr<TextEditor> textEditor = GetTextEditorInternal();
if (textEditor) {
return textEditor.forget();
}
// Make sure this is the actual body of the document
if (this != OwnerDoc()->GetBodyElement()) {
return nullptr;
}
// For designmode, try to get document's editor
nsPresContext* presContext = GetPresContext(eForComposedDoc);
if (!presContext) {
return nullptr;
}
nsCOMPtr<nsIDocShell> docShell = presContext->GetDocShell();
if (!docShell) {
return nullptr;
}
RefPtr<HTMLEditor> htmlEditor = docShell->GetHTMLEditor();
return htmlEditor.forget();
}
bool HTMLBodyElement::IsEventAttributeNameInternal(nsAtom* aName) {
return nsContentUtils::IsEventAttributeName(
aName, EventNameType_HTML | EventNameType_HTMLBodyOrFramesetOnly);
}
nsresult HTMLBodyElement::BindToTree(BindContext& aContext, nsINode& aParent) {
nsresult rv = nsGenericHTMLElement::BindToTree(aContext, aParent);
NS_ENSURE_SUCCESS(rv, rv);
return mAttrs.ForceMapped(this, &aContext.OwnerDoc());
}
nsresult HTMLBodyElement::AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
const nsAttrValue* aValue,
const nsAttrValue* aOldValue,
nsIPrincipal* aSubjectPrincipal,
bool aNotify) {
nsresult rv = nsGenericHTMLElement::AfterSetAttr(
aNameSpaceID, aName, aValue, aOldValue, aSubjectPrincipal, aNotify);
NS_ENSURE_SUCCESS(rv, rv);
// if the last mapped attribute was removed, don't clear the
// nsMappedAttributes, our style can still depend on the containing frame
// element
if (!aValue && IsAttributeMapped(aName)) {
nsresult rv = mAttrs.ForceMapped(this, OwnerDoc());
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
#define EVENT(name_, id_, type_, \
struct_) /* nothing; handled by the superclass */
// nsGenericHTMLElement::GetOnError returns
// already_AddRefed<EventHandlerNonNull> while other getters return
// EventHandlerNonNull*, so allow passing in the type to use here.
#define WINDOW_EVENT_HELPER(name_, type_) \
type_* HTMLBodyElement::GetOn##name_() { \
if (nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow()) { \
nsGlobalWindowInner* globalWin = nsGlobalWindowInner::Cast(win); \
return globalWin->GetOn##name_(); \
} \
return nullptr; \
} \
void HTMLBodyElement::SetOn##name_(type_* handler) { \
nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow(); \
if (!win) { \
return; \
} \
\
nsGlobalWindowInner* globalWin = nsGlobalWindowInner::Cast(win); \
return globalWin->SetOn##name_(handler); \
}
#define WINDOW_EVENT(name_, id_, type_, struct_) \
WINDOW_EVENT_HELPER(name_, EventHandlerNonNull)
#define BEFOREUNLOAD_EVENT(name_, id_, type_, struct_) \
WINDOW_EVENT_HELPER(name_, OnBeforeUnloadEventHandlerNonNull)
#include "mozilla/EventNameList.h" // IWYU pragma: keep
#undef BEFOREUNLOAD_EVENT
#undef WINDOW_EVENT
#undef WINDOW_EVENT_HELPER
#undef EVENT
} // namespace mozilla::dom