dom/html/HTMLOptionsCollection.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/dom/HTMLOptionsCollection.h"
   7
   8 #include "HTMLOptGroupElement.h"
   9 #include "mozAutoDocUpdate.h"
  10 #include "mozilla/dom/BindingUtils.h"
  11 #include "mozilla/dom/Element.h"
  12 #include "mozilla/dom/HTMLOptionElement.h"
  13 #include "mozilla/dom/HTMLOptionsCollectionBinding.h"
  14 #include "mozilla/dom/HTMLSelectElement.h"
  15 #include "nsContentCreatorFunctions.h"
  16 #include "nsError.h"
  17 #include "nsFormSubmission.h"
  18 #include "nsGkAtoms.h"
  19 #include "nsIComboboxControlFrame.h"
  20 #include "nsIDocument.h"
  21 #include "nsIDOMHTMLOptGroupElement.h"
  22 #include "nsIFormControlFrame.h"
  23 #include "nsIForm.h"
  24 #include "nsIFormProcessor.h"
  25 #include "nsIListControlFrame.h"
  26 #include "nsLayoutUtils.h"
  27 #include "nsMappedAttributes.h"
  28 #include "nsRuleData.h"
  29 #include "nsServiceManagerUtils.h"
  30 #include "nsStyleConsts.h"
  31 #include "jsfriendapi.h"
  32
  33 namespace mozilla {
  34 namespace dom {
  35
  36 HTMLOptionsCollection::HTMLOptionsCollection(HTMLSelectElement* aSelect)
  37 {
  38   // Do not maintain a reference counted reference. When
  39   // the select goes away, it will let us know.
  40   mSelect = aSelect;
  41 }
  42
  43 HTMLOptionsCollection::~HTMLOptionsCollection()
  44 {
  45   DropReference();
  46 }
  47
  48 void
  49 HTMLOptionsCollection::DropReference()
  50 {
  51   // Drop our (non ref-counted) reference
  52   mSelect = nullptr;
  53 }
  54
  55 nsresult
  56 HTMLOptionsCollection::GetOptionIndex(Element* aOption,
  57                                       int32_t aStartIndex,
  58                                       bool aForward,
  59                                       int32_t* aIndex)
  60 {
  61   // NOTE: aIndex shouldn't be set if the returned value isn't NS_OK.
  62
  63   int32_t index;
  64
  65   // Make the common case fast
  66   if (aStartIndex == 0 && aForward) {
  67     index = mElements.IndexOf(aOption);
  68     if (index == -1) {
  69       return NS_ERROR_FAILURE;
  70     }
  71
  72     *aIndex = index;
  73     return NS_OK;
  74   }
  75
  76   int32_t high = mElements.Length();
  77   int32_t step = aForward ? 1 : -1;
  78
  79   for (index = aStartIndex; index < high && index > -1; index += step) {
  80     if (mElements[index] == aOption) {
  81       *aIndex = index;
  82       return NS_OK;
  83     }
  84   }
  85
  86   return NS_ERROR_FAILURE;
  87 }
  88
  89
  90 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(HTMLOptionsCollection, mElements)
  91
  92 // nsISupports
  93
  94 // QueryInterface implementation for HTMLOptionsCollection
  95 NS_INTERFACE_TABLE_HEAD(HTMLOptionsCollection)
  96   NS_WRAPPERCACHE_INTERFACE_TABLE_ENTRY
  97   NS_INTERFACE_TABLE(HTMLOptionsCollection,
  98                      nsIHTMLCollection,
  99                      nsIDOMHTMLOptionsCollection,
 100                      nsIDOMHTMLCollection)
 101   NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(HTMLOptionsCollection)
 102 NS_INTERFACE_MAP_END
 103
 104
 105 NS_IMPL_CYCLE_COLLECTING_ADDREF(HTMLOptionsCollection)
 106 NS_IMPL_CYCLE_COLLECTING_RELEASE(HTMLOptionsCollection)
 107
 108
 109 JSObject*
 110 HTMLOptionsCollection::WrapObject(JSContext* aCx)
 111 {
 112   return HTMLOptionsCollectionBinding::Wrap(aCx, this);
 113 }
 114
 115 NS_IMETHODIMP
 116 HTMLOptionsCollection::GetLength(uint32_t* aLength)
 117 {
 118   *aLength = mElements.Length();
 119
 120   return NS_OK;
 121 }
 122
 123 NS_IMETHODIMP
 124 HTMLOptionsCollection::SetLength(uint32_t aLength)
 125 {
 126   if (!mSelect) {
 127     return NS_ERROR_UNEXPECTED;
 128   }
 129
 130   return mSelect->SetLength(aLength);
 131 }
 132
 133 NS_IMETHODIMP
 134 HTMLOptionsCollection::SetOption(uint32_t aIndex,
 135                                  nsIDOMHTMLOptionElement* aOption)
 136 {
 137   if (!mSelect) {
 138     return NS_OK;
 139   }
 140
 141   // if the new option is null, just remove this option.  Note that it's safe
 142   // to pass a too-large aIndex in here.
 143   if (!aOption) {
 144     mSelect->Remove(aIndex);
 145
 146     // We're done.
 147     return NS_OK;
 148   }
 149
 150   nsresult rv = NS_OK;
 151
 152   uint32_t index = uint32_t(aIndex);
 153
 154   // Now we're going to be setting an option in our collection
 155   if (index > mElements.Length()) {
 156     // Fill our array with blank options up to (but not including, since we're
 157     // about to change it) aIndex, for compat with other browsers.
 158     rv = SetLength(index);
 159     NS_ENSURE_SUCCESS(rv, rv);
 160   }
 161
 162   NS_ASSERTION(index <= mElements.Length(), "SetLength lied");
 163
 164   nsCOMPtr<nsIDOMNode> ret;
 165   if (index == mElements.Length()) {
 166     nsCOMPtr<nsIDOMNode> node = do_QueryInterface(aOption);
 167     rv = mSelect->AppendChild(node, getter_AddRefs(ret));
 168   } else {
 169     // Find the option they're talking about and replace it
 170     // hold a strong reference to follow COM rules.
 171     nsRefPtr<HTMLOptionElement> refChild = ItemAsOption(index);
 172     NS_ENSURE_TRUE(refChild, NS_ERROR_UNEXPECTED);
 173
 174     nsCOMPtr<nsINode> parent = refChild->GetParent();
 175     if (parent) {
 176       nsCOMPtr<nsINode> node = do_QueryInterface(aOption);
 177       ErrorResult res;
 178       parent->ReplaceChild(*node, *refChild, res);
 179       rv = res.ErrorCode();
 180     }
 181   }
 182
 183   return rv;
 184 }
 185
 186 int32_t
 187 HTMLOptionsCollection::GetSelectedIndex(ErrorResult& aError)
 188 {
 189   if (!mSelect) {
 190     aError.Throw(NS_ERROR_UNEXPECTED);
 191     return 0;
 192   }
 193
 194   int32_t selectedIndex;
 195   aError = mSelect->GetSelectedIndex(&selectedIndex);
 196   return selectedIndex;
 197 }
 198
 199 NS_IMETHODIMP
 200 HTMLOptionsCollection::GetSelectedIndex(int32_t* aSelectedIndex)
 201 {
 202   ErrorResult rv;
 203   *aSelectedIndex = GetSelectedIndex(rv);
 204   return rv.ErrorCode();
 205 }
 206
 207 void
 208 HTMLOptionsCollection::SetSelectedIndex(int32_t aSelectedIndex,
 209                                         ErrorResult& aError)
 210 {
 211   if (!mSelect) {
 212     aError.Throw(NS_ERROR_UNEXPECTED);
 213     return;
 214   }
 215
 216   aError = mSelect->SetSelectedIndex(aSelectedIndex);
 217 }
 218
 219 NS_IMETHODIMP
 220 HTMLOptionsCollection::SetSelectedIndex(int32_t aSelectedIndex)
 221 {
 222   ErrorResult rv;
 223   SetSelectedIndex(aSelectedIndex, rv);
 224   return rv.ErrorCode();
 225 }
 226
 227 NS_IMETHODIMP
 228 HTMLOptionsCollection::Item(uint32_t aIndex, nsIDOMNode** aReturn)
 229 {
 230   nsISupports* item = GetElementAt(aIndex);
 231   if (!item) {
 232     *aReturn = nullptr;
 233
 234     return NS_OK;
 235   }
 236
 237   return CallQueryInterface(item, aReturn);
 238 }
 239
 240 Element*
 241 HTMLOptionsCollection::GetElementAt(uint32_t aIndex)
 242 {
 243   return ItemAsOption(aIndex);
 244 }
 245
 246 HTMLOptionElement*
 247 HTMLOptionsCollection::NamedGetter(const nsAString& aName, bool& aFound)
 248 {
 249   uint32_t count = mElements.Length();
 250   for (uint32_t i = 0; i < count; i++) {
 251     HTMLOptionElement* content = mElements.ElementAt(i);
 252     if (content &&
 253         (content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name, aName,
 254                               eCaseMatters) ||
 255          content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::id, aName,
 256                               eCaseMatters))) {
 257       aFound = true;
 258       return content;
 259     }
 260   }
 261
 262   aFound = false;
 263   return nullptr;
 264 }
 265
 266 nsINode*
 267 HTMLOptionsCollection::GetParentObject()
 268 {
 269   return mSelect;
 270 }
 271
 272 NS_IMETHODIMP
 273 HTMLOptionsCollection::NamedItem(const nsAString& aName,
 274                                  nsIDOMNode** aReturn)
 275 {
 276   NS_IF_ADDREF(*aReturn = GetNamedItem(aName));
 277
 278   return NS_OK;
 279 }
 280
 281 void
 282 HTMLOptionsCollection::GetSupportedNames(unsigned aFlags,
 283                                          nsTArray<nsString>& aNames)
 284 {
 285   if (!(aFlags & JSITER_HIDDEN)) {
 286     return;
 287   }
 288
 289   nsAutoTArray<nsIAtom*, 8> atoms;
 290   for (uint32_t i = 0; i < mElements.Length(); ++i) {
 291     HTMLOptionElement* content = mElements.ElementAt(i);
 292     if (content) {
 293       // Note: HasName means the names is exposed on the document,
 294       // which is false for options, so we don't check it here.
 295       const nsAttrValue* val = content->GetParsedAttr(nsGkAtoms::name);
 296       if (val && val->Type() == nsAttrValue::eAtom) {
 297         nsIAtom* name = val->GetAtomValue();
 298         if (!atoms.Contains(name)) {
 299           atoms.AppendElement(name);
 300         }
 301       }
 302       if (content->HasID()) {
 303         nsIAtom* id = content->GetID();
 304         if (!atoms.Contains(id)) {
 305           atoms.AppendElement(id);
 306         }
 307       }
 308     }
 309   }
 310
 311   aNames.SetCapacity(atoms.Length());
 312   for (uint32_t i = 0; i < atoms.Length(); ++i) {
 313     aNames.AppendElement(nsDependentAtomString(atoms[i]));
 314   }
 315 }
 316
 317 NS_IMETHODIMP
 318 HTMLOptionsCollection::GetSelect(nsIDOMHTMLSelectElement** aReturn)
 319 {
 320   NS_IF_ADDREF(*aReturn = mSelect);
 321   return NS_OK;
 322 }
 323
 324 NS_IMETHODIMP
 325 HTMLOptionsCollection::Add(nsIDOMHTMLOptionElement* aOption,
 326                            nsIVariant* aBefore)
 327 {
 328   if (!aOption) {
 329     return NS_ERROR_INVALID_ARG;
 330   }
 331
 332   if (!mSelect) {
 333     return NS_ERROR_NOT_INITIALIZED;
 334   }
 335
 336   nsCOMPtr<nsIDOMHTMLElement> elem = do_QueryInterface(aOption);
 337   return mSelect->Add(elem, aBefore);
 338 }
 339
 340 void
 341 HTMLOptionsCollection::Add(const HTMLOptionOrOptGroupElement& aElement,
 342                            const Nullable<HTMLElementOrLong>& aBefore,
 343                            ErrorResult& aError)
 344 {
 345   if (!mSelect) {
 346     aError.Throw(NS_ERROR_NOT_INITIALIZED);
 347     return;
 348   }
 349
 350   mSelect->Add(aElement, aBefore, aError);
 351 }
 352
 353 void
 354 HTMLOptionsCollection::Remove(int32_t aIndex, ErrorResult& aError)
 355 {
 356   if (!mSelect) {
 357     aError.Throw(NS_ERROR_UNEXPECTED);
 358     return;
 359   }
 360
 361   uint32_t len = 0;
 362   mSelect->GetLength(&len);
 363   if (aIndex < 0 || (uint32_t)aIndex >= len)
 364     aIndex = 0;
 365
 366   aError = mSelect->Remove(aIndex);
 367 }
 368
 369 NS_IMETHODIMP
 370 HTMLOptionsCollection::Remove(int32_t aIndex)
 371 {
 372   ErrorResult rv;
 373   Remove(aIndex, rv);
 374   return rv.ErrorCode();
 375 }
 376
 377 } // namespace dom
 378 } // namespace mozilla