Skip to main content

hpx_browser/css_selectors/
element.rs

1/// Trait for DOM elements that can be matched against CSS selectors.
2pub trait Element: Sized + Clone {
3    fn local_name(&self) -> &str;
4    fn namespace(&self) -> Option<&str> {
5        None
6    }
7    fn id(&self) -> Option<&str>;
8    fn has_class(&self, name: &str) -> bool;
9    fn has_attribute(&self, name: &str) -> bool;
10    fn attribute_value(&self, name: &str) -> Option<&str>;
11    fn parent_element(&self) -> Option<Self>;
12    fn prev_sibling_element(&self) -> Option<Self>;
13    fn next_sibling_element(&self) -> Option<Self>;
14    fn first_child_element(&self) -> Option<Self>;
15    fn last_child_element(&self) -> Option<Self>;
16
17    fn is_root(&self) -> bool {
18        self.parent_element().is_none()
19    }
20    fn is_empty(&self) -> bool {
21        self.first_child_element().is_none()
22    }
23    fn is_link(&self) -> bool {
24        false
25    }
26    fn is_visited(&self) -> bool {
27        false
28    }
29    fn is_hover(&self) -> bool {
30        false
31    }
32    fn is_active(&self) -> bool {
33        false
34    }
35    fn is_focus(&self) -> bool {
36        false
37    }
38    fn is_focus_within(&self) -> bool {
39        false
40    }
41    fn is_focus_visible(&self) -> bool {
42        false
43    }
44    fn is_enabled(&self) -> bool {
45        false
46    }
47    fn is_disabled(&self) -> bool {
48        false
49    }
50    fn is_checked(&self) -> bool {
51        false
52    }
53    fn is_target(&self) -> bool {
54        false
55    }
56    fn is_read_write(&self) -> bool {
57        false
58    }
59    fn is_read_only(&self) -> bool {
60        !self.is_read_write()
61    }
62    fn is_required(&self) -> bool {
63        false
64    }
65    fn is_optional(&self) -> bool {
66        !self.is_required()
67    }
68    fn is_valid(&self) -> bool {
69        true
70    }
71    fn is_invalid(&self) -> bool {
72        !self.is_valid()
73    }
74    fn is_default(&self) -> bool {
75        false
76    }
77    fn is_indeterminate(&self) -> bool {
78        false
79    }
80    fn is_placeholder_shown(&self) -> bool {
81        false
82    }
83    fn is_any_link(&self) -> bool {
84        self.is_link() || self.is_visited()
85    }
86    fn is_in_range(&self) -> bool {
87        false
88    }
89    fn is_out_of_range(&self) -> bool {
90        false
91    }
92    fn lang(&self) -> Option<&str> {
93        None
94    }
95
96    fn child_elements(&self) -> Vec<Self> {
97        let mut children = Vec::new();
98        let mut child = self.first_child_element();
99        while let Some(c) = child {
100            let next = c.next_sibling_element();
101            children.push(c);
102            child = next;
103        }
104        children
105    }
106
107    fn sibling_index(&self) -> i32 {
108        let mut index = 1;
109        let mut sib = self.prev_sibling_element();
110        while let Some(s) = sib {
111            index += 1;
112            sib = s.prev_sibling_element();
113        }
114        index
115    }
116
117    fn sibling_index_from_end(&self) -> i32 {
118        let mut index = 1;
119        let mut sib = self.next_sibling_element();
120        while let Some(s) = sib {
121            index += 1;
122            sib = s.next_sibling_element();
123        }
124        index
125    }
126
127    fn sibling_type_index(&self) -> i32 {
128        let name = self.local_name().to_ascii_lowercase();
129        let mut index = 1;
130        let mut sib = self.prev_sibling_element();
131        while let Some(s) = sib {
132            if s.local_name().eq_ignore_ascii_case(&name) {
133                index += 1;
134            }
135            sib = s.prev_sibling_element();
136        }
137        index
138    }
139
140    fn sibling_type_index_from_end(&self) -> i32 {
141        let name = self.local_name().to_ascii_lowercase();
142        let mut index = 1;
143        let mut sib = self.next_sibling_element();
144        while let Some(s) = sib {
145            if s.local_name().eq_ignore_ascii_case(&name) {
146                index += 1;
147            }
148            sib = s.next_sibling_element();
149        }
150        index
151    }
152
153    fn sibling_type_count(&self) -> i32 {
154        self.sibling_type_index() + self.sibling_type_index_from_end() - 1
155    }
156}