summaryrefslogtreecommitdiffstats
path: root/dom/html/HTMLButtonElement.h
blob: a226349fb0fe4666cd767c7f7ea997ea9d1c51bb (plain)
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
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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_HTMLButtonElement_h
#define mozilla_dom_HTMLButtonElement_h

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

namespace mozilla {
class EventChainPostVisitor;
class EventChainPreVisitor;
namespace dom {
class FormData;

class HTMLButtonElement final : public nsGenericHTMLFormControlElementWithState,
                                public ConstraintValidation {
 public:
  using ConstraintValidation::GetValidationMessage;

  explicit HTMLButtonElement(
      already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
      FromParser aFromParser = NOT_FROM_PARSER);

  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(
      HTMLButtonElement, nsGenericHTMLFormControlElementWithState)

  // nsISupports
  NS_DECL_ISUPPORTS_INHERITED

  virtual int32_t TabIndexDefault() override;

  NS_IMPL_FROMNODE_HTML_WITH_TAG(HTMLButtonElement, button)

  // Element
  virtual bool IsInteractiveHTMLContent() const override { return true; }

  // nsGenericHTMLFormElement
  void SaveState() override;
  bool RestoreState(PresState* aState) override;

  // overriden nsIFormControl methods
  NS_IMETHOD Reset() override;
  NS_IMETHOD SubmitNamesValues(FormData* aFormData) override;

  virtual void FieldSetDisabledChanged(bool aNotify) override;

  // EventTarget
  void GetEventTargetParent(EventChainPreVisitor& aVisitor) override;
  MOZ_CAN_RUN_SCRIPT_BOUNDARY
  virtual nsresult PostHandleEvent(EventChainPostVisitor& aVisitor) override;

  // nsINode
  virtual nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
  virtual JSObject* WrapNode(JSContext* aCx,
                             JS::Handle<JSObject*> aGivenProto) override;

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

  void UpdateBarredFromConstraintValidation();
  // Element
  ElementState IntrinsicState() const override;
  /**
   * Called when an attribute is about to be changed
   */
  virtual nsresult BeforeSetAttr(int32_t aNameSpaceID, nsAtom* aName,
                                 const nsAttrValueOrString* aValue,
                                 bool aNotify) override;
  /**
   * Called when an attribute has just been changed
   */
  virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
                                const nsAttrValue* aValue,
                                const nsAttrValue* aOldValue,
                                nsIPrincipal* aSubjectPrincipal,
                                bool aNotify) override;
  virtual bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
                              const nsAString& aValue,
                              nsIPrincipal* aMaybeScriptedPrincipal,
                              nsAttrValue& aResult) override;

  // nsGenericHTMLElement
  virtual bool IsHTMLFocusable(bool aWithMouse, bool* aIsFocusable,
                               int32_t* aTabIndex) override;
  virtual bool IsDisabledForEvents(WidgetEvent* aEvent) override;

  // WebIDL
  bool Disabled() const { return GetBoolAttr(nsGkAtoms::disabled); }
  void SetDisabled(bool aDisabled, ErrorResult& aError) {
    SetHTMLBoolAttr(nsGkAtoms::disabled, aDisabled, aError);
  }
  // GetFormAction implemented in superclass
  void SetFormAction(const nsAString& aFormAction, ErrorResult& aRv) {
    SetHTMLAttr(nsGkAtoms::formaction, aFormAction, aRv);
  }
  void GetFormEnctype(nsAString& aFormEncType);
  void SetFormEnctype(const nsAString& aFormEnctype, ErrorResult& aRv) {
    SetHTMLAttr(nsGkAtoms::formenctype, aFormEnctype, aRv);
  }
  void GetFormMethod(nsAString& aFormMethod);
  void SetFormMethod(const nsAString& aFormMethod, ErrorResult& aRv) {
    SetHTMLAttr(nsGkAtoms::formmethod, aFormMethod, aRv);
  }
  bool FormNoValidate() const { return GetBoolAttr(nsGkAtoms::formnovalidate); }
  void SetFormNoValidate(bool aFormNoValidate, ErrorResult& aError) {
    SetHTMLBoolAttr(nsGkAtoms::formnovalidate, aFormNoValidate, aError);
  }
  void GetFormTarget(DOMString& aFormTarget) {
    GetHTMLAttr(nsGkAtoms::formtarget, aFormTarget);
  }
  void SetFormTarget(const nsAString& aFormTarget, ErrorResult& aRv) {
    SetHTMLAttr(nsGkAtoms::formtarget, aFormTarget, aRv);
  }
  void GetName(DOMString& aName) { GetHTMLAttr(nsGkAtoms::name, aName); }
  void SetName(const nsAString& aName, ErrorResult& aRv) {
    SetHTMLAttr(nsGkAtoms::name, aName, aRv);
  }
  void GetType(nsAString& aType);
  void SetType(const nsAString& aType, ErrorResult& aRv) {
    SetHTMLAttr(nsGkAtoms::type, aType, aRv);
  }
  void GetValue(DOMString& aValue) { GetHTMLAttr(nsGkAtoms::value, aValue); }
  void SetValue(const nsAString& aValue, ErrorResult& aRv) {
    SetHTMLAttr(nsGkAtoms::value, aValue, aRv);
  }

  // Override SetCustomValidity so we update our state properly when it's called
  // via bindings.
  void SetCustomValidity(const nsAString& aError);

 protected:
  virtual ~HTMLButtonElement();

  bool mDisabledChanged : 1;
  bool mInInternalActivate : 1;
  bool mInhibitStateRestoration : 1;
};

}  // namespace dom
}  // namespace mozilla

#endif  // mozilla_dom_HTMLButtonElement_h