2015-05-03 22:32:37 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
2012-05-21 15:12:37 +04:00
|
|
|
/* 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/. */
|
1998-04-14 00:24:54 +04:00
|
|
|
#ifndef nsIContent_h___
|
|
|
|
#define nsIContent_h___
|
|
|
|
|
2019-02-02 01:28:54 +03:00
|
|
|
#include "mozilla/FlushType.h"
|
2013-10-02 15:40:07 +04:00
|
|
|
#include "nsINode.h"
|
2017-08-17 02:48:52 +03:00
|
|
|
#include "nsStringFwd.h"
|
2005-11-16 23:29:29 +03:00
|
|
|
|
1998-08-30 00:20:38 +04:00
|
|
|
// Forward declarations
|
2003-07-03 06:45:34 +04:00
|
|
|
class nsIURI;
|
2006-07-19 08:36:36 +04:00
|
|
|
class nsTextFragment;
|
2009-12-25 00:20:05 +03:00
|
|
|
class nsIFrame;
|
1998-07-15 02:34:27 +04:00
|
|
|
|
2011-03-11 05:48:57 +03:00
|
|
|
namespace mozilla {
|
2014-03-18 08:48:19 +04:00
|
|
|
class EventChainPreVisitor;
|
2017-04-06 09:51:29 +03:00
|
|
|
struct URLExtraData;
|
2013-12-02 14:26:11 +04:00
|
|
|
namespace dom {
|
Bug 1555216 - Change the signature of BindToTree to be (BindContext&, nsINode& aParentNode). r=bzbarsky
BindContext was going to have way more information at first, but then I realized
that most of the things I wanted to know were basically a flag away using the
parent node.
Still I think it's worth it, now experimenting with BindToTree will only mean
adding a field to a struct that's included from a couple cpp files, instead of a
massive pain.
I also think this is clearer, and doing this highlights quite a few
inconsistencies in our code which I've left untouched, but commented with
FIXMEs.
Steps are:
$ for file in $(rg 'nsresult BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#nsresult BindToTree(Document\* aDocument, nsIContent\* aParent,#nsresult BindToTree(BindContext\&, nsINode\& aParent)#g' $file; done
$ for file in $(rg 'nsresult BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's# nsIContent\* aBindingParent) override#override#g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#::BindToTree(Document\* aDocument, nsIContent\* aParent,#::BindToTree(BindContext\& aContext, nsINode\& aParent)#g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#nsIContent\* aBindingParent)##g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#::BindToTree(aDocument, aParent, aBindingParent)#::BindToTree(aContext, aParent)#g' $file; done
$ ./mach clang-format
Then manual fixups.
Depends on D32948
Differential Revision: https://phabricator.services.mozilla.com/D32949
2019-05-29 07:27:04 +03:00
|
|
|
struct BindContext;
|
2013-12-02 14:26:11 +04:00
|
|
|
class ShadowRoot;
|
2017-10-19 09:31:36 +03:00
|
|
|
class HTMLSlotElement;
|
2013-12-02 14:26:11 +04:00
|
|
|
} // namespace dom
|
2011-11-27 15:51:53 +04:00
|
|
|
namespace widget {
|
2020-12-21 08:52:03 +03:00
|
|
|
enum class IMEEnabled;
|
2011-11-27 15:51:53 +04:00
|
|
|
struct IMEState;
|
|
|
|
} // namespace widget
|
|
|
|
} // namespace mozilla
|
2011-03-11 05:48:57 +03:00
|
|
|
|
1998-04-14 00:24:54 +04:00
|
|
|
// IID for the nsIContent interface
|
2018-01-05 01:32:15 +03:00
|
|
|
// Must be kept in sync with xpcom/rust/xpcom/src/interfaces/nonidl.rs
|
2011-11-16 11:50:18 +04:00
|
|
|
#define NS_ICONTENT_IID \
|
2018-11-30 13:46:48 +03:00
|
|
|
{ \
|
2015-09-18 15:18:42 +03:00
|
|
|
0x8e1bab9d, 0x8815, 0x4d2c, { \
|
|
|
|
0xa2, 0x4d, 0x7a, 0xba, 0x52, 0x39, 0xdc, 0x22 \
|
|
|
|
} \
|
|
|
|
}
|
2006-05-15 12:07:35 +04:00
|
|
|
|
2002-07-27 09:02:38 +04:00
|
|
|
/**
|
|
|
|
* A node of content in a document's content model. This interface
|
|
|
|
* is supported by all content objects.
|
|
|
|
*/
|
2008-01-04 14:24:41 +03:00
|
|
|
class nsIContent : public nsINode {
|
1998-04-14 00:24:54 +04:00
|
|
|
public:
|
2020-12-21 08:52:03 +03:00
|
|
|
using IMEEnabled = mozilla::widget::IMEEnabled;
|
Bug 1555216 - Change the signature of BindToTree to be (BindContext&, nsINode& aParentNode). r=bzbarsky
BindContext was going to have way more information at first, but then I realized
that most of the things I wanted to know were basically a flag away using the
parent node.
Still I think it's worth it, now experimenting with BindToTree will only mean
adding a field to a struct that's included from a couple cpp files, instead of a
massive pain.
I also think this is clearer, and doing this highlights quite a few
inconsistencies in our code which I've left untouched, but commented with
FIXMEs.
Steps are:
$ for file in $(rg 'nsresult BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#nsresult BindToTree(Document\* aDocument, nsIContent\* aParent,#nsresult BindToTree(BindContext\&, nsINode\& aParent)#g' $file; done
$ for file in $(rg 'nsresult BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's# nsIContent\* aBindingParent) override#override#g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#::BindToTree(Document\* aDocument, nsIContent\* aParent,#::BindToTree(BindContext\& aContext, nsINode\& aParent)#g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#nsIContent\* aBindingParent)##g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#::BindToTree(aDocument, aParent, aBindingParent)#::BindToTree(aContext, aParent)#g' $file; done
$ ./mach clang-format
Then manual fixups.
Depends on D32948
Differential Revision: https://phabricator.services.mozilla.com/D32949
2019-05-29 07:27:04 +03:00
|
|
|
using IMEState = mozilla::widget::IMEState;
|
|
|
|
using BindContext = mozilla::dom::BindContext;
|
|
|
|
|
2018-07-07 02:52:42 +03:00
|
|
|
void ConstructUbiNode(void* storage) override;
|
|
|
|
|
2006-08-31 23:59:43 +04:00
|
|
|
#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
|
2005-11-16 23:29:29 +03:00
|
|
|
|
2018-09-21 23:45:49 +03:00
|
|
|
explicit nsIContent(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
|
|
|
|
: nsINode(std::move(aNodeInfo)) {
|
2014-03-15 23:00:17 +04:00
|
|
|
MOZ_ASSERT(mNodeInfo);
|
2019-11-15 15:49:10 +03:00
|
|
|
MOZ_ASSERT(static_cast<nsINode*>(this) == reinterpret_cast<nsINode*>(this));
|
2012-06-19 07:47:35 +04:00
|
|
|
SetNodeIsContent();
|
2005-09-24 22:43:15 +04:00
|
|
|
}
|
2006-09-13 01:19:43 +04:00
|
|
|
#endif // MOZILLA_INTERNAL_API
|
2003-11-07 12:47:23 +03:00
|
|
|
|
2008-01-04 14:24:41 +03:00
|
|
|
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICONTENT_IID)
|
|
|
|
|
2020-03-17 17:53:00 +03:00
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS_FINAL_DELETECYCLECOLLECTABLE
|
|
|
|
|
2018-03-29 01:07:40 +03:00
|
|
|
NS_DECL_CYCLE_COLLECTION_CLASS(nsIContent)
|
|
|
|
|
2020-03-17 17:53:00 +03:00
|
|
|
NS_DECL_DOMARENA_DESTROY
|
|
|
|
|
2018-05-08 20:52:38 +03:00
|
|
|
NS_IMPL_FROMNODE_HELPER(nsIContent, IsContent())
|
|
|
|
|
2002-07-27 09:02:38 +04:00
|
|
|
/**
|
2005-04-06 03:54:35 +04:00
|
|
|
* 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.
|
Bug 1555216 - Change the signature of BindToTree to be (BindContext&, nsINode& aParentNode). r=bzbarsky
BindContext was going to have way more information at first, but then I realized
that most of the things I wanted to know were basically a flag away using the
parent node.
Still I think it's worth it, now experimenting with BindToTree will only mean
adding a field to a struct that's included from a couple cpp files, instead of a
massive pain.
I also think this is clearer, and doing this highlights quite a few
inconsistencies in our code which I've left untouched, but commented with
FIXMEs.
Steps are:
$ for file in $(rg 'nsresult BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#nsresult BindToTree(Document\* aDocument, nsIContent\* aParent,#nsresult BindToTree(BindContext\&, nsINode\& aParent)#g' $file; done
$ for file in $(rg 'nsresult BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's# nsIContent\* aBindingParent) override#override#g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#::BindToTree(Document\* aDocument, nsIContent\* aParent,#::BindToTree(BindContext\& aContext, nsINode\& aParent)#g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#nsIContent\* aBindingParent)##g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#::BindToTree(aDocument, aParent, aBindingParent)#::BindToTree(aContext, aParent)#g' $file; done
$ ./mach clang-format
Then manual fixups.
Depends on D32948
Differential Revision: https://phabricator.services.mozilla.com/D32949
2019-05-29 07:27:04 +03:00
|
|
|
* 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.
|
2005-04-06 03:54:35 +04:00
|
|
|
* @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
|
2018-07-31 21:18:38 +03:00
|
|
|
*
|
|
|
|
* TODO(emilio): Should we move to nsIContent::BindToTree most of the
|
|
|
|
* FragmentOrElement / CharacterData duplicated code?
|
2005-04-06 03:54:35 +04:00
|
|
|
*/
|
Bug 1555216 - Change the signature of BindToTree to be (BindContext&, nsINode& aParentNode). r=bzbarsky
BindContext was going to have way more information at first, but then I realized
that most of the things I wanted to know were basically a flag away using the
parent node.
Still I think it's worth it, now experimenting with BindToTree will only mean
adding a field to a struct that's included from a couple cpp files, instead of a
massive pain.
I also think this is clearer, and doing this highlights quite a few
inconsistencies in our code which I've left untouched, but commented with
FIXMEs.
Steps are:
$ for file in $(rg 'nsresult BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#nsresult BindToTree(Document\* aDocument, nsIContent\* aParent,#nsresult BindToTree(BindContext\&, nsINode\& aParent)#g' $file; done
$ for file in $(rg 'nsresult BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's# nsIContent\* aBindingParent) override#override#g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#::BindToTree(Document\* aDocument, nsIContent\* aParent,#::BindToTree(BindContext\& aContext, nsINode\& aParent)#g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#nsIContent\* aBindingParent)##g' $file; done
$ for file in $(rg '::BindToTree\(' | cut -d : -f 1 | sort | uniq); do sed -i 's#::BindToTree(aDocument, aParent, aBindingParent)#::BindToTree(aContext, aParent)#g' $file; done
$ ./mach clang-format
Then manual fixups.
Depends on D32948
Differential Revision: https://phabricator.services.mozilla.com/D32949
2019-05-29 07:27:04 +03:00
|
|
|
virtual nsresult BindToTree(BindContext&, nsINode& aParent) = 0;
|
2005-04-06 03:54:35 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
2016-07-22 06:10:23 +03:00
|
|
|
* the removal have been dispatched.
|
2005-04-06 03:54:35 +04:00
|
|
|
* @param aDeep Whether to recursively unbind the entire subtree rooted at
|
2011-10-17 18:59:28 +04:00
|
|
|
* this node. The only time false should be passed is when the
|
2005-04-06 03:54:35 +04:00
|
|
|
* 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.
|
|
|
|
*/
|
2019-05-29 01:47:08 +03:00
|
|
|
virtual void UnbindFromTree(bool aNullParent = true) = 0;
|
2006-05-15 16:47:53 +04:00
|
|
|
|
2010-02-11 20:34:01 +03:00
|
|
|
enum {
|
|
|
|
/**
|
2010-02-21 03:52:50 +03:00
|
|
|
* All XBL flattened tree children of the node, as well as :before and
|
|
|
|
* :after anonymous content and native anonymous children.
|
2010-02-11 20:34:01 +03:00
|
|
|
*
|
|
|
|
* @note the result children order is
|
2010-02-21 03:52:50 +03:00
|
|
|
* 1. :before generated node
|
2021-10-05 17:54:47 +03:00
|
|
|
* 2. Shadow DOM flattened tree children of this node
|
2010-02-21 03:52:50 +03:00
|
|
|
* 3. native anonymous nodes
|
|
|
|
* 4. :after generated node
|
2010-02-11 20:34:01 +03:00
|
|
|
*/
|
|
|
|
eAllChildren = 0,
|
|
|
|
|
|
|
|
/**
|
2021-10-05 17:54:47 +03:00
|
|
|
* Skip native anonymous content created for placeholder of HTML input.
|
2010-02-11 20:34:01 +03:00
|
|
|
*/
|
2021-10-05 17:54:47 +03:00
|
|
|
eSkipPlaceholderContent = 1 << 0,
|
2016-12-01 06:34:57 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2021-10-05 17:54:47 +03:00
|
|
|
eSkipDocumentLevelNativeAnonymousContent = 1 << 1,
|
2010-02-11 20:34:01 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2021-10-05 17:54:47 +03:00
|
|
|
* Return the flattened tree children of the node, depending on the filter, as
|
|
|
|
* well as native anonymous children.
|
2010-02-11 20:34:01 +03:00
|
|
|
*/
|
2012-08-22 19:56:38 +04:00
|
|
|
virtual already_AddRefed<nsINodeList> GetChildren(uint32_t aFilter) = 0;
|
2010-02-11 20:34:01 +03:00
|
|
|
|
2006-08-03 12:57:02 +04:00
|
|
|
/**
|
2008-01-04 14:24:41 +03:00
|
|
|
* Makes this content anonymous
|
|
|
|
* @see nsIAnonymousContentCreator
|
2006-08-03 12:57:02 +04:00
|
|
|
*/
|
2013-09-25 00:29:27 +04:00
|
|
|
void SetIsNativeAnonymousRoot() {
|
2019-11-18 11:49:27 +03:00
|
|
|
SetFlags(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE |
|
2018-05-10 19:48:08 +03:00
|
|
|
NODE_IS_NATIVE_ANONYMOUS_ROOT);
|
2006-08-03 12:57:02 +04:00
|
|
|
}
|
|
|
|
|
2008-02-26 15:40:18 +03:00
|
|
|
/**
|
2012-10-10 23:04:42 +04:00
|
|
|
* Returns |this| if it is not chrome-only/native anonymous, otherwise
|
|
|
|
* first non chrome-only/native anonymous ancestor.
|
2008-02-26 15:40:18 +03:00
|
|
|
*/
|
2018-03-07 17:09:27 +03:00
|
|
|
nsIContent* FindFirstNonChromeOnlyAccessContent() const;
|
2008-02-26 15:40:18 +03:00
|
|
|
|
2009-06-09 11:41:19 +04:00
|
|
|
/**
|
|
|
|
* 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).
|
|
|
|
*/
|
2013-10-02 15:40:07 +04:00
|
|
|
inline bool IsInHTMLDocument() const;
|
2009-06-09 11:41:19 +04:00
|
|
|
|
2016-06-28 17:24:48 +03:00
|
|
|
/**
|
|
|
|
* Returns true if in a chrome document
|
|
|
|
*/
|
2018-03-08 02:59:25 +03:00
|
|
|
inline bool IsInChromeDocument() const;
|
2016-06-28 17:24:48 +03:00
|
|
|
|
2012-06-22 11:41:56 +04:00
|
|
|
/**
|
|
|
|
* Get the namespace that this element's tag is defined in
|
|
|
|
* @return the namespace
|
|
|
|
*/
|
2012-08-22 19:56:38 +04:00
|
|
|
inline int32_t GetNameSpaceID() const { return mNodeInfo->NamespaceID(); }
|
2012-06-22 11:41:56 +04:00
|
|
|
|
2015-03-03 14:08:59 +03:00
|
|
|
inline bool IsHTMLElement() const {
|
|
|
|
return IsInNamespace(kNameSpaceID_XHTML);
|
2012-06-22 11:41:56 +04:00
|
|
|
}
|
|
|
|
|
2018-11-13 15:48:21 +03:00
|
|
|
inline bool IsHTMLElement(const nsAtom* aTag) const {
|
2015-03-03 14:08:59 +03:00
|
|
|
return mNodeInfo->Equals(aTag, kNameSpaceID_XHTML);
|
2012-06-22 11:41:56 +04:00
|
|
|
}
|
|
|
|
|
2015-03-03 14:08:59 +03:00
|
|
|
template <typename First, typename... Args>
|
|
|
|
inline bool IsAnyOfHTMLElements(First aFirst, Args... aArgs) const {
|
|
|
|
return IsHTMLElement() && IsNodeInternal(aFirst, aArgs...);
|
2012-06-22 11:41:56 +04:00
|
|
|
}
|
|
|
|
|
2015-03-03 14:08:59 +03:00
|
|
|
inline bool IsSVGElement() const { return IsInNamespace(kNameSpaceID_SVG); }
|
2012-06-22 11:41:56 +04:00
|
|
|
|
2018-11-13 15:48:21 +03:00
|
|
|
inline bool IsSVGElement(const nsAtom* aTag) const {
|
2015-03-03 14:08:59 +03:00
|
|
|
return mNodeInfo->Equals(aTag, kNameSpaceID_SVG);
|
2012-06-22 11:41:56 +04:00
|
|
|
}
|
|
|
|
|
2015-03-03 14:08:59 +03:00
|
|
|
template <typename First, typename... Args>
|
|
|
|
inline bool IsAnyOfSVGElements(First aFirst, Args... aArgs) const {
|
|
|
|
return IsSVGElement() && IsNodeInternal(aFirst, aArgs...);
|
2012-06-22 11:41:56 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
inline bool IsXULElement() const { return IsInNamespace(kNameSpaceID_XUL); }
|
|
|
|
|
2018-11-13 15:48:21 +03:00
|
|
|
inline bool IsXULElement(const nsAtom* aTag) const {
|
2013-07-19 08:13:35 +04:00
|
|
|
return mNodeInfo->Equals(aTag, kNameSpaceID_XUL);
|
|
|
|
}
|
|
|
|
|
2015-03-03 14:08:59 +03:00
|
|
|
template <typename First, typename... Args>
|
|
|
|
inline bool IsAnyOfXULElements(First aFirst, Args... aArgs) const {
|
|
|
|
return IsXULElement() && IsNodeInternal(aFirst, aArgs...);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool IsMathMLElement() const {
|
2012-06-22 11:41:56 +04:00
|
|
|
return IsInNamespace(kNameSpaceID_MathML);
|
|
|
|
}
|
|
|
|
|
2018-11-13 15:48:21 +03:00
|
|
|
inline bool IsMathMLElement(const nsAtom* aTag) const {
|
2012-06-22 11:41:56 +04:00
|
|
|
return mNodeInfo->Equals(aTag, kNameSpaceID_MathML);
|
|
|
|
}
|
|
|
|
|
2015-03-03 14:08:59 +03:00
|
|
|
template <typename First, typename... Args>
|
|
|
|
inline bool IsAnyOfMathMLElements(First aFirst, Args... aArgs) const {
|
|
|
|
return IsMathMLElement() && IsNodeInternal(aFirst, aArgs...);
|
|
|
|
}
|
2018-04-13 17:32:50 +03:00
|
|
|
|
2016-08-19 06:16:45 +03:00
|
|
|
bool IsGeneratedContentContainerForBefore() const {
|
|
|
|
return IsRootOfNativeAnonymousSubtree() &&
|
|
|
|
mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsGeneratedContentContainerForAfter() const {
|
|
|
|
return IsRootOfNativeAnonymousSubtree() &&
|
|
|
|
mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentafter;
|
|
|
|
}
|
|
|
|
|
2019-03-25 01:13:53 +03:00
|
|
|
bool IsGeneratedContentContainerForMarker() const {
|
|
|
|
return IsRootOfNativeAnonymousSubtree() &&
|
|
|
|
mNodeInfo->NameAtom() == nsGkAtoms::mozgeneratedcontentmarker;
|
|
|
|
}
|
|
|
|
|
2006-07-19 08:36:36 +04:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-08-22 19:56:38 +04:00
|
|
|
virtual uint32_t TextLength() const = 0;
|
2006-07-19 08:36:36 +04:00
|
|
|
|
2016-07-22 06:10:23 +03:00
|
|
|
/**
|
|
|
|
* Determines if an event attribute name (such as onclick) is valid for
|
|
|
|
* a given element type.
|
|
|
|
* @note calls nsContentUtils::IsEventAttributeName with right flag
|
2017-07-04 23:54:30 +03:00
|
|
|
* @note *Internal is overridden by subclasses as needed
|
2016-07-22 06:10:23 +03:00
|
|
|
* @param aName the event name to look up
|
|
|
|
*/
|
2017-10-03 01:05:19 +03:00
|
|
|
bool IsEventAttributeName(nsAtom* aName);
|
2017-07-04 23:54:30 +03:00
|
|
|
|
2017-10-03 01:05:19 +03:00
|
|
|
virtual bool IsEventAttributeNameInternal(nsAtom* aName) { return false; }
|
2013-01-03 00:24:07 +04:00
|
|
|
|
2006-07-19 08:36:36 +04:00
|
|
|
/**
|
|
|
|
* Query method to see if the frame is nothing but whitespace
|
2011-10-17 18:59:28 +04:00
|
|
|
* NOTE: Always returns false for elements
|
2006-07-19 08:36:36 +04:00
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual bool TextIsOnlyWhitespace() = 0;
|
2006-07-19 08:36:36 +04:00
|
|
|
|
2017-03-17 00:10:22 +03:00
|
|
|
/**
|
|
|
|
* Thread-safe version of TextIsOnlyWhitespace.
|
|
|
|
*/
|
|
|
|
virtual bool ThreadSafeTextIsOnlyWhitespace() const = 0;
|
|
|
|
|
2004-07-25 01:12:43 +04:00
|
|
|
/**
|
|
|
|
* Check if this content is focusable and in the current tab order.
|
2016-07-22 06:10:23 +03:00
|
|
|
* Note: most callers should use nsIFrame::IsFocusable() instead as it
|
2004-07-25 01:12:43 +04:00
|
|
|
* checks visibility and other layout factors as well.
|
|
|
|
* Tabbable is indicated by a nonnegative tabindex & is a subset of focusable.
|
2016-07-22 06:10:23 +03:00
|
|
|
* For example, only the selected radio button in a group is in the
|
2004-07-25 01:12:43 +04:00
|
|
|
* tab order, unless the radio group has no selection in which case
|
2016-07-22 06:10:23 +03:00
|
|
|
* 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
|
2004-07-25 01:12:43 +04:00
|
|
|
* radio buttons are always focusable via clicking or script.
|
2005-01-07 02:41:52 +03:00
|
|
|
* 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.
|
2004-07-25 01:12:43 +04:00
|
|
|
* @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.
|
|
|
|
*/
|
2013-11-20 02:21:16 +04:00
|
|
|
bool IsFocusable(int32_t* aTabIndex = nullptr, bool aWithMouse = false);
|
|
|
|
virtual bool IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse);
|
2004-07-25 01:12:43 +04:00
|
|
|
|
2022-10-14 04:20:08 +03:00
|
|
|
// https://html.spec.whatwg.org/multipage/interaction.html#focus-delegate
|
|
|
|
mozilla::dom::Element* GetFocusDelegate(bool aWithMouse) const;
|
|
|
|
|
2005-11-15 02:55:24 +03:00
|
|
|
/*
|
|
|
|
* Get desired IME state for the content.
|
|
|
|
*
|
|
|
|
* @return The desired IME status for the content.
|
2011-11-27 15:51:53 +04:00
|
|
|
* This is a combination of an IME enabled value and
|
|
|
|
* an IME open value of widget::IMEState.
|
2020-12-21 08:52:03 +03:00
|
|
|
* 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.
|
2011-11-27 15:51:53 +04:00
|
|
|
*/
|
|
|
|
virtual IMEState GetDesiredIMEState();
|
2005-11-15 02:55:24 +03:00
|
|
|
|
2013-12-02 14:26:11 +04:00
|
|
|
/**
|
|
|
|
* Gets the ShadowRoot binding for this element.
|
|
|
|
*
|
|
|
|
* @return The ShadowRoot currently bound to this element.
|
|
|
|
*/
|
2017-12-31 22:57:32 +03:00
|
|
|
inline mozilla::dom::ShadowRoot* GetShadowRoot() const;
|
2013-12-02 14:26:11 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2017-12-23 11:23:42 +03:00
|
|
|
mozilla::dom::ShadowRoot* GetContainingShadow() const {
|
|
|
|
const nsExtendedContentSlots* slots = GetExistingExtendedContentSlots();
|
|
|
|
return slots ? slots->mContainingShadow.get() : nullptr;
|
|
|
|
}
|
2013-12-02 14:26:11 +04:00
|
|
|
|
2017-10-19 09:31:36 +03:00
|
|
|
/**
|
|
|
|
* Gets the assigned slot associated with this content.
|
|
|
|
*
|
|
|
|
* @return The assigned slot element or null.
|
|
|
|
*/
|
2017-12-23 11:23:42 +03:00
|
|
|
mozilla::dom::HTMLSlotElement* GetAssignedSlot() const {
|
|
|
|
const nsExtendedContentSlots* slots = GetExistingExtendedContentSlots();
|
|
|
|
return slots ? slots->mAssignedSlot.get() : nullptr;
|
|
|
|
}
|
2017-10-19 09:31:36 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the assigned slot associated with this content.
|
|
|
|
*
|
|
|
|
* @param aSlot The assigned slot.
|
|
|
|
*/
|
2017-12-23 11:23:42 +03:00
|
|
|
void SetAssignedSlot(mozilla::dom::HTMLSlotElement* aSlot);
|
2017-10-19 09:31:36 +03:00
|
|
|
|
2017-11-02 11:53:44 +03:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
2021-07-20 21:06:25 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-04-16 22:15:28 +04:00
|
|
|
/**
|
2016-08-19 03:03:49 +03:00
|
|
|
* Same as GetFlattenedTreeParentNode, but returns null if the parent is
|
|
|
|
* non-nsIContent.
|
|
|
|
*/
|
2017-12-31 22:57:32 +03:00
|
|
|
inline nsIContent* GetFlattenedTreeParent() const;
|
2016-08-19 03:03:49 +03:00
|
|
|
|
2022-05-26 19:12:46 +03:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
2019-08-28 01:10:46 +03:00
|
|
|
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:
|
2002-03-31 14:14:01 +04:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*
|
2019-09-06 23:27:09 +03:00
|
|
|
* NOTE: this is only called for elements listed in
|
|
|
|
* RequiresDoneCreatingElement. This is an efficiency measure.
|
2002-03-31 14:14:01 +04:00
|
|
|
*
|
|
|
|
* If you also need to determine whether the parser is the one creating your
|
2003-10-30 16:47:29 +03:00
|
|
|
* element (through createElement() or cloneNode() generally) then add a
|
2012-08-22 19:56:38 +04:00
|
|
|
* uint32_t aFromParser to the NS_NewXXX() constructor for your element and
|
2013-03-28 23:41:32 +04:00
|
|
|
* have the parser pass the appropriate flags. See HTMLInputElement.cpp and
|
2002-03-31 14:14:01 +04:00
|
|
|
* 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).
|
|
|
|
*/
|
2004-01-10 02:54:21 +03:00
|
|
|
virtual void DoneCreatingElement() {}
|
2002-03-31 14:14:01 +04:00
|
|
|
|
2004-06-02 04:25:00 +04:00
|
|
|
/**
|
|
|
|
* This method is called when the parser finishes creating the element's
|
|
|
|
* children, if any are present.
|
|
|
|
*
|
2019-09-06 23:27:09 +03:00
|
|
|
* NOTE: this is only called for elements listed in
|
|
|
|
* RequiresDoneAddingChildren. This is an efficiency measure.
|
2004-06-02 04:25:00 +04:00
|
|
|
*
|
|
|
|
* 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
|
2013-03-28 23:41:32 +04:00
|
|
|
* have the parser pass true. See HTMLInputElement.cpp and
|
2004-06-02 04:25:00 +04:00
|
|
|
* nsHTMLContentSink::MakeContentObject().
|
2005-09-22 06:33:36 +04:00
|
|
|
*
|
|
|
|
* @param aHaveNotified Whether there has been a
|
|
|
|
* ContentInserted/ContentAppended notification for this content node
|
|
|
|
* yet.
|
2004-06-02 04:25:00 +04:00
|
|
|
*/
|
2011-11-16 11:50:18 +04:00
|
|
|
virtual void DoneAddingChildren(bool aHaveNotified) {}
|
2004-06-02 04:25:00 +04:00
|
|
|
|
|
|
|
/**
|
2017-07-29 02:44:39 +03:00
|
|
|
* 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.
|
|
|
|
*
|
2011-10-17 18:59:28 +04:00
|
|
|
* @returns false if the element was created by the parser and
|
2017-07-29 02:44:39 +03:00
|
|
|
* it is an HTML textarea, select, or object
|
2006-04-05 10:04:29 +04:00
|
|
|
* element and not all children have been added.
|
2017-07-29 02:44:39 +03:00
|
|
|
*
|
2011-10-17 18:59:28 +04:00
|
|
|
* @returns true otherwise.
|
2004-06-02 04:25:00 +04:00
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual bool IsDoneAddingChildren() { return true; }
|
2004-06-02 04:25:00 +04:00
|
|
|
|
2019-09-06 23:27:09 +03:00
|
|
|
/**
|
|
|
|
* 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 ||
|
2022-06-23 01:31:42 +03:00
|
|
|
aName == nsGkAtoms::audio || aName == nsGkAtoms::video)) {
|
2019-09-06 23:27:09 +03:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2005-11-02 03:41:51 +03:00
|
|
|
/**
|
|
|
|
* Get the ID of this content node (the atom corresponding to the
|
2014-05-30 11:36:53 +04:00
|
|
|
* value of the id attribute). This may be null if there is no ID.
|
2005-11-02 03:41:51 +03:00
|
|
|
*/
|
2017-10-03 01:05:19 +03:00
|
|
|
nsAtom* GetID() const {
|
2011-04-08 06:29:50 +04:00
|
|
|
if (HasID()) {
|
2010-06-04 05:09:20 +04:00
|
|
|
return DoGetID();
|
|
|
|
}
|
2012-07-30 18:20:58 +04:00
|
|
|
return nullptr;
|
2010-06-04 05:09:20 +04:00
|
|
|
}
|
2005-11-02 03:41:51 +03:00
|
|
|
|
2007-06-28 06:48:16 +04:00
|
|
|
/**
|
|
|
|
* Should be called when the node can become editable or when it can stop
|
|
|
|
* being editable (for example when its contentEditable attribute changes,
|
2011-06-01 05:46:57 +04:00
|
|
|
* when it is moved into an editable parent, ...). If aNotify is true and
|
|
|
|
* the node is an element, this will notify the state change.
|
2007-06-28 06:48:16 +04:00
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
virtual void UpdateEditableState(bool aNotify);
|
2006-06-02 17:28:14 +04:00
|
|
|
|
2007-11-30 20:57:03 +03:00
|
|
|
/**
|
2008-04-11 02:47:01 +04:00
|
|
|
* Destroy this node and its children. Ideally this shouldn't be needed
|
2007-11-30 20:57:03 +03:00
|
|
|
* but for now we need to do it to break cycles.
|
|
|
|
*/
|
2016-03-04 19:54:10 +03:00
|
|
|
virtual void DestroyContent() {}
|
2007-11-30 20:57:03 +03:00
|
|
|
|
2008-04-11 02:47:01 +04:00
|
|
|
/**
|
|
|
|
* Saves the form state of this node and its children.
|
|
|
|
*/
|
|
|
|
virtual void SaveSubtreeState() = 0;
|
|
|
|
|
2009-12-25 00:20:05 +03:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-03-15 00:14:02 +04:00
|
|
|
nsIFrame* GetPrimaryFrame() const {
|
2016-03-31 13:58:25 +03:00
|
|
|
return (IsInUncomposedDoc() || IsInShadowTree()) ? mPrimaryFrame : nullptr;
|
2012-03-15 00:14:02 +04:00
|
|
|
}
|
2017-09-17 18:21:32 +03:00
|
|
|
|
2019-02-02 01:28:54 +03:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2017-09-17 18:21:32 +03:00
|
|
|
// Defined in nsIContentInlines.h because it needs nsIFrame.
|
|
|
|
inline void SetPrimaryFrame(nsIFrame* aFrame);
|
2009-12-25 00:20:05 +03:00
|
|
|
|
2011-12-20 18:54:14 +04:00
|
|
|
nsresult LookupNamespaceURIInternal(const nsAString& aNamespacePrefix,
|
|
|
|
nsAString& aNamespaceURI) const;
|
2010-04-19 19:40:16 +04:00
|
|
|
|
2010-07-22 20:22:44 +04:00
|
|
|
/**
|
|
|
|
* If this content has independent selection, e.g., if this is input field
|
|
|
|
* or textarea, this return TRUE. Otherwise, false.
|
|
|
|
*/
|
2020-03-20 16:23:00 +03:00
|
|
|
bool HasIndependentSelection() const;
|
2010-07-22 20:22:44 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-05-06 11:53:11 +04:00
|
|
|
mozilla::dom::Element* GetEditingHost();
|
2010-07-22 20:22:44 +04:00
|
|
|
|
2017-06-07 06:10:07 +03:00
|
|
|
bool SupportsLangAttr() const {
|
|
|
|
return IsHTMLElement() || IsSVGElement() || IsXULElement();
|
|
|
|
}
|
|
|
|
|
2011-08-12 23:12:45 +04:00
|
|
|
/**
|
2015-10-13 14:08:30 +03:00
|
|
|
* Determining language. Look at the nearest ancestor element that has a lang
|
2012-02-20 00:49:34 +04:00
|
|
|
* attribute in the XML namespace or is an HTML/SVG element and has a lang in
|
2017-06-15 22:48:26 +03:00
|
|
|
* no namespace attribute.
|
|
|
|
*
|
|
|
|
* Returns null if no language was specified. Can return the empty atom.
|
2011-08-12 23:12:45 +04:00
|
|
|
*/
|
2017-10-03 01:05:19 +03:00
|
|
|
nsAtom* GetLang() const;
|
2017-06-15 22:48:26 +03:00
|
|
|
|
2015-10-13 14:08:30 +03:00
|
|
|
bool GetLang(nsAString& aResult) const {
|
2017-06-15 22:48:26 +03:00
|
|
|
if (auto* lang = GetLang()) {
|
|
|
|
aResult.Assign(nsDependentAtomString(lang));
|
|
|
|
return true;
|
2011-08-12 23:12:45 +04:00
|
|
|
}
|
2017-06-15 22:48:26 +03:00
|
|
|
|
2015-10-13 14:08:30 +03:00
|
|
|
return false;
|
2011-08-12 23:12:45 +04:00
|
|
|
}
|
|
|
|
|
2011-02-11 10:47:00 +03:00
|
|
|
// Overloaded from nsINode
|
2019-07-15 20:22:30 +03:00
|
|
|
nsIURI* GetBaseURI(bool aTryUseXHRDocBaseURI = false) const override;
|
2011-02-11 10:47:00 +03:00
|
|
|
|
2017-03-10 10:04:34 +03:00
|
|
|
// Returns base URI for style attribute.
|
2017-10-06 07:45:33 +03:00
|
|
|
nsIURI* GetBaseURIForStyleAttr() const;
|
2017-03-10 10:04:34 +03:00
|
|
|
|
2017-04-06 09:51:29 +03:00
|
|
|
// Returns the URL data for style attribute.
|
2017-11-06 00:23:49 +03:00
|
|
|
// 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;
|
2017-04-06 09:51:29 +03:00
|
|
|
|
2018-04-05 20:42:41 +03:00
|
|
|
void GetEventTargetParent(mozilla::EventChainPreVisitor& aVisitor) override;
|
2011-06-24 06:17:59 +04:00
|
|
|
|
2018-03-29 01:07:40 +03:00
|
|
|
bool IsPurple() const { return mRefCnt.IsPurple(); }
|
|
|
|
|
|
|
|
void RemovePurple() { mRefCnt.RemovePurple(); }
|
2012-01-31 00:08:13 +04:00
|
|
|
|
2018-03-29 01:07:40 +03:00
|
|
|
bool OwnedOnlyByTheDOMTree() {
|
|
|
|
uint32_t rc = mRefCnt.get();
|
|
|
|
if (GetParent()) {
|
|
|
|
--rc;
|
|
|
|
}
|
|
|
|
rc -= GetChildCount();
|
|
|
|
return rc == 0;
|
|
|
|
}
|
2017-07-19 04:04:34 +03:00
|
|
|
|
2010-06-04 05:09:20 +04:00
|
|
|
protected:
|
2017-12-23 11:23:42 +03:00
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
|
2018-06-30 01:30:37 +03:00
|
|
|
virtual void TraverseExtendedSlots(nsCycleCollectionTraversalCallback&);
|
2023-02-15 17:12:33 +03:00
|
|
|
virtual void UnlinkExtendedSlots(nsIContent&);
|
2017-12-23 11:23:42 +03:00
|
|
|
|
2018-08-27 22:20:53 +03:00
|
|
|
virtual size_t SizeOfExcludingThis(
|
|
|
|
mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
|
2017-12-23 11:23:42 +03:00
|
|
|
/**
|
|
|
|
* @see nsIContent::GetContainingShadow
|
|
|
|
*/
|
|
|
|
RefPtr<mozilla::dom::ShadowRoot> mContainingShadow;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @see nsIContent::GetAssignedSlot
|
|
|
|
*/
|
|
|
|
RefPtr<mozilla::dom::HTMLSlotElement> mAssignedSlot;
|
2021-07-20 21:06:25 +03:00
|
|
|
|
|
|
|
mozilla::dom::HTMLSlotElement* mManualSlotAssignment = nullptr;
|
2017-12-23 11:23:42 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
class nsContentSlots : public nsINode::nsSlots {
|
|
|
|
public:
|
2018-06-30 01:30:37 +03:00
|
|
|
nsContentSlots() : nsINode::nsSlots(), mExtendedSlots(0) {}
|
|
|
|
|
|
|
|
~nsContentSlots() {
|
|
|
|
if (!(mExtendedSlots & sNonOwningExtendedSlotsFlag)) {
|
|
|
|
delete GetExtendedContentSlots();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-23 11:23:42 +03:00
|
|
|
void Traverse(nsCycleCollectionTraversalCallback& aCb) override {
|
|
|
|
nsINode::nsSlots::Traverse(aCb);
|
|
|
|
if (mExtendedSlots) {
|
2018-06-30 01:30:37 +03:00
|
|
|
GetExtendedContentSlots()->TraverseExtendedSlots(aCb);
|
2017-12-23 11:23:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-15 17:12:33 +03:00
|
|
|
void Unlink(nsINode& aNode) override {
|
|
|
|
nsINode::nsSlots::Unlink(aNode);
|
2017-12-23 11:23:42 +03:00
|
|
|
if (mExtendedSlots) {
|
2023-02-15 17:12:33 +03:00
|
|
|
GetExtendedContentSlots()->UnlinkExtendedSlots(*aNode.AsContent());
|
2018-06-30 01:30:37 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetExtendedContentSlots(nsExtendedContentSlots* aSlots, bool aOwning) {
|
|
|
|
mExtendedSlots = reinterpret_cast<uintptr_t>(aSlots);
|
|
|
|
if (!aOwning) {
|
|
|
|
mExtendedSlots |= sNonOwningExtendedSlotsFlag;
|
2017-12-23 11:23:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-27 22:20:53 +03:00
|
|
|
// OwnsExtendedSlots returns true if we have no extended slots or if we
|
|
|
|
// have extended slots and own them.
|
2018-06-30 01:30:37 +03:00
|
|
|
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;
|
2017-12-23 11:23:42 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
// 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();
|
2018-06-30 01:30:37 +03:00
|
|
|
return slots ? slots->GetExtendedContentSlots() : nullptr;
|
2017-12-23 11:23:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
nsExtendedContentSlots* GetExistingExtendedContentSlots() {
|
|
|
|
nsContentSlots* slots = GetExistingContentSlots();
|
2018-06-30 01:30:37 +03:00
|
|
|
return slots ? slots->GetExtendedContentSlots() : nullptr;
|
2017-12-23 11:23:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
nsExtendedContentSlots* ExtendedContentSlots() {
|
|
|
|
nsContentSlots* slots = ContentSlots();
|
2018-06-30 01:30:37 +03:00
|
|
|
if (!slots->GetExtendedContentSlots()) {
|
|
|
|
slots->SetExtendedContentSlots(CreateExtendedSlots(), true);
|
2017-12-23 11:23:42 +03:00
|
|
|
}
|
2018-06-30 01:30:37 +03:00
|
|
|
return slots->GetExtendedContentSlots();
|
2017-12-23 11:23:42 +03:00
|
|
|
}
|
|
|
|
|
2010-06-04 05:09:20 +04:00
|
|
|
/**
|
|
|
|
* Hook for implementing GetID. This is guaranteed to only be
|
2011-04-08 06:29:50 +04:00
|
|
|
* called if HasID() is true.
|
2010-06-04 05:09:20 +04:00
|
|
|
*/
|
2017-10-03 01:05:19 +03:00
|
|
|
nsAtom* DoGetID() const;
|
2010-06-04 05:09:20 +04:00
|
|
|
|
2020-02-21 13:41:47 +03:00
|
|
|
~nsIContent() = default;
|
2018-03-29 01:07:40 +03:00
|
|
|
|
2008-09-11 07:22:20 +04:00
|
|
|
public:
|
2021-04-05 13:49:40 +03:00
|
|
|
#if defined(DEBUG) || defined(MOZ_DUMP_PAINTING)
|
2021-02-23 23:08:13 +03:00
|
|
|
# define MOZ_DOM_LIST
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef MOZ_DOM_LIST
|
2021-09-10 19:39:15 +03:00
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
|
2001-10-16 09:31:36 +04:00
|
|
|
/**
|
|
|
|
* List the content (and anything it contains) out to the given
|
|
|
|
* file stream. Use aIndent as the base indent during formatting.
|
|
|
|
*/
|
2012-08-22 19:56:38 +04:00
|
|
|
virtual void List(FILE* out = stdout, int32_t aIndent = 0) const = 0;
|
2001-10-16 09:31:36 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Dump the content (and anything it contains) out to the given
|
|
|
|
* file stream. Use aIndent as the base indent during formatting.
|
|
|
|
*/
|
2012-08-22 19:56:38 +04:00
|
|
|
virtual void DumpContent(FILE* out = stdout, int32_t aIndent = 0,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aDumpAll = true) const = 0;
|
2001-10-16 09:31:36 +04:00
|
|
|
#endif
|
2003-11-07 12:47:23 +03:00
|
|
|
|
2004-07-25 01:12:43 +04:00
|
|
|
enum ETabFocusType {
|
2016-10-11 21:13:36 +03:00
|
|
|
eTabFocus_textControlsMask =
|
|
|
|
(1 << 0), // textboxes and lists always tabbable
|
2004-07-25 01:12:43 +04:00
|
|
|
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:
|
2012-08-22 19:56:38 +04:00
|
|
|
static int32_t sTabFocusModel;
|
2004-07-25 01:12:43 +04:00
|
|
|
|
2005-01-30 02:47:35 +03:00
|
|
|
// accessibility.tabfocus_applies_to_xul pref - if it is set to true,
|
|
|
|
// the tabfocus bit field applies to xul elements.
|
2011-09-29 10:19:26 +04:00
|
|
|
static bool sTabFocusModelAppliesToXUL;
|
1998-04-14 00:24:54 +04:00
|
|
|
};
|
|
|
|
|
2005-11-11 17:36:26 +03:00
|
|
|
NS_DEFINE_STATIC_IID_ACCESSOR(nsIContent, NS_ICONTENT_IID)
|
|
|
|
|
1998-04-14 00:24:54 +04:00
|
|
|
#endif /* nsIContent_h___ */
|