summaryrefslogtreecommitdiffstats
path: root/dom/html/HTMLMeterElement.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/html/HTMLMeterElement.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/html/HTMLMeterElement.cpp')
-rw-r--r--dom/html/HTMLMeterElement.cpp266
1 files changed, 266 insertions, 0 deletions
diff --git a/dom/html/HTMLMeterElement.cpp b/dom/html/HTMLMeterElement.cpp
new file mode 100644
index 000000000..dd0e21470
--- /dev/null
+++ b/dom/html/HTMLMeterElement.cpp
@@ -0,0 +1,266 @@
+/* -*- 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/. */
+
+#include "HTMLMeterElement.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/dom/HTMLMeterElementBinding.h"
+
+NS_IMPL_NS_NEW_HTML_ELEMENT(Meter)
+
+namespace mozilla {
+namespace dom {
+
+const double HTMLMeterElement::kDefaultValue = 0.0;
+const double HTMLMeterElement::kDefaultMin = 0.0;
+const double HTMLMeterElement::kDefaultMax = 1.0;
+
+
+HTMLMeterElement::HTMLMeterElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
+ : nsGenericHTMLElement(aNodeInfo)
+{
+}
+
+HTMLMeterElement::~HTMLMeterElement()
+{
+}
+
+NS_IMPL_ELEMENT_CLONE(HTMLMeterElement)
+
+EventStates
+HTMLMeterElement::IntrinsicState() const
+{
+ EventStates state = nsGenericHTMLElement::IntrinsicState();
+
+ state |= GetOptimumState();
+
+ return state;
+}
+
+bool
+HTMLMeterElement::ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute,
+ const nsAString& aValue, nsAttrValue& aResult)
+{
+ if (aNamespaceID == kNameSpaceID_None) {
+ if (aAttribute == nsGkAtoms::value || aAttribute == nsGkAtoms::max ||
+ aAttribute == nsGkAtoms::min || aAttribute == nsGkAtoms::low ||
+ aAttribute == nsGkAtoms::high || aAttribute == nsGkAtoms::optimum) {
+ return aResult.ParseDoubleValue(aValue);
+ }
+ }
+
+ return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute,
+ aValue, aResult);
+}
+
+/*
+ * Value getters :
+ * const getters used by XPCOM methods and by IntrinsicState
+ */
+
+double
+HTMLMeterElement::Min() const
+{
+ /**
+ * If the attribute min is defined, the minimum is this value.
+ * Otherwise, the minimum is the default value.
+ */
+ const nsAttrValue* attrMin = mAttrsAndChildren.GetAttr(nsGkAtoms::min);
+ if (attrMin && attrMin->Type() == nsAttrValue::eDoubleValue) {
+ return attrMin->GetDoubleValue();
+ }
+ return kDefaultMin;
+}
+
+double
+HTMLMeterElement::Max() const
+{
+ /**
+ * If the attribute max is defined, the maximum is this value.
+ * Otherwise, the maximum is the default value.
+ * If the maximum value is less than the minimum value,
+ * the maximum value is the same as the minimum value.
+ */
+ double max;
+
+ const nsAttrValue* attrMax = mAttrsAndChildren.GetAttr(nsGkAtoms::max);
+ if (attrMax && attrMax->Type() == nsAttrValue::eDoubleValue) {
+ max = attrMax->GetDoubleValue();
+ } else {
+ max = kDefaultMax;
+ }
+
+ return std::max(max, Min());
+}
+
+double
+HTMLMeterElement::Value() const
+{
+ /**
+ * If the attribute value is defined, the actual value is this value.
+ * Otherwise, the actual value is the default value.
+ * If the actual value is less than the minimum value,
+ * the actual value is the same as the minimum value.
+ * If the actual value is greater than the maximum value,
+ * the actual value is the same as the maximum value.
+ */
+ double value;
+
+ const nsAttrValue* attrValue = mAttrsAndChildren.GetAttr(nsGkAtoms::value);
+ if (attrValue && attrValue->Type() == nsAttrValue::eDoubleValue) {
+ value = attrValue->GetDoubleValue();
+ } else {
+ value = kDefaultValue;
+ }
+
+ double min = Min();
+
+ if (value <= min) {
+ return min;
+ }
+
+ return std::min(value, Max());
+}
+
+double
+HTMLMeterElement::Low() const
+{
+ /**
+ * If the low value is defined, the low value is this value.
+ * Otherwise, the low value is the minimum value.
+ * If the low value is less than the minimum value,
+ * the low value is the same as the minimum value.
+ * If the low value is greater than the maximum value,
+ * the low value is the same as the maximum value.
+ */
+
+ double min = Min();
+
+ const nsAttrValue* attrLow = mAttrsAndChildren.GetAttr(nsGkAtoms::low);
+ if (!attrLow || attrLow->Type() != nsAttrValue::eDoubleValue) {
+ return min;
+ }
+
+ double low = attrLow->GetDoubleValue();
+
+ if (low <= min) {
+ return min;
+ }
+
+ return std::min(low, Max());
+}
+
+double
+HTMLMeterElement::High() const
+{
+ /**
+ * If the high value is defined, the high value is this value.
+ * Otherwise, the high value is the maximum value.
+ * If the high value is less than the low value,
+ * the high value is the same as the low value.
+ * If the high value is greater than the maximum value,
+ * the high value is the same as the maximum value.
+ */
+
+ double max = Max();
+
+ const nsAttrValue* attrHigh = mAttrsAndChildren.GetAttr(nsGkAtoms::high);
+ if (!attrHigh || attrHigh->Type() != nsAttrValue::eDoubleValue) {
+ return max;
+ }
+
+ double high = attrHigh->GetDoubleValue();
+
+ if (high >= max) {
+ return max;
+ }
+
+ return std::max(high, Low());
+}
+
+double
+HTMLMeterElement::Optimum() const
+{
+ /**
+ * If the optimum value is defined, the optimum value is this value.
+ * Otherwise, the optimum value is the midpoint between
+ * the minimum value and the maximum value :
+ * min + (max - min)/2 = (min + max)/2
+ * If the optimum value is less than the minimum value,
+ * the optimum value is the same as the minimum value.
+ * If the optimum value is greater than the maximum value,
+ * the optimum value is the same as the maximum value.
+ */
+
+ double max = Max();
+
+ double min = Min();
+
+ const nsAttrValue* attrOptimum =
+ mAttrsAndChildren.GetAttr(nsGkAtoms::optimum);
+ if (!attrOptimum || attrOptimum->Type() != nsAttrValue::eDoubleValue) {
+ return (min + max) / 2.0;
+ }
+
+ double optimum = attrOptimum->GetDoubleValue();
+
+ if (optimum <= min) {
+ return min;
+ }
+
+ return std::min(optimum, max);
+}
+
+EventStates
+HTMLMeterElement::GetOptimumState() const
+{
+ /*
+ * If the optimum value is in [minimum, low[,
+ * return if the value is in optimal, suboptimal or sub-suboptimal region
+ *
+ * If the optimum value is in [low, high],
+ * return if the value is in optimal or suboptimal region
+ *
+ * If the optimum value is in ]high, maximum],
+ * return if the value is in optimal, suboptimal or sub-suboptimal region
+ */
+ double value = Value();
+ double low = Low();
+ double high = High();
+ double optimum = Optimum();
+
+ if (optimum < low) {
+ if (value < low) {
+ return NS_EVENT_STATE_OPTIMUM;
+ }
+ if (value <= high) {
+ return NS_EVENT_STATE_SUB_OPTIMUM;
+ }
+ return NS_EVENT_STATE_SUB_SUB_OPTIMUM;
+ }
+ if (optimum > high) {
+ if (value > high) {
+ return NS_EVENT_STATE_OPTIMUM;
+ }
+ if (value >= low) {
+ return NS_EVENT_STATE_SUB_OPTIMUM;
+ }
+ return NS_EVENT_STATE_SUB_SUB_OPTIMUM;
+ }
+ // optimum in [low, high]
+ if (value >= low && value <= high) {
+ return NS_EVENT_STATE_OPTIMUM;
+ }
+ return NS_EVENT_STATE_SUB_OPTIMUM;
+}
+
+JSObject*
+HTMLMeterElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return HTMLMeterElementBinding::Wrap(aCx, this, aGivenProto);
+}
+
+} // namespace dom
+} // namespace mozilla