void txMozillaXMLOutput::endDocument(nsresult aResult)
{
closePrevious(eCloseElement | eFlushText);
// This should really be handled by nsIDocument::Reset
if (mCreatingNewDocument && !mHaveTitleElement) {
nsCOMPtr<nsIDOMNSDocument> domDoc = do_QueryInterface(mDocument);
if (domDoc) {
domDoc->SetTitle(EmptyString());
}
}
if (!mRefreshString.IsEmpty()) {
nsCOMPtr<nsIDocument> doc = do_QueryInterface(mDocument);
nsIScriptGlobalObject *sgo = doc->GetScriptGlobalObject();
if (sgo) {
nsCOMPtr<nsIRefreshURI> refURI =
do_QueryInterface(sgo->GetDocShell());
if (refURI) {
refURI->SetupRefreshURIFromHeader(doc->GetBaseURI(),
mRefreshString);
}
}
}
if (mNotifier) {
mNotifier->OnTransformEnd(aResult);
}
}
void txMozillaXMLOutput::characters(const nsAString& aData, PRBool aDOE)
{
closePrevious(eCloseElement);
if (mBadChildLevel) {
return;
}
mText.Append(aData);
}
nsresult
txMozillaXMLOutput::characters(const nsSubstring& aData, PRBool aDOE)
{
nsresult rv = closePrevious(PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
if (!mBadChildLevel) {
mText.Append(aData);
}
return NS_OK;
}
void txMozillaXMLOutput::comment(const nsAString& aData)
{
closePrevious(eCloseElement | eFlushText);
if (mBadChildLevel) {
return;
}
TX_ENSURE_CURRENTNODE;
nsCOMPtr<nsIDOMComment> comment;
nsresult rv = mDocument->CreateComment(aData,
getter_AddRefs(comment));
NS_ASSERTION(NS_SUCCEEDED(rv), "Can't create comment");
nsCOMPtr<nsIDOMNode> resultNode;
rv = mCurrentNode->AppendChild(comment, getter_AddRefs(resultNode));
NS_ASSERTION(NS_SUCCEEDED(rv), "Can't append comment");
}
nsresult
txMozillaXMLOutput::processingInstruction(const nsString& aTarget, const nsString& aData)
{
nsresult rv = closePrevious(PR_TRUE);
NS_ENSURE_SUCCESS(rv, rv);
if (mOutputFormat.mMethod == eHTMLOutput)
return NS_OK;
TX_ENSURE_CURRENTNODE;
rv = nsContentUtils::CheckQName(aTarget, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIContent> pi;
rv = NS_NewXMLProcessingInstruction(getter_AddRefs(pi),
mNodeInfoManager, aTarget, aData);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStyleSheetLinkingElement> ssle;
if (mCreatingNewDocument) {
ssle = do_QueryInterface(pi);
if (ssle) {
ssle->InitStyleLinkElement(PR_FALSE);
ssle->SetEnableUpdates(PR_FALSE);
}
}
rv = mCurrentNode->AppendChildTo(pi, PR_TRUE);
NS_ENSURE_SUCCESS(rv, rv);
if (ssle) {
ssle->SetEnableUpdates(PR_TRUE);
PRBool willNotify;
PRBool isAlternate;
rv = ssle->UpdateStyleSheet(mNotifier, &willNotify, &isAlternate);
if (mNotifier && NS_SUCCEEDED(rv) && willNotify && !isAlternate) {
mNotifier->AddPendingStylesheet();
}
}
return NS_OK;
}
void txMozillaXMLOutput::processingInstruction(const nsAString& aTarget, const nsAString& aData)
{
if (mOutputFormat.mMethod == eHTMLOutput)
return;
closePrevious(eCloseElement | eFlushText);
TX_ENSURE_CURRENTNODE;
nsCOMPtr<nsIDOMProcessingInstruction> pi;
nsresult rv = mDocument->CreateProcessingInstruction(aTarget, aData,
getter_AddRefs(pi));
NS_ASSERTION(NS_SUCCEEDED(rv), "Can't create processing instruction");
if (NS_FAILED(rv))
return;
nsCOMPtr<nsIStyleSheetLinkingElement> ssle;
if (mCreatingNewDocument) {
ssle = do_QueryInterface(pi);
if (ssle) {
ssle->InitStyleLinkElement(nsnull, PR_FALSE);
ssle->SetEnableUpdates(PR_FALSE);
}
}
nsCOMPtr<nsIDOMNode> resultNode;
rv = mCurrentNode->AppendChild(pi, getter_AddRefs(resultNode));
NS_ASSERTION(NS_SUCCEEDED(rv), "Can't append processing instruction");
if (NS_FAILED(rv))
return;
if (ssle) {
ssle->SetEnableUpdates(PR_TRUE);
rv = ssle->UpdateStyleSheet(nsnull, mNotifier);
if (rv == NS_ERROR_HTMLPARSER_BLOCK) {
nsCOMPtr<nsIStyleSheet> stylesheet;
ssle->GetStyleSheet(*getter_AddRefs(stylesheet));
if (mNotifier) {
mNotifier->AddStyleSheet(stylesheet);
}
}
}
}
nsresult
txMozillaXMLOutput::endDocument(nsresult aResult)
{
TX_ENSURE_CURRENTNODE;
if (NS_FAILED(aResult)) {
if (mNotifier) {
mNotifier->OnTransformEnd(aResult);
}
return NS_OK;
}
nsresult rv = closePrevious(PR_TRUE);
if (NS_FAILED(rv)) {
if (mNotifier) {
mNotifier->OnTransformEnd(rv);
}
return rv;
}
// This should really be handled by nsIDocument::EndLoad
mDocument->SetReadyStateInternal(nsIDocument::READYSTATE_INTERACTIVE);
if (!mRefreshString.IsEmpty()) {
nsPIDOMWindow *win = mDocument->GetWindow();
if (win) {
nsCOMPtr<nsIRefreshURI> refURI =
do_QueryInterface(win->GetDocShell());
if (refURI) {
refURI->SetupRefreshURIFromHeader(mDocument->GetDocBaseURI(),
mRefreshString);
}
}
}
if (mNotifier) {
mNotifier->OnTransformEnd();
}
return NS_OK;
}
nsresult
txMozillaXMLOutput::comment(const nsString& aData)
{
nsresult rv = closePrevious(PR_TRUE);
NS_ENSURE_SUCCESS(rv, rv);
if (mBadChildLevel) {
return NS_OK;
}
TX_ENSURE_CURRENTNODE;
nsCOMPtr<nsIContent> comment;
rv = NS_NewCommentNode(getter_AddRefs(comment), mNodeInfoManager);
NS_ENSURE_SUCCESS(rv, rv);
rv = comment->SetText(aData, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
return mCurrentNode->AppendChildTo(comment, PR_TRUE);
}
nsresult
txMozillaXMLOutput::startElementInternal(nsIAtom* aPrefix,
nsIAtom* aLocalName,
PRInt32 aNsID)
{
TX_ENSURE_CURRENTNODE;
if (mBadChildLevel) {
++mBadChildLevel;
PR_LOG(txLog::xslt, PR_LOG_DEBUG,
("startElement, mBadChildLevel = %d\n", mBadChildLevel));
return NS_OK;
}
nsresult rv = closePrevious(PR_TRUE);
NS_ENSURE_SUCCESS(rv, rv);
// Push and init state
if (mTreeDepth == MAX_REFLOW_DEPTH) {
// eCloseElement couldn't add the parent so we fail as well or we've
// reached the limit of the depth of the tree that we allow.
++mBadChildLevel;
PR_LOG(txLog::xslt, PR_LOG_DEBUG,
("startElement, mBadChildLevel = %d\n", mBadChildLevel));
return NS_OK;
}
++mTreeDepth;
rv = mTableStateStack.push(NS_INT32_TO_PTR(mTableState));
NS_ENSURE_SUCCESS(rv, rv);
if (!mCurrentNodeStack.AppendObject(mCurrentNode)) {
return NS_ERROR_OUT_OF_MEMORY;
}
mTableState = NORMAL;
mOpenedElementIsHTML = PR_FALSE;
// Create the element
nsCOMPtr<nsINodeInfo> ni;
ni = mNodeInfoManager->GetNodeInfo(aLocalName, aPrefix, aNsID);
NS_ENSURE_TRUE(ni, NS_ERROR_OUT_OF_MEMORY);
NS_NewElement(getter_AddRefs(mOpenedElement), aNsID, ni.forget(), PR_FALSE);
// Set up the element and adjust state
if (!mNoFixup) {
if (aNsID == kNameSpaceID_XHTML) {
mOpenedElementIsHTML = (mOutputFormat.mMethod == eHTMLOutput);
rv = startHTMLElement(mOpenedElement, mOpenedElementIsHTML);
NS_ENSURE_SUCCESS(rv, rv);
}
}
if (mCreatingNewDocument) {
// Handle all sorts of stylesheets
nsCOMPtr<nsIStyleSheetLinkingElement> ssle =
do_QueryInterface(mOpenedElement);
if (ssle) {
ssle->InitStyleLinkElement(PR_FALSE);
ssle->SetEnableUpdates(PR_FALSE);
}
}
return NS_OK;
}
nsresult
txMozillaXMLOutput::endElement()
{
TX_ENSURE_CURRENTNODE;
if (mBadChildLevel) {
--mBadChildLevel;
PR_LOG(txLog::xslt, PR_LOG_DEBUG,
("endElement, mBadChildLevel = %d\n", mBadChildLevel));
return NS_OK;
}
--mTreeDepth;
nsresult rv = closePrevious(PR_TRUE);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(mCurrentNode->IsElement(), "borked mCurrentNode");
NS_ENSURE_TRUE(mCurrentNode->IsElement(), NS_ERROR_UNEXPECTED);
nsIContent* element = static_cast<nsIContent*>
(static_cast<nsINode*>
(mCurrentNode));
// Handle html-elements
if (!mNoFixup) {
if (element->IsHTML()) {
rv = endHTMLElement(element);
NS_ENSURE_SUCCESS(rv, rv);
}
// Handle script elements
if (element->Tag() == nsGkAtoms::script &&
(element->IsHTML() ||
element->GetNameSpaceID() == kNameSpaceID_SVG)) {
rv = element->DoneAddingChildren(PR_TRUE);
// If the act of insertion evaluated the script, we're fine.
// Else, add this script element to the array of loading scripts.
if (rv == NS_ERROR_HTMLPARSER_BLOCK) {
nsCOMPtr<nsIScriptElement> sele = do_QueryInterface(element);
rv = mNotifier->AddScriptElement(sele);
NS_ENSURE_SUCCESS(rv, rv);
}
}
}
if (mCreatingNewDocument) {
// Handle all sorts of stylesheets
nsCOMPtr<nsIStyleSheetLinkingElement> ssle =
do_QueryInterface(mCurrentNode);
if (ssle) {
ssle->SetEnableUpdates(PR_TRUE);
PRBool willNotify;
PRBool isAlternate;
nsresult rv = ssle->UpdateStyleSheet(mNotifier, &willNotify,
&isAlternate);
if (mNotifier && NS_SUCCEEDED(rv) && willNotify && !isAlternate) {
mNotifier->AddPendingStylesheet();
}
}
}
// Add the element to the tree if it wasn't added before and take one step
// up the tree
PRUint32 last = mCurrentNodeStack.Count() - 1;
NS_ASSERTION(last != (PRUint32)-1, "empty stack");
nsCOMPtr<nsINode> parent = mCurrentNodeStack.SafeObjectAt(last);
mCurrentNodeStack.RemoveObjectAt(last);
if (mCurrentNode == mNonAddedNode) {
if (parent == mDocument) {
NS_ASSERTION(!mRootContentCreated,
"Parent to add to shouldn't be a document if we "
"have a root content");
mRootContentCreated = PR_TRUE;
}
// Check to make sure that script hasn't inserted the node somewhere
// else in the tree
if (!mCurrentNode->GetNodeParent()) {
parent->AppendChildTo(mNonAddedNode, PR_TRUE);
}
mNonAddedNode = nsnull;
}
mCurrentNode = parent;
mTableState =
static_cast<TableState>(NS_PTR_TO_INT32(mTableStateStack.pop()));
return NS_OK;
}
void txMozillaXMLOutput::startElement(const nsAString& aName,
const PRInt32 aNsID)
{
TX_ENSURE_CURRENTNODE;
if (mBadChildLevel) {
++mBadChildLevel;
PR_LOG(txLog::xslt, PR_LOG_DEBUG,
("startElement, mBadChildLevel = %d\n", mBadChildLevel));
return;
}
closePrevious(eCloseElement | eFlushText);
if (mBadChildLevel || mTreeDepth == MAX_REFLOW_DEPTH) {
// eCloseElement couldn't add the parent so we fail as well or we've
// reached the limit of the depth of the tree that we allow.
++mBadChildLevel;
PR_LOG(txLog::xslt, PR_LOG_DEBUG,
("startElement, mBadChildLevel = %d\n", mBadChildLevel));
return;
}
++mTreeDepth;
nsresult rv = mTableStateStack.push(NS_INT32_TO_PTR(mTableState));
if (NS_FAILED(rv)) {
return;
}
mTableState = NORMAL;
nsCOMPtr<nsIDOMElement> element;
mDontAddCurrent = PR_FALSE;
if ((mOutputFormat.mMethod == eHTMLOutput) && (aNsID == kNameSpaceID_None)) {
if (mDocumentIsHTML) {
rv = mDocument->CreateElement(aName,
getter_AddRefs(element));
}
else {
nsAutoString lcname;
ToLowerCase(aName, lcname);
rv = mDocument->CreateElementNS(NS_LITERAL_STRING(kXHTMLNameSpaceURI),
lcname,
getter_AddRefs(element));
}
if (NS_FAILED(rv)) {
return;
}
startHTMLElement(element, PR_FALSE);
}
else {
nsAutoString nsURI;
gTxNameSpaceManager->GetNameSpaceURI(aNsID, nsURI);
rv = mDocument->CreateElementNS(nsURI, aName,
getter_AddRefs(element));
NS_ASSERTION(NS_SUCCEEDED(rv), "Can't create element");
if (NS_FAILED(rv)) {
return;
}
if (aNsID == kNameSpaceID_XHTML) {
startHTMLElement(element, PR_TRUE);
} else if (aNsID == kNameSpaceID_SVG &&
txHTMLAtoms::script->Equals(aName)) {
mDontAddCurrent = PR_TRUE;
}
}
if (mCreatingNewDocument) {
// Handle all sorts of stylesheets
nsCOMPtr<nsIStyleSheetLinkingElement> ssle =
do_QueryInterface(element);
if (ssle) {
ssle->InitStyleLinkElement(nsnull, PR_FALSE);
ssle->SetEnableUpdates(PR_FALSE);
}
}
mParentNode = mCurrentNode;
mCurrentNode = do_QueryInterface(element);
}
void txMozillaXMLOutput::endElement(const nsAString& aName, const PRInt32 aNsID)
{
TX_ENSURE_CURRENTNODE;
if (mBadChildLevel) {
--mBadChildLevel;
PR_LOG(txLog::xslt, PR_LOG_DEBUG,
("endElement, mBadChildLevel = %d\n", mBadChildLevel));
return;
}
--mTreeDepth;
#ifdef DEBUG
if (mTableState != ADDED_TBODY) {
nsAutoString nodeName;
mCurrentNode->GetNodeName(nodeName);
NS_ASSERTION(nodeName.Equals(aName,
nsCaseInsensitiveStringComparator()),
"Unbalanced startElement and endElement calls!");
}
else {
nsCOMPtr<nsIDOMNode> parent;
mCurrentNode->GetParentNode(getter_AddRefs(parent));
nsAutoString nodeName;
parent->GetNodeName(nodeName);
NS_ASSERTION(nodeName.Equals(aName,
nsCaseInsensitiveStringComparator()),
"Unbalanced startElement and endElement calls!");
}
#endif
closePrevious(eCloseElement | eFlushText);
// Handle html-elements
if ((mOutputFormat.mMethod == eHTMLOutput && aNsID == kNameSpaceID_None) ||
aNsID == kNameSpaceID_XHTML) {
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(mCurrentNode);
NS_ASSERTION(element, "endElement'ing non-element");
endHTMLElement(element);
}
// Handle svg script elements
if (aNsID == kNameSpaceID_SVG && txHTMLAtoms::script->Equals(aName)) {
// Add this script element to the array of loading script elements.
nsCOMPtr<nsIScriptElement> scriptElement =
do_QueryInterface(mCurrentNode);
NS_ASSERTION(scriptElement, "Need script element");
mNotifier->AddScriptElement(scriptElement);
}
if (mCreatingNewDocument) {
// Handle all sorts of stylesheets
nsCOMPtr<nsIStyleSheetLinkingElement> ssle =
do_QueryInterface(mCurrentNode);
if (ssle) {
ssle->SetEnableUpdates(PR_TRUE);
if (ssle->UpdateStyleSheet(nsnull, mNotifier) ==
NS_ERROR_HTMLPARSER_BLOCK) {
nsCOMPtr<nsIStyleSheet> stylesheet;
ssle->GetStyleSheet(*getter_AddRefs(stylesheet));
if (mNotifier) {
mNotifier->AddStyleSheet(stylesheet);
}
}
}
}
// Add the element to the tree if it wasn't added before and take one step
// up the tree
// we can't use GetParentNode to check if mCurrentNode is the
// "non-added node" since that does strange things when we've called
// BindToTree manually
if (mCurrentNode == mNonAddedNode) {
nsCOMPtr<nsIDocument> document = do_QueryInterface(mNonAddedParent);
if (document && !mRootContent) {
mRootContent = do_QueryInterface(mCurrentNode);
// XXXbz what to do on failure here?
document->SetRootContent(mRootContent);
}
else {
nsCOMPtr<nsIDOMNode> resultNode;
mNonAddedParent->AppendChild(mCurrentNode,
getter_AddRefs(resultNode));
}
mCurrentNode = mNonAddedParent;
mNonAddedParent = nsnull;
mNonAddedNode = nsnull;
}
else {
nsCOMPtr<nsIDOMNode> parent;
mCurrentNode->GetParentNode(getter_AddRefs(parent));
mCurrentNode = parent;
}
mTableState =
NS_STATIC_CAST(TableState, NS_PTR_TO_INT32(mTableStateStack.pop()));
}
