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
/* 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 https://mozilla.org/MPL/2.0/. */
use dom_struct::dom_struct;
use html5ever::{local_name, LocalName, Prefix};
use js::rust::HandleObject;
use crate::dom::bindings::codegen::Bindings::HTMLProgressElementBinding::HTMLProgressElementMethods;
use crate::dom::bindings::inheritance::Castable;
use crate::dom::bindings::num::Finite;
use crate::dom::bindings::root::{DomRoot, MutNullableDom};
use crate::dom::document::Document;
use crate::dom::element::Element;
use crate::dom::htmlelement::HTMLElement;
use crate::dom::node::Node;
use crate::dom::nodelist::NodeList;
#[dom_struct]
pub struct HTMLProgressElement {
htmlelement: HTMLElement,
labels_node_list: MutNullableDom<NodeList>,
}
impl HTMLProgressElement {
fn new_inherited(
local_name: LocalName,
prefix: Option<Prefix>,
document: &Document,
) -> HTMLProgressElement {
HTMLProgressElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document),
labels_node_list: MutNullableDom::new(None),
}
}
#[allow(crown::unrooted_must_root)]
pub fn new(
local_name: LocalName,
prefix: Option<Prefix>,
document: &Document,
proto: Option<HandleObject>,
) -> DomRoot<HTMLProgressElement> {
Node::reflect_node_with_proto(
Box::new(HTMLProgressElement::new_inherited(
local_name, prefix, document,
)),
document,
proto,
)
}
}
impl HTMLProgressElementMethods for HTMLProgressElement {
// https://html.spec.whatwg.org/multipage/#dom-lfe-labels
make_labels_getter!(Labels, labels_node_list);
// https://html.spec.whatwg.org/multipage/#dom-progress-value
fn Value(&self) -> Finite<f64> {
// In case of missing `value`, parse error, or negative `value`, `value` should be
// interpreted as 0. As `get_string_attribute` returns an empty string in case the
// attribute is missing, this case is handeled as the default of the `map_or` function.
//
// It is safe to wrap the number coming from `parse_floating_point_number` as it will
// return Err on inf and nan
self.upcast::<Element>()
.get_string_attribute(&local_name!("value"))
.parse_floating_point_number()
.map_or(Finite::wrap(0.0), |v| {
if v < 0.0 {
Finite::wrap(0.0)
} else {
Finite::wrap(v.min(*self.Max()))
}
})
}
// https://html.spec.whatwg.org/multipage/#dom-progress-value
fn SetValue(&self, new_val: Finite<f64>) {
if 0.0 <= *new_val {
self.upcast::<Element>()
.set_string_attribute(&local_name!("value"), (*new_val).to_string().into());
}
}
// https://html.spec.whatwg.org/multipage/#dom-progress-max
fn Max(&self) -> Finite<f64> {
// In case of missing `max`, parse error, or negative `max`, `max` should be interpreted as
// 1.0. As `get_string_attribute` returns an empty string in case the attribute is missing,
// these cases are handeled by `map_or`
self.upcast::<Element>()
.get_string_attribute(&local_name!("max"))
.parse_floating_point_number()
.map_or(Finite::wrap(1.0), |m| {
if m <= 0.0 {
Finite::wrap(1.0)
} else {
Finite::wrap(m)
}
})
}
// https://html.spec.whatwg.org/multipage/#dom-progress-max
fn SetMax(&self, new_val: Finite<f64>) {
self.upcast::<Element>()
.set_string_attribute(&local_name!("max"), (*new_val).to_string().into());
}
// https://html.spec.whatwg.org/multipage/#dom-progress-position
fn Position(&self) -> Finite<f64> {
let value = self
.upcast::<Element>()
.get_string_attribute(&local_name!("value"));
if value.is_empty() {
Finite::wrap(-1.0)
} else {
let value = self.Value();
let max = self.Max();
// An unsafe Finite constructor might be nice here, as it's unlikely for the
// compiler to infer the following guarantees. It is probably premature
// optimization though.
//
// Safety: `ret` have to be a finite, defined number. This is the case since both
// value and max is finite, max > 0, and a value >> max cannot exist, as
// Self::Value(&self) enforces value <= max.
Finite::wrap(*value / *max)
}
}
}