dom/html/HTMLMeterElement.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "HTMLMeterElement.h"
   8 #include "mozilla/dom/HTMLMeterElementBinding.h"
   9
  10 NS_IMPL_NS_NEW_HTML_ELEMENT(Meter)
  11
  12 namespace mozilla::dom {
  13
  14 static const double kDefaultValue = 0.0;
  15 static const double kDefaultMin = 0.0;
  16 static const double kDefaultMax = 1.0;
  17
  18 HTMLMeterElement::HTMLMeterElement(
  19     already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
  20     : nsGenericHTMLElement(std::move(aNodeInfo)) {}
  21
  22 HTMLMeterElement::~HTMLMeterElement() = default;
  23
  24 NS_IMPL_ELEMENT_CLONE(HTMLMeterElement)
  25
  26 static bool IsInterestingAttr(int32_t aNamespaceID, nsAtom* aAttribute) {
  27   if (aNamespaceID != kNameSpaceID_None) {
  28     return false;
  29   }
  30   return aAttribute == nsGkAtoms::value || aAttribute == nsGkAtoms::max ||
  31          aAttribute == nsGkAtoms::min || aAttribute == nsGkAtoms::low ||
  32          aAttribute == nsGkAtoms::high || aAttribute == nsGkAtoms::optimum;
  33 }
  34
  35 bool HTMLMeterElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
  36                                       const nsAString& aValue,
  37                                       nsIPrincipal* aMaybeScriptedPrincipal,
  38                                       nsAttrValue& aResult) {
  39   if (IsInterestingAttr(aNamespaceID, aAttribute)) {
  40     return aResult.ParseDoubleValue(aValue);
  41   }
  42   return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
  43                                               aMaybeScriptedPrincipal, aResult);
  44 }
  45
  46 void HTMLMeterElement::AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
  47                                     const nsAttrValue* aValue,
  48                                     const nsAttrValue* aOldValue,
  49                                     nsIPrincipal* aSubjectPrincipal,
  50                                     bool aNotify) {
  51   if (IsInterestingAttr(aNameSpaceID, aName)) {
  52     UpdateOptimumState(aNotify);
  53   }
  54   nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName, aValue, aOldValue,
  55                                      aSubjectPrincipal, aNotify);
  56 }
  57
  58 void HTMLMeterElement::UpdateOptimumState(bool aNotify) {
  59   AutoStateChangeNotifier notifier(*this, aNotify);
  60   RemoveStatesSilently(ElementState::METER_OPTIMUM_STATES);
  61   AddStatesSilently(GetOptimumState());
  62 }
  63
  64 double HTMLMeterElement::Min() const {
  65   /**
  66    * If the attribute min is defined, the minimum is this value.
  67    * Otherwise, the minimum is the default value.
  68    */
  69   const nsAttrValue* attrMin = mAttrs.GetAttr(nsGkAtoms::min);
  70   if (attrMin && attrMin->Type() == nsAttrValue::eDoubleValue) {
  71     return attrMin->GetDoubleValue();
  72   }
  73   return kDefaultMin;
  74 }
  75
  76 double HTMLMeterElement::Max() const {
  77   /**
  78    * If the attribute max is defined, the maximum is this value.
  79    * Otherwise, the maximum is the default value.
  80    * If the maximum value is less than the minimum value,
  81    * the maximum value is the same as the minimum value.
  82    */
  83   double max;
  84
  85   const nsAttrValue* attrMax = mAttrs.GetAttr(nsGkAtoms::max);
  86   if (attrMax && attrMax->Type() == nsAttrValue::eDoubleValue) {
  87     max = attrMax->GetDoubleValue();
  88   } else {
  89     max = kDefaultMax;
  90   }
  91
  92   return std::max(max, Min());
  93 }
  94
  95 double HTMLMeterElement::Value() const {
  96   /**
  97    * If the attribute value is defined, the actual value is this value.
  98    * Otherwise, the actual value is the default value.
  99    * If the actual value is less than the minimum value,
 100    * the actual value is the same as the minimum value.
 101    * If the actual value is greater than the maximum value,
 102    * the actual value is the same as the maximum value.
 103    */
 104   double value;
 105
 106   const nsAttrValue* attrValue = mAttrs.GetAttr(nsGkAtoms::value);
 107   if (attrValue && attrValue->Type() == nsAttrValue::eDoubleValue) {
 108     value = attrValue->GetDoubleValue();
 109   } else {
 110     value = kDefaultValue;
 111   }
 112
 113   double min = Min();
 114
 115   if (value <= min) {
 116     return min;
 117   }
 118
 119   return std::min(value, Max());
 120 }
 121
 122 double HTMLMeterElement::Position() const {
 123   const double max = Max();
 124   const double min = Min();
 125   const double value = Value();
 126
 127   double range = max - min;
 128   return range != 0.0 ? (value - min) / range : 1.0;
 129 }
 130
 131 double HTMLMeterElement::Low() const {
 132   /**
 133    * If the low value is defined, the low value is this value.
 134    * Otherwise, the low value is the minimum value.
 135    * If the low value is less than the minimum value,
 136    * the low value is the same as the minimum value.
 137    * If the low value is greater than the maximum value,
 138    * the low value is the same as the maximum value.
 139    */
 140
 141   double min = Min();
 142
 143   const nsAttrValue* attrLow = mAttrs.GetAttr(nsGkAtoms::low);
 144   if (!attrLow || attrLow->Type() != nsAttrValue::eDoubleValue) {
 145     return min;
 146   }
 147
 148   double low = attrLow->GetDoubleValue();
 149
 150   if (low <= min) {
 151     return min;
 152   }
 153
 154   return std::min(low, Max());
 155 }
 156
 157 double HTMLMeterElement::High() const {
 158   /**
 159    * If the high value is defined, the high value is this value.
 160    * Otherwise, the high value is the maximum value.
 161    * If the high value is less than the low value,
 162    * the high value is the same as the low value.
 163    * If the high value is greater than the maximum value,
 164    * the high value is the same as the maximum value.
 165    */
 166
 167   double max = Max();
 168
 169   const nsAttrValue* attrHigh = mAttrs.GetAttr(nsGkAtoms::high);
 170   if (!attrHigh || attrHigh->Type() != nsAttrValue::eDoubleValue) {
 171     return max;
 172   }
 173
 174   double high = attrHigh->GetDoubleValue();
 175
 176   if (high >= max) {
 177     return max;
 178   }
 179
 180   return std::max(high, Low());
 181 }
 182
 183 double HTMLMeterElement::Optimum() const {
 184   /**
 185    * If the optimum value is defined, the optimum value is this value.
 186    * Otherwise, the optimum value is the midpoint between
 187    * the minimum value and the maximum value :
 188    * min + (max - min)/2 = (min + max)/2
 189    * If the optimum value is less than the minimum value,
 190    * the optimum value is the same as the minimum value.
 191    * If the optimum value is greater than the maximum value,
 192    * the optimum value is the same as the maximum value.
 193    */
 194
 195   double max = Max();
 196
 197   double min = Min();
 198
 199   const nsAttrValue* attrOptimum = mAttrs.GetAttr(nsGkAtoms::optimum);
 200   if (!attrOptimum || attrOptimum->Type() != nsAttrValue::eDoubleValue) {
 201     return (min + max) / 2.0;
 202   }
 203
 204   double optimum = attrOptimum->GetDoubleValue();
 205
 206   if (optimum <= min) {
 207     return min;
 208   }
 209
 210   return std::min(optimum, max);
 211 }
 212
 213 ElementState HTMLMeterElement::GetOptimumState() const {
 214   /*
 215    * If the optimum value is in [minimum, low[,
 216    *     return if the value is in optimal, suboptimal or sub-suboptimal region
 217    *
 218    * If the optimum value is in [low, high],
 219    *     return if the value is in optimal or suboptimal region
 220    *
 221    * If the optimum value is in ]high, maximum],
 222    *     return if the value is in optimal, suboptimal or sub-suboptimal region
 223    */
 224   double value = Value();
 225   double low = Low();
 226   double high = High();
 227   double optimum = Optimum();
 228
 229   if (optimum < low) {
 230     if (value < low) {
 231       return ElementState::OPTIMUM;
 232     }
 233     if (value <= high) {
 234       return ElementState::SUB_OPTIMUM;
 235     }
 236     return ElementState::SUB_SUB_OPTIMUM;
 237   }
 238   if (optimum > high) {
 239     if (value > high) {
 240       return ElementState::OPTIMUM;
 241     }
 242     if (value >= low) {
 243       return ElementState::SUB_OPTIMUM;
 244     }
 245     return ElementState::SUB_SUB_OPTIMUM;
 246   }
 247   // optimum in [low, high]
 248   if (value >= low && value <= high) {
 249     return ElementState::OPTIMUM;
 250   }
 251   return ElementState::SUB_OPTIMUM;
 252 }
 253
 254 JSObject* HTMLMeterElement::WrapNode(JSContext* aCx,
 255                                      JS::Handle<JSObject*> aGivenProto) {
 256   return HTMLMeterElement_Binding::Wrap(aCx, this, aGivenProto);
 257 }
 258
 259 }  // namespace mozilla::dom