2007-03-22 10:30:00 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is Mozilla Communicator client code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Base class for DOM Core's nsIDOMComment, nsIDOMDocumentType, nsIDOMText,
|
|
|
|
* nsIDOMCDATASection, and nsIDOMProcessingInstruction nodes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef nsGenericDOMDataNode_h___
|
|
|
|
#define nsGenericDOMDataNode_h___
|
|
|
|
|
2009-07-26 15:05:41 -07:00
|
|
|
#include "nsIContent.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "nsIDOMCharacterData.h"
|
2007-05-14 02:11:38 -07:00
|
|
|
#include "nsIDOMEventTarget.h"
|
2008-06-04 10:53:34 -07:00
|
|
|
#include "nsIDOM3Text.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "nsTextFragment.h"
|
|
|
|
#include "nsDOMError.h"
|
|
|
|
#include "nsIEventListenerManager.h"
|
|
|
|
#include "nsGenericElement.h"
|
|
|
|
#include "nsCycleCollectionParticipant.h"
|
2008-07-19 08:11:37 -07:00
|
|
|
#include "nsContentUtils.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2009-01-14 20:38:07 -08:00
|
|
|
#ifdef MOZ_SMIL
|
|
|
|
#include "nsISMILAttr.h"
|
|
|
|
#endif // MOZ_SMIL
|
|
|
|
|
2009-07-26 15:05:41 -07:00
|
|
|
// This bit is set to indicate that if the text node changes to
|
|
|
|
// non-whitespace, we may need to create a frame for it. This bit must
|
|
|
|
// not be set on nodes that already have a frame.
|
|
|
|
#define NS_CREATE_FRAME_IF_NON_WHITESPACE (1 << NODE_TYPE_SPECIFIC_BITS_OFFSET)
|
|
|
|
|
|
|
|
// This bit is set to indicate that if the text node changes to
|
|
|
|
// whitespace, we may need to reframe it (or its ancestors).
|
|
|
|
#define NS_REFRAME_IF_WHITESPACE (1 << (NODE_TYPE_SPECIFIC_BITS_OFFSET + 1))
|
|
|
|
|
|
|
|
// This bit is set to indicate that the text may be part of a selection.
|
|
|
|
#define NS_TEXT_IN_SELECTION (1 << (NODE_TYPE_SPECIFIC_BITS_OFFSET + 2))
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
class nsIDOMAttr;
|
|
|
|
class nsIDOMEventListener;
|
|
|
|
class nsIDOMNodeList;
|
|
|
|
class nsIFrame;
|
|
|
|
class nsIDOMText;
|
|
|
|
class nsINodeInfo;
|
|
|
|
class nsURI;
|
|
|
|
|
|
|
|
class nsGenericDOMDataNode : public nsIContent
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
|
|
|
|
|
|
nsGenericDOMDataNode(nsINodeInfo *aNodeInfo);
|
|
|
|
virtual ~nsGenericDOMDataNode();
|
|
|
|
|
|
|
|
// Implementation for nsIDOMNode
|
|
|
|
nsresult GetNodeValue(nsAString& aNodeValue);
|
|
|
|
nsresult SetNodeValue(const nsAString& aNodeValue);
|
|
|
|
nsresult GetAttributes(nsIDOMNamedNodeMap** aAttributes)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aAttributes);
|
|
|
|
*aAttributes = nsnull;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
nsresult HasChildNodes(PRBool* aHasChildNodes)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aHasChildNodes);
|
|
|
|
*aHasChildNodes = PR_FALSE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
nsresult HasAttributes(PRBool* aHasAttributes)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aHasAttributes);
|
|
|
|
*aHasAttributes = PR_FALSE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
nsresult InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild,
|
|
|
|
nsIDOMNode** aReturn)
|
|
|
|
{
|
2010-04-15 01:28:57 -07:00
|
|
|
return ReplaceOrInsertBefore(PR_FALSE, aNewChild, aRefChild, aReturn);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
nsresult ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild,
|
|
|
|
nsIDOMNode** aReturn)
|
|
|
|
{
|
2010-04-15 01:28:57 -07:00
|
|
|
return ReplaceOrInsertBefore(PR_TRUE, aNewChild, aOldChild, aReturn);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
nsresult RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn)
|
|
|
|
{
|
2010-04-15 01:28:57 -07:00
|
|
|
return nsINode::RemoveChild(aOldChild, aReturn);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
nsresult AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aReturn)
|
|
|
|
{
|
2010-04-15 01:28:57 -07:00
|
|
|
return InsertBefore(aNewChild, nsnull, aReturn);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
nsresult GetNamespaceURI(nsAString& aNamespaceURI);
|
|
|
|
nsresult GetLocalName(nsAString& aLocalName);
|
|
|
|
nsresult GetPrefix(nsAString& aPrefix);
|
|
|
|
nsresult SetPrefix(const nsAString& aPrefix);
|
|
|
|
nsresult Normalize();
|
|
|
|
nsresult IsSupported(const nsAString& aFeature,
|
|
|
|
const nsAString& aVersion,
|
|
|
|
PRBool* aReturn);
|
|
|
|
|
|
|
|
// Implementation for nsIDOMCharacterData
|
|
|
|
nsresult GetData(nsAString& aData) const;
|
|
|
|
nsresult SetData(const nsAString& aData);
|
|
|
|
nsresult GetLength(PRUint32* aLength);
|
|
|
|
nsresult SubstringData(PRUint32 aOffset, PRUint32 aCount,
|
|
|
|
nsAString& aReturn);
|
|
|
|
nsresult AppendData(const nsAString& aArg);
|
|
|
|
nsresult InsertData(PRUint32 aOffset, const nsAString& aArg);
|
|
|
|
nsresult DeleteData(PRUint32 aOffset, PRUint32 aCount);
|
|
|
|
nsresult ReplaceData(PRUint32 aOffset, PRUint32 aCount,
|
|
|
|
const nsAString& aArg);
|
|
|
|
|
|
|
|
// nsINode methods
|
|
|
|
virtual PRUint32 GetChildCount() const;
|
|
|
|
virtual nsIContent *GetChildAt(PRUint32 aIndex) const;
|
2008-12-03 06:02:03 -08:00
|
|
|
virtual nsIContent * const * GetChildArray(PRUint32* aChildCount) const;
|
2007-03-22 10:30:00 -07:00
|
|
|
virtual PRInt32 IndexOf(nsINode* aPossibleChild) const;
|
|
|
|
virtual nsresult InsertChildAt(nsIContent* aKid, PRUint32 aIndex,
|
|
|
|
PRBool aNotify);
|
2009-06-28 15:44:22 -07:00
|
|
|
virtual nsresult RemoveChildAt(PRUint32 aIndex, PRBool aNotify, PRBool aMutationEvent = PR_TRUE);
|
2007-03-22 10:30:00 -07:00
|
|
|
virtual nsresult PreHandleEvent(nsEventChainPreVisitor& aVisitor);
|
|
|
|
virtual nsresult PostHandleEvent(nsEventChainPostVisitor& aVisitor);
|
|
|
|
virtual nsresult DispatchDOMEvent(nsEvent* aEvent, nsIDOMEvent* aDOMEvent,
|
|
|
|
nsPresContext* aPresContext,
|
|
|
|
nsEventStatus* aEventStatus);
|
2009-06-23 04:23:52 -07:00
|
|
|
virtual nsIEventListenerManager* GetListenerManager(PRBool aCreateIfNotFound);
|
2007-05-14 02:11:38 -07:00
|
|
|
virtual nsresult AddEventListenerByIID(nsIDOMEventListener *aListener,
|
|
|
|
const nsIID& aIID);
|
|
|
|
virtual nsresult RemoveEventListenerByIID(nsIDOMEventListener *aListener,
|
|
|
|
const nsIID& aIID);
|
|
|
|
virtual nsresult GetSystemEventGroup(nsIDOMEventGroup** aGroup);
|
2009-04-24 02:18:37 -07:00
|
|
|
virtual nsIScriptContext* GetContextForEventHandlers(nsresult* aRv)
|
2008-07-19 08:11:37 -07:00
|
|
|
{
|
2009-04-24 02:18:37 -07:00
|
|
|
return nsContentUtils::GetContextForEventHandlers(this, aRv);
|
2008-07-19 08:11:37 -07:00
|
|
|
}
|
2010-04-19 08:41:33 -07:00
|
|
|
virtual void GetTextContent(nsAString &aTextContent)
|
|
|
|
{
|
|
|
|
#ifdef DEBUG
|
|
|
|
nsresult rv =
|
|
|
|
#endif
|
|
|
|
GetNodeValue(aTextContent);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "GetNodeValue() failed?");
|
|
|
|
}
|
|
|
|
virtual nsresult SetTextContent(const nsAString& aTextContent)
|
|
|
|
{
|
|
|
|
// Batch possible DOMSubtreeModified events.
|
|
|
|
mozAutoSubtreeModified subtree(GetOwnerDoc(), nsnull);
|
|
|
|
return SetNodeValue(aTextContent);
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
// Implementation for nsIContent
|
|
|
|
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
|
|
|
|
nsIContent* aBindingParent,
|
|
|
|
PRBool aCompileEventHandlers);
|
|
|
|
virtual void UnbindFromTree(PRBool aDeep = PR_TRUE,
|
|
|
|
PRBool aNullParent = PR_TRUE);
|
|
|
|
|
2010-02-11 09:34:01 -08:00
|
|
|
virtual already_AddRefed<nsINodeList> GetChildren(PRInt32 aChildType);
|
|
|
|
|
2007-07-26 07:16:19 -07:00
|
|
|
virtual nsIAtom *GetIDAttributeName() const;
|
2007-03-22 10:30:00 -07:00
|
|
|
virtual already_AddRefed<nsINodeInfo> GetExistingAttrNameFromQName(const nsAString& aStr) const;
|
|
|
|
nsresult SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
|
|
|
|
const nsAString& aValue, PRBool aNotify)
|
|
|
|
{
|
|
|
|
return SetAttr(aNameSpaceID, aName, nsnull, aValue, aNotify);
|
|
|
|
}
|
|
|
|
virtual nsresult SetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
|
|
|
|
nsIAtom* aPrefix, const nsAString& aValue,
|
|
|
|
PRBool aNotify);
|
|
|
|
virtual nsresult UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
|
|
|
|
PRBool aNotify);
|
|
|
|
virtual PRBool GetAttr(PRInt32 aNameSpaceID, nsIAtom *aAttribute,
|
|
|
|
nsAString& aResult) const;
|
|
|
|
virtual PRBool HasAttr(PRInt32 aNameSpaceID, nsIAtom *aAttribute) const;
|
|
|
|
virtual const nsAttrName* GetAttrNameAt(PRUint32 aIndex) const;
|
|
|
|
virtual PRUint32 GetAttrCount() const;
|
|
|
|
virtual const nsTextFragment *GetText();
|
|
|
|
virtual PRUint32 TextLength();
|
|
|
|
virtual nsresult SetText(const PRUnichar* aBuffer, PRUint32 aLength,
|
|
|
|
PRBool aNotify);
|
|
|
|
// Need to implement this here too to avoid hiding.
|
|
|
|
nsresult SetText(const nsAString& aStr, PRBool aNotify)
|
|
|
|
{
|
|
|
|
return SetText(aStr.BeginReading(), aStr.Length(), aNotify);
|
|
|
|
}
|
|
|
|
virtual nsresult AppendText(const PRUnichar* aBuffer, PRUint32 aLength,
|
|
|
|
PRBool aNotify);
|
|
|
|
virtual PRBool TextIsOnlyWhitespace();
|
|
|
|
virtual void AppendTextTo(nsAString& aResult);
|
2007-11-30 09:57:03 -08:00
|
|
|
virtual void DestroyContent();
|
2008-04-10 15:47:01 -07:00
|
|
|
virtual void SaveSubtreeState();
|
2009-01-14 20:38:07 -08:00
|
|
|
|
|
|
|
#ifdef MOZ_SMIL
|
2010-03-16 16:17:32 -07:00
|
|
|
virtual nsISMILAttr* GetAnimatedAttr(nsIAtom* /*aName*/)
|
2009-01-14 20:38:07 -08:00
|
|
|
{
|
|
|
|
return nsnull;
|
|
|
|
}
|
2009-09-02 17:28:37 -07:00
|
|
|
virtual nsresult GetSMILOverrideStyle(nsIDOMCSSStyleDeclaration** aStyle);
|
|
|
|
virtual nsICSSStyleRule* GetSMILOverrideStyleRule();
|
|
|
|
virtual nsresult SetSMILOverrideStyleRule(nsICSSStyleRule* aStyleRule,
|
|
|
|
PRBool aNotify);
|
2009-01-14 20:38:07 -08:00
|
|
|
#endif // MOZ_SMIL
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
#ifdef DEBUG
|
|
|
|
virtual void List(FILE* out, PRInt32 aIndent) const;
|
|
|
|
virtual void DumpContent(FILE* out, PRInt32 aIndent, PRBool aDumpAll) const;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
virtual nsIContent *GetBindingParent() const;
|
|
|
|
virtual PRBool IsNodeOfType(PRUint32 aFlags) const;
|
|
|
|
|
|
|
|
virtual already_AddRefed<nsIURI> GetBaseURI() const;
|
|
|
|
virtual PRBool IsLink(nsIURI** aURI) const;
|
|
|
|
|
2010-06-03 18:09:20 -07:00
|
|
|
virtual nsIAtom* DoGetID() const;
|
2008-09-10 20:22:20 -07:00
|
|
|
virtual const nsAttrValue* DoGetClasses() const;
|
2007-03-22 10:30:00 -07:00
|
|
|
NS_IMETHOD WalkContentStyleRules(nsRuleWalker* aRuleWalker);
|
|
|
|
virtual nsICSSStyleRule* GetInlineStyleRule();
|
|
|
|
NS_IMETHOD SetInlineStyleRule(nsICSSStyleRule* aStyleRule, PRBool aNotify);
|
|
|
|
NS_IMETHOD_(PRBool) IsAttributeMapped(const nsIAtom* aAttribute) const;
|
|
|
|
virtual nsChangeHint GetAttributeChangeHint(const nsIAtom* aAttribute,
|
|
|
|
PRInt32 aModType) const;
|
|
|
|
virtual nsIAtom *GetClassAttributeName() const;
|
|
|
|
|
|
|
|
virtual nsresult Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const
|
|
|
|
{
|
|
|
|
*aResult = CloneDataNode(aNodeInfo, PR_TRUE);
|
|
|
|
if (!*aResult) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ADDREF(*aResult);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2008-07-25 03:37:37 -07:00
|
|
|
nsresult SplitData(PRUint32 aOffset, nsIContent** aReturn,
|
|
|
|
PRBool aCloneAfterOriginal = PR_TRUE);
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
//----------------------------------------
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
void ToCString(nsAString& aBuf, PRInt32 aOffset, PRInt32 aLen) const;
|
|
|
|
#endif
|
|
|
|
|
2009-05-12 13:20:42 -07:00
|
|
|
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsGenericDOMDataNode)
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
protected:
|
2010-04-19 08:40:16 -07:00
|
|
|
virtual mozilla::dom::Element* GetNameSpaceElement()
|
|
|
|
{
|
|
|
|
nsINode *parent = GetNodeParent();
|
|
|
|
|
2010-05-06 06:59:55 -07:00
|
|
|
return parent && parent->IsElement() ? parent->AsElement() : nsnull;
|
2010-04-19 08:40:16 -07:00
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
/**
|
|
|
|
* There are a set of DOM- and scripting-specific instance variables
|
|
|
|
* 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 nsDataSlots : public nsINode::nsSlots
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsDataSlots(PtrBits aFlags)
|
|
|
|
: nsINode::nsSlots(aFlags),
|
|
|
|
mBindingParent(nsnull)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The nearest enclosing content node with a binding that created us.
|
|
|
|
* @see nsIContent::GetBindingParent
|
|
|
|
*/
|
|
|
|
nsIContent* mBindingParent; // [Weak]
|
|
|
|
};
|
|
|
|
|
|
|
|
// Override from nsINode
|
|
|
|
virtual nsINode::nsSlots* CreateSlots();
|
|
|
|
|
|
|
|
nsDataSlots *GetDataSlots()
|
|
|
|
{
|
2007-07-08 00:08:04 -07:00
|
|
|
return static_cast<nsDataSlots*>(GetSlots());
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
nsDataSlots *GetExistingDataSlots() const
|
|
|
|
{
|
2007-07-08 00:08:04 -07:00
|
|
|
return static_cast<nsDataSlots*>(GetExistingSlots());
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
nsresult SplitText(PRUint32 aOffset, nsIDOMText** aReturn);
|
|
|
|
|
2008-06-04 10:53:34 -07:00
|
|
|
friend class nsText3Tearoff;
|
|
|
|
|
2008-07-13 12:28:22 -07:00
|
|
|
static PRInt32 FirstLogicallyAdjacentTextNode(nsIContent* aParent,
|
|
|
|
PRInt32 aIndex);
|
2008-06-04 10:53:34 -07:00
|
|
|
|
2008-07-13 12:28:22 -07:00
|
|
|
static PRInt32 LastLogicallyAdjacentTextNode(nsIContent* aParent,
|
|
|
|
PRInt32 aIndex,
|
|
|
|
PRUint32 aCount);
|
2008-06-04 10:53:34 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
nsresult SetTextInternal(PRUint32 aOffset, PRUint32 aCount,
|
|
|
|
const PRUnichar* aBuffer, PRUint32 aLength,
|
|
|
|
PRBool aNotify);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method to clone this node. This needs to be overriden by all derived
|
|
|
|
* classes. If aCloneText is true the text content will be cloned too.
|
|
|
|
*
|
|
|
|
* @param aOwnerDocument the ownerDocument of the clone
|
|
|
|
* @param aCloneText if true the text content will be cloned too
|
|
|
|
* @return the clone
|
|
|
|
*/
|
|
|
|
virtual nsGenericDOMDataNode *CloneDataNode(nsINodeInfo *aNodeInfo,
|
|
|
|
PRBool aCloneText) const = 0;
|
|
|
|
|
|
|
|
nsTextFragment mText;
|
|
|
|
|
|
|
|
private:
|
|
|
|
void SetBidiStatus();
|
|
|
|
|
|
|
|
already_AddRefed<nsIAtom> GetCurrentValueAtom();
|
|
|
|
};
|
|
|
|
|
2010-04-19 08:40:16 -07:00
|
|
|
class nsGenericTextNode : public nsGenericDOMDataNode
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsGenericTextNode(nsINodeInfo *aNodeInfo) : nsGenericDOMDataNode(aNodeInfo)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool IsElementContentWhitespace()
|
|
|
|
{
|
|
|
|
return TextIsOnlyWhitespace();
|
|
|
|
}
|
|
|
|
nsresult GetWholeText(nsAString& aWholeText);
|
|
|
|
|
|
|
|
nsIContent* ReplaceWholeText(const nsAFlatString& aContent,
|
|
|
|
nsresult *aResult);
|
|
|
|
};
|
|
|
|
|
2008-06-04 10:53:34 -07:00
|
|
|
/** Tearoff class for the nsIDOM3Text portion of nsGenericDOMDataNode. */
|
|
|
|
class nsText3Tearoff : public nsIDOM3Text
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
|
|
|
|
|
|
NS_DECL_NSIDOM3TEXT
|
|
|
|
|
|
|
|
NS_DECL_CYCLE_COLLECTION_CLASS(nsText3Tearoff)
|
|
|
|
|
2010-04-19 08:40:16 -07:00
|
|
|
nsText3Tearoff(nsGenericTextNode *aNode) : mNode(aNode)
|
2008-06-04 10:53:34 -07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual ~nsText3Tearoff() {}
|
|
|
|
|
|
|
|
private:
|
2010-04-19 08:40:16 -07:00
|
|
|
nsRefPtr<nsGenericTextNode> mNode;
|
2008-06-04 10:53:34 -07:00
|
|
|
};
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Mostly implement the nsIDOMNode API by forwarding the methods to
|
|
|
|
* nsGenericDOMDataNode
|
|
|
|
*
|
|
|
|
* Note that classes using this macro will need to implement:
|
|
|
|
* NS_IMETHOD GetNodeType(PRUint16* aNodeType);
|
|
|
|
* nsGenericDOMDataNode *CloneDataNode(nsINodeInfo *aNodeInfo,
|
|
|
|
* PRBool aCloneText) const;
|
|
|
|
*/
|
|
|
|
#define NS_IMPL_NSIDOMNODE_USING_GENERIC_DOM_DATA \
|
|
|
|
NS_IMETHOD GetNodeName(nsAString& aNodeName); \
|
|
|
|
NS_IMETHOD GetLocalName(nsAString& aLocalName) { \
|
|
|
|
return nsGenericDOMDataNode::GetLocalName(aLocalName); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetNodeValue(nsAString& aNodeValue); \
|
|
|
|
NS_IMETHOD SetNodeValue(const nsAString& aNodeValue); \
|
|
|
|
NS_IMETHOD GetNodeType(PRUint16* aNodeType); \
|
|
|
|
NS_IMETHOD GetParentNode(nsIDOMNode** aParentNode) { \
|
|
|
|
return nsGenericDOMDataNode::GetParentNode(aParentNode); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetChildNodes(nsIDOMNodeList** aChildNodes) { \
|
|
|
|
return nsGenericDOMDataNode::GetChildNodes(aChildNodes); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD HasChildNodes(PRBool* aHasChildNodes) { \
|
|
|
|
return nsGenericDOMDataNode::HasChildNodes(aHasChildNodes); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD HasAttributes(PRBool* aHasAttributes) { \
|
|
|
|
return nsGenericDOMDataNode::HasAttributes(aHasAttributes); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetFirstChild(nsIDOMNode** aFirstChild) { \
|
|
|
|
return nsGenericDOMDataNode::GetFirstChild(aFirstChild); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetLastChild(nsIDOMNode** aLastChild) { \
|
|
|
|
return nsGenericDOMDataNode::GetLastChild(aLastChild); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetPreviousSibling(nsIDOMNode** aPreviousSibling) { \
|
|
|
|
return nsGenericDOMDataNode::GetPreviousSibling(aPreviousSibling); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetNextSibling(nsIDOMNode** aNextSibling) { \
|
|
|
|
return nsGenericDOMDataNode::GetNextSibling(aNextSibling); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetAttributes(nsIDOMNamedNodeMap** aAttributes) { \
|
|
|
|
return nsGenericDOMDataNode::GetAttributes(aAttributes); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, \
|
|
|
|
nsIDOMNode** aReturn) { \
|
|
|
|
return nsGenericDOMDataNode::InsertBefore(aNewChild, aRefChild, \
|
|
|
|
aReturn); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD AppendChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn) { \
|
|
|
|
return nsGenericDOMDataNode::AppendChild(aOldChild, aReturn); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, \
|
|
|
|
nsIDOMNode** aReturn) { \
|
|
|
|
return nsGenericDOMDataNode::ReplaceChild(aNewChild, aOldChild, \
|
|
|
|
aReturn); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn) { \
|
|
|
|
return nsGenericDOMDataNode::RemoveChild(aOldChild, aReturn); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetOwnerDocument(nsIDOMDocument** aOwnerDocument) { \
|
|
|
|
return nsGenericDOMDataNode::GetOwnerDocument(aOwnerDocument); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetNamespaceURI(nsAString& aNamespaceURI) { \
|
|
|
|
return nsGenericDOMDataNode::GetNamespaceURI(aNamespaceURI); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD GetPrefix(nsAString& aPrefix) { \
|
|
|
|
return nsGenericDOMDataNode::GetPrefix(aPrefix); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD SetPrefix(const nsAString& aPrefix) { \
|
|
|
|
return nsGenericDOMDataNode::SetPrefix(aPrefix); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD Normalize() { \
|
|
|
|
return NS_OK; \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD IsSupported(const nsAString& aFeature, \
|
|
|
|
const nsAString& aVersion, \
|
|
|
|
PRBool* aReturn) { \
|
|
|
|
return nsGenericDOMDataNode::IsSupported(aFeature, aVersion, aReturn); \
|
|
|
|
} \
|
|
|
|
NS_IMETHOD CloneNode(PRBool aDeep, nsIDOMNode** aReturn) { \
|
|
|
|
return nsNodeUtils::CloneNodeImpl(this, aDeep, aReturn); \
|
|
|
|
} \
|
|
|
|
virtual nsGenericDOMDataNode *CloneDataNode(nsINodeInfo *aNodeInfo, \
|
|
|
|
PRBool aCloneText) const;
|
|
|
|
|
|
|
|
#endif /* nsGenericDOMDataNode_h___ */
|