The Tor Browser: content/xul/templates/src/nsXULSortService.cpp@6474c204b198 (annotated)

content/xul/templates/src/nsXULSortService.cpp@6474c204b198 (annotated)

content/xul/templates/src/nsXULSortService.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/.
  *
  * This Original Code has been modified by IBM Corporation.
  * Modifications made by IBM described herein are
  * Copyright (c) International Business Machines
  * Corporation, 2000
  *
  * Modifications to Mozilla code or documentation
  * identified per MPL Section 3.3
  *
  * Date         Modified by     Description of modification
  * 03/27/2000   IBM Corp.       Added PR_CALLBACK for Optlink
  *                               use in OS2
  */
 /*
   This file provides the implementation for the sort service manager.
  */
 #include "nsCOMPtr.h"
 #include "nsIContent.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNode.h"
 #include "nsIServiceManager.h"
 #include "nsGkAtoms.h"
 #include "nsNameSpaceManager.h"
 #include "nsXULContentUtils.h"
 #include "nsString.h"
 #include "nsQuickSort.h"
 #include "nsWhitespaceTokenizer.h"
 #include "nsXULSortService.h"
 #include "nsIDOMXULElement.h"
 #include "nsIXULTemplateBuilder.h"
 #include "nsTemplateMatch.h"
 #include "nsICollation.h"
 #include "nsUnicharUtils.h"
 NS_IMPL_ISUPPORTS(XULSortServiceImpl, nsIXULSortService)
 void
 XULSortServiceImpl::SetSortHints(nsIContent *aNode, nsSortState* aSortState)
 {
   // set sort and sortDirection attributes when is sort is done
   aNode->SetAttr(kNameSpaceID_None, nsGkAtoms::sort,
                  aSortState->sort, true);
   nsAutoString direction;
   if (aSortState->direction == nsSortState_descending)
     direction.AssignLiteral("descending");
   else if (aSortState->direction == nsSortState_ascending)
     direction.AssignLiteral("ascending");
   aNode->SetAttr(kNameSpaceID_None, nsGkAtoms::sortDirection,
                  direction, true);
   // for trees, also set the sort info on the currently sorted column
   if (aNode->NodeInfo()->Equals(nsGkAtoms::tree, kNameSpaceID_XUL)) {
     if (aSortState->sortKeys.Count() >= 1) {
       nsAutoString sortkey;
       aSortState->sortKeys[0]->ToString(sortkey);
       SetSortColumnHints(aNode, sortkey, direction);
     }
   }
 }
 void
 XULSortServiceImpl::SetSortColumnHints(nsIContent *content,
                                        const nsAString &sortResource,
                                        const nsAString &sortDirection)
 {
   // set sort info on current column. This ensures that the
   // column header sort indicator is updated properly.
   for (nsIContent* child = content->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     if (child->IsXUL()) {
       nsIAtom *tag = child->Tag();
       if (tag == nsGkAtoms::treecols) {
         SetSortColumnHints(child, sortResource, sortDirection);
       } else if (tag == nsGkAtoms::treecol) {
         nsAutoString value;
         child->GetAttr(kNameSpaceID_None, nsGkAtoms::sort, value);
         // also check the resource attribute for older code
         if (value.IsEmpty())
           child->GetAttr(kNameSpaceID_None, nsGkAtoms::resource, value);
         if (value == sortResource) {
           child->SetAttr(kNameSpaceID_None, nsGkAtoms::sortActive,
                          NS_LITERAL_STRING("true"), true);
           child->SetAttr(kNameSpaceID_None, nsGkAtoms::sortDirection,
                          sortDirection, true);
           // Note: don't break out of loop; want to set/unset
           // attribs on ALL sort columns
         } else if (!value.IsEmpty()) {
           child->UnsetAttr(kNameSpaceID_None, nsGkAtoms::sortActive,
                            true);
           child->UnsetAttr(kNameSpaceID_None, nsGkAtoms::sortDirection,
                            true);
         }
       }
     }
   }
 }
 nsresult
 XULSortServiceImpl::GetItemsToSort(nsIContent *aContainer,
                                    nsSortState* aSortState,
                                    nsTArray<contentSortInfo>& aSortItems)
 {
   // if there is a template attached to the sort node, use the builder to get
   // the items to be sorted
   nsCOMPtr<nsIDOMXULElement> element = do_QueryInterface(aContainer);
   if (element) {
     nsCOMPtr<nsIXULTemplateBuilder> builder;
     element->GetBuilder(getter_AddRefs(builder));
     if (builder) {
       nsresult rv = builder->GetQueryProcessor(getter_AddRefs(aSortState->processor));
       if (NS_FAILED(rv) || !aSortState->processor)
         return rv;
       return GetTemplateItemsToSort(aContainer, builder, aSortState, aSortItems);
     }
   }
   // if there is no template builder, just get the children. For trees,
   // get the treechildren element as use that as the parent
   nsCOMPtr<nsIContent> treechildren;
   if (aContainer->NodeInfo()->Equals(nsGkAtoms::tree, kNameSpaceID_XUL)) {
     nsXULContentUtils::FindChildByTag(aContainer,
                                       kNameSpaceID_XUL,
                                       nsGkAtoms::treechildren,
                                       getter_AddRefs(treechildren));
     if (!treechildren)
       return NS_OK;
     aContainer = treechildren;
   }
   for (nsIContent* child = aContainer->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     contentSortInfo* cinfo = aSortItems.AppendElement();
     if (!cinfo)
       return NS_ERROR_OUT_OF_MEMORY;
     cinfo->content = child;
   }
   return NS_OK;
 }
 nsresult
 XULSortServiceImpl::GetTemplateItemsToSort(nsIContent* aContainer,
                                            nsIXULTemplateBuilder* aBuilder,
                                            nsSortState* aSortState,
                                            nsTArray<contentSortInfo>& aSortItems)
 {
   for (nsIContent* child = aContainer->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     nsCOMPtr<nsIDOMElement> childnode = do_QueryInterface(child);
     nsCOMPtr<nsIXULTemplateResult> result;
     nsresult rv = aBuilder->GetResultForContent(childnode, getter_AddRefs(result));
     NS_ENSURE_SUCCESS(rv, rv);
     if (result) {
       contentSortInfo* cinfo = aSortItems.AppendElement();
       if (!cinfo)
         return NS_ERROR_OUT_OF_MEMORY;
       cinfo->content = child;
       cinfo->result = result;
     }
     else if (aContainer->Tag() != nsGkAtoms::_template) {
       rv = GetTemplateItemsToSort(child, aBuilder, aSortState, aSortItems);
       NS_ENSURE_SUCCESS(rv, rv);
     }
   }
   return NS_OK;
 }
 int
 testSortCallback(const void *data1, const void *data2, void *privateData)
 {
   /// Note: testSortCallback is a small C callback stub for NS_QuickSort
   contentSortInfo *left = (contentSortInfo *)data1;
   contentSortInfo *right = (contentSortInfo *)data2;
   nsSortState* sortState = (nsSortState *)privateData;
   int32_t sortOrder = 0;
   if (sortState->direction == nsSortState_natural && sortState->processor) {
     // sort in natural order
     sortState->processor->CompareResults(left->result, right->result,
                                          nullptr, sortState->sortHints, &sortOrder);
   }
   else {
     int32_t length = sortState->sortKeys.Count();
     for (int32_t t = 0; t < length; t++) {
       // for templates, use the query processor to do sorting
       if (sortState->processor) {
         sortState->processor->CompareResults(left->result, right->result,
                                              sortState->sortKeys[t],
                                              sortState->sortHints, &sortOrder);
         if (sortOrder)
           break;
       }
       else {
         // no template, so just compare attributes. Ignore namespaces for now.
         nsAutoString leftstr, rightstr;
         left->content->GetAttr(kNameSpaceID_None, sortState->sortKeys[t], leftstr);
         right->content->GetAttr(kNameSpaceID_None, sortState->sortKeys[t], rightstr);
         sortOrder = XULSortServiceImpl::CompareValues(leftstr, rightstr, sortState->sortHints);
       }
     }
   }
   if (sortState->direction == nsSortState_descending)
     sortOrder = -sortOrder;
   return sortOrder;
 }
 nsresult
 XULSortServiceImpl::SortContainer(nsIContent *aContainer, nsSortState* aSortState)
 {
   nsTArray<contentSortInfo> items;
   nsresult rv = GetItemsToSort(aContainer, aSortState, items);
   NS_ENSURE_SUCCESS(rv, rv);
   uint32_t numResults = items.Length();
   if (!numResults)
     return NS_OK;
   uint32_t i;
   // inbetweenSeparatorSort sorts the items between separators independently
   if (aSortState->inbetweenSeparatorSort) {
     uint32_t startIndex = 0;
     for (i = 0; i < numResults; i++) {
       if (i > startIndex + 1) {
         nsAutoString type;
         items[i].result->GetType(type);
         if (type.EqualsLiteral("separator")) {
           if (aSortState->invertSort)
             InvertSortInfo(items, startIndex, i - startIndex);
           else
             NS_QuickSort((void *)(items.Elements() + startIndex), i - startIndex,
                          sizeof(contentSortInfo), testSortCallback, (void*)aSortState);
           startIndex = i + 1;
         }
       }
     }
     if (i > startIndex + 1) {
       if (aSortState->invertSort)
         InvertSortInfo(items, startIndex, i - startIndex);
       else
         NS_QuickSort((void *)(items.Elements() + startIndex), i - startIndex,
                      sizeof(contentSortInfo), testSortCallback, (void*)aSortState);
     }
   } else {
     // if the items are just being inverted, that is, just switching between
     // ascending and descending, just reverse the list.
     if (aSortState->invertSort)
       InvertSortInfo(items, 0, numResults);
     else
       NS_QuickSort((void *)items.Elements(), numResults,
                    sizeof(contentSortInfo), testSortCallback, (void*)aSortState);
   }
   // first remove the items from the old positions
   for (i = 0; i < numResults; i++) {
     nsIContent* child = items[i].content;
     nsIContent* parent = child->GetParent();
     if (parent) {
       // remember the parent so that it can be reinserted back
       // into the same parent. This is necessary as multiple rules
       // may generate results which get placed in different locations.
       items[i].parent = parent;
       int32_t index = parent->IndexOf(child);
       parent->RemoveChildAt(index, true);
     }
   }
   // now add the items back in sorted order
   for (i = 0; i < numResults; i++)
   {
     nsIContent* child = items[i].content;
     nsIContent* parent = items[i].parent;
     if (parent) {
       parent->AppendChildTo(child, true);
       // if it's a container in a tree or menu, find its children,
       // and sort those also
       if (!child->AttrValueIs(kNameSpaceID_None, nsGkAtoms::container,
                               nsGkAtoms::_true, eCaseMatters))
         continue;
       for (nsIContent* grandchild = child->GetFirstChild();
            grandchild;
            grandchild = grandchild->GetNextSibling()) {
         nsINodeInfo *ni = grandchild->NodeInfo();
         nsIAtom *localName = ni->NameAtom();
         if (ni->NamespaceID() == kNameSpaceID_XUL &&
             (localName == nsGkAtoms::treechildren ||
              localName == nsGkAtoms::menupopup)) {
           SortContainer(grandchild, aSortState);
         }
       }
     }
   }
   return NS_OK;
 }
 nsresult
 XULSortServiceImpl::InvertSortInfo(nsTArray<contentSortInfo>& aData,
                                    int32_t aStart, int32_t aNumItems)
 {
   if (aNumItems > 1) {
     // reverse the items in the array starting from aStart
     int32_t upPoint = (aNumItems + 1) / 2 + aStart;
     int32_t downPoint = (aNumItems - 2) / 2 + aStart;
     int32_t half = aNumItems / 2;
     while (half-- > 0) {
       aData[downPoint--].swap(aData[upPoint++]);
     }
   }
   return NS_OK;
 }
 nsresult
 XULSortServiceImpl::InitializeSortState(nsIContent* aRootElement,
                                         nsIContent* aContainer,
                                         const nsAString& aSortKey,
                                         const nsAString& aSortHints,
                                         nsSortState* aSortState)
 {
   // used as an optimization for the content builder
   if (aContainer != aSortState->lastContainer.get()) {
     aSortState->lastContainer = aContainer;
     aSortState->lastWasFirst = false;
     aSortState->lastWasLast = false;
   }
   // The attributes allowed are either:
   //    sort="key1 key2 ..."
   // or sortResource="key1" sortResource2="key2"
   // The latter is for backwards compatibility, and is equivalent to concatenating
   // both values in the sort attribute
   nsAutoString sort(aSortKey);
   aSortState->sortKeys.Clear();
   if (sort.IsEmpty()) {
     nsAutoString sortResource, sortResource2;
     aRootElement->GetAttr(kNameSpaceID_None, nsGkAtoms::sortResource, sortResource);
     if (!sortResource.IsEmpty()) {
       nsCOMPtr<nsIAtom> sortkeyatom = do_GetAtom(sortResource);
       aSortState->sortKeys.AppendObject(sortkeyatom);
       sort.Append(sortResource);
       aRootElement->GetAttr(kNameSpaceID_None, nsGkAtoms::sortResource2, sortResource2);
       if (!sortResource2.IsEmpty()) {
         nsCOMPtr<nsIAtom> sortkeyatom2 = do_GetAtom(sortResource2);
         aSortState->sortKeys.AppendObject(sortkeyatom2);
         sort.AppendLiteral(" ");
         sort.Append(sortResource2);
       }
     }
   }
   else {
     nsWhitespaceTokenizer tokenizer(sort);
     while (tokenizer.hasMoreTokens()) {
       nsCOMPtr<nsIAtom> keyatom = do_GetAtom(tokenizer.nextToken());
       NS_ENSURE_TRUE(keyatom, NS_ERROR_OUT_OF_MEMORY);
       aSortState->sortKeys.AppendObject(keyatom);
     }
   }
   aSortState->sort.Assign(sort);
   aSortState->direction = nsSortState_natural;
   bool noNaturalState = false;
   nsWhitespaceTokenizer tokenizer(aSortHints);
   while (tokenizer.hasMoreTokens()) {
     const nsDependentSubstring& token(tokenizer.nextToken());
     if (token.EqualsLiteral("comparecase"))
       aSortState->sortHints |= nsIXULSortService::SORT_COMPARECASE;
     else if (token.EqualsLiteral("integer"))
       aSortState->sortHints |= nsIXULSortService::SORT_INTEGER;
     else if (token.EqualsLiteral("descending"))
       aSortState->direction = nsSortState_descending;
     else if (token.EqualsLiteral("ascending"))
       aSortState->direction = nsSortState_ascending;
     else if (token.EqualsLiteral("twostate"))
       noNaturalState = true;
   }
   // if the twostate flag was set, the natural order is skipped and only
   // ascending and descending are allowed
   if (aSortState->direction == nsSortState_natural && noNaturalState) {
     aSortState->direction = nsSortState_ascending;
   }
   // set up sort order info
   aSortState->invertSort = false;
   nsAutoString existingsort;
   aRootElement->GetAttr(kNameSpaceID_None, nsGkAtoms::sort, existingsort);
   nsAutoString existingsortDirection;
   aRootElement->GetAttr(kNameSpaceID_None, nsGkAtoms::sortDirection, existingsortDirection);
   // if just switching direction, set the invertSort flag
   if (sort.Equals(existingsort)) {
     if (aSortState->direction == nsSortState_descending) {
       if (existingsortDirection.EqualsLiteral("ascending"))
         aSortState->invertSort = true;
     }
     else if (aSortState->direction == nsSortState_ascending &&
              existingsortDirection.EqualsLiteral("descending")) {
       aSortState->invertSort = true;
     }
   }
   // sort items between separators independently
   aSortState->inbetweenSeparatorSort =
     aRootElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::sortSeparators,
                               nsGkAtoms::_true, eCaseMatters);
   // sort static content (non template generated nodes) after generated content
   aSortState->sortStaticsLast = aRootElement->AttrValueIs(kNameSpaceID_None,
                                   nsGkAtoms::sortStaticsLast,
                                   nsGkAtoms::_true, eCaseMatters);
   aSortState->initialized = true;
   return NS_OK;
 }
 int32_t
 XULSortServiceImpl::CompareValues(const nsAString& aLeft,
                                   const nsAString& aRight,
                                   uint32_t aSortHints)
 {
   if (aSortHints & SORT_INTEGER) {
     nsresult err;
     int32_t leftint = PromiseFlatString(aLeft).ToInteger(&err);
     if (NS_SUCCEEDED(err)) {
       int32_t rightint = PromiseFlatString(aRight).ToInteger(&err);
       if (NS_SUCCEEDED(err)) {
         return leftint - rightint;
       }
     }
     // if they aren't integers, just fall through and compare strings
   }
   if (aSortHints & SORT_COMPARECASE) {
     return ::Compare(aLeft, aRight);
   }
   nsICollation* collation = nsXULContentUtils::GetCollation();
   if (collation) {
     int32_t result;
     collation->CompareString(nsICollation::kCollationCaseInSensitive,
                              aLeft, aRight, &result);
     return result;
   }
   return ::Compare(aLeft, aRight, nsCaseInsensitiveStringComparator());
 }
 NS_IMETHODIMP
 XULSortServiceImpl::Sort(nsIDOMNode* aNode,
                          const nsAString& aSortKey,
                          const nsAString& aSortHints)
 {
   // get root content node
   nsCOMPtr<nsIContent> sortNode = do_QueryInterface(aNode);
   if (!sortNode)
     return NS_ERROR_FAILURE;
   nsSortState sortState;
   nsresult rv = InitializeSortState(sortNode, sortNode,
                                     aSortKey, aSortHints, &sortState);
   NS_ENSURE_SUCCESS(rv, rv);
   // store sort info in attributes on content
   SetSortHints(sortNode, &sortState);
   rv = SortContainer(sortNode, &sortState);
   sortState.processor = nullptr; // don't hang on to this reference
   return rv;
 }
 nsresult
 NS_NewXULSortService(nsIXULSortService** sortService)
 {
   *sortService = new XULSortServiceImpl();
   if (!*sortService)
     return NS_ERROR_OUT_OF_MEMORY;
   NS_ADDREF(*sortService);
   return NS_OK;
 }

The Tor Browser / annotate

content/xul/templates/src/nsXULSortService.cpp@6474c204b198 (annotated)

content/xul/templates/src/nsXULSortService.cpp