зеркало из https://github.com/mozilla/gecko-dev.git
Bug 561221 - nsDocumentEncoder should not use nsIDOM* interfaces internally, r=sicking
This commit is contained in:
Родитель
dd1503788c
Коммит
b515516d74
|
@ -232,8 +232,8 @@ public:
|
|||
* This method fills the |aArray| with all ancestor nodes of |aNode|
|
||||
* including |aNode| at the zero index.
|
||||
*/
|
||||
static nsresult GetAncestors(nsIDOMNode* aNode,
|
||||
nsTArray<nsIDOMNode*>* aArray);
|
||||
static nsresult GetAncestors(nsINode* aNode,
|
||||
nsTArray<nsINode*>& aArray);
|
||||
|
||||
/*
|
||||
* This method fills |aAncestorNodes| with all ancestor nodes of |aNode|
|
||||
|
|
|
@ -1460,20 +1460,13 @@ nsContentUtils::ContentIsCrossDocDescendantOf(nsINode* aPossibleDescendant,
|
|||
|
||||
// static
|
||||
nsresult
|
||||
nsContentUtils::GetAncestors(nsIDOMNode* aNode,
|
||||
nsTArray<nsIDOMNode*>* aArray)
|
||||
nsContentUtils::GetAncestors(nsINode* aNode,
|
||||
nsTArray<nsINode*>& aArray)
|
||||
{
|
||||
NS_ENSURE_ARG_POINTER(aNode);
|
||||
|
||||
nsCOMPtr<nsIDOMNode> node(aNode);
|
||||
nsCOMPtr<nsIDOMNode> ancestor;
|
||||
|
||||
do {
|
||||
aArray->AppendElement(node.get());
|
||||
node->GetParentNode(getter_AddRefs(ancestor));
|
||||
node.swap(ancestor);
|
||||
} while (node);
|
||||
|
||||
while (aNode) {
|
||||
aArray.AppendElement(aNode);
|
||||
aNode = aNode->GetNodeParent();
|
||||
}
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
|
|
|
@ -62,6 +62,7 @@
|
|||
#include "nsIDOMProcessingInstruction.h"
|
||||
#include "nsIDOMDocumentType.h"
|
||||
#include "nsIDOMNodeList.h"
|
||||
#include "nsIRange.h"
|
||||
#include "nsIDOMRange.h"
|
||||
#include "nsIDOMDocument.h"
|
||||
#include "nsICharsetConverterManager.h"
|
||||
|
@ -98,38 +99,38 @@ public:
|
|||
|
||||
protected:
|
||||
void Initialize();
|
||||
nsresult SerializeNodeStart(nsIDOMNode* aNode, PRInt32 aStartOffset,
|
||||
nsresult SerializeNodeStart(nsINode* aNode, PRInt32 aStartOffset,
|
||||
PRInt32 aEndOffset, nsAString& aStr,
|
||||
nsIDOMNode* aOriginalNode = nsnull);
|
||||
nsresult SerializeToStringRecursive(nsIDOMNode* aNode,
|
||||
nsINode* aOriginalNode = nsnull);
|
||||
nsresult SerializeToStringRecursive(nsINode* aNode,
|
||||
nsAString& aStr,
|
||||
PRBool aDontSerializeRoot);
|
||||
nsresult SerializeNodeEnd(nsIDOMNode* aNode, nsAString& aStr);
|
||||
nsresult SerializeRangeToString(nsIDOMRange *aRange,
|
||||
nsresult SerializeNodeEnd(nsINode* aNode, nsAString& aStr);
|
||||
nsresult SerializeRangeToString(nsIRange *aRange,
|
||||
nsAString& aOutputString);
|
||||
nsresult SerializeRangeNodes(nsIDOMRange* aRange,
|
||||
nsIDOMNode* aNode,
|
||||
nsresult SerializeRangeNodes(nsIRange* aRange,
|
||||
nsINode* aNode,
|
||||
nsAString& aString,
|
||||
PRInt32 aDepth);
|
||||
nsresult SerializeRangeContextStart(const nsTArray<nsIDOMNode*>& aAncestorArray,
|
||||
nsresult SerializeRangeContextStart(const nsTArray<nsINode*>& aAncestorArray,
|
||||
nsAString& aString);
|
||||
nsresult SerializeRangeContextEnd(const nsTArray<nsIDOMNode*>& aAncestorArray,
|
||||
nsresult SerializeRangeContextEnd(const nsTArray<nsINode*>& aAncestorArray,
|
||||
nsAString& aString);
|
||||
|
||||
nsresult FlushText(nsAString& aString, PRBool aForce);
|
||||
|
||||
static PRBool IsTag(nsIDOMNode* aNode, nsIAtom* aAtom);
|
||||
static PRBool IsTag(nsIContent* aContent, nsIAtom* aAtom);
|
||||
|
||||
virtual PRBool IncludeInContext(nsIDOMNode *aNode);
|
||||
virtual PRBool IncludeInContext(nsINode *aNode);
|
||||
|
||||
nsCOMPtr<nsIDocument> mDocument;
|
||||
nsCOMPtr<nsISelection> mSelection;
|
||||
nsCOMPtr<nsIDOMRange> mRange;
|
||||
nsCOMPtr<nsIDOMNode> mNode;
|
||||
nsCOMPtr<nsIRange> mRange;
|
||||
nsCOMPtr<nsINode> mNode;
|
||||
nsCOMPtr<nsIOutputStream> mStream;
|
||||
nsCOMPtr<nsIContentSerializer> mSerializer;
|
||||
nsCOMPtr<nsIUnicodeEncoder> mUnicodeEncoder;
|
||||
nsCOMPtr<nsIDOMNode> mCommonParent;
|
||||
nsCOMPtr<nsINode> mCommonParent;
|
||||
nsCOMPtr<nsIDocumentEncoderNodeFixup> mNodeFixup;
|
||||
nsCOMPtr<nsICharsetConverterManager> mCharsetConverterManager;
|
||||
|
||||
|
@ -141,7 +142,7 @@ protected:
|
|||
PRUint32 mEndDepth;
|
||||
PRInt32 mStartRootIndex;
|
||||
PRInt32 mEndRootIndex;
|
||||
nsAutoTArray<nsIDOMNode*, 8> mCommonAncestors;
|
||||
nsAutoTArray<nsINode*, 8> mCommonAncestors;
|
||||
nsAutoTArray<nsIContent*, 8> mStartNodes;
|
||||
nsAutoTArray<PRInt32, 8> mStartOffsets;
|
||||
nsAutoTArray<nsIContent*, 8> mEndNodes;
|
||||
|
@ -220,7 +221,7 @@ nsDocumentEncoder::SetSelection(nsISelection* aSelection)
|
|||
NS_IMETHODIMP
|
||||
nsDocumentEncoder::SetRange(nsIDOMRange* aRange)
|
||||
{
|
||||
mRange = aRange;
|
||||
mRange = do_QueryInterface(aRange);
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
|
@ -228,7 +229,7 @@ NS_IMETHODIMP
|
|||
nsDocumentEncoder::SetNode(nsIDOMNode* aNode)
|
||||
{
|
||||
mNodeIsContainer = PR_FALSE;
|
||||
mNode = aNode;
|
||||
mNode = do_QueryInterface(aNode);
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
|
@ -236,7 +237,7 @@ NS_IMETHODIMP
|
|||
nsDocumentEncoder::SetContainerNode(nsIDOMNode *aContainer)
|
||||
{
|
||||
mNodeIsContainer = PR_TRUE;
|
||||
mNode = aContainer;
|
||||
mNode = do_QueryInterface(aContainer);
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
|
@ -256,28 +257,33 @@ nsDocumentEncoder::GetMimeType(nsAString& aMimeType)
|
|||
|
||||
|
||||
PRBool
|
||||
nsDocumentEncoder::IncludeInContext(nsIDOMNode *aNode)
|
||||
nsDocumentEncoder::IncludeInContext(nsINode *aNode)
|
||||
{
|
||||
return PR_FALSE;
|
||||
}
|
||||
|
||||
nsresult
|
||||
nsDocumentEncoder::SerializeNodeStart(nsIDOMNode* aNode,
|
||||
nsDocumentEncoder::SerializeNodeStart(nsINode* aNode,
|
||||
PRInt32 aStartOffset,
|
||||
PRInt32 aEndOffset,
|
||||
nsAString& aStr,
|
||||
nsIDOMNode* aOriginalNode)
|
||||
nsINode* aOriginalNode)
|
||||
{
|
||||
PRUint16 type;
|
||||
|
||||
nsCOMPtr<nsIDOMNode> node;
|
||||
nsINode* node = nsnull;
|
||||
nsCOMPtr<nsINode> fixedNodeKungfuDeathGrip;
|
||||
|
||||
// Caller didn't do fixup, so we'll do it ourselves
|
||||
if (!aOriginalNode) {
|
||||
aOriginalNode = aNode;
|
||||
if (mNodeFixup) {
|
||||
PRBool dummy;
|
||||
mNodeFixup->FixupNode(aNode, &dummy, getter_AddRefs(node));
|
||||
nsCOMPtr<nsIDOMNode> domNodeIn = do_QueryInterface(aNode);
|
||||
nsCOMPtr<nsIDOMNode> domNodeOut;
|
||||
mNodeFixup->FixupNode(domNodeIn, &dummy, getter_AddRefs(domNodeOut));
|
||||
fixedNodeKungfuDeathGrip = do_QueryInterface(domNodeOut);
|
||||
node = fixedNodeKungfuDeathGrip;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -286,6 +292,7 @@ nsDocumentEncoder::SerializeNodeStart(nsIDOMNode* aNode,
|
|||
if (!node)
|
||||
node = aNode;
|
||||
|
||||
//XXX Remove QIing to nsIDOM* when fixing bug 562321.
|
||||
node->GetNodeType(&type);
|
||||
switch (type) {
|
||||
case nsIDOMNode::ELEMENT_NODE:
|
||||
|
@ -327,48 +334,47 @@ nsDocumentEncoder::SerializeNodeStart(nsIDOMNode* aNode,
|
|||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
nsresult
|
||||
nsDocumentEncoder::SerializeNodeEnd(nsIDOMNode* aNode,
|
||||
nsDocumentEncoder::SerializeNodeEnd(nsINode* aNode,
|
||||
nsAString& aStr)
|
||||
{
|
||||
PRUint16 type;
|
||||
|
||||
aNode->GetNodeType(&type);
|
||||
switch (type) {
|
||||
case nsIDOMNode::ELEMENT_NODE:
|
||||
{
|
||||
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
|
||||
mSerializer->AppendElementEnd(element, aStr);
|
||||
break;
|
||||
}
|
||||
//XXX Remove QIing to nsIDOM* when fixing bug 562321.
|
||||
if (aNode->IsNodeOfType(nsINode::eELEMENT)) {
|
||||
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
|
||||
mSerializer->AppendElementEnd(element, aStr);
|
||||
}
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
nsresult
|
||||
nsDocumentEncoder::SerializeToStringRecursive(nsIDOMNode* aNode,
|
||||
nsDocumentEncoder::SerializeToStringRecursive(nsINode* aNode,
|
||||
nsAString& aStr,
|
||||
PRBool aDontSerializeRoot)
|
||||
{
|
||||
nsresult rv = NS_OK;
|
||||
PRBool serializeClonedChildren = PR_FALSE;
|
||||
nsCOMPtr<nsIDOMNode> maybeFixedNode;
|
||||
|
||||
if (mNodeFixup)
|
||||
mNodeFixup->FixupNode(aNode, &serializeClonedChildren, getter_AddRefs(maybeFixedNode));
|
||||
nsINode* maybeFixedNode = nsnull;
|
||||
|
||||
// Keep the node from FixupNode alive.
|
||||
nsCOMPtr<nsINode> fixedNodeKungfuDeathGrip;
|
||||
if (mNodeFixup) {
|
||||
nsCOMPtr<nsIDOMNode> domNodeIn = do_QueryInterface(aNode);
|
||||
nsCOMPtr<nsIDOMNode> domNodeOut;
|
||||
mNodeFixup->FixupNode(domNodeIn, &serializeClonedChildren, getter_AddRefs(domNodeOut));
|
||||
fixedNodeKungfuDeathGrip = do_QueryInterface(domNodeOut);
|
||||
maybeFixedNode = fixedNodeKungfuDeathGrip;
|
||||
}
|
||||
|
||||
if (!maybeFixedNode)
|
||||
maybeFixedNode = aNode;
|
||||
|
||||
if (mIsCopying) {
|
||||
nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
|
||||
if (content){
|
||||
nsIFrame* frame = content->GetPrimaryFrame();
|
||||
if (aNode->IsNodeOfType(nsINode::eCONTENT)) {
|
||||
nsIFrame* frame = static_cast<nsIContent*>(aNode)->GetPrimaryFrame();
|
||||
if (frame) {
|
||||
PRBool isSelectable;
|
||||
frame->IsSelectable(&isSelectable, nsnull);
|
||||
|
@ -384,32 +390,11 @@ nsDocumentEncoder::SerializeToStringRecursive(nsIDOMNode* aNode,
|
|||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
|
||||
nsIDOMNode *node;
|
||||
if (serializeClonedChildren)
|
||||
node = maybeFixedNode;
|
||||
else
|
||||
node = aNode;
|
||||
nsINode* node = serializeClonedChildren ? maybeFixedNode : aNode;
|
||||
|
||||
PRBool hasChildren = PR_FALSE;
|
||||
node->HasChildNodes(&hasChildren);
|
||||
|
||||
if (hasChildren) {
|
||||
nsCOMPtr<nsIDOMNodeList> childNodes;
|
||||
rv = node->GetChildNodes(getter_AddRefs(childNodes));
|
||||
NS_ENSURE_TRUE(childNodes, NS_SUCCEEDED(rv) ? NS_ERROR_FAILURE : rv);
|
||||
|
||||
PRInt32 index, count;
|
||||
|
||||
childNodes->GetLength((PRUint32*)&count);
|
||||
for (index = 0; index < count; index++) {
|
||||
nsCOMPtr<nsIDOMNode> child;
|
||||
|
||||
rv = childNodes->Item(index, getter_AddRefs(child));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
rv = SerializeToStringRecursive(child, aStr, PR_FALSE);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
for (nsINode::ChildIterator iter(node); !iter.IsDone(); iter.Next()) {
|
||||
rv = SerializeToStringRecursive(iter, aStr, PR_FALSE);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
|
||||
if (!aDontSerializeRoot) {
|
||||
|
@ -421,10 +406,9 @@ nsDocumentEncoder::SerializeToStringRecursive(nsIDOMNode* aNode,
|
|||
}
|
||||
|
||||
PRBool
|
||||
nsDocumentEncoder::IsTag(nsIDOMNode* aNode, nsIAtom* aAtom)
|
||||
nsDocumentEncoder::IsTag(nsIContent* aContent, nsIAtom* aAtom)
|
||||
{
|
||||
nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
|
||||
return content && content->Tag() == aAtom;
|
||||
return aContent && aContent->Tag() == aAtom;
|
||||
}
|
||||
|
||||
static nsresult
|
||||
|
@ -635,15 +619,9 @@ static nsresult GetNextNode(nsIDOMNode* aNode, nsTArray<PRInt32>& aIndexArray,
|
|||
}
|
||||
#endif
|
||||
|
||||
static PRBool IsTextNode(nsIDOMNode *aNode)
|
||||
static PRBool IsTextNode(nsINode *aNode)
|
||||
{
|
||||
if (!aNode) return PR_FALSE;
|
||||
PRUint16 nodeType;
|
||||
aNode->GetNodeType(&nodeType);
|
||||
if (nodeType == nsIDOMNode::TEXT_NODE ||
|
||||
nodeType == nsIDOMNode::CDATA_SECTION_NODE)
|
||||
return PR_TRUE;
|
||||
return PR_FALSE;
|
||||
return aNode && aNode->IsNodeOfType(nsINode::eTEXT);
|
||||
}
|
||||
|
||||
static nsresult GetLengthOfDOMNode(nsIDOMNode *aNode, PRUint32 &aCount)
|
||||
|
@ -673,8 +651,8 @@ static nsresult GetLengthOfDOMNode(nsIDOMNode *aNode, PRUint32 &aCount)
|
|||
}
|
||||
|
||||
nsresult
|
||||
nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
|
||||
nsIDOMNode* aNode,
|
||||
nsDocumentEncoder::SerializeRangeNodes(nsIRange* aRange,
|
||||
nsINode* aNode,
|
||||
nsAString& aString,
|
||||
PRInt32 aDepth)
|
||||
{
|
||||
|
@ -704,19 +682,18 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
|
|||
{
|
||||
// due to implementation it is impossible for text node to be both start and end of
|
||||
// range. We would have handled that case without getting here.
|
||||
//XXXsmaug What does this all mean?
|
||||
if (IsTextNode(aNode))
|
||||
{
|
||||
if (startNode == content)
|
||||
{
|
||||
PRInt32 startOffset;
|
||||
aRange->GetStartOffset(&startOffset);
|
||||
PRInt32 startOffset = aRange->StartOffset();
|
||||
rv = SerializeNodeStart(aNode, startOffset, -1, aString);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
else
|
||||
{
|
||||
PRInt32 endOffset;
|
||||
aRange->GetEndOffset(&endOffset);
|
||||
PRInt32 endOffset = aRange->EndOffset();
|
||||
rv = SerializeNodeStart(aNode, 0, endOffset, aString);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
|
@ -741,7 +718,7 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
|
|||
|
||||
// do some calculations that will tell us which children of this
|
||||
// node are in the range.
|
||||
nsCOMPtr<nsIDOMNode> childAsNode;
|
||||
nsIContent* childAsNode = nsnull;
|
||||
PRInt32 startOffset = 0, endOffset = -1;
|
||||
if (startNode == content && mStartRootIndex >= aDepth)
|
||||
startOffset = mStartOffsets[mStartRootIndex - aDepth];
|
||||
|
@ -761,9 +738,7 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
|
|||
// intermediate points on the list use the endOffset of the
|
||||
// location of the ancestor, rather than just past it. So we need
|
||||
// to add one here in order to include it in the children we serialize.
|
||||
nsCOMPtr<nsIDOMNode> endParent;
|
||||
aRange->GetEndContainer(getter_AddRefs(endParent));
|
||||
if (aNode != endParent)
|
||||
if (aNode != aRange->GetEndParent())
|
||||
{
|
||||
endOffset++;
|
||||
}
|
||||
|
@ -771,7 +746,7 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
|
|||
// serialize the children of this node that are in the range
|
||||
for (j=startOffset; j<endOffset; j++)
|
||||
{
|
||||
childAsNode = do_QueryInterface(content->GetChildAt(j));
|
||||
childAsNode = content->GetChildAt(j);
|
||||
|
||||
if ((j==startOffset) || (j==endOffset-1))
|
||||
rv = SerializeRangeNodes(aRange, childAsNode, aString, aDepth+1);
|
||||
|
@ -793,14 +768,14 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
|
|||
}
|
||||
|
||||
nsresult
|
||||
nsDocumentEncoder::SerializeRangeContextStart(const nsTArray<nsIDOMNode*>& aAncestorArray,
|
||||
nsDocumentEncoder::SerializeRangeContextStart(const nsTArray<nsINode*>& aAncestorArray,
|
||||
nsAString& aString)
|
||||
{
|
||||
PRInt32 i = aAncestorArray.Length();
|
||||
nsresult rv = NS_OK;
|
||||
|
||||
while (i > 0) {
|
||||
nsIDOMNode *node = aAncestorArray.ElementAt(--i);
|
||||
nsINode *node = aAncestorArray.ElementAt(--i);
|
||||
|
||||
if (!node)
|
||||
break;
|
||||
|
@ -817,7 +792,7 @@ nsDocumentEncoder::SerializeRangeContextStart(const nsTArray<nsIDOMNode*>& aAnce
|
|||
}
|
||||
|
||||
nsresult
|
||||
nsDocumentEncoder::SerializeRangeContextEnd(const nsTArray<nsIDOMNode*>& aAncestorArray,
|
||||
nsDocumentEncoder::SerializeRangeContextEnd(const nsTArray<nsINode*>& aAncestorArray,
|
||||
nsAString& aString)
|
||||
{
|
||||
PRInt32 i = 0;
|
||||
|
@ -825,7 +800,7 @@ nsDocumentEncoder::SerializeRangeContextEnd(const nsTArray<nsIDOMNode*>& aAncest
|
|||
nsresult rv = NS_OK;
|
||||
|
||||
while (i < count) {
|
||||
nsIDOMNode *node = aAncestorArray.ElementAt(i++);
|
||||
nsINode *node = aAncestorArray.ElementAt(i++);
|
||||
|
||||
if (!node)
|
||||
break;
|
||||
|
@ -842,34 +817,24 @@ nsDocumentEncoder::SerializeRangeContextEnd(const nsTArray<nsIDOMNode*>& aAncest
|
|||
}
|
||||
|
||||
nsresult
|
||||
nsDocumentEncoder::SerializeRangeToString(nsIDOMRange *aRange,
|
||||
nsDocumentEncoder::SerializeRangeToString(nsIRange *aRange,
|
||||
nsAString& aOutputString)
|
||||
{
|
||||
if (!aRange)
|
||||
if (!aRange || aRange->Collapsed())
|
||||
return NS_OK;
|
||||
|
||||
PRBool collapsed;
|
||||
|
||||
aRange->GetCollapsed(&collapsed);
|
||||
|
||||
if (collapsed)
|
||||
return NS_OK;
|
||||
|
||||
nsCOMPtr<nsIDOMNode> startParent, endParent;
|
||||
PRInt32 startOffset, endOffset;
|
||||
|
||||
aRange->GetCommonAncestorContainer(getter_AddRefs(mCommonParent));
|
||||
mCommonParent = aRange->GetCommonAncestor();
|
||||
|
||||
if (!mCommonParent)
|
||||
return NS_OK;
|
||||
|
||||
aRange->GetStartContainer(getter_AddRefs(startParent));
|
||||
nsINode* startParent = aRange->GetStartParent();
|
||||
NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
|
||||
aRange->GetStartOffset(&startOffset);
|
||||
PRInt32 startOffset = aRange->StartOffset();
|
||||
|
||||
aRange->GetEndContainer(getter_AddRefs(endParent));
|
||||
nsINode* endParent = aRange->GetEndParent();
|
||||
NS_ENSURE_TRUE(endParent, NS_ERROR_FAILURE);
|
||||
aRange->GetEndOffset(&endOffset);
|
||||
PRInt32 endOffset = aRange->EndOffset();
|
||||
|
||||
mCommonAncestors.Clear();
|
||||
mStartNodes.Clear();
|
||||
|
@ -877,10 +842,12 @@ nsDocumentEncoder::SerializeRangeToString(nsIDOMRange *aRange,
|
|||
mEndNodes.Clear();
|
||||
mEndOffsets.Clear();
|
||||
|
||||
nsContentUtils::GetAncestors(mCommonParent, &mCommonAncestors);
|
||||
nsContentUtils::GetAncestorsAndOffsets(startParent, startOffset,
|
||||
nsContentUtils::GetAncestors(mCommonParent, mCommonAncestors);
|
||||
nsCOMPtr<nsIDOMNode> sp = do_QueryInterface(startParent);
|
||||
nsContentUtils::GetAncestorsAndOffsets(sp, startOffset,
|
||||
&mStartNodes, &mStartOffsets);
|
||||
nsContentUtils::GetAncestorsAndOffsets(endParent, endOffset,
|
||||
nsCOMPtr<nsIDOMNode> ep = do_QueryInterface(endParent);
|
||||
nsContentUtils::GetAncestorsAndOffsets(ep, endOffset,
|
||||
&mEndNodes, &mEndOffsets);
|
||||
|
||||
nsCOMPtr<nsIContent> commonContent = do_QueryInterface(mCommonParent);
|
||||
|
@ -953,23 +920,27 @@ nsDocumentEncoder::EncodeToString(nsAString& aOutputString)
|
|||
NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
|
||||
if (node != prevNode) {
|
||||
if (prevNode) {
|
||||
rv = SerializeNodeEnd(prevNode, aOutputString);
|
||||
nsCOMPtr<nsINode> p = do_QueryInterface(prevNode);
|
||||
rv = SerializeNodeEnd(p, aOutputString);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
prevNode = nsnull;
|
||||
}
|
||||
nsCOMPtr<nsIContent> content = do_QueryInterface(node);
|
||||
if (content && content->Tag() == nsGkAtoms::tr) {
|
||||
rv = SerializeNodeStart(node, 0, -1, aOutputString);
|
||||
nsCOMPtr<nsINode> n = do_QueryInterface(node);
|
||||
rv = SerializeNodeStart(n, 0, -1, aOutputString);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
prevNode = node;
|
||||
}
|
||||
}
|
||||
|
||||
rv = SerializeRangeToString(range, aOutputString);
|
||||
nsCOMPtr<nsIRange> r = do_QueryInterface(range);
|
||||
rv = SerializeRangeToString(r, aOutputString);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
if (prevNode) {
|
||||
rv = SerializeNodeEnd(prevNode, aOutputString);
|
||||
nsCOMPtr<nsINode> p = do_QueryInterface(prevNode);
|
||||
rv = SerializeNodeEnd(p, aOutputString);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
}
|
||||
|
||||
|
@ -986,9 +957,7 @@ nsDocumentEncoder::EncodeToString(nsAString& aOutputString)
|
|||
rv = mSerializer->AppendDocumentStart(domdoc, aOutputString);
|
||||
|
||||
if (NS_SUCCEEDED(rv)) {
|
||||
nsCOMPtr<nsIDOMNode> doc(do_QueryInterface(mDocument));
|
||||
|
||||
rv = SerializeToStringRecursive(doc, aOutputString, PR_FALSE);
|
||||
rv = SerializeToStringRecursive(mDocument, aOutputString, PR_FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1099,7 +1068,7 @@ protected:
|
|||
PRBool IsFirstNode(nsIDOMNode *aNode);
|
||||
PRBool IsLastNode(nsIDOMNode *aNode);
|
||||
PRBool IsEmptyTextContent(nsIDOMNode* aNode);
|
||||
virtual PRBool IncludeInContext(nsIDOMNode *aNode);
|
||||
virtual PRBool IncludeInContext(nsINode *aNode);
|
||||
|
||||
PRBool mIsTextWidget;
|
||||
};
|
||||
|
@ -1274,7 +1243,7 @@ nsHTMLCopyEncoder::EncodeToStringWithContext(nsAString& aContextString,
|
|||
// leaf of ancestors might be text node. If so discard it.
|
||||
PRInt32 count = mCommonAncestors.Length();
|
||||
PRInt32 i;
|
||||
nsCOMPtr<nsIDOMNode> node;
|
||||
nsCOMPtr<nsINode> node;
|
||||
if (count > 0)
|
||||
node = mCommonAncestors.ElementAt(0);
|
||||
|
||||
|
@ -1315,7 +1284,7 @@ nsHTMLCopyEncoder::EncodeToStringWithContext(nsAString& aContextString,
|
|||
|
||||
|
||||
PRBool
|
||||
nsHTMLCopyEncoder::IncludeInContext(nsIDOMNode *aNode)
|
||||
nsHTMLCopyEncoder::IncludeInContext(nsINode *aNode)
|
||||
{
|
||||
nsCOMPtr<nsIContent> content(do_QueryInterface(aNode));
|
||||
|
||||
|
@ -1471,7 +1440,8 @@ nsHTMLCopyEncoder::GetPromotedPoint(Endpoint aWhere, nsIDOMNode *aNode, PRInt32
|
|||
if (aWhere == kStart)
|
||||
{
|
||||
// some special casing for text nodes
|
||||
if (IsTextNode(aNode))
|
||||
nsCOMPtr<nsINode> t = do_QueryInterface(aNode);
|
||||
if (IsTextNode(t))
|
||||
{
|
||||
// if not at beginning of text node, we are done
|
||||
if (offset > 0)
|
||||
|
@ -1551,7 +1521,8 @@ nsHTMLCopyEncoder::GetPromotedPoint(Endpoint aWhere, nsIDOMNode *aNode, PRInt32
|
|||
if (aWhere == kEnd)
|
||||
{
|
||||
// some special casing for text nodes
|
||||
if (IsTextNode(aNode))
|
||||
nsCOMPtr<nsINode> n = do_QueryInterface(aNode);
|
||||
if (IsTextNode(n))
|
||||
{
|
||||
// if not at end of text node, we are done
|
||||
PRUint32 len;
|
||||
|
@ -1653,7 +1624,8 @@ nsHTMLCopyEncoder::GetChildAt(nsIDOMNode *aParent, PRInt32 aOffset)
|
|||
PRBool
|
||||
nsHTMLCopyEncoder::IsMozBR(nsIDOMNode* aNode)
|
||||
{
|
||||
if (IsTag(aNode, nsGkAtoms::br))
|
||||
nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
|
||||
if (IsTag(content, nsGkAtoms::br))
|
||||
{
|
||||
nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(aNode);
|
||||
if (elem)
|
||||
|
@ -1696,14 +1668,15 @@ nsHTMLCopyEncoder::GetNodeLocation(nsIDOMNode *inChild,
|
|||
PRBool
|
||||
nsHTMLCopyEncoder::IsRoot(nsIDOMNode* aNode)
|
||||
{
|
||||
if (aNode)
|
||||
nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
|
||||
if (content)
|
||||
{
|
||||
if (mIsTextWidget)
|
||||
return (IsTag(aNode, nsGkAtoms::div));
|
||||
else
|
||||
return (IsTag(aNode, nsGkAtoms::body) ||
|
||||
IsTag(aNode, nsGkAtoms::td) ||
|
||||
IsTag(aNode, nsGkAtoms::th));
|
||||
return (IsTag(content, nsGkAtoms::div));
|
||||
|
||||
return (IsTag(content, nsGkAtoms::body) ||
|
||||
IsTag(content, nsGkAtoms::td) ||
|
||||
IsTag(content, nsGkAtoms::th));
|
||||
}
|
||||
return PR_FALSE;
|
||||
}
|
||||
|
|
Загрузка…
Ссылка в новой задаче