v/vlib/jsdom/dom.js.v

251 lines
5.5 KiB
V

// DOM API for JS backend
module jsdom
[heap]
pub struct JS.Node {
baseURI JS.String [noinit]
childNodes JS.NodeList [noinit]
firstChild voidptr [noinit]
isConnected JS.bool [noinit]
lastChild voidptr [noinit]
nextSibling voidptr [noinit]
nodeName JS.String [noinit]
nodeType NodeType [noinit]
nodeValue voidptr [noinit]
ownerDocument JS.Document [noinit]
parentNode voidptr [noinit]
parentElement JS.Element [noinit]
previousSibling voidptr [noinit]
textContext voidptr
}
pub struct JS.NodeList {
pub mut:
length JS.Number
}
pub enum NodeType {
element = 1
attribute = 2
text = 3
cdata_section = 4
entity_reference = 5
entity = 6
processing_instruction = 7
comment = 8
document = 9
document_type = 10
document_fragment = 11
notation = 12
}
pub struct Node {
node JS.Node [noinit]
}
pub fn (n Node) typ() NodeType {
return n.node.nodeType
}
/// IEventTarget interface is implemented by objects that can receive events and may have listeners for them.
// In other words, any target of events implements the three methods associated with this interface.
// TODO: remove_event_listener and dispatch_event
pub interface IEventTarget {
add_event_listener(event string, cb EventCallback)
}
/// The DOM Node interface is an abstract base class upon which many other DOM API objects are based, thus
// letting those object types to be used similarly and often interchangeably. As an abstract class,
// there is no such thing as a plain Node object. All objects that implement Node functionality are based on one of its subclasses.
// Most notable are Document, Element, and DocumentFragment.
pub interface INode {
IEventTarget
typ() NodeType
}
pub fn (elem Node) add_event_listener(event string, cb EventCallback) {
#elem.node.addEventListener(event.str, function (event) { let e = jsdom__dispatch_event_target(this);
#let ev = jsdom__dispatch_event(event); ev.event = event;
#return cb(e,ev)
#});
}
pub fn (n INode) is_(ty NodeType) bool {
res := false
#res.val = n.node.nodeType == ty
return res
}
pub fn (n INode) document() ?Document {
res := Document{}
if n.is_(.document) {
#res.node = n.node
return res
} else {
return none
}
}
pub fn (n INode) element() ?Element {
res := Element{}
if n.is_(.element) {
#res.node = n.node
return res
} else {
return none
}
}
pub fn (n INode) append_child(child INode) {
#n.node.appendChild(child.node)
}
pub fn (n INode) clone_node(deep ...int) INode {
cloned := Node{}
if deep.len == 0 {
#cloned.node = n.node.cloneNode()
} else {
#cloned.node = n.node.cloneNode(deep.arr.get(new int(0)).val)
}
return cloned
}
pub fn (n INode) contains(other INode) bool {
res := false
#res.val = n.node.contains(other.node)
return res
}
pub fn (n INode) get_root_node() INode {
root := Node{}
#root.node = n.node.getRootNode()
return root
}
pub fn (n INode) has_child_nodes() bool {
res := false
#res.val = n.node.hasChildNodes()
return res
}
pub fn (n INode) insert_before(new_node INode, reference_node INode) Node {
inserted := Node{}
#inserted.node = n.node.insertBefore(new_node.node,reference_node.node)
return inserted
}
/*
pub fn (x Node) == (y Node) bool {
res := false
#res.val = x.node.isEqualNode(y.node)
return res
}*/
pub fn (n INode) remove_child(child INode) {
#n.node.removeChild(child.node)
}
pub fn (n INode) replace_child(new_child INode, old_child INode) INode {
#old_child.node = n.node.replace_child(new_child.node,old_child.node)
return old_child
}
pub struct JS.EventTarget {}
fn dispatch_event_target(target JS.EventTarget) IEventTarget {
mut ret := IEventTarget(Element{})
#if (target instanceof HTMLCanvasElement) { ret = new jsdom__HTMLCanvasElement({}); ret.node = target; }
#else if (target instanceof HTMLElement) { ret = new jsdom__HTMLElement({}); ret.node = target; }
#else if (target instanceof Window) { ret = new jsdom__Window({}); ret.node = target;}
#else if (target instanceof SVGElement) { ret = new jsdom__SVGElement({}); ret.node = target; }
#else if (target instanceof Element) { ret = new jsdom__Element({}); ret.node = target; }
#else if (target instanceof Document) { ret = new jsdom__Document({}); ret.node = target; }
return ret
}
pub type EventCallback = fn (_ IEventTarget, _ IEvent)
pub const (
document = Document{}
window = Window{}
)
fn init() {
#jsdom__document.node = document;
#jsdom__window.node = window;
}
pub struct JS.DOMMatrix {
pub:
is_2d JS.Boolean [noinit]
is_identity JS.Boolean [noinit]
pub mut:
m11 JS.Number [noinit]
m12 JS.Number [noinit]
m13 JS.Number [noinit]
m14 JS.Number [noinit]
m21 JS.Number [noinit]
m22 JS.Number [noinit]
m23 JS.Number [noinit]
m24 JS.Number [noinit]
m31 JS.Number [noinit]
m32 JS.Number [noinit]
m33 JS.Number [noinit]
m34 JS.Number [noinit]
m41 JS.Number [noinit]
m42 JS.Number [noinit]
m43 JS.Number [noinit]
m44 JS.Number [noinit]
a JS.Number [noinit]
b JS.Number [noinit]
c JS.Number [noinit]
d JS.Number [noinit]
e JS.Number [noinit]
f JS.Number [noinit]
}
pub struct DOMMatrix {
matrix JS.DOMMatrix [noinit]
}
pub fn (matrix DOMMatrix) str() string {
fmt := ''
#fmt.str = matrix.matrix + ''
return fmt
}
pub fn new_matrix(init []f64) DOMMatrix {
#let tmp = new Array();
for val in init {
_ := val
#tmp.push(val);
}
mut m := JS.DOMMatrix{}
#m = new DOMMatrix(tmp);
return DOMMatrix{m}
}
pub fn (m DOMMatrix) invert_self() {
#m.matrix.invertSelf();
}
pub fn (m DOMMatrix) is_2d() bool {
res := false
#res.val = m.matrix.is2D.val;
return res
}