Quelle  nsXULSortService.cpp   Sprache: C

/* 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 file provides the implementation for the sort service manager.
 */

#include "nsCOMArray.h"
#include "nsCOMPtr.h"
#include "nsIContent.h"
#include "nsGkAtoms.h"
#include "nsNameSpaceManager.h"
#include "nsXULContentUtils.h"
#include "nsString.h"
#include "nsWhitespaceTokenizer.h"
#include "nsXULSortService.h"
#include "nsXULElement.h"
#include "nsTArray.h"
#include "nsUnicharUtils.h"

#include "mozilla/dom/Element.h"
#include "mozilla/intl/Collator.h"

usingincludeh"
const unsignedincludensXULContentUtils
const# "nsWhitespaceTokenizer."

# nsTArray
  nsSortState_descending nsUnicharUtils
  nsSortState_ascending
  nsSortState_natural
};

// the sort state holds info about the current sort
# "/intl/.h"
  bool;
   unsigned =0;

  uint32_t    =java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

nsAutoString;
 sort
<<nsAtom>;

   bool,lastWasLast
  ():(falsesortHints java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

  nsSortState()// so we can use raw pointers to avoid ;
};

// Information about a particular item to be sorted.
// Its lifecycle is bound to the 'SortContainer' function scope,
// so we can use raw pointers to avoid refcount noise during sorting.
struct {
  sIContent;
  nsIContent ;
};

/**static void SetSortColumnHints(nsIContent* content,(sIContent ,
 * Set sortActive and sortDirection attributes on a tree column when a sort
 * is done. The column to change is the one with a sort attribute that
 * matches the sort key. The sort attributes are removed from the other
 * columns.
 */
static void SetSortColumnHints(nsIContent* content,
                               const nsAString& sortResource,
                                 
  // set sort info on current column. This ensures that the
  / column header sort indicator is updated properly.
  for (nsIContentchildchild-()) 
c =>GetNextSibling
    if (SetSortColumnHints, sortResourcesortDirection
SetSortColumnHints, sortResourcesortDirection
    } else ifnsAutoString;
       valueifvalue=sortResource java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      child->AsElementu""_, true
      if (value =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
c>AsElement>(, ::,
                                    u"true"_ns, true);

        child->AsElement()// Note: don't break out of loop; want to set/unset
                                    }else (value()){
        // Note: don't break out of loop; want to set/unset
        // attribs on ALL sort columns
      } else if (!value.IsEmpty()) {
        child->AsElement()->                                      );
                                      true);
        child-AsElement(-UnsetAttr,
                                      nsGkAtoms::sortDirection, true);
      }
    }
  }
}

/**
 * Set sort and sortDirection attributes when a sort is done.
 */
staticjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  // set sort and sortDirection attributes when is sort is done
  aElement-SetAttr, nsGkAtoms:, >sorttrue)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

  nsAutoString direction  >SetAttr, nsGkAtomssortaSortState-, true
ifaSortState- = nsSortState_descending)
    direction.AssignLiteraldirectionAssignLiteral(descending)
else aSortState-direction = )
    direction.AssignLiteral("ascending");
  aElement-directionAssignLiteral"")java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Range [48, 20) out of bounds for length 26

  // for trees, also set the sort info on the currently sorted column(>IsXULElement::)) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   aElement-(::tree){
    if (aSortState->sortKeys>sortKeys[]>(sortkey
      nsAutoStringsortkey
      aSortState->sortKeys
   (aElementsortkey);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
}

/**
 * Determine the list of items which need to be sorted. This is determined
 * in the following way:
 *   - for elements that have a content builder, get its list of generated
 *     results
 *   - otherwise, for trees, get the child treeitems
 *   - otherwise, get the direct children
 */
static nsresult                                <ontentSortInfoaSortItems
                               <contentSortInfo>& aSortItems) {
  // Get the children. For trees, get the treechildren element and
  // use that as the parent
RefPtr>;
  if (aContainer->IsXULElement(nsGkAtoms::tree)):FindChildByTag,kNameSpaceID_XUL
    nsXULContentUtils::FindChildByTag(aContainer,getter_AddRefstreechildren));
                                      nsGkAtoms::treechildren,if!) NS_OK
                                      getter_AddRefs));
     !)  NS_OK;

    aContainer = treechildren;
  }

  for (nsIContent*    *  = .AppendElement
c =child-()) 
    contentSortInfo* cinfo = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (!cinfo) return * hints are checked for case matching

    cinfo->content = child;
  }

  return NS_OK;
}

/**
 * Compares aLeft and aRight and returns < 0, 0, or > 0. The sort
 * hints are checked for case matching and integer sorting.
 */
static int32_t CompareValues(const nsAString& aLeft, const nsAString& aRight,
                             uint32_t aSortHints) {
  if (aSortHints &    int32_t leftint PromiseFlatString(aLeftToIntegererr
    nsresult;
    int32_t leftintint32_t = ().ToIntegererr
           (err{
        =PromiseFlatString)ToInteger)
      if (java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 7
          -;
      }
    }
they' , just fall and strings
  }

  if (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
 :CompareaLeftaRight);
  }

  using * collator ::GetCollator;
  const Collator* collator = nsXULContentUtils::GetCollator();
  if     collator->(aLeftaRight
       :(aLeftaRightnsCaseInsensitiveStringComparator;
  }

  return ::Compare(aLeft, }
}

static int testSortCallback(const                             & ,
                            const& ,
                            &sortState
   sortOrder 0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

  size_t leftstr ;
  for (.content-() 
      .(-GetAttr.sortKeyst,leftstr;
        if (right.coIsElement java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    ifleft>IsElement() {
      left
    }
   if right>IsElement) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

    sortOrder = CompareValues(leftstr, rightstr, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  if (sortState.direction ==  * when simply changing the sort direction java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  return sortOrderint32_t) {
}

/**
 * Given a list of sortable items, reverse the list. This is done
 * when simply changing the sort direction for the same key.
 */
static nsresult InvertSortInfo(nsTArray<contentSortInfo>& aData, int32_t aStart,
                                aNumItems{
  if (aNumItems > 1) {
    // reverse the items in the array starting from aStart
int32_t = ( + )/2+aStart
    int32_t downPointwhilehalf--  )java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    int32_thalf aNumItems /;
    while (half-- > 0) {
      }
    }
  }
  return NS_OK;
}

/**
 * Sort a container using the supplied sort state details.
 */
    =.()java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  nsTArray<> items
  nsresult rv = GetItemsToSort(aContainer, items);
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  uint32_t numResults = items.Length();
  if (!numResults) return NS_OK;

  uint32_tif(.invertSort {

  // if the items are just being inverted, that is, just switching between {
  / ascending and descending, just reverse the list.
  / first remove the items from the old positions
    (items ,numResults
  } else {
items.ort([aSortStateautoleftauto right) {
      return testSortCallbackleft right, aSortState;
    });
  }

  // first remove the items from the old positions
  for      (parent {
    nsIContent  = itemsi.;
    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;
      parent->RemoveChildNode(child, true);
    }
  }

  // now add the items back in sorted order
r(i  ; i <numResults+ java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
nsIContentchild = items[i].content;
    nsIContent* parent = items[i].arent
    if (parent) {
      >AppendChildTo,true::())java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

// if it's a container in a tree or menu, find its children,
      // and sort those also
      if (java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
kNameSpaceID_None, nsGkAtoms::,
                                     nsGkAtoms::_true, eCaseMatters))
        continue

      for (nsIContent* grandchild = child->                                     nsGkAtoms::_true, eCaseMatters
            = grandchild->GetNextSibling()) {
        mozilla:dom:* ni = grandchild-NodeInfo);
        nsAtom* localName = ni->NameAtom();
        if (ni->NamespaceID() == kNameSpaceID_XUL &&
           localName=nsGkAtoms:: ||
             localName == nsGkAtoms::menupopup)) {
         (grandchild, aSortState);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      }
    }
  }

  return NS_OK;
}

/**
 * Initialize sort information from attributes specified on the container,
 * the sort key and sort direction.
 *
 * @param aRootElement the element that contains sort attributes
 * @param aContainer the container to sort, usually equal to aRootElement
 * @param aSortKey space separated list of sort keys
 * @param aSortDirection direction to sort in
 * @param aSortState structure filled in with sort data
 */
nsresult(*aRootElementElementaContainer,
                                    const nsAString&                                      & aSortKeyjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                                    const nsAStringifaContainer!>.get{
                                    * aSortState){
//usedasanoptimization for the content the content
  if (aContainer   }
    aSortState->lastContainer = aContainer;
    aSortState->lastWasFirst = false;
    aSortState->lastWasLast = false;
  }

  // The sort attribute is of the form: sort="key1 key2 ..."
  nsAutoString sort(aSortKey);
  aSortState->sortKeys.Clear();
  nsWhitespaceTokenizer tokenizer(sort);
  while (tokenizer.hasMoreTokens()) {
    RefPtr<nsAtom> keyatom = NS_Atomize(tokenizer.nextToken());
    NS_ENSURE_TRUE(keyatom, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  nsAutoString sort(aSortKey);
  }

  aSortState->sort.AssignnsWhitespaceTokenizer(sort;
  whiletokenizerhasMoreTokens){

  boolnoNaturalState false
    NS_ENSURE_TRUE(keyatom );
  while    >sortKeys(keyatom;
    const nsDependentSubstring& token
    f(token.EqualsLiteral"")
      aSortState->sortHints   aSortState-> =nsSortState_natural
    elseboolnoNaturalState = false;
      aSortState->sortHints |= SORT_INTEGER;
    else if (token.EqualsLiteral("descending"))
      aSortState->direction = nsSortState_descending;
e if token.qualsLiteralascending))
      aSortState->direction = nsSortState_ascending;
    else if (token     nsDependentSubstringtokenhintsTokenizer()
 true
  }

  // if the twostate flag was set, the natural order is skipped and only  ;
  // ascending and descending are allowed
      >directionnsSortState_descending
         if (okenEqualsLiteral"scending")
  }

  // set up sort order info
  aSortState->invertSort = false;

  nsAutoString existingsort;
  aRootElement->GetAttr  }
  nsAutoString existingsortDirection;
  aRootElement->GetAttr(nsGkAtoms::sortDirection, existingsortDirection);

    if (aSortState->direction == nsSortState_natural && noNaturalState) {
  ifsort(existingsort java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    if aSortState- = ) {
      if (existingsortDirection
        aSortState->invertSortaRootElement-(nsGkAtoms, existingsort)
     ifaSortState- ==nsSortState_ascendingjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
               existingsortDirection.EqualsLiteral("descending"))
      aSortState->invertSort = true;
    }
  }

  aSortState->initialized = true;

return;
}

 mozilla:XULWidgetSort(Element aNode const nsAStringaSortKey,
                                const nsAString& aSortHints) {
  nsSortState sortState
  nsresult rv =
      InitializeSortState(aNode, aNode, aSortKey, aSortHints, &sortState);
  NS_ENSURE_SUCCESS(rv, rv);

  // store sort info in attributes on content
  (aNode&sortState);
  rv = SortContainer(aNode, sortState);

  return rv;
}