diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/base/nsIContent.h | 798 |
1 files changed, 798 insertions, 0 deletions
diff --git a/dom/base/nsIContent.h b/dom/base/nsIContent.h new file mode 100644 index 0000000000..e7c6e2056f --- /dev/null +++ b/dom/base/nsIContent.h @@ -0,0 +1,798 @@ +/* -*- 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/. */ +#ifndef nsIContent_h___ +#define nsIContent_h___ + +#include "mozilla/FlushType.h" +#include "nsINode.h" +#include "nsStringFwd.h" + +// Forward declarations +class nsIURI; +class nsTextFragment; +class nsIFrame; + +namespace mozilla { +class EventChainPreVisitor; +struct URLExtraData; +namespace dom { +struct BindContext; +class ShadowRoot; +class HTMLSlotElement; +} // namespace dom +namespace widget { +enum class IMEEnabled; +struct IMEState; +} // namespace widget +} // namespace mozilla + +// IID for the nsIContent interface +// Must be kept in sync with xpcom/rust/xpcom/src/interfaces/nonidl.rs +#define NS_ICONTENT_IID \ + { \ + 0x8e1bab9d, 0x8815, 0x4d2c, { \ + 0xa2, 0x4d, 0x7a, 0xba, 0x52, 0x39, 0xdc, 0x22 \ + } \ + } + +/** + * A node of content in a document's content model. This interface + * is supported by all content objects. + */ +class nsIContent : public nsINode { + public: + using IMEEnabled = mozilla::widget::IMEEnabled; + using IMEState = mozilla::widget::IMEState; + using BindContext = mozilla::dom::BindContext; + + void ConstructUbiNode(void* storage) override; + +#ifdef MOZILLA_INTERNAL_API + // If you're using the external API, the only thing you can know about + // nsIContent is that it exists with an IID + + explicit nsIContent(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo) + : nsINode(std::move(aNodeInfo)) { + MOZ_ASSERT(mNodeInfo); + MOZ_ASSERT(static_cast<nsINode*>(this) == reinterpret_cast<nsINode*>(this)); + SetNodeIsContent(); + } +#endif // MOZILLA_INTERNAL_API + + NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICONTENT_IID) + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS_FINAL_DELETECYCLECOLLECTABLE + + NS_DECL_CYCLE_COLLECTION_CLASS(nsIContent) + + NS_DECL_DOMARENA_DESTROY + + NS_IMPL_FROMNODE_HELPER(nsIContent, IsContent()) + + /** + * Bind this content node to a tree. If this method throws, the caller must + * call UnbindFromTree() on the node. In the typical case of a node being + * appended to a parent, this will be called after the node has been added to + * the parent's child list and before nsIDocumentObserver notifications for + * the addition are dispatched. + * BindContext propagates various information down the subtree; see its + * documentation to know how to set it up. + * @param aParent The new parent node for the content node. May be a document. + * @note This method must not be called by consumers of nsIContent on a node + * that is already bound to a tree. Call UnbindFromTree first. + * @note This method will handle rebinding descendants appropriately (eg + * changing their binding parent as needed). + * @note This method does not add the content node to aParent's child list + * @throws NS_ERROR_OUT_OF_MEMORY if that happens + * + * TODO(emilio): Should we move to nsIContent::BindToTree most of the + * FragmentOrElement / CharacterData duplicated code? + */ + virtual nsresult BindToTree(BindContext&, nsINode& aParent) = 0; + + /** + * Unbind this content node from a tree. This will set its current document + * and binding parent to null. In the typical case of a node being removed + * from a parent, this will be called after it has been removed from the + * parent's child list and after the nsIDocumentObserver notifications for + * the removal have been dispatched. + * @param aDeep Whether to recursively unbind the entire subtree rooted at + * this node. The only time false should be passed is when the + * parent node of the content is being destroyed. + * @param aNullParent Whether to null out the parent pointer as well. This + * is usually desirable. This argument should only be false while + * recursively calling UnbindFromTree when a subtree is detached. + * @note This method is safe to call on nodes that are not bound to a tree. + */ + virtual void UnbindFromTree(bool aNullParent = true) = 0; + + enum { + /** + * All XBL flattened tree children of the node, as well as :before and + * :after anonymous content and native anonymous children. + * + * @note the result children order is + * 1. :before generated node + * 2. Shadow DOM flattened tree children of this node + * 3. native anonymous nodes + * 4. :after generated node + */ + eAllChildren = 0, + + /** + * Skip native anonymous content created for placeholder of HTML input. + */ + eSkipPlaceholderContent = 1 << 0, + + /** + * Skip native anonymous content created by ancestor frames of the root + * element's primary frame, such as scrollbar elements created by the root + * scroll frame. + */ + eSkipDocumentLevelNativeAnonymousContent = 1 << 1, + }; + + /** + * Return the flattened tree children of the node, depending on the filter, as + * well as native anonymous children. + */ + virtual already_AddRefed<nsINodeList> GetChildren(uint32_t aFilter) = 0; + + /** + * Makes this content anonymous + * @see nsIAnonymousContentCreator + */ + void SetIsNativeAnonymousRoot() { + SetFlags(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE | + NODE_IS_NATIVE_ANONYMOUS_ROOT); + } + + /** + * Returns |this| if it is not chrome-only/native anonymous, otherwise + * first non chrome-only/native anonymous ancestor. + */ + nsIContent* FindFirstNonChromeOnlyAccessContent() const; + + /** + * Return true iff this node is in an HTML document (in the HTML5 sense of + * the term, i.e. not in an XHTML/XML document). + */ + inline bool IsInHTMLDocument() const; + + /** + * Returns true if in a chrome document + */ + inline bool IsInChromeDocument() const; + + /** + * Get the namespace that this element's tag is defined in + * @return the namespace + */ + inline int32_t GetNameSpaceID() const { return mNodeInfo->NamespaceID(); } + + inline bool IsHTMLElement() const { + return IsInNamespace(kNameSpaceID_XHTML); + } + + inline bool IsHTMLElement(const nsAtom* aTag) const { + return mNodeInfo->Equals(aTag, kNameSpaceID_XHTML); + } + + template <typename First, typename... Args> + inline bool IsAnyOfHTMLElements(First aFirst, Args... aArgs) const { + return IsHTMLElement() && IsNodeInternal(aFirst, aArgs...); + } + + inline bool IsSVGElement() const { return IsInNamespace(kNameSpaceID_SVG); } + + inline bool IsSVGElement(const nsAtom* aTag) const { + return mNodeInfo->Equals(aTag, kNameSpaceID_SVG); + } + + template <typename First, typename... Args> + inline bool IsAnyOfSVGElements(First aFirst, Args... aArgs) const { + return IsSVGElement() && IsNodeInternal(aFirst, aArgs...); + } + + inline bool IsXULElement() const { return IsInNamespace(kNameSpaceID_XUL); } + + inline bool IsXULElement(const nsAtom* aTag) const { + return mNodeInfo->Equals(aTag, kNameSpaceID_XUL); + } + + template <typename First, typename... Args> + inline bool IsAnyOfXULElements(First aFirst, Args... aArgs) const { + return IsXULElement() && IsNodeInternal(aFirst, aArgs...); + } + + inline bool IsMathMLElement() const { + return IsInNamespace(kNameSpaceID_MathML); + } + + inline bool IsMathMLElement(const nsAtom* aTag) const { + return mNodeInfo->Equals(aTag, kNameSpaceID_MathML); + } + + template <typename First, typename... Args> + inline bool IsAnyOfMathMLElements(First aFirst, Args... aArgs) const { + return IsMathMLElement() && IsNodeInternal(aFirst, aArgs...); + } + + bool IsGeneratedContentContainerForBefore() const { + return IsRootOfNativeAnonymousSubtree() && + mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore; + } + + bool IsGeneratedContentContainerForAfter() const { + return IsRootOfNativeAnonymousSubtree() && + mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentafter; + } + + bool IsGeneratedContentContainerForMarker() const { + return IsRootOfNativeAnonymousSubtree() && + mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentmarker; + } + + /** + * Get direct access (but read only) to the text in the text content. + * NOTE: For elements this is *not* the concatenation of all text children, + * it is simply null; + */ + virtual const nsTextFragment* GetText() = 0; + + /** + * Get the length of the text content. + * NOTE: This should not be called on elements. + */ + virtual uint32_t TextLength() const = 0; + + /** + * Determines if an event attribute name (such as onclick) is valid for + * a given element type. + * @note calls nsContentUtils::IsEventAttributeName with right flag + * @note *Internal is overridden by subclasses as needed + * @param aName the event name to look up + */ + bool IsEventAttributeName(nsAtom* aName); + + virtual bool IsEventAttributeNameInternal(nsAtom* aName) { return false; } + + /** + * Query method to see if the frame is nothing but whitespace + * NOTE: Always returns false for elements + */ + virtual bool TextIsOnlyWhitespace() = 0; + + /** + * Thread-safe version of TextIsOnlyWhitespace. + */ + virtual bool ThreadSafeTextIsOnlyWhitespace() const = 0; + + /** + * Check if this content is focusable and in the current tab order. + * Note: most callers should use nsIFrame::IsFocusable() instead as it + * checks visibility and other layout factors as well. + * Tabbable is indicated by a nonnegative tabindex & is a subset of focusable. + * For example, only the selected radio button in a group is in the + * tab order, unless the radio group has no selection in which case + * all of the visible, non-disabled radio buttons in the group are + * in the tab order. On the other hand, all of the visible, non-disabled + * radio buttons are always focusable via clicking or script. + * Also, depending on either the accessibility.tabfocus pref or + * a system setting (nowadays: Full keyboard access, mac only) + * some widgets may be focusable but removed from the tab order. + * @param [inout, optional] aTabIndex the computed tab index + * In: default tabindex for element (-1 nonfocusable, == 0 focusable) + * Out: computed tabindex + * @param [optional] aTabIndex the computed tab index + * < 0 if not tabbable + * == 0 if in normal tab order + * > 0 can be tabbed to in the order specified by this value + * @return whether the content is focusable via mouse, kbd or script. + */ + bool IsFocusable(int32_t* aTabIndex = nullptr, bool aWithMouse = false); + virtual bool IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse); + + // https://html.spec.whatwg.org/multipage/interaction.html#focus-delegate + mozilla::dom::Element* GetFocusDelegate(bool aWithMouse) const; + + /* + * Get desired IME state for the content. + * + * @return The desired IME status for the content. + * This is a combination of an IME enabled value and + * an IME open value of widget::IMEState. + * If you return IMEEnabled::Disabled, you should not set the OPEN + * nor CLOSE value. + * IMEEnabled::Password should be returned only from password editor, + * this value has a special meaning. It is used as alternative of + * IMEEnabled::Disabled. IMEENabled::Plugin should be returned only + * when plug-in has focus. When a plug-in is focused content, we + * should send native events directly. Because we don't process some + * native events, but they may be needed by the plug-in. + */ + virtual IMEState GetDesiredIMEState(); + + /** + * Gets the ShadowRoot binding for this element. + * + * @return The ShadowRoot currently bound to this element. + */ + inline mozilla::dom::ShadowRoot* GetShadowRoot() const; + + /** + * Gets the root of the node tree for this content if it is in a shadow tree. + * + * @return The ShadowRoot that is the root of the node tree. + */ + mozilla::dom::ShadowRoot* GetContainingShadow() const { + const nsExtendedContentSlots* slots = GetExistingExtendedContentSlots(); + return slots ? slots->mContainingShadow.get() : nullptr; + } + + /** + * Gets the assigned slot associated with this content. + * + * @return The assigned slot element or null. + */ + mozilla::dom::HTMLSlotElement* GetAssignedSlot() const { + const nsExtendedContentSlots* slots = GetExistingExtendedContentSlots(); + return slots ? slots->mAssignedSlot.get() : nullptr; + } + + /** + * Sets the assigned slot associated with this content. + * + * @param aSlot The assigned slot. + */ + void SetAssignedSlot(mozilla::dom::HTMLSlotElement* aSlot); + + /** + * Gets the assigned slot associated with this content based on parent's + * shadow root mode. Returns null if parent's shadow root is "closed". + * https://dom.spec.whatwg.org/#dom-slotable-assignedslot + * + * @return The assigned slot element or null. + */ + mozilla::dom::HTMLSlotElement* GetAssignedSlotByMode() const; + + mozilla::dom::HTMLSlotElement* GetManualSlotAssignment() const { + const nsExtendedContentSlots* slots = GetExistingExtendedContentSlots(); + return slots ? slots->mManualSlotAssignment : nullptr; + } + + void SetManualSlotAssignment(mozilla::dom::HTMLSlotElement* aSlot) { + MOZ_ASSERT(aSlot || GetExistingExtendedContentSlots()); + ExtendedContentSlots()->mManualSlotAssignment = aSlot; + } + + /** + * Same as GetFlattenedTreeParentNode, but returns null if the parent is + * non-nsIContent. + */ + inline nsIContent* GetFlattenedTreeParent() const; + + /** + * Get the index of a child within this content's flat tree children. + * + * @param aPossibleChild the child to get the index of. + * @return the index of the child, or Nothing if not a child. Be aware that + * anonymous children (e.g. a <div> child of an <input> element) will + * result in Nothing. + */ + mozilla::Maybe<uint32_t> ComputeFlatTreeIndexOf( + const nsINode* aPossibleChild) const; + + protected: + // Handles getting inserted or removed directly under a <slot> element. + // This is meant to only be called from the two functions below. + inline void HandleInsertionToOrRemovalFromSlot(); + + // Handles Shadow-DOM-related state tracking. Meant to be called near the + // end of BindToTree(), only if the tree we're in actually changed, that is, + // after the subtree has been bound to the new parent. + inline void HandleShadowDOMRelatedInsertionSteps(bool aHadParent); + + // Handles Shadow-DOM related state tracking. Meant to be called near the + // beginning of UnbindFromTree(), before the node has lost the reference to + // its parent. + inline void HandleShadowDOMRelatedRemovalSteps(bool aNullParent); + + public: + /** + * This method is called when the parser finishes creating the element. This + * particularly means that it has done everything you would expect it to have + * done after it encounters the > at the end of the tag (for HTML or XML). + * This includes setting the attributes, setting the document / form, and + * placing the element into the tree at its proper place. + * + * For container elements, this is called *before* any of the children are + * created or added into the tree. + * + * NOTE: this is only called for elements listed in + * RequiresDoneCreatingElement. This is an efficiency measure. + * + * If you also need to determine whether the parser is the one creating your + * element (through createElement() or cloneNode() generally) then add a + * uint32_t aFromParser to the NS_NewXXX() constructor for your element and + * have the parser pass the appropriate flags. See HTMLInputElement.cpp and + * nsHTMLContentSink::MakeContentObject(). + * + * DO NOT USE THIS METHOD to get around the fact that it's hard to deal with + * attributes dynamically. If you make attributes affect your element from + * this method, it will only happen on initialization and JavaScript will not + * be able to create elements (which requires them to first create the + * element and then call setAttribute() directly, at which point + * DoneCreatingElement() has already been called and is out of the picture). + */ + virtual void DoneCreatingElement() {} + + /** + * This method is called when the parser finishes creating the element's + * children, if any are present. + * + * NOTE: this is only called for elements listed in + * RequiresDoneAddingChildren. This is an efficiency measure. + * + * If you also need to determine whether the parser is the one creating your + * element (through createElement() or cloneNode() generally) then add a + * boolean aFromParser to the NS_NewXXX() constructor for your element and + * have the parser pass true. See HTMLInputElement.cpp and + * nsHTMLContentSink::MakeContentObject(). + * + * @param aHaveNotified Whether there has been a + * ContentInserted/ContentAppended notification for this content node + * yet. + */ + virtual void DoneAddingChildren(bool aHaveNotified) {} + + /** + * For HTML textarea, select, and object elements, returns true if all + * children have been added OR if the element was not created by the parser. + * Returns true for all other elements. + * + * @returns false if the element was created by the parser and + * it is an HTML textarea, select, or object + * element and not all children have been added. + * + * @returns true otherwise. + */ + virtual bool IsDoneAddingChildren() { return true; } + + /** + * Returns true if an element needs its DoneCreatingElement method to be + * called after it has been created. + * @see nsIContent::DoneCreatingElement + * + * @param aNamespaceID the node's namespace ID + * @param aName the node's tag name + */ + static inline bool RequiresDoneCreatingElement(int32_t aNamespace, + nsAtom* aName) { + if (aNamespace == kNameSpaceID_XHTML && + (aName == nsGkAtoms::input || aName == nsGkAtoms::button || + aName == nsGkAtoms::audio || aName == nsGkAtoms::video)) { + MOZ_ASSERT( + !RequiresDoneAddingChildren(aNamespace, aName), + "Both DoneCreatingElement and DoneAddingChildren on a same element " + "isn't supported."); + return true; + } + return false; + } + + /** + * Returns true if an element needs its DoneAddingChildren method to be + * called after all of its children have been added. + * @see nsIContent::DoneAddingChildren + * + * @param aNamespace the node's namespace ID + * @param aName the node's tag name + */ + static inline bool RequiresDoneAddingChildren(int32_t aNamespace, + nsAtom* aName) { + return (aNamespace == kNameSpaceID_XHTML && + (aName == nsGkAtoms::select || aName == nsGkAtoms::textarea || + aName == nsGkAtoms::head || aName == nsGkAtoms::title || + aName == nsGkAtoms::object || aName == nsGkAtoms::output)) || + (aNamespace == kNameSpaceID_SVG && aName == nsGkAtoms::title) || + (aNamespace == kNameSpaceID_XUL && aName == nsGkAtoms::linkset); + } + + /** + * Get the ID of this content node (the atom corresponding to the + * value of the id attribute). This may be null if there is no ID. + */ + nsAtom* GetID() const { + if (HasID()) { + return DoGetID(); + } + return nullptr; + } + + /** + * Should be called when the node can become editable or when it can stop + * being editable (for example when its contentEditable attribute changes, + * when it is moved into an editable parent, ...). If aNotify is true and + * the node is an element, this will notify the state change. + */ + virtual void UpdateEditableState(bool aNotify); + + /** + * Destroy this node and its children. Ideally this shouldn't be needed + * but for now we need to do it to break cycles. + */ + virtual void DestroyContent() {} + + /** + * Saves the form state of this node and its children. + */ + virtual void SaveSubtreeState() = 0; + + /** + * Getter and setter for our primary frame pointer. This is the frame that + * is most closely associated with the content. A frame is more closely + * associated with the content than another frame if the one frame contains + * directly or indirectly the other frame (e.g., when a frame is scrolled + * there is a scroll frame that contains the frame being scrolled). This + * frame is always the first continuation. + * + * In the case of absolutely positioned elements and floated elements, this + * frame is the out of flow frame, not the placeholder. + */ + nsIFrame* GetPrimaryFrame() const { + return (IsInUncomposedDoc() || IsInShadowTree()) ? mPrimaryFrame : nullptr; + } + + /** + * Get the primary frame for this content with flushing + * + * @param aType the kind of flush to do, typically FlushType::Frames or + * FlushType::Layout + * @return the primary frame + */ + nsIFrame* GetPrimaryFrame(mozilla::FlushType aType); + + // Defined in nsIContentInlines.h because it needs nsIFrame. + inline void SetPrimaryFrame(nsIFrame* aFrame); + + nsresult LookupNamespaceURIInternal(const nsAString& aNamespacePrefix, + nsAString& aNamespaceURI) const; + + /** + * If this content has independent selection, e.g., if this is input field + * or textarea, this return TRUE. Otherwise, false. + */ + bool HasIndependentSelection() const; + + /** + * If the content is a part of HTML editor, this returns editing + * host content. When the content is in designMode, this returns its body + * element. Also, when the content isn't editable, this returns null. + */ + mozilla::dom::Element* GetEditingHost(); + + bool SupportsLangAttr() const { + return IsHTMLElement() || IsSVGElement() || IsXULElement(); + } + + /** + * Determining language. Look at the nearest ancestor element that has a lang + * attribute in the XML namespace or is an HTML/SVG element and has a lang in + * no namespace attribute. + * + * Returns null if no language was specified. Can return the empty atom. + */ + nsAtom* GetLang() const; + + bool GetLang(nsAString& aResult) const { + if (auto* lang = GetLang()) { + aResult.Assign(nsDependentAtomString(lang)); + return true; + } + + return false; + } + + // Overloaded from nsINode + nsIURI* GetBaseURI(bool aTryUseXHRDocBaseURI = false) const override; + + // Returns base URI for style attribute. + nsIURI* GetBaseURIForStyleAttr() const; + + // Returns the URL data for style attribute. + // If aSubjectPrincipal is passed, it should be the scripted principal + // responsible for generating the URL data. + already_AddRefed<mozilla::URLExtraData> GetURLDataForStyleAttr( + nsIPrincipal* aSubjectPrincipal = nullptr) const; + + void GetEventTargetParent(mozilla::EventChainPreVisitor& aVisitor) override; + + bool IsPurple() const { return mRefCnt.IsPurple(); } + + void RemovePurple() { mRefCnt.RemovePurple(); } + + bool OwnedOnlyByTheDOMTree() { + uint32_t rc = mRefCnt.get(); + if (GetParent()) { + --rc; + } + rc -= GetChildCount(); + return rc == 0; + } + + protected: + /** + * Lazily allocated extended slots to avoid + * that may only be instantiated when a content object is accessed + * through the DOM. Rather than burn actual slots in the content + * objects for each of these instance variables, we put them off + * in a side structure that's only allocated when the content is + * accessed through the DOM. + */ + class nsExtendedContentSlots { + public: + nsExtendedContentSlots(); + virtual ~nsExtendedContentSlots(); + + virtual void TraverseExtendedSlots(nsCycleCollectionTraversalCallback&); + virtual void UnlinkExtendedSlots(); + + virtual size_t SizeOfExcludingThis( + mozilla::MallocSizeOf aMallocSizeOf) const; + + /** + * @see nsIContent::GetContainingShadow + */ + RefPtr<mozilla::dom::ShadowRoot> mContainingShadow; + + /** + * @see nsIContent::GetAssignedSlot + */ + RefPtr<mozilla::dom::HTMLSlotElement> mAssignedSlot; + + mozilla::dom::HTMLSlotElement* mManualSlotAssignment = nullptr; + }; + + class nsContentSlots : public nsINode::nsSlots { + public: + nsContentSlots() : nsINode::nsSlots(), mExtendedSlots(0) {} + + ~nsContentSlots() { + if (!(mExtendedSlots & sNonOwningExtendedSlotsFlag)) { + delete GetExtendedContentSlots(); + } + } + + void Traverse(nsCycleCollectionTraversalCallback& aCb) override { + nsINode::nsSlots::Traverse(aCb); + if (mExtendedSlots) { + GetExtendedContentSlots()->TraverseExtendedSlots(aCb); + } + } + + void Unlink() override { + nsINode::nsSlots::Unlink(); + if (mExtendedSlots) { + GetExtendedContentSlots()->UnlinkExtendedSlots(); + } + } + + void SetExtendedContentSlots(nsExtendedContentSlots* aSlots, bool aOwning) { + mExtendedSlots = reinterpret_cast<uintptr_t>(aSlots); + if (!aOwning) { + mExtendedSlots |= sNonOwningExtendedSlotsFlag; + } + } + + // OwnsExtendedSlots returns true if we have no extended slots or if we + // have extended slots and own them. + bool OwnsExtendedSlots() const { + return !(mExtendedSlots & sNonOwningExtendedSlotsFlag); + } + + nsExtendedContentSlots* GetExtendedContentSlots() const { + return reinterpret_cast<nsExtendedContentSlots*>( + mExtendedSlots & ~sNonOwningExtendedSlotsFlag); + } + + private: + static const uintptr_t sNonOwningExtendedSlotsFlag = 1u; + + uintptr_t mExtendedSlots; + }; + + // Override from nsINode + nsContentSlots* CreateSlots() override { return new nsContentSlots(); } + + nsContentSlots* ContentSlots() { + return static_cast<nsContentSlots*>(Slots()); + } + + const nsContentSlots* GetExistingContentSlots() const { + return static_cast<nsContentSlots*>(GetExistingSlots()); + } + + nsContentSlots* GetExistingContentSlots() { + return static_cast<nsContentSlots*>(GetExistingSlots()); + } + + virtual nsExtendedContentSlots* CreateExtendedSlots() { + return new nsExtendedContentSlots(); + } + + const nsExtendedContentSlots* GetExistingExtendedContentSlots() const { + const nsContentSlots* slots = GetExistingContentSlots(); + return slots ? slots->GetExtendedContentSlots() : nullptr; + } + + nsExtendedContentSlots* GetExistingExtendedContentSlots() { + nsContentSlots* slots = GetExistingContentSlots(); + return slots ? slots->GetExtendedContentSlots() : nullptr; + } + + nsExtendedContentSlots* ExtendedContentSlots() { + nsContentSlots* slots = ContentSlots(); + if (!slots->GetExtendedContentSlots()) { + slots->SetExtendedContentSlots(CreateExtendedSlots(), true); + } + return slots->GetExtendedContentSlots(); + } + + /** + * Hook for implementing GetID. This is guaranteed to only be + * called if HasID() is true. + */ + nsAtom* DoGetID() const; + + ~nsIContent() = default; + + public: +#if defined(DEBUG) || defined(MOZ_DUMP_PAINTING) +# define MOZ_DOM_LIST +#endif + +#ifdef MOZ_DOM_LIST + /** + * An alias for List() with default arguments. Since some debuggers can't + * figure the default arguments easily, having an out-of-line, non-static + * function helps quite a lot. + */ + void Dump(); + + /** + * List the content (and anything it contains) out to the given + * file stream. Use aIndent as the base indent during formatting. + */ + virtual void List(FILE* out = stdout, int32_t aIndent = 0) const = 0; + + /** + * Dump the content (and anything it contains) out to the given + * file stream. Use aIndent as the base indent during formatting. + */ + virtual void DumpContent(FILE* out = stdout, int32_t aIndent = 0, + bool aDumpAll = true) const = 0; +#endif + + enum ETabFocusType { + eTabFocus_textControlsMask = + (1 << 0), // textboxes and lists always tabbable + eTabFocus_formElementsMask = (1 << 1), // non-text form elements + eTabFocus_linksMask = (1 << 2), // links + eTabFocus_any = 1 + (1 << 1) + (1 << 2) // everything that can be focused + }; + + // Tab focus model bit field: + static int32_t sTabFocusModel; + + // accessibility.tabfocus_applies_to_xul pref - if it is set to true, + // the tabfocus bit field applies to xul elements. + static bool sTabFocusModelAppliesToXUL; +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(nsIContent, NS_ICONTENT_IID) + +#endif /* nsIContent_h___ */ |