Module dom

Declaration of the Document Object Model for the JavaScript backend.

Types

EventTarget = ref EventTargetObj

Window = ref WindowObj

Frame = ref FrameObj

ClassList = ref ClassListObj

NodeType = enum
  ElementNode = 1, AttributeNode, TextNode, CDATANode, EntityRefNode, EntityNode,
  ProcessingInstructionNode, CommentNode, DocumentNode, DocumentTypeNode,
  DocumentFragmentNode, NotationNode

Node = ref NodeObj

Document = ref DocumentObj

Element = ref ElementObj

HtmlElement = ref object of Element
  contentEditable*: cstring
  isContentEditable*: bool
  dir*: cstring
  offsetHeight*: int
  offsetWidth*: int
  offsetLeft*: int
  offsetTop*: int

LinkElement = ref LinkObj

EmbedElement = ref EmbedObj

AnchorElement = ref AnchorObj

OptionElement = ref OptionObj

TextAreaElement = ref object of ElementObj
  value*: cstring
  selectionStart*, selectionEnd*: int
  selectionDirection*: cstring
  rows*, cols*: int

FormElement = ref FormObj

ImageElement = ref ImageObj

Style = ref StyleObj

Event = ref EventObj

TouchList {...}{.importc.} = ref object of RootObj
  length*: int

TouchEvent {...}{.importc.} = ref object of Event
  changedTouches*, targetTouches*, touches*: TouchList

Touch {...}{.importc.} = ref object of RootObj
  identifier*: int
  screenX*, screenY*, clientX*, clientY*, pageX*, pageY*: int
  target*: Element
  radiusX*, radiusY*: int
  rotationAngle*: int
  force*: float

Location = ref LocationObj

History = ref HistoryObj

Navigator = ref NavigatorObj

TPlugin {...}{.importc.} = object of RootObj
  description*: cstring
  filename*: cstring
  name*: cstring

TMimeType {...}{.importc.} = object of RootObj
  description*: cstring
  enabledPlugin*: ref TPlugin
  suffixes*: seq[cstring]
  `type`*: cstring

TLocationBar {...}{.importc.} = object of RootObj
  visible*: bool

TMenuBar = TLocationBar

TPersonalBar = TLocationBar

TScrollBars = TLocationBar

TToolBar = TLocationBar

TStatusBar = TLocationBar

TTimeOut {...}{.importc.} = object of RootObj

TInterval {...}{.importc.} = object of RootObj

AddEventListenerOptions = object
  capture*: bool
  once*: bool
  passive*: bool

BoundingRect {...}{.importc.} = ref object
  top*, bottom*, left*, right*, x*, y*, width*, height*: float

PerformanceMemory {...}{.importc.} = ref object
  jsHeapSizeLimit*: float
  totalJSHeapSize*: float
  usedJSHeapSize*: float

PerformanceTiming {...}{.importc.} = ref object
  connectStart*: float
  domComplete*: float
  domContentLoadedEventEnd*: float
  domContentLoadedEventStart*: float
  domInteractive*: float
  domLoading*: float
  domainLookupEnd*: float
  domainLookupStart*: float
  fetchStart*: float
  loadEventEnd*: float
  loadEventStart*: float
  navigationStart*: float
  redirectEnd*: float
  redirectStart*: float
  requestStart*: float
  responseEnd*: float
  responseStart*: float
  secureConnectionStart*: float
  unloadEventEnd*: float
  unloadEventStart*: float

Performance {...}{.importc.} = ref object
  memory*: PerformanceMemory
  timing*: PerformanceTiming

TEventHandlers {...}{.deprecated.} = EventTargetObj

TWindow {...}{.deprecated.} = WindowObj

TFrame {...}{.deprecated.} = FrameObj

TNode {...}{.deprecated.} = NodeObj

TDocument {...}{.deprecated.} = DocumentObj

TElement {...}{.deprecated.} = ElementObj

TLink {...}{.deprecated.} = LinkObj

TEmbed {...}{.deprecated.} = EmbedObj

TAnchor {...}{.deprecated.} = AnchorObj

TOption {...}{.deprecated.} = OptionObj

TForm {...}{.deprecated.} = FormObj

TImage {...}{.deprecated.} = ImageObj

TNodeType {...}{.deprecated.} = NodeType

TEvent {...}{.deprecated.} = EventObj

TLocation {...}{.deprecated.} = LocationObj

THistory {...}{.deprecated.} = HistoryObj

TNavigator {...}{.deprecated.} = NavigatorObj

TStyle {...}{.deprecated.} = StyleObj

TScreen {...}{.deprecated.} = ScreenObj

TApplet {...}{.importc, deprecated.} = object of RootObj

Vars

window: Window

document: Document

navigator: Navigator

screen: Screen

Procs

proc addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event);
                     useCapture: bool = false)

proc addEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event);
                     options: AddEventListenerOptions)

proc removeEventListener(et: EventTarget; ev: cstring; cb: proc (ev: Event);
                        useCapture: bool = false)

proc dispatchEvent(et: EventTarget; ev: Event)

proc alert(w: Window; msg: cstring)

proc back(w: Window)

proc blur(w: Window)

proc captureEvents(w: Window; eventMask: int) {...}{.deprecated.}

proc clearInterval(w: Window; interval: ref TInterval)

proc clearTimeout(w: Window; timeout: ref TTimeOut)

proc close(w: Window)

proc confirm(w: Window; msg: cstring): bool

proc disableExternalCapture(w: Window)

proc enableExternalCapture(w: Window)

proc find(w: Window; text: cstring; caseSensitive = false; backwards = false)

proc focus(w: Window)

proc forward(w: Window)

proc handleEvent(w: Window; e: Event)

proc home(w: Window)

proc moveBy(w: Window; x, y: int)

proc moveTo(w: Window; x, y: int)

proc open(w: Window; uri, windowname: cstring; properties: cstring = nil): Window

proc print(w: Window)

proc prompt(w: Window; text, default: cstring): cstring

proc releaseEvents(w: Window; eventMask: int) {...}{.deprecated.}

proc resizeBy(w: Window; x, y: int)

proc resizeTo(w: Window; x, y: int)

proc routeEvent(w: Window; event: Event)

proc scrollBy(w: Window; x, y: int)

proc scrollTo(w: Window; x, y: int)

proc setInterval(w: Window; code: cstring; pause: int): ref TInterval

proc setInterval(w: Window; function: proc (); pause: int): ref TInterval

proc setTimeout(w: Window; code: cstring; pause: int): ref TTimeOut

proc setTimeout(w: Window; function: proc (); pause: int): ref TInterval

proc stop(w: Window)

proc requestAnimationFrame(w: Window; function: proc (time: float)): int

proc cancelAnimationFrame(w: Window; id: int)

proc appendChild(n, child: Node)

proc appendData(n: Node; data: cstring)

proc cloneNode(n: Node; copyContent: bool): Node

proc deleteData(n: Node; start, len: int)

proc getAttribute(n: Node; attr: cstring): cstring

proc getAttributeNode(n: Node; attr: cstring): Node

proc getBoundingClientRect(e: Node): BoundingRect

proc hasChildNodes(n: Node): bool

proc insertBefore(n, newNode, before: Node)

proc insertData(n: Node; position: int; data: cstring)

proc removeAttribute(n: Node; attr: cstring)

proc removeAttributeNode(n, attr: Node)

proc removeChild(n, child: Node)

proc replaceChild(n, newNode, oldNode: Node)

proc replaceData(n: Node; start, len: int; text: cstring)

proc scrollIntoView(n: Node; alignToTop: bool = true)

proc setAttribute(n: Node; name, value: cstring)

proc setAttributeNode(n: Node; attr: Node)

proc captureEvents(d: Document; eventMask: int) {...}{.deprecated.}

proc createAttribute(d: Document; identifier: cstring): Node

proc createElement(d: Document; identifier: cstring): Element

proc createTextNode(d: Document; identifier: cstring): Node

proc getElementById(d: Document; id: cstring): Element

proc getElementsByName(d: Document; name: cstring): seq[Element]

proc getElementsByTagName(d: Document; name: cstring): seq[Element]

proc getElementsByClassName(d: Document; name: cstring): seq[Element]

proc getSelection(d: Document): cstring

proc handleEvent(d: Document; event: Event)

proc open(d: Document)

proc releaseEvents(d: Document; eventMask: int) {...}{.deprecated.}

proc routeEvent(d: Document; event: Event)

proc write(d: Document; text: cstring)

proc writeln(d: Document; text: cstring)

proc querySelector(d: Document; selectors: cstring): Element

proc querySelectorAll(d: Document; selectors: cstring): seq[Element]

proc blur(e: Element)

proc click(e: Element)

proc focus(e: Element)

proc handleEvent(e: Element; event: Event)

proc select(e: Element)

proc getElementsByTagName(e: Element; name: cstring): seq[Element]

proc getElementsByClassName(e: Element; name: cstring): seq[Element]

proc reset(f: FormElement)

proc submit(f: FormElement)

proc play(e: EmbedElement)

proc stop(e: EmbedElement)

proc reload(loc: Location)

proc replace(loc: Location; s: cstring)

proc back(h: History)

proc forward(h: History)

proc go(h: History; pagesToJump: int)

proc pushState[T](h: History; stateObject: T; title, url: cstring)

proc javaEnabled(h: Navigator): bool

proc add(c: ClassList; class: cstring)

proc remove(c: ClassList; class: cstring)

proc contains(c: ClassList; class: cstring): bool

proc toggle(c: ClassList; class: cstring)

proc getAttribute(s: Style; attr: cstring; caseSensitive = false): cstring

proc removeAttribute(s: Style; attr: cstring; caseSensitive = false)

proc setAttribute(s: Style; attr, value: cstring; caseSensitive = false)

proc preventDefault(ev: Event)

proc identifiedTouch(list: TouchList): Touch

proc item(list: TouchList; i: int): Touch

proc now(p: Performance): float

proc decodeURI(uri: cstring): cstring {...}{.importc, nodecl.}

proc encodeURI(uri: cstring): cstring {...}{.importc, nodecl.}

proc escape(uri: cstring): cstring {...}{.importc, nodecl.}

proc unescape(uri: cstring): cstring {...}{.importc, nodecl.}

proc decodeURIComponent(uri: cstring): cstring {...}{.importc, nodecl.}

proc encodeURIComponent(uri: cstring): cstring {...}{.importc, nodecl.}

proc isFinite(x: BiggestFloat): bool {...}{.importc, nodecl.}

proc isNaN(x: BiggestFloat): bool {...}{.importc, nodecl.}

proc parseFloat(s: cstring): BiggestFloat {...}{.importc, nodecl.}

proc parseInt(s: cstring): int {...}{.importc, nodecl.}

proc parseInt(s: cstring; radix: int): int {...}{.importc, nodecl.}

proc newEvent(name: cstring): Event {...}{.importcpp: "new Event(@)", constructor.}