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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
/* 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/. */
use dom::bindings::codegen::HTMLDocumentBinding;
use dom::bindings::utils::{DOMString, ErrorResult, Fallible, Traceable};
use dom::bindings::utils::{CacheableWrapper, BindingObject, WrapperCache};
use dom::document::{AbstractDocument, Document, WrappableDocument, HTML};
use dom::element::HTMLHeadElementTypeId;
use dom::htmlcollection::HTMLCollection;
use dom::node::{AbstractNode, ScriptView, ElementNodeTypeId};
use dom::window::Window;
use js::jsapi::{JSObject, JSContext, JSTracer};
use servo_util::tree::TreeNodeRef;
use std::libc;
use std::ptr;
use std::str::eq_slice;
pub struct HTMLDocument {
parent: Document
}
impl HTMLDocument {
pub fn new(window: Option<@mut Window>) -> AbstractDocument {
let doc = @mut HTMLDocument {
parent: Document::new(window, HTML)
};
let compartment = window.get_ref().page.js_info.get_ref().js_compartment;
AbstractDocument::as_abstract(compartment.cx.ptr, doc)
}
fn get_scope_and_cx(&self) -> (*JSObject, *JSContext) {
let win = self.parent.window.get_ref();
let cx = win.page.js_info.get_ref().js_compartment.cx.ptr;
let cache = win.get_wrappercache();
let scope = cache.get_wrapper();
(scope, cx)
}
}
impl WrappableDocument for HTMLDocument {
fn init_wrapper(@mut self, cx: *JSContext) {
self.wrap_object_shared(cx, ptr::null()); //XXXjdm a proper scope would be nice
}
}
impl HTMLDocument {
pub fn NamedGetter(&self, _cx: *JSContext, _name: &DOMString, _found: &mut bool) -> Fallible<*JSObject> {
Ok(ptr::null())
}
pub fn GetDomain(&self) -> Fallible<DOMString> {
Ok(None)
}
pub fn SetDomain(&self, _domain: &DOMString) -> ErrorResult {
Ok(())
}
pub fn GetCookie(&self) -> Fallible<DOMString> {
Ok(None)
}
pub fn SetCookie(&self, _cookie: &DOMString) -> ErrorResult {
Ok(())
}
pub fn GetHead(&self) -> Option<AbstractNode<ScriptView>> {
match self.parent.root {
None => None,
Some(root) => {
let mut headNode: Option<AbstractNode<ScriptView>> = None;
let _ = for child in root.traverse_preorder() {
if child.type_id() == ElementNodeTypeId(HTMLHeadElementTypeId) {
headNode = Some(child);
break;
}
};
headNode
}
}
}
pub fn Images(&self) -> @mut HTMLCollection {
self.parent.createHTMLCollection(|elem| eq_slice(elem.tag_name, "img"))
}
pub fn Embeds(&self) -> @mut HTMLCollection {
self.parent.createHTMLCollection(|elem| eq_slice(elem.tag_name, "embed"))
}
pub fn Plugins(&self) -> @mut HTMLCollection {
self.Embeds()
}
pub fn Links(&self) -> @mut HTMLCollection {
self.parent.createHTMLCollection(|elem|
(eq_slice(elem.tag_name, "a") || eq_slice(elem.tag_name, "area"))
&& elem.get_attr("href").is_some())
}
pub fn Forms(&self) -> @mut HTMLCollection {
self.parent.createHTMLCollection(|elem| eq_slice(elem.tag_name, "form"))
}
pub fn Scripts(&self) -> @mut HTMLCollection {
self.parent.createHTMLCollection(|elem| eq_slice(elem.tag_name, "script"))
}
pub fn Close(&self) -> ErrorResult {
Ok(())
}
pub fn DesignMode(&self) -> DOMString {
None
}
pub fn SetDesignMode(&self, _mode: &DOMString) -> ErrorResult {
Ok(())
}
pub fn ExecCommand(&self, _command_id: &DOMString, _show_ui: bool, _value: &DOMString) -> Fallible<bool> {
Ok(false)
}
pub fn QueryCommandEnabled(&self, _command_id: &DOMString) -> Fallible<bool> {
Ok(false)
}
pub fn QueryCommandIndeterm(&self, _command_id: &DOMString) -> Fallible<bool> {
Ok(false)
}
pub fn QueryCommandState(&self, _command_id: &DOMString) -> Fallible<bool> {
Ok(false)
}
pub fn QueryCommandSupported(&self, _command_id: &DOMString) -> bool {
false
}
pub fn QueryCommandValue(&self, _command_id: &DOMString) -> Fallible<DOMString> {
Ok(None)
}
pub fn FgColor(&self) -> DOMString {
None
}
pub fn SetFgColor(&self, _color: &DOMString) {
}
pub fn LinkColor(&self) -> DOMString {
None
}
pub fn SetLinkColor(&self, _color: &DOMString) {
}
pub fn VlinkColor(&self) -> DOMString {
None
}
pub fn SetVlinkColor(&self, _color: &DOMString) {
}
pub fn AlinkColor(&self) -> DOMString {
None
}
pub fn SetAlinkColor(&self, _color: &DOMString) {
}
pub fn BgColor(&self) -> DOMString {
None
}
pub fn SetBgColor(&self, _color: &DOMString) {
}
pub fn Anchors(&self) -> @mut HTMLCollection {
self.parent.createHTMLCollection(|elem|
eq_slice(elem.tag_name, "a") && elem.get_attr("name").is_some())
}
pub fn Applets(&self) -> @mut HTMLCollection {
// FIXME: This should be return OBJECT elements containing applets.
self.parent.createHTMLCollection(|elem| eq_slice(elem.tag_name, "applet"))
}
pub fn Clear(&self) {
}
pub fn GetAll(&self, _cx: *JSContext) -> Fallible<*libc::c_void> {
Ok(ptr::null())
}
}
impl CacheableWrapper for HTMLDocument {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
self.parent.get_wrappercache()
}
fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
let mut unused = false;
HTMLDocumentBinding::Wrap(cx, scope, self, &mut unused)
}
}
impl BindingObject for HTMLDocument {
fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
self.parent.GetParentObject(cx)
}
}
impl Traceable for HTMLDocument {
fn trace(&self, tracer: *mut JSTracer) {
self.parent.trace(tracer);
}
}
|
