docshell/base/nsDocShellEnumerator.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is the Mozilla browser.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Netscape Communications, Inc.
  20  * Portions created by the Initial Developer are Copyright (C) 1999
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39
  40 #include "nsDocShellEnumerator.h"
  41
  42 #include "nsIDocShellTreeItem.h"
  43 #include "nsIDocShellTreeNode.h"
  44
  45 nsDocShellEnumerator::nsDocShellEnumerator(PRInt32 inEnumerationDirection)
  46 : mRootItem(nsnull)
  47 , mCurIndex(0)
  48 , mDocShellType(nsIDocShellTreeItem::typeAll)
  49 , mArrayValid(PR_FALSE)
  50 , mEnumerationDirection(inEnumerationDirection)
  51 {
  52 }
  53
  54 nsDocShellEnumerator::~nsDocShellEnumerator()
  55 {
  56 }
  57
  58 NS_IMPL_ISUPPORTS1(nsDocShellEnumerator, nsISimpleEnumerator)
  59
  60
  61 /* nsISupports getNext (); */
  62 NS_IMETHODIMP nsDocShellEnumerator::GetNext(nsISupports **outCurItem)
  63 {
  64   NS_ENSURE_ARG_POINTER(outCurItem);
  65   *outCurItem = nsnull;
  66
  67   nsresult rv = EnsureDocShellArray();
  68   if (NS_FAILED(rv)) return rv;
  69
  70   if (mCurIndex >= mItemArray.Length()) {
  71     return NS_ERROR_FAILURE;
  72   }
  73
  74   // post-increment is important here
  75   return CallQueryInterface(mItemArray[mCurIndex++], outCurItem);
  76 }
  77
  78 /* boolean hasMoreElements (); */
  79 NS_IMETHODIMP nsDocShellEnumerator::HasMoreElements(PRBool *outHasMore)
  80 {
  81   NS_ENSURE_ARG_POINTER(outHasMore);
  82   *outHasMore = PR_FALSE;
  83
  84   nsresult rv = EnsureDocShellArray();
  85   if (NS_FAILED(rv)) return rv;
  86
  87   *outHasMore = (mCurIndex < mItemArray.Length());
  88   return NS_OK;
  89 }
  90
  91 nsresult nsDocShellEnumerator::GetEnumerationRootItem(nsIDocShellTreeItem * *aEnumerationRootItem)
  92 {
  93   NS_ENSURE_ARG_POINTER(aEnumerationRootItem);
  94   *aEnumerationRootItem = mRootItem;
  95   NS_IF_ADDREF(*aEnumerationRootItem);
  96   return NS_OK;
  97 }
  98
  99 nsresult nsDocShellEnumerator::SetEnumerationRootItem(nsIDocShellTreeItem * aEnumerationRootItem)
 100 {
 101   mRootItem = aEnumerationRootItem;
 102   ClearState();
 103   return NS_OK;
 104 }
 105
 106 nsresult nsDocShellEnumerator::GetEnumDocShellType(PRInt32 *aEnumerationItemType)
 107 {
 108   NS_ENSURE_ARG_POINTER(aEnumerationItemType);
 109   *aEnumerationItemType = mDocShellType;
 110   return NS_OK;
 111 }
 112
 113 nsresult nsDocShellEnumerator::SetEnumDocShellType(PRInt32 aEnumerationItemType)
 114 {
 115   mDocShellType = aEnumerationItemType;
 116   ClearState();
 117   return NS_OK;
 118 }
 119
 120 nsresult nsDocShellEnumerator::First()
 121 {
 122   mCurIndex = 0;
 123   return EnsureDocShellArray();
 124 }
 125
 126 nsresult nsDocShellEnumerator::EnsureDocShellArray()
 127 {
 128   if (!mArrayValid)
 129   {
 130     mArrayValid = PR_TRUE;
 131     return BuildDocShellArray(mItemArray);
 132   }
 133
 134   return NS_OK;
 135 }
 136
 137 nsresult nsDocShellEnumerator::ClearState()
 138 {
 139   mItemArray.Clear();
 140   mArrayValid = PR_FALSE;
 141   mCurIndex = 0;
 142   return NS_OK;
 143 }
 144
 145 nsresult nsDocShellEnumerator::BuildDocShellArray(nsTArray<nsIDocShellTreeItem*>& inItemArray)
 146 {
 147   NS_ENSURE_TRUE(mRootItem, NS_ERROR_NOT_INITIALIZED);
 148   inItemArray.Clear();
 149   return BuildArrayRecursive(mRootItem, inItemArray);
 150 }
 151
 152 nsresult nsDocShellForwardsEnumerator::BuildArrayRecursive(nsIDocShellTreeItem* inItem, nsTArray<nsIDocShellTreeItem*>& inItemArray)
 153 {
 154   nsresult rv;
 155   nsCOMPtr<nsIDocShellTreeNode> itemAsNode = do_QueryInterface(inItem, &rv);
 156   if (NS_FAILED(rv)) return rv;
 157
 158   PRInt32   itemType;
 159   // add this item to the array
 160   if ((mDocShellType == nsIDocShellTreeItem::typeAll) ||
 161       (NS_SUCCEEDED(inItem->GetItemType(&itemType)) && (itemType == mDocShellType)))
 162   {
 163     if (!inItemArray.AppendElement(inItem))
 164       return NS_ERROR_OUT_OF_MEMORY;
 165   }
 166
 167   PRInt32   numChildren;
 168   rv = itemAsNode->GetChildCount(&numChildren);
 169   if (NS_FAILED(rv)) return rv;
 170
 171   for (PRInt32 i = 0; i < numChildren; ++i)
 172   {
 173     nsCOMPtr<nsIDocShellTreeItem> curChild;
 174     rv = itemAsNode->GetChildAt(i, getter_AddRefs(curChild));
 175     if (NS_FAILED(rv)) return rv;
 176
 177     rv = BuildArrayRecursive(curChild, inItemArray);
 178     if (NS_FAILED(rv)) return rv;
 179   }
 180
 181   return NS_OK;
 182 }
 183
 184
 185 nsresult nsDocShellBackwardsEnumerator::BuildArrayRecursive(nsIDocShellTreeItem* inItem, nsTArray<nsIDocShellTreeItem*>& inItemArray)
 186 {
 187   nsresult rv;
 188   nsCOMPtr<nsIDocShellTreeNode> itemAsNode = do_QueryInterface(inItem, &rv);
 189   if (NS_FAILED(rv)) return rv;
 190
 191   PRInt32   numChildren;
 192   rv = itemAsNode->GetChildCount(&numChildren);
 193   if (NS_FAILED(rv)) return rv;
 194
 195   for (PRInt32 i = numChildren - 1; i >= 0; --i)
 196   {
 197     nsCOMPtr<nsIDocShellTreeItem> curChild;
 198     rv = itemAsNode->GetChildAt(i, getter_AddRefs(curChild));
 199     if (NS_FAILED(rv)) return rv;
 200
 201     rv = BuildArrayRecursive(curChild, inItemArray);
 202     if (NS_FAILED(rv)) return rv;
 203   }
 204
 205   PRInt32   itemType;
 206   // add this item to the array
 207   if ((mDocShellType == nsIDocShellTreeItem::typeAll) ||
 208       (NS_SUCCEEDED(inItem->GetItemType(&itemType)) && (itemType == mDocShellType)))
 209   {
 210     if (!inItemArray.AppendElement(inItem))
 211       return NS_ERROR_OUT_OF_MEMORY;
 212   }
 213
 214
 215   return NS_OK;
 216 }
 217
 218