DXR will be turned off on Tuesday, December 29th. It will redirect to Searchfox.
See the announcement on Discourse.

DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (c68fe15a81fc)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */

#ifndef mozilla_dom_HTMLOptionElement_h__
#ifndef mozilla_dom_HTMLOptionElement_h__
#define mozilla_dom_HTMLOptionElement_h__

#include "mozilla/Attributes.h"
#include "nsGenericHTMLElement.h"
#include "mozilla/dom/HTMLFormElement.h"

namespace mozilla {
namespace mozilla {
namespace dom {

class HTMLSelectElement;

class HTMLOptionElement final : public nsGenericHTMLElement {
class HTMLOptionElement final : public nsGenericHTMLElement {
 public:
  explicit HTMLOptionElement(
      already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);

  static already_AddRefed<HTMLOptionElement> Option(
  static already_AddRefed<HTMLOptionElement> Option(
      const GlobalObject& aGlobal, const nsAString& aText,
      const Optional<nsAString>& aValue, bool aDefaultSelected, bool aSelected,
      ErrorResult& aError);

  NS_IMPL_FROMNODE_HTML_WITH_TAG(HTMLOptionElement, option)


  // nsISupports
  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLOptionElement, nsGenericHTMLElement)

  using mozilla::dom::Element::GetText;


  bool Selected() const { return mIsSelected; }
  void SetSelected(bool aValue);

  void SetSelectedChanged(bool aValue) { mSelectedChanged = aValue; }


  virtual nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute,
                                              int32_t aModType) const override;

  virtual nsresult BeforeSetAttr(int32_t aNamespaceID, nsAtom* aName,
                                 const nsAttrValueOrString* aValue,
                                 const nsAttrValueOrString* aValue,
                                 bool aNotify) override;
  virtual nsresult AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
                                const nsAttrValue* aValue,
                                const nsAttrValue* aOldValue,
                                nsIPrincipal* aSubjectPrincipal,
                                nsIPrincipal* aSubjectPrincipal,
                                bool aNotify) override;

  void SetSelectedInternal(bool aValue, bool aNotify);

  /**
   * This callback is called by an optgroup on all its option elements whenever
   * its disabled state is changed so that option elements can know their
   * its disabled state is changed so that option elements can know their
   * disabled state might have changed.
   */
  void OptGroupDisabledChanged(bool aNotify);

  /**
   * Check our disabled content attribute and optgroup's (if it exists) disabled
   * state to decide whether our disabled flag should be toggled.
   */
   */
  void UpdateDisabledState(bool aNotify);

  virtual nsresult BindToTree(BindContext&, nsINode& aParent) override;
  virtual void UnbindFromTree(bool aNullParent = true) override;


  // nsIContent
  virtual EventStates IntrinsicState() const override;

  virtual nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;


  nsresult CopyInnerTo(mozilla::dom::Element* aDest);

  bool Disabled() const { return GetBoolAttr(nsGkAtoms::disabled); }

  void SetDisabled(bool aValue, ErrorResult& aRv) {
    SetHTMLBoolAttr(nsGkAtoms::disabled, aValue, aRv);
  }
  }

  HTMLFormElement* GetForm();

  void GetRenderedLabel(nsAString& aLabel) {
    if (!GetAttr(kNameSpaceID_None, nsGkAtoms::label, aLabel) ||
    if (!GetAttr(kNameSpaceID_None, nsGkAtoms::label, aLabel) ||
        aLabel.IsEmpty()) {
      GetText(aLabel);
    }
  }


  void GetLabel(DOMString& aLabel) {
    if (!GetAttr(kNameSpaceID_None, nsGkAtoms::label, aLabel)) {
      GetText(aLabel);
    }
    }
  }
  void SetLabel(const nsAString& aLabel, ErrorResult& aError) {
    SetHTMLAttr(nsGkAtoms::label, aLabel, aError);
  }


  bool DefaultSelected() const {
    return HasAttr(kNameSpaceID_None, nsGkAtoms::selected);
  }
  void SetDefaultSelected(bool aValue, ErrorResult& aRv) {
    SetHTMLBoolAttr(nsGkAtoms::selected, aValue, aRv);
    SetHTMLBoolAttr(nsGkAtoms::selected, aValue, aRv);
  }

  void GetValue(nsAString& aValue) {
    if (!GetAttr(kNameSpaceID_None, nsGkAtoms::value, aValue)) {
    if (!GetAttr(kNameSpaceID_None, nsGkAtoms::value, aValue)) {
      GetText(aValue);
    }
  }
  void SetValue(const nsAString& aValue, ErrorResult& aRv) {
    SetHTMLAttr(nsGkAtoms::value, aValue, aRv);
    SetHTMLAttr(nsGkAtoms::value, aValue, aRv);
  }

  void GetText(nsAString& aText);
  void SetText(const nsAString& aText, ErrorResult& aRv);


  int32_t Index();

 protected:
  virtual ~HTMLOptionElement();


  virtual JSObject* WrapNode(JSContext* aCx,
                             JS::Handle<JSObject*> aGivenProto) override;

  /**
   * Get the select content element that contains this option, this
   * Get the select content element that contains this option, this
   * intentionally does not return nsresult, all we care about is if
   * there's a select associated with this option or not.
   * there's a select associated with this option or not.
   */
  HTMLSelectElement* GetSelect();

  bool mSelectedChanged;
  bool mIsSelected;
  bool mIsSelected;

  // True only while we're under the SetOptionsSelectedByIndex call when our
  // "selected" attribute is changing and mSelectedChanged is false.
  bool mIsInSetDefaultSelected;
};

}  // namespace dom
}  // namespace dom
}  // namespace mozilla

#endif  // mozilla_dom_HTMLOptionElement_h__