diff options
Diffstat (limited to 'dom/xul/templates/nsXULContentBuilder.cpp')
| -rw-r--r-- | dom/xul/templates/nsXULContentBuilder.cpp | 1976 |
1 files changed, 1976 insertions, 0 deletions
diff --git a/dom/xul/templates/nsXULContentBuilder.cpp b/dom/xul/templates/nsXULContentBuilder.cpp new file mode 100644 index 000000000..71c285cc4 --- /dev/null +++ b/dom/xul/templates/nsXULContentBuilder.cpp @@ -0,0 +1,1976 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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/. */ + +#include "mozilla/ArrayUtils.h" + +#include "nsContentCID.h" +#include "nsIDocument.h" +#include "nsIDOMNodeList.h" +#include "nsIDOMXULDocument.h" +#include "mozilla/dom/NodeInfo.h" +#include "nsIServiceManager.h" +#include "nsIXULDocument.h" + +#include "nsContentSupportMap.h" +#include "nsRDFConMemberTestNode.h" +#include "nsRDFPropertyTestNode.h" +#include "nsXULSortService.h" +#include "nsTemplateRule.h" +#include "nsTemplateMap.h" +#include "nsTArray.h" +#include "nsXPIDLString.h" +#include "nsGkAtoms.h" +#include "nsXULContentUtils.h" +#include "nsXULElement.h" +#include "nsXULTemplateBuilder.h" +#include "nsNodeInfoManager.h" +#include "nsContentCreatorFunctions.h" +#include "nsContentUtils.h" +#include "nsAttrName.h" +#include "nsNodeUtils.h" +#include "mozAutoDocUpdate.h" +#include "nsTextNode.h" +#include "mozilla/dom/Element.h" + +#include "PLDHashTable.h" +#include "rdf.h" + +using namespace mozilla; +using namespace mozilla::dom; + +//---------------------------------------------------------------------- +// +// Return values for EnsureElementHasGenericChild() +// +#define NS_ELEMENT_GOT_CREATED NS_RDF_NO_VALUE +#define NS_ELEMENT_WAS_THERE NS_OK + +//---------------------------------------------------------------------- +// +// nsXULContentBuilder +// + +/** + * The content builder generates DOM nodes from a template. The actual content + * generation is done entirely inside BuildContentFromTemplate. + * + * Content generation is centered around the generation node (the node with + * uri="?member" on it). Nodes above the generation node are unique and + * generated only once. BuildContentFromTemplate will be passed the unique + * flag as an argument for content at this point and will recurse until it + * finds the generation node. + * + * Once the generation node has been found, the results for that content node + * are added to the content map, stored in mContentSupportMap. + * + * If recursion is allowed, generation continues, where the generation node + * becomes the container to insert into. + */ +class nsXULContentBuilder : public nsXULTemplateBuilder +{ +public: + // nsIXULTemplateBuilder interface + NS_IMETHOD CreateContents(nsIContent* aElement, bool aForceCreation) override; + + NS_IMETHOD HasGeneratedContent(nsIRDFResource* aResource, + nsIAtom* aTag, + bool* aGenerated) override; + + NS_IMETHOD GetResultForContent(nsIDOMElement* aContent, + nsIXULTemplateResult** aResult) override; + + // nsIMutationObserver interface + NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED + NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED + +protected: + friend nsresult + NS_NewXULContentBuilder(nsISupports* aOuter, REFNSIID aIID, void** aResult); + + nsXULContentBuilder(); + + void Traverse(nsCycleCollectionTraversalCallback& aCb) const override + { + mSortState.Traverse(aCb); + } + + virtual void Uninit(bool aIsFinal) override; + + // Implementation methods + nsresult + OpenContainer(nsIContent* aElement); + + nsresult + CloseContainer(nsIContent* aElement); + + /** + * Build content from a template for a given result. This will be called + * recursively or on demand and will be called for every node in the + * generated content tree. + */ + nsresult + BuildContentFromTemplate(nsIContent *aTemplateNode, + nsIContent *aResourceNode, + nsIContent *aRealNode, + bool aIsUnique, + bool aIsSelfReference, + nsIXULTemplateResult* aChild, + bool aNotify, + nsTemplateMatch* aMatch, + nsIContent** aContainer, + int32_t* aNewIndexInContainer); + + /** + * Copy the attributes from the template node to the node generated + * from it, performing any substitutions. + * + * @param aTemplateNode node within template + * @param aRealNode generated node to set attibutes upon + * @param aResult result to look up variable->value bindings in + * @param aNotify true to notify of DOM changes + */ + nsresult + CopyAttributesToElement(nsIContent* aTemplateNode, + nsIContent* aRealNode, + nsIXULTemplateResult* aResult, + bool aNotify); + + /** + * Add any necessary persistent attributes (persist="...") from the + * local store to a generated node. + * + * @param aTemplateNode node within template + * @param aRealNode generated node to set persisted attibutes upon + * @param aResult result to look up variable->value bindings in + */ + nsresult + AddPersistentAttributes(Element* aTemplateNode, + nsIXULTemplateResult* aResult, + nsIContent* aRealNode); + + /** + * Recalculate any attributes that have variable references. This will + * be called when a binding has been changed to update the attributes. + * The attributes are copied from the node aTemplateNode in the template + * to the generated node aRealNode, using the values from the result + * aResult. This method will operate recursively. + * + * @param aTemplateNode node within template + * @param aRealNode generated node to set attibutes upon + * @param aResult result to look up variable->value bindings in + */ + nsresult + SynchronizeUsingTemplate(nsIContent *aTemplateNode, + nsIContent* aRealNode, + nsIXULTemplateResult* aResult); + + /** + * Remove the generated node aContent from the DOM and the hashtables + * used by the content builder. + */ + nsresult + RemoveMember(nsIContent* aContent); + + /** + * Create the appropriate generated content for aElement, by calling + * CreateContainerContents. + * + * @param aElement element to generate content inside + * @param aForceCreation true to force creation for closed items such as menus + */ + nsresult + CreateTemplateAndContainerContents(nsIContent* aElement, + bool aForceCreation); + + /** + * Generate the results for a template, by calling + * CreateContainerContentsForQuerySet for each queryset. + * + * @param aElement element to generate content inside + * @param aResult reference point for query + * @param aForceCreation true to force creation for closed items such as menus + * @param aNotify true to notify of DOM changes as each element is inserted + * @param aNotifyAtEnd notify at the end of all DOM changes + */ + nsresult + CreateContainerContents(nsIContent* aElement, + nsIXULTemplateResult* aResult, + bool aForceCreation, + bool aNotify, + bool aNotifyAtEnd); + + /** + * Generate the results for a query. + * + * @param aElement element to generate content inside + * @param aResult reference point for query + * @param aNotify true to notify of DOM changes + * @param aContainer container content was added inside + * @param aNewIndexInContainer index with container in which content was added + */ + nsresult + CreateContainerContentsForQuerySet(nsIContent* aElement, + nsIXULTemplateResult* aResult, + bool aNotify, + nsTemplateQuerySet* aQuerySet, + nsIContent** aContainer, + int32_t* aNewIndexInContainer); + + /** + * Check if an element with a particular tag exists with a container. + * If it is not present, append a new element with that tag into the + * container. + * + * @param aParent parent container + * @param aNameSpaceID namespace of tag to locate or create + * @param aTag tag to locate or create + * @param aNotify true to notify of DOM changes + * @param aResult set to the found or created node. + */ + nsresult + EnsureElementHasGenericChild(nsIContent* aParent, + int32_t aNameSpaceID, + nsIAtom* aTag, + bool aNotify, + nsIContent** aResult); + + bool + IsOpen(nsIContent* aElement); + + nsresult + RemoveGeneratedContent(nsIContent* aElement); + + nsresult + GetElementsForResult(nsIXULTemplateResult* aResult, + nsCOMArray<nsIContent>& aElements); + + nsresult + CreateElement(int32_t aNameSpaceID, + nsIAtom* aTag, + Element** aResult); + + /** + * Set the container and empty attributes on a node. If + * aIgnoreNonContainers is true, then the element is not changed + * for non-containers. Otherwise, the container attribute will be set to + * false. + * + * @param aElement element to set attributes on + * @param aResult result to use to determine state of attributes + * @param aIgnoreNonContainers true to not change for non-containers + * @param aNotify true to notify of DOM changes + */ + nsresult + SetContainerAttrs(nsIContent *aElement, + nsIXULTemplateResult* aResult, + bool aIgnoreNonContainers, + bool aNotify); + + virtual nsresult + RebuildAll() override; + + // GetInsertionLocations, ReplaceMatch and SynchronizeResult are inherited + // from nsXULTemplateBuilder + + /** + * Return true if the result can be inserted into the template as + * generated content. For the content builder, aLocations will be set + * to the list of containers where the content should be inserted. + */ + virtual bool + GetInsertionLocations(nsIXULTemplateResult* aOldResult, + nsCOMArray<nsIContent>** aLocations) override; + + /** + * Remove the content associated with aOldResult which no longer matches, + * and/or generate content for a new match. + */ + virtual nsresult + ReplaceMatch(nsIXULTemplateResult* aOldResult, + nsTemplateMatch* aNewMatch, + nsTemplateRule* aNewMatchRule, + void *aContext) override; + + /** + * Synchronize a result bindings with the generated content for that + * result. This will be called as a result of the template builder's + * ResultBindingChanged method. + */ + virtual nsresult + SynchronizeResult(nsIXULTemplateResult* aResult) override; + + /** + * Compare a result to a content node. If the generated content for the + * result should come before aContent, set aSortOrder to -1. If it should + * come after, set sortOrder to 1. If both are equal, set to 0. + */ + nsresult + CompareResultToNode(nsIXULTemplateResult* aResult, nsIContent* aContent, + int32_t* aSortOrder); + + /** + * Insert a generated node into the container where it should go according + * to the current sort. aNode is the generated content node and aResult is + * the result for the generated node. + */ + nsresult + InsertSortedNode(nsIContent* aContainer, + nsIContent* aNode, + nsIXULTemplateResult* aResult, + bool aNotify); + + /** + * Maintains a mapping between elements in the DOM and the matches + * that they support. + */ + nsContentSupportMap mContentSupportMap; + + /** + * Maintains a mapping from an element in the DOM to the template + * element that it was created from. + */ + nsTemplateMap mTemplateMap; + + /** + * Information about the currently active sort + */ + nsSortState mSortState; +}; + +nsresult +NS_NewXULContentBuilder(nsISupports* aOuter, REFNSIID aIID, void** aResult) +{ + NS_PRECONDITION(aOuter == nullptr, "no aggregation"); + if (aOuter) + return NS_ERROR_NO_AGGREGATION; + + nsresult rv; + nsXULContentBuilder* result = new nsXULContentBuilder(); + NS_ADDREF(result); // stabilize + + rv = result->InitGlobals(); + + if (NS_SUCCEEDED(rv)) + rv = result->QueryInterface(aIID, aResult); + + NS_RELEASE(result); + return rv; +} + +nsXULContentBuilder::nsXULContentBuilder() +{ + mSortState.initialized = false; +} + +void +nsXULContentBuilder::Uninit(bool aIsFinal) +{ + if (! aIsFinal && mRoot) { + nsresult rv = RemoveGeneratedContent(mRoot); + if (NS_FAILED(rv)) + return; + } + + // Nuke the content support map completely. + mContentSupportMap.Clear(); + mTemplateMap.Clear(); + + mSortState.initialized = false; + + nsXULTemplateBuilder::Uninit(aIsFinal); +} + +nsresult +nsXULContentBuilder::BuildContentFromTemplate(nsIContent *aTemplateNode, + nsIContent *aResourceNode, + nsIContent *aRealNode, + bool aIsUnique, + bool aIsSelfReference, + nsIXULTemplateResult* aChild, + bool aNotify, + nsTemplateMatch* aMatch, + nsIContent** aContainer, + int32_t* aNewIndexInContainer) +{ + // This is the mother lode. Here is where we grovel through an + // element in the template, copying children from the template + // into the "real" content tree, performing substitution as we go + // by looking stuff up using the results. + // + // |aTemplateNode| is the element in the "template tree", whose + // children we will duplicate and move into the "real" content + // tree. + // + // |aResourceNode| is the element in the "real" content tree that + // has the "id" attribute set to an result's id. This is + // not directly used here, but rather passed down to the XUL + // sort service to perform container-level sort. + // + // |aRealNode| is the element in the "real" content tree to which + // the new elements will be copied. + // + // |aIsUnique| is set to "true" so long as content has been + // "unique" (or "above" the resource element) so far in the + // template. + // + // |aIsSelfReference| should be set to "true" for cases where + // the reference and member variables are the same, indicating + // that the generated node is the same as the reference point, + // so generation should not recurse, or else an infinite loop + // would occur. + // + // |aChild| is the result for which we are building content. + // + // |aNotify| is set to "true" if content should be constructed + // "noisily"; that is, whether the document observers should be + // notified when new content is added to the content model. + // + // |aContainer| is an out parameter that will be set to the first + // container element in the "real" content tree to which content + // was appended. + // + // |aNewIndexInContainer| is an out parameter that will be set to + // the index in aContainer at which new content is first + // constructed. + // + // If |aNotify| is "false", then |aContainer| and + // |aNewIndexInContainer| are used to determine where in the + // content model new content is constructed. This allows a single + // notification to be propagated to document observers. + // + + nsresult rv; + + if (MOZ_LOG_TEST(gXULTemplateLog, LogLevel::Debug)) { + MOZ_LOG(gXULTemplateLog, LogLevel::Debug, + ("nsXULContentBuilder::BuildContentFromTemplate (is unique: %d)", + aIsUnique)); + + nsAutoString id; + aChild->GetId(id); + + MOZ_LOG(gXULTemplateLog, LogLevel::Debug, + ("Tags: [Template: %s Resource: %s Real: %s] for id %s", + nsAtomCString(aTemplateNode->NodeInfo()->NameAtom()).get(), + nsAtomCString(aResourceNode->NodeInfo()->NameAtom()).get(), + nsAtomCString(aRealNode->NodeInfo()->NameAtom()).get(), NS_ConvertUTF16toUTF8(id).get())); + } + + // Iterate through all of the template children, constructing + // "real" content model nodes for each "template" child. + for (nsIContent* tmplKid = aTemplateNode->GetFirstChild(); + tmplKid; + tmplKid = tmplKid->GetNextSibling()) { + + int32_t nameSpaceID = tmplKid->GetNameSpaceID(); + + // Check whether this element is the generation element. The generation + // element is the element that is cookie-cutter copied once for each + // different result specified by |aChild|. + // + // Nodes that appear -above- the generation element + // (that is, are ancestors of the generation element in the + // content model) are unique across all values of |aChild|, + // and are created only once. + // + // Nodes that appear -below- the generation element (that is, + // are descendants of the generation element in the content + // model), are cookie-cutter copied for each distinct value of + // |aChild|. + // + // For example, in a <tree> template: + // + // <tree> + // <template> + // <treechildren> [1] + // <treeitem uri="rdf:*"> [2] + // <treerow> [3] + // <treecell value="rdf:urn:foo" /> [4] + // <treecell value="rdf:urn:bar" /> [5] + // </treerow> + // </treeitem> + // </treechildren> + // </template> + // </tree> + // + // The <treeitem> element [2] is the generation element. This + // element, and all of its descendants ([3], [4], and [5]) + // will be duplicated for each different |aChild|. + // It's ancestor <treechildren> [1] is unique, and + // will only be created -once-, no matter how many <treeitem>s + // are created below it. + // + // isUnique will be true for nodes above the generation element, + // isGenerationElement will be true for the generation element, + // and both will be false for descendants + bool isGenerationElement = false; + bool isUnique = aIsUnique; + + // We identify the resource element by presence of a + // "uri='rdf:*'" attribute. (We also support the older + // "uri='...'" syntax.) + if (tmplKid->HasAttr(kNameSpaceID_None, nsGkAtoms::uri) && aMatch->IsActive()) { + isGenerationElement = true; + isUnique = false; + } + + MOZ_ASSERT_IF(isGenerationElement, tmplKid->IsElement()); + + nsIAtom *tag = tmplKid->NodeInfo()->NameAtom(); + + if (MOZ_LOG_TEST(gXULTemplateLog, LogLevel::Debug)) { + MOZ_LOG(gXULTemplateLog, LogLevel::Debug, + ("xultemplate[%p] building %s %s %s", + this, nsAtomCString(tag).get(), + (isGenerationElement ? "[resource]" : ""), + (isUnique ? "[unique]" : ""))); + } + + // Set to true if the child we're trying to create now + // already existed in the content model. + bool realKidAlreadyExisted = false; + + nsCOMPtr<nsIContent> realKid; + if (isUnique) { + // The content is "unique"; that is, we haven't descended + // far enough into the template to hit the generation + // element yet. |EnsureElementHasGenericChild()| will + // conditionally create the element iff it isn't there + // already. + rv = EnsureElementHasGenericChild(aRealNode, nameSpaceID, tag, aNotify, getter_AddRefs(realKid)); + if (NS_FAILED(rv)) + return rv; + + if (rv == NS_ELEMENT_WAS_THERE) { + realKidAlreadyExisted = true; + } + else { + // Potentially remember the index of this element as the first + // element that we've generated. Note that we remember + // this -before- we recurse! + if (aContainer && !*aContainer) { + *aContainer = aRealNode; + NS_ADDREF(*aContainer); + + uint32_t indx = aRealNode->GetChildCount(); + + // Since EnsureElementHasGenericChild() added us, make + // sure to subtract one for our real index. + *aNewIndexInContainer = indx - 1; + } + } + + // Recurse until we get to the resource element. Since + // -we're- unique, assume that our child will be + // unique. The check for the "resource" element at the top + // of the function will trip this to |false| as soon as we + // encounter it. + rv = BuildContentFromTemplate(tmplKid, aResourceNode, realKid, true, + aIsSelfReference, aChild, aNotify, aMatch, + aContainer, aNewIndexInContainer); + + if (NS_FAILED(rv)) + return rv; + } + else if (isGenerationElement) { + // It's the "resource" element. Create a new element using + // the namespace ID and tag from the template element. + nsCOMPtr<Element> element; + rv = CreateElement(nameSpaceID, tag, getter_AddRefs(element)); + if (NS_FAILED(rv)) + return rv; + realKid = element.forget(); + + // Add the resource element to the content support map so + // we can remove the match based on the content node later. + mContentSupportMap.Put(realKid, aMatch); + + // Assign the element an 'id' attribute using result's id + nsAutoString id; + rv = aChild->GetId(id); + if (NS_FAILED(rv)) + return rv; + + rv = realKid->SetAttr(kNameSpaceID_None, nsGkAtoms::id, id, false); + if (NS_FAILED(rv)) + return rv; + + // Set up the element's 'container' and 'empty' attributes. + SetContainerAttrs(realKid, aChild, true, false); + } + else if (tag == nsGkAtoms::textnode && + nameSpaceID == kNameSpaceID_XUL) { + // <xul:text value="..."> is replaced by text of the + // actual value of the 'rdf:resource' attribute for the + // given node. + // SynchronizeUsingTemplate contains code used to update textnodes, + // so make sure to modify both when changing this + char16_t attrbuf[128]; + nsFixedString attrValue(attrbuf, ArrayLength(attrbuf), 0); + tmplKid->GetAttr(kNameSpaceID_None, nsGkAtoms::value, attrValue); + if (!attrValue.IsEmpty()) { + nsAutoString value; + rv = SubstituteText(aChild, attrValue, value); + if (NS_FAILED(rv)) return rv; + + RefPtr<nsTextNode> content = + new nsTextNode(mRoot->NodeInfo()->NodeInfoManager()); + + content->SetText(value, false); + + rv = aRealNode->AppendChildTo(content, aNotify); + if (NS_FAILED(rv)) return rv; + + // XXX Don't bother remembering text nodes as the + // first element we've generated? + } + } + else if (tmplKid->IsNodeOfType(nsINode::eTEXT)) { + nsCOMPtr<nsIDOMNode> tmplTextNode = do_QueryInterface(tmplKid); + if (!tmplTextNode) { + NS_ERROR("textnode not implementing nsIDOMNode??"); + return NS_ERROR_FAILURE; + } + nsCOMPtr<nsIDOMNode> clonedNode; + tmplTextNode->CloneNode(false, 1, getter_AddRefs(clonedNode)); + nsCOMPtr<nsIContent> clonedContent = do_QueryInterface(clonedNode); + if (!clonedContent) { + NS_ERROR("failed to clone textnode"); + return NS_ERROR_FAILURE; + } + rv = aRealNode->AppendChildTo(clonedContent, aNotify); + if (NS_FAILED(rv)) return rv; + } + else { + // It's just a generic element. Create it! + nsCOMPtr<Element> element; + rv = CreateElement(nameSpaceID, tag, getter_AddRefs(element)); + if (NS_FAILED(rv)) return rv; + realKid = element.forget(); + } + + if (realKid && !realKidAlreadyExisted) { + // Potentially remember the index of this element as the + // first element that we've generated. + if (aContainer && !*aContainer) { + *aContainer = aRealNode; + NS_ADDREF(*aContainer); + + uint32_t indx = aRealNode->GetChildCount(); + + // Since we haven't inserted any content yet, our new + // index in the container will be the current count of + // elements in the container. + *aNewIndexInContainer = indx; + } + + // Remember the template kid from which we created the + // real kid. This allows us to sync back up with the + // template to incrementally build content. + mTemplateMap.Put(realKid, tmplKid); + + rv = CopyAttributesToElement(tmplKid, realKid, aChild, false); + if (NS_FAILED(rv)) return rv; + + // Add any persistent attributes + if (isGenerationElement) { + rv = AddPersistentAttributes(tmplKid->AsElement(), aChild, + realKid); + if (NS_FAILED(rv)) return rv; + } + + // the unique content recurses up above. Also, don't recurse if + // this is a self reference (a reference to the same resource) + // or we'll end up regenerating the same content. + if (!aIsSelfReference && !isUnique) { + // this call creates the content inside the generation node, + // for example the label below: + // <vbox uri="?"> + // <label value="?title"/> + // </vbox> + rv = BuildContentFromTemplate(tmplKid, aResourceNode, realKid, false, + false, aChild, false, aMatch, + nullptr /* don't care */, + nullptr /* don't care */); + if (NS_FAILED(rv)) return rv; + + if (isGenerationElement) { + // build the next level of children + rv = CreateContainerContents(realKid, aChild, false, + false, false); + if (NS_FAILED(rv)) return rv; + } + } + + // We'll _already_ have added the unique elements; but if + // it's -not- unique, then use the XUL sort service now to + // append the element to the content model. + if (! isUnique) { + rv = NS_ERROR_UNEXPECTED; + + if (isGenerationElement) + rv = InsertSortedNode(aRealNode, realKid, aChild, aNotify); + + if (NS_FAILED(rv)) { + rv = aRealNode->AppendChildTo(realKid, aNotify); + NS_ASSERTION(NS_SUCCEEDED(rv), "unable to insert element"); + } + } + } + } + + return NS_OK; +} + +nsresult +nsXULContentBuilder::CopyAttributesToElement(nsIContent* aTemplateNode, + nsIContent* aRealNode, + nsIXULTemplateResult* aResult, + bool aNotify) +{ + nsresult rv; + + // Copy all attributes from the template to the new element + uint32_t numAttribs = aTemplateNode->GetAttrCount(); + + for (uint32_t attr = 0; attr < numAttribs; attr++) { + const nsAttrName* name = aTemplateNode->GetAttrNameAt(attr); + int32_t attribNameSpaceID = name->NamespaceID(); + // Hold a strong reference here so that the atom doesn't go away + // during UnsetAttr. + nsCOMPtr<nsIAtom> attribName = name->LocalName(); + + // XXXndeakin ignore namespaces until bug 321182 is fixed + if (attribName != nsGkAtoms::id && attribName != nsGkAtoms::uri) { + // Create a buffer here, because there's a chance that an + // attribute in the template is going to be an RDF URI, which is + // usually longish. + char16_t attrbuf[128]; + nsFixedString attribValue(attrbuf, ArrayLength(attrbuf), 0); + aTemplateNode->GetAttr(attribNameSpaceID, attribName, attribValue); + if (!attribValue.IsEmpty()) { + nsAutoString value; + rv = SubstituteText(aResult, attribValue, value); + if (NS_FAILED(rv)) + return rv; + + // if the string is empty after substitutions, remove the + // attribute + if (!value.IsEmpty()) { + rv = aRealNode->SetAttr(attribNameSpaceID, + attribName, + name->GetPrefix(), + value, + aNotify); + } + else { + rv = aRealNode->UnsetAttr(attribNameSpaceID, + attribName, + aNotify); + } + + if (NS_FAILED(rv)) + return rv; + } + } + } + + return NS_OK; +} + +nsresult +nsXULContentBuilder::AddPersistentAttributes(Element* aTemplateNode, + nsIXULTemplateResult* aResult, + nsIContent* aRealNode) +{ + if (!mRoot) + return NS_OK; + + nsCOMPtr<nsIRDFResource> resource; + nsresult rv = GetResultResource(aResult, getter_AddRefs(resource)); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString attribute, persist; + aTemplateNode->GetAttr(kNameSpaceID_None, nsGkAtoms::persist, persist); + + while (!persist.IsEmpty()) { + attribute.Truncate(); + + int32_t offset = persist.FindCharInSet(" ,"); + if (offset > 0) { + persist.Left(attribute, offset); + persist.Cut(0, offset + 1); + } + else { + attribute = persist; + persist.Truncate(); + } + + attribute.Trim(" "); + + if (attribute.IsEmpty()) + break; + + nsCOMPtr<nsIAtom> tag; + int32_t nameSpaceID; + + RefPtr<mozilla::dom::NodeInfo> ni = + aTemplateNode->GetExistingAttrNameFromQName(attribute); + if (ni) { + tag = ni->NameAtom(); + nameSpaceID = ni->NamespaceID(); + } + else { + tag = NS_Atomize(attribute); + NS_ENSURE_TRUE(tag, NS_ERROR_OUT_OF_MEMORY); + + nameSpaceID = kNameSpaceID_None; + } + + nsCOMPtr<nsIRDFResource> property; + rv = nsXULContentUtils::GetResource(nameSpaceID, tag, getter_AddRefs(property)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIRDFNode> target; + rv = mDB->GetTarget(resource, property, true, getter_AddRefs(target)); + NS_ENSURE_SUCCESS(rv, rv); + + if (! target) + continue; + + nsCOMPtr<nsIRDFLiteral> value = do_QueryInterface(target); + NS_ASSERTION(value != nullptr, "unable to stomach that sort of node"); + if (! value) + continue; + + const char16_t* valueStr; + rv = value->GetValueConst(&valueStr); + NS_ENSURE_SUCCESS(rv, rv); + + rv = aRealNode->SetAttr(nameSpaceID, tag, nsDependentString(valueStr), + false); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +nsresult +nsXULContentBuilder::SynchronizeUsingTemplate(nsIContent* aTemplateNode, + nsIContent* aRealElement, + nsIXULTemplateResult* aResult) +{ + // check all attributes on the template node; if they reference a resource, + // update the equivalent attribute on the content node + nsresult rv; + rv = CopyAttributesToElement(aTemplateNode, aRealElement, aResult, true); + if (NS_FAILED(rv)) + return rv; + + uint32_t count = aTemplateNode->GetChildCount(); + + for (uint32_t loop = 0; loop < count; ++loop) { + nsIContent *tmplKid = aTemplateNode->GetChildAt(loop); + + if (! tmplKid) + break; + + nsIContent *realKid = aRealElement->GetChildAt(loop); + if (! realKid) + break; + + // check for text nodes and update them accordingly. + // This code is similar to that in BuildContentFromTemplate + if (tmplKid->NodeInfo()->Equals(nsGkAtoms::textnode, + kNameSpaceID_XUL)) { + char16_t attrbuf[128]; + nsFixedString attrValue(attrbuf, ArrayLength(attrbuf), 0); + tmplKid->GetAttr(kNameSpaceID_None, nsGkAtoms::value, attrValue); + if (!attrValue.IsEmpty()) { + nsAutoString value; + rv = SubstituteText(aResult, attrValue, value); + if (NS_FAILED(rv)) return rv; + realKid->SetText(value, true); + } + } + + rv = SynchronizeUsingTemplate(tmplKid, realKid, aResult); + if (NS_FAILED(rv)) return rv; + } + + return NS_OK; +} + +nsresult +nsXULContentBuilder::RemoveMember(nsIContent* aContent) +{ + nsCOMPtr<nsIContent> parent = aContent->GetParent(); + if (parent) { + int32_t pos = parent->IndexOf(aContent); + + NS_ASSERTION(pos >= 0, "parent doesn't think this child has an index"); + if (pos < 0) return NS_OK; + + // Note: RemoveChildAt sets |child|'s document to null so that + // it'll get knocked out of the XUL doc's resource-to-element + // map. + parent->RemoveChildAt(pos, true); + } + + // Remove from the content support map. + mContentSupportMap.Remove(aContent); + + // Remove from the template map + mTemplateMap.Remove(aContent); + + return NS_OK; +} + +nsresult +nsXULContentBuilder::CreateTemplateAndContainerContents(nsIContent* aElement, + bool aForceCreation) +{ + // Generate both 1) the template content for the current element, + // and 2) recursive subcontent (if the current element refers to a + // container result). + + MOZ_LOG(gXULTemplateLog, LogLevel::Info, + ("nsXULContentBuilder::CreateTemplateAndContainerContents start - flags: %d", + mFlags)); + + if (! mQueryProcessor) + return NS_OK; + + // for the root element, get the ref attribute and generate content + if (aElement == mRoot) { + if (! mRootResult) { + nsAutoString ref; + mRoot->GetAttr(kNameSpaceID_None, nsGkAtoms::ref, ref); + + if (! ref.IsEmpty()) { + nsresult rv = mQueryProcessor->TranslateRef(mDataSource, ref, + getter_AddRefs(mRootResult)); + if (NS_FAILED(rv)) + return rv; + } + } + + if (mRootResult) { + CreateContainerContents(aElement, mRootResult, aForceCreation, + false, true); + } + } + else if (!(mFlags & eDontRecurse)) { + // The content map will contain the generation elements (the ones that + // are given ids) and only those elements, so get the reference point + // from the corresponding match. + nsTemplateMatch *match = nullptr; + if (mContentSupportMap.Get(aElement, &match)) + CreateContainerContents(aElement, match->mResult, aForceCreation, + false, true); + } + + MOZ_LOG(gXULTemplateLog, LogLevel::Info, + ("nsXULContentBuilder::CreateTemplateAndContainerContents end")); + + return NS_OK; +} + +nsresult +nsXULContentBuilder::CreateContainerContents(nsIContent* aElement, + nsIXULTemplateResult* aResult, + bool aForceCreation, + bool aNotify, + bool aNotifyAtEnd) +{ + if (!aForceCreation && !IsOpen(aElement)) + return NS_OK; + + // don't generate children if recursion or child processing isn't allowed + if (aResult != mRootResult) { + if (mFlags & eDontRecurse) + return NS_OK; + + bool mayProcessChildren; + nsresult rv = aResult->GetMayProcessChildren(&mayProcessChildren); + if (NS_FAILED(rv) || !mayProcessChildren) + return rv; + } + + nsCOMPtr<nsIRDFResource> refResource; + GetResultResource(aResult, getter_AddRefs(refResource)); + if (! refResource) + return NS_ERROR_FAILURE; + + // Avoid re-entrant builds for the same resource. + if (IsActivated(refResource)) + return NS_OK; + + ActivationEntry entry(refResource, &mTop); + + // Compile the rules now, if they haven't been already. + if (! mQueriesCompiled) { + nsresult rv = CompileQueries(); + if (NS_FAILED(rv)) + return rv; + } + + if (mQuerySets.Length() == 0) + return NS_OK; + + // See if the element's templates contents have been generated: + // this prevents a re-entrant call from triggering another + // generation. + nsXULElement *xulcontent = nsXULElement::FromContent(aElement); + if (xulcontent) { + if (xulcontent->GetTemplateGenerated()) + return NS_OK; + + // Now mark the element's contents as being generated so that + // any re-entrant calls don't trigger an infinite recursion. + xulcontent->SetTemplateGenerated(); + } + + int32_t newIndexInContainer = -1; + nsIContent* container = nullptr; + + int32_t querySetCount = mQuerySets.Length(); + + for (int32_t r = 0; r < querySetCount; r++) { + nsTemplateQuerySet* queryset = mQuerySets[r]; + + nsIAtom* tag = queryset->GetTag(); + if (tag && tag != aElement->NodeInfo()->NameAtom()) + continue; + + CreateContainerContentsForQuerySet(aElement, aResult, aNotify, queryset, + &container, &newIndexInContainer); + } + + if (aNotifyAtEnd && container) { + MOZ_AUTO_DOC_UPDATE(container->GetUncomposedDoc(), UPDATE_CONTENT_MODEL, + true); + nsNodeUtils::ContentAppended(container, + container->GetChildAt(newIndexInContainer), + newIndexInContainer); + } + + NS_IF_RELEASE(container); + + return NS_OK; +} + +nsresult +nsXULContentBuilder::CreateContainerContentsForQuerySet(nsIContent* aElement, + nsIXULTemplateResult* aResult, + bool aNotify, + nsTemplateQuerySet* aQuerySet, + nsIContent** aContainer, + int32_t* aNewIndexInContainer) +{ + if (MOZ_LOG_TEST(gXULTemplateLog, LogLevel::Debug)) { + nsAutoString id; + aResult->GetId(id); + MOZ_LOG(gXULTemplateLog, LogLevel::Debug, + ("nsXULContentBuilder::CreateContainerContentsForQuerySet start for ref %s\n", + NS_ConvertUTF16toUTF8(id).get())); + } + + if (! mQueryProcessor) + return NS_OK; + + nsCOMPtr<nsISimpleEnumerator> results; + nsresult rv = mQueryProcessor->GenerateResults(mDataSource, aResult, + aQuerySet->mCompiledQuery, + getter_AddRefs(results)); + if (NS_FAILED(rv) || !results) + return rv; + + bool hasMoreResults; + rv = results->HasMoreElements(&hasMoreResults); + + for (; NS_SUCCEEDED(rv) && hasMoreResults; + rv = results->HasMoreElements(&hasMoreResults)) { + nsCOMPtr<nsISupports> nr; + rv = results->GetNext(getter_AddRefs(nr)); + if (NS_FAILED(rv)) + return rv; + + nsCOMPtr<nsIXULTemplateResult> nextresult = do_QueryInterface(nr); + if (!nextresult) + return NS_ERROR_UNEXPECTED; + + nsCOMPtr<nsIRDFResource> resultid; + rv = GetResultResource(nextresult, getter_AddRefs(resultid)); + if (NS_FAILED(rv)) + return rv; + + if (!resultid) + continue; + + nsTemplateMatch *newmatch = + nsTemplateMatch::Create(aQuerySet->Priority(), + nextresult, aElement); + if (!newmatch) + return NS_ERROR_OUT_OF_MEMORY; + + // check if there is already an existing match. If so, a previous + // query already generated content so the match is just added to the + // end of the set of matches. + + bool generateContent = true; + + nsTemplateMatch* prevmatch = nullptr; + nsTemplateMatch* existingmatch = nullptr; + nsTemplateMatch* removematch = nullptr; + if (mMatchMap.Get(resultid, &existingmatch)){ + // check if there is an existing match that matched a rule + while (existingmatch) { + // break out once we've reached a query in the list with a + // higher priority, as the new match list is sorted by + // priority, and the new match should be inserted here + int32_t priority = existingmatch->QuerySetPriority(); + if (priority > aQuerySet->Priority()) + break; + + // skip over non-matching containers + if (existingmatch->GetContainer() == aElement) { + // if the same priority is already found, replace it. This can happen + // when a container is removed and readded + if (priority == aQuerySet->Priority()) { + removematch = existingmatch; + break; + } + + if (existingmatch->IsActive()) + generateContent = false; + } + + prevmatch = existingmatch; + existingmatch = existingmatch->mNext; + } + } + + if (removematch) { + // remove the generated content for the existing match + rv = ReplaceMatch(removematch->mResult, nullptr, nullptr, aElement); + if (NS_FAILED(rv)) + return rv; + + if (mFlags & eLoggingEnabled) + OutputMatchToLog(resultid, removematch, false); + } + + if (generateContent) { + // find the rule that matches. If none match, the content does not + // need to be generated + + int16_t ruleindex; + nsTemplateRule* matchedrule = nullptr; + rv = DetermineMatchedRule(aElement, nextresult, aQuerySet, + &matchedrule, &ruleindex); + if (NS_FAILED(rv)) { + nsTemplateMatch::Destroy(newmatch, false); + return rv; + } + + if (matchedrule) { + rv = newmatch->RuleMatched(aQuerySet, matchedrule, + ruleindex, nextresult); + if (NS_FAILED(rv)) { + nsTemplateMatch::Destroy(newmatch, false); + return rv; + } + + // Grab the template node + nsCOMPtr<nsIContent> action = matchedrule->GetAction(); + BuildContentFromTemplate(action, aElement, aElement, true, + mRefVariable == matchedrule->GetMemberVariable(), + nextresult, aNotify, newmatch, + aContainer, aNewIndexInContainer); + } + } + + if (mFlags & eLoggingEnabled) + OutputMatchToLog(resultid, newmatch, true); + + if (prevmatch) { + prevmatch->mNext = newmatch; + } + else { + mMatchMap.Put(resultid, newmatch); + } + + if (removematch) { + newmatch->mNext = removematch->mNext; + nsTemplateMatch::Destroy(removematch, true); + } + else { + newmatch->mNext = existingmatch; + } + } + + return rv; +} + +nsresult +nsXULContentBuilder::EnsureElementHasGenericChild(nsIContent* parent, + int32_t nameSpaceID, + nsIAtom* tag, + bool aNotify, + nsIContent** result) +{ + nsresult rv; + + rv = nsXULContentUtils::FindChildByTag(parent, nameSpaceID, tag, result); + if (NS_FAILED(rv)) + return rv; + + if (rv == NS_RDF_NO_VALUE) { + // we need to construct a new child element. + nsCOMPtr<Element> element; + + rv = CreateElement(nameSpaceID, tag, getter_AddRefs(element)); + if (NS_FAILED(rv)) + return rv; + + // XXX Note that the notification ensures we won't batch insertions! This could be bad! - Dave + rv = parent->AppendChildTo(element, aNotify); + if (NS_FAILED(rv)) + return rv; + + element.forget(result); + return NS_ELEMENT_GOT_CREATED; + } + else { + return NS_ELEMENT_WAS_THERE; + } +} + +bool +nsXULContentBuilder::IsOpen(nsIContent* aElement) +{ + // Determine if this is a <treeitem> or <menu> element + + // XXXhyatt Use the XBL service to obtain a base tag. + if (aElement->IsAnyOfXULElements(nsGkAtoms::menu, + nsGkAtoms::menubutton, + nsGkAtoms::toolbarbutton, + nsGkAtoms::button, + nsGkAtoms::treeitem)) + return aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open, + nsGkAtoms::_true, eCaseMatters); + return true; +} + +nsresult +nsXULContentBuilder::RemoveGeneratedContent(nsIContent* aElement) +{ + // Keep a queue of "ungenerated" elements that we have to probe + // for generated content. + AutoTArray<nsIContent*, 8> ungenerated; + if (ungenerated.AppendElement(aElement) == nullptr) + return NS_ERROR_OUT_OF_MEMORY; + + uint32_t count; + while (0 != (count = ungenerated.Length())) { + // Pull the next "ungenerated" element off the queue. + uint32_t last = count - 1; + nsCOMPtr<nsIContent> element = ungenerated[last]; + ungenerated.RemoveElementAt(last); + + uint32_t i = element->GetChildCount(); + + while (i-- > 0) { + nsCOMPtr<nsIContent> child = element->GetChildAt(i); + + // Optimize for the <template> element, because we *know* + // it won't have any generated content: there's no reason + // to even check this subtree. + // XXX should this check |child| rather than |element|? Otherwise + // it should be moved outside the inner loop. Bug 297290. + if (element->NodeInfo()->Equals(nsGkAtoms::_template, + kNameSpaceID_XUL) || + !element->IsElement()) + continue; + + // If the element is in the template map, then we + // assume it's been generated and nuke it. + nsCOMPtr<nsIContent> tmpl; + mTemplateMap.GetTemplateFor(child, getter_AddRefs(tmpl)); + + if (! tmpl) { + // No 'template' attribute, so this must not have been + // generated. We'll need to examine its kids. + if (ungenerated.AppendElement(child) == nullptr) + return NS_ERROR_OUT_OF_MEMORY; + continue; + } + + // If we get here, it's "generated". Bye bye! + element->RemoveChildAt(i, true); + + // Remove this and any children from the content support map. + mContentSupportMap.Remove(child); + + // Remove from the template map + mTemplateMap.Remove(child); + } + } + + return NS_OK; +} + +nsresult +nsXULContentBuilder::GetElementsForResult(nsIXULTemplateResult* aResult, + nsCOMArray<nsIContent>& aElements) +{ + // if the root has been removed from the document, just return + // since there won't be any generated content any more + nsCOMPtr<nsIXULDocument> xuldoc = do_QueryInterface(mRoot->GetComposedDoc()); + if (! xuldoc) + return NS_OK; + + nsAutoString id; + aResult->GetId(id); + + xuldoc->GetElementsForID(id, aElements); + + return NS_OK; +} + +nsresult +nsXULContentBuilder::CreateElement(int32_t aNameSpaceID, + nsIAtom* aTag, + Element** aResult) +{ + nsCOMPtr<nsIDocument> doc = mRoot->GetComposedDoc(); + NS_ASSERTION(doc != nullptr, "not initialized"); + if (! doc) + return NS_ERROR_NOT_INITIALIZED; + + RefPtr<mozilla::dom::NodeInfo> nodeInfo = + doc->NodeInfoManager()->GetNodeInfo(aTag, nullptr, aNameSpaceID, + nsIDOMNode::ELEMENT_NODE); + + return NS_NewElement(aResult, nodeInfo.forget(), NOT_FROM_PARSER); +} + +nsresult +nsXULContentBuilder::SetContainerAttrs(nsIContent *aElement, + nsIXULTemplateResult* aResult, + bool aIgnoreNonContainers, + bool aNotify) +{ + NS_PRECONDITION(aResult != nullptr, "null ptr"); + if (! aResult) + return NS_ERROR_NULL_POINTER; + + bool iscontainer; + aResult->GetIsContainer(&iscontainer); + + if (aIgnoreNonContainers && !iscontainer) + return NS_OK; + + NS_NAMED_LITERAL_STRING(true_, "true"); + NS_NAMED_LITERAL_STRING(false_, "false"); + + const nsAString& newcontainer = + iscontainer ? true_ : false_; + + aElement->SetAttr(kNameSpaceID_None, nsGkAtoms::container, + newcontainer, aNotify); + + if (iscontainer && !(mFlags & eDontTestEmpty)) { + bool isempty; + aResult->GetIsEmpty(&isempty); + + const nsAString& newempty = + (iscontainer && isempty) ? true_ : false_; + + aElement->SetAttr(kNameSpaceID_None, nsGkAtoms::empty, + newempty, aNotify); + } + + return NS_OK; +} + + +//---------------------------------------------------------------------- +// +// nsIXULTemplateBuilder methods +// + +NS_IMETHODIMP +nsXULContentBuilder::CreateContents(nsIContent* aElement, bool aForceCreation) +{ + NS_PRECONDITION(aElement != nullptr, "null ptr"); + if (! aElement) + return NS_ERROR_NULL_POINTER; + + // don't build contents for closed elements. aForceCreation will be true + // when a menu is about to be opened, so the content should be built anyway. + if (!aForceCreation && !IsOpen(aElement)) + return NS_OK; + + return CreateTemplateAndContainerContents(aElement, aForceCreation); +} + +NS_IMETHODIMP +nsXULContentBuilder::HasGeneratedContent(nsIRDFResource* aResource, + nsIAtom* aTag, + bool* aGenerated) +{ + *aGenerated = false; + NS_ENSURE_TRUE(mRoot, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_STATE(mRootResult); + + nsCOMPtr<nsIRDFResource> rootresource; + nsresult rv = mRootResult->GetResource(getter_AddRefs(rootresource)); + if (NS_FAILED(rv)) + return rv; + + // the root resource is always acceptable + if (aResource == rootresource) { + if (!aTag || mRoot->NodeInfo()->NameAtom() == aTag) + *aGenerated = true; + } + else { + const char* uri; + aResource->GetValueConst(&uri); + + NS_ConvertUTF8toUTF16 refID(uri); + + // just return if the node is no longer in a document + nsCOMPtr<nsIXULDocument> xuldoc = do_QueryInterface(mRoot->GetComposedDoc()); + if (! xuldoc) + return NS_OK; + + nsCOMArray<nsIContent> elements; + xuldoc->GetElementsForID(refID, elements); + + uint32_t cnt = elements.Count(); + + for (int32_t i = int32_t(cnt) - 1; i >= 0; --i) { + nsCOMPtr<nsIContent> content = elements.SafeObjectAt(i); + + do { + nsTemplateMatch* match; + if (content == mRoot || mContentSupportMap.Get(content, &match)) { + // If we've got a tag, check it to ensure we're consistent. + if (!aTag || content->NodeInfo()->NameAtom() == aTag) { + *aGenerated = true; + return NS_OK; + } + } + + content = content->GetParent(); + } while (content); + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsXULContentBuilder::GetResultForContent(nsIDOMElement* aElement, + nsIXULTemplateResult** aResult) +{ + NS_ENSURE_ARG_POINTER(aElement); + NS_ENSURE_ARG_POINTER(aResult); + + nsCOMPtr<nsIContent> content = do_QueryInterface(aElement); + if (content == mRoot) { + *aResult = mRootResult; + } + else { + nsTemplateMatch *match = nullptr; + if (mContentSupportMap.Get(content, &match)) + *aResult = match->mResult; + else + *aResult = nullptr; + } + + NS_IF_ADDREF(*aResult); + return NS_OK; +} + +//---------------------------------------------------------------------- +// +// nsIDocumentObserver methods +// + +void +nsXULContentBuilder::AttributeChanged(nsIDocument* aDocument, + Element* aElement, + int32_t aNameSpaceID, + nsIAtom* aAttribute, + int32_t aModType, + const nsAttrValue* aOldValue) +{ + nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this); + + // Handle "open" and "close" cases. We do this handling before + // we've notified the observer, so that content is already created + // for the frame system to walk. + if (aElement->GetNameSpaceID() == kNameSpaceID_XUL && + aAttribute == nsGkAtoms::open) { + // We're on a XUL tag, and an ``open'' attribute changed. + if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open, + nsGkAtoms::_true, eCaseMatters)) + OpenContainer(aElement); + else + CloseContainer(aElement); + } + + if ((aNameSpaceID == kNameSpaceID_XUL) && + ((aAttribute == nsGkAtoms::sort) || + (aAttribute == nsGkAtoms::sortDirection) || + (aAttribute == nsGkAtoms::sortResource) || + (aAttribute == nsGkAtoms::sortResource2))) + mSortState.initialized = false; + + // Pass along to the generic template builder. + nsXULTemplateBuilder::AttributeChanged(aDocument, aElement, aNameSpaceID, + aAttribute, aModType, aOldValue); +} + +void +nsXULContentBuilder::NodeWillBeDestroyed(const nsINode* aNode) +{ + nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this); + // Break circular references + mContentSupportMap.Clear(); + + nsXULTemplateBuilder::NodeWillBeDestroyed(aNode); +} + + +//---------------------------------------------------------------------- +// +// nsXULTemplateBuilder methods +// + +bool +nsXULContentBuilder::GetInsertionLocations(nsIXULTemplateResult* aResult, + nsCOMArray<nsIContent>** aLocations) +{ + *aLocations = nullptr; + + nsAutoString ref; + nsresult rv = aResult->GetBindingFor(mRefVariable, ref); + if (NS_FAILED(rv)) + return false; + + nsCOMPtr<nsIXULDocument> xuldoc = do_QueryInterface(mRoot->GetComposedDoc()); + if (! xuldoc) + return false; + + *aLocations = new nsCOMArray<nsIContent>; + NS_ENSURE_TRUE(*aLocations, false); + + xuldoc->GetElementsForID(ref, **aLocations); + uint32_t count = (*aLocations)->Count(); + + bool found = false; + + for (uint32_t t = 0; t < count; t++) { + nsCOMPtr<nsIContent> content = (*aLocations)->SafeObjectAt(t); + + nsTemplateMatch* refmatch; + if (content == mRoot || mContentSupportMap.Get(content, &refmatch)) { + // See if we've built the container contents for "content" + // yet. If not, we don't need to build any content. This + // happens, for example, if we receive an assertion on a + // closed folder in a tree widget or on a menu that hasn't + // yet been opened. + nsXULElement *xulcontent = nsXULElement::FromContent(content); + if (!xulcontent || xulcontent->GetTemplateGenerated()) { + found = true; + continue; + } + } + + // clear the item in the list since we don't want to insert there + (*aLocations)->ReplaceObjectAt(nullptr, t); + } + + return found; +} + +nsresult +nsXULContentBuilder::ReplaceMatch(nsIXULTemplateResult* aOldResult, + nsTemplateMatch* aNewMatch, + nsTemplateRule* aNewMatchRule, + void *aContext) + +{ + nsresult rv; + nsIContent* content = static_cast<nsIContent*>(aContext); + + // update the container attributes for the match + if (content) { + nsAutoString ref; + if (aNewMatch) + rv = aNewMatch->mResult->GetBindingFor(mRefVariable, ref); + else + rv = aOldResult->GetBindingFor(mRefVariable, ref); + if (NS_FAILED(rv)) + return rv; + + if (!ref.IsEmpty()) { + nsCOMPtr<nsIXULTemplateResult> refResult; + rv = GetResultForId(ref, getter_AddRefs(refResult)); + if (NS_FAILED(rv)) + return rv; + + if (refResult) + SetContainerAttrs(content, refResult, false, true); + } + } + + if (aOldResult) { + nsCOMArray<nsIContent> elements; + rv = GetElementsForResult(aOldResult, elements); + if (NS_FAILED(rv)) + return rv; + + uint32_t count = elements.Count(); + + for (int32_t e = int32_t(count) - 1; e >= 0; --e) { + nsCOMPtr<nsIContent> child = elements.SafeObjectAt(e); + + nsTemplateMatch* match; + if (mContentSupportMap.Get(child, &match)) { + if (content == match->GetContainer()) + RemoveMember(child); + } + } + } + + if (aNewMatch) { + nsCOMPtr<nsIContent> action = aNewMatchRule->GetAction(); + return BuildContentFromTemplate(action, content, content, true, + mRefVariable == aNewMatchRule->GetMemberVariable(), + aNewMatch->mResult, true, aNewMatch, + nullptr, nullptr); + } + + return NS_OK; +} + + +nsresult +nsXULContentBuilder::SynchronizeResult(nsIXULTemplateResult* aResult) +{ + nsCOMArray<nsIContent> elements; + GetElementsForResult(aResult, elements); + + uint32_t cnt = elements.Count(); + + for (int32_t i = int32_t(cnt) - 1; i >= 0; --i) { + nsCOMPtr<nsIContent> element = elements.SafeObjectAt(i); + + nsTemplateMatch* match; + if (! mContentSupportMap.Get(element, &match)) + continue; + + nsCOMPtr<nsIContent> templateNode; + mTemplateMap.GetTemplateFor(element, getter_AddRefs(templateNode)); + + NS_ASSERTION(templateNode, "couldn't find template node for element"); + if (! templateNode) + continue; + + // this node was created by a XUL template, so update it accordingly + SynchronizeUsingTemplate(templateNode, element, aResult); + } + + return NS_OK; +} + +//---------------------------------------------------------------------- +// +// Implementation methods +// + +nsresult +nsXULContentBuilder::OpenContainer(nsIContent* aElement) +{ + if (aElement != mRoot) { + if (mFlags & eDontRecurse) + return NS_OK; + + bool rightBuilder = false; + + nsCOMPtr<nsIXULDocument> xuldoc = do_QueryInterface(aElement->GetComposedDoc()); + if (! xuldoc) + return NS_OK; + + // See if we're responsible for this element + nsIContent* content = aElement; + do { + nsCOMPtr<nsIXULTemplateBuilder> builder; + xuldoc->GetTemplateBuilderFor(content, getter_AddRefs(builder)); + if (builder) { + if (builder == this) + rightBuilder = true; + break; + } + + content = content->GetParent(); + } while (content); + + if (! rightBuilder) + return NS_OK; + } + + CreateTemplateAndContainerContents(aElement, false); + + return NS_OK; +} + +nsresult +nsXULContentBuilder::CloseContainer(nsIContent* aElement) +{ + return NS_OK; +} + +nsresult +nsXULContentBuilder::RebuildAll() +{ + NS_ENSURE_TRUE(mRoot, NS_ERROR_NOT_INITIALIZED); + + // Bail out early if we are being torn down. + nsCOMPtr<nsIDocument> doc = mRoot->GetComposedDoc(); + if (!doc) + return NS_OK; + + if (mQueriesCompiled) + Uninit(false); + + nsresult rv = CompileQueries(); + if (NS_FAILED(rv)) + return rv; + + if (mQuerySets.Length() == 0) + return NS_OK; + + nsXULElement *xulcontent = nsXULElement::FromContent(mRoot); + if (xulcontent) + xulcontent->ClearTemplateGenerated(); + + // Now, regenerate both the template- and container-generated + // contents for the current element... + CreateTemplateAndContainerContents(mRoot, false); + + return NS_OK; +} + +/**** Sorting Methods ****/ + +nsresult +nsXULContentBuilder::CompareResultToNode(nsIXULTemplateResult* aResult, + nsIContent* aContent, + int32_t* aSortOrder) +{ + NS_ASSERTION(aSortOrder, "CompareResultToNode: null out param aSortOrder"); + + *aSortOrder = 0; + + nsTemplateMatch *match = nullptr; + if (!mContentSupportMap.Get(aContent, &match)) { + *aSortOrder = mSortState.sortStaticsLast ? -1 : 1; + return NS_OK; + } + + if (!mQueryProcessor) + return NS_OK; + + if (mSortState.direction == nsSortState_natural) { + // sort in natural order + nsresult rv = mQueryProcessor->CompareResults(aResult, match->mResult, + nullptr, mSortState.sortHints, + aSortOrder); + NS_ENSURE_SUCCESS(rv, rv); + } + else { + // iterate over each sort key and compare. If the nodes are equal, + // continue to compare using the next sort key. If not equal, stop. + int32_t length = mSortState.sortKeys.Count(); + for (int32_t t = 0; t < length; t++) { + nsresult rv = mQueryProcessor->CompareResults(aResult, match->mResult, + mSortState.sortKeys[t], + mSortState.sortHints, aSortOrder); + NS_ENSURE_SUCCESS(rv, rv); + + if (*aSortOrder) + break; + } + } + + // flip the sort order if performing a descending sorting + if (mSortState.direction == nsSortState_descending) + *aSortOrder = -*aSortOrder; + + return NS_OK; +} + +nsresult +nsXULContentBuilder::InsertSortedNode(nsIContent* aContainer, + nsIContent* aNode, + nsIXULTemplateResult* aResult, + bool aNotify) +{ + nsresult rv; + + if (!mSortState.initialized) { + nsAutoString sort, sortDirection, sortHints; + mRoot->GetAttr(kNameSpaceID_None, nsGkAtoms::sort, sort); + mRoot->GetAttr(kNameSpaceID_None, nsGkAtoms::sortDirection, sortDirection); + mRoot->GetAttr(kNameSpaceID_None, nsGkAtoms::sorthints, sortHints); + sortDirection += ' '; + sortDirection += sortHints; + rv = XULSortServiceImpl::InitializeSortState(mRoot, aContainer, + sort, sortDirection, &mSortState); + NS_ENSURE_SUCCESS(rv, rv); + } + + // when doing a natural sort, items will typically be sorted according to + // the order they appear in the datasource. For RDF, cache whether the + // reference parent is an RDF Seq. That way, the items can be sorted in the + // order they are in the Seq. + mSortState.isContainerRDFSeq = false; + if (mSortState.direction == nsSortState_natural) { + nsCOMPtr<nsISupports> ref; + nsresult rv = aResult->GetBindingObjectFor(mRefVariable, getter_AddRefs(ref)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIRDFResource> container = do_QueryInterface(ref); + + if (container) { + rv = gRDFContainerUtils->IsSeq(mDB, container, &mSortState.isContainerRDFSeq); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + bool childAdded = false; + uint32_t numChildren = aContainer->GetChildCount(); + + if (mSortState.direction != nsSortState_natural || + (mSortState.direction == nsSortState_natural && mSortState.isContainerRDFSeq)) + { + // because numChildren gets modified + int32_t realNumChildren = numChildren; + nsIContent *child = nullptr; + + // rjc says: determine where static XUL ends and generated XUL/RDF begins + int32_t staticCount = 0; + + nsAutoString staticValue; + aContainer->GetAttr(kNameSpaceID_None, nsGkAtoms::staticHint, staticValue); + if (!staticValue.IsEmpty()) + { + // found "static" XUL element count hint + nsresult strErr = NS_OK; + staticCount = staticValue.ToInteger(&strErr); + if (NS_FAILED(strErr)) + staticCount = 0; + } else { + // compute the "static" XUL element count + for (nsIContent* child = aContainer->GetFirstChild(); + child; + child = child->GetNextSibling()) { + + if (nsContentUtils::HasNonEmptyAttr(child, kNameSpaceID_None, + nsGkAtoms::_template)) + break; + else + ++staticCount; + } + + if (mSortState.sortStaticsLast) { + // indicate that static XUL comes after RDF-generated content by + // making negative + staticCount = -staticCount; + } + + // save the "static" XUL element count hint + nsAutoString valueStr; + valueStr.AppendInt(staticCount); + aContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::staticHint, valueStr, false); + } + + if (staticCount <= 0) { + numChildren += staticCount; + staticCount = 0; + } else if (staticCount > (int32_t)numChildren) { + staticCount = numChildren; + numChildren -= staticCount; + } + + // figure out where to insert the node when a sort order is being imposed + if (numChildren > 0) { + nsIContent *temp; + int32_t direction; + + // rjc says: The following is an implementation of a fairly optimal + // binary search insertion sort... with interpolation at either end-point. + + if (mSortState.lastWasFirst) { + child = aContainer->GetChildAt(staticCount); + temp = child; + rv = CompareResultToNode(aResult, temp, &direction); + if (direction < 0) { + aContainer->InsertChildAt(aNode, staticCount, aNotify); + childAdded = true; + } else + mSortState.lastWasFirst = false; + } else if (mSortState.lastWasLast) { + child = aContainer->GetChildAt(realNumChildren - 1); + temp = child; + rv = CompareResultToNode(aResult, temp, &direction); + if (direction > 0) { + aContainer->InsertChildAt(aNode, realNumChildren, aNotify); + childAdded = true; + } else + mSortState.lastWasLast = false; + } + + int32_t left = staticCount + 1, right = realNumChildren, x; + while (!childAdded && right >= left) { + x = (left + right) / 2; + child = aContainer->GetChildAt(x - 1); + temp = child; + + rv = CompareResultToNode(aResult, temp, &direction); + if ((x == left && direction < 0) || + (x == right && direction >= 0) || + left == right) + { + int32_t thePos = (direction > 0 ? x : x - 1); + aContainer->InsertChildAt(aNode, thePos, aNotify); + childAdded = true; + + mSortState.lastWasFirst = (thePos == staticCount); + mSortState.lastWasLast = (thePos >= realNumChildren); + + break; + } + if (direction < 0) + right = x - 1; + else + left = x + 1; + } + } + } + + // if the child hasn't been inserted yet, just add it at the end. Note + // that an append isn't done as there may be static content afterwards. + if (!childAdded) + aContainer->InsertChildAt(aNode, numChildren, aNotify); + + return NS_OK; +} |