html/dom

Search:
Group by:

Types

AttrData = object
  qualifiedName*: CAtom
  namespace*: CAtom
  value*: string
ButtonType = enum
  btSubmit = "submit", btReset = "reset", btButton = "button"
CharacterData = ref object of Node
  data* {.jsgetset.}: RefString
Comment = ref object of CharacterData
Crypto = ref object
  urandom*: PosixStream
CSSStyleDeclaration = ref object
  decls*: seq[CSSDeclaration]
CustomElementRegistry = ref object
  rt*: JSRuntime
DependencyInfo = array[DependencyType, seq[Element]]
DependencyType = enum
  dtHover, dtChecked, dtFocus, dtTarget
Document = ref DocumentObj
DocumentFragment = ref object of ParentNode
  host*: Element
DocumentReadyState = enum
  rsLoading = "loading", rsInteractive = "interactive", rsComplete = "complete"
DocumentType = ref object of Node
  name* {.jsget.}: string
  publicId* {.jsget.}: string
  systemId* {.jsget.}: string
DocumentWriteBuffer = ref object
  data*: string
  i*: int
  prev*: DocumentWriteBuffer
DOMRect = ref object
  x* {.jsgetset.}: float64
  y* {.jsgetset.}: float64
  width* {.jsgetset.}: float64
  height* {.jsgetset.}: float64
Element = ref object of ParentNode
  namespaceURI* {.jsget.}: CAtom
  localName* {.jsget.}: CAtom
  id* {.jsget.}: CAtom
  classList* {.jsget.}: DOMTokenList
  attrs*: seq[AttrData]
  cachedStyle*: CSSStyleDeclaration
  computed*: CSSValues
  box*: RootRef
FormAssociatedElement = ref object of HTMLElement
  form*: HTMLFormElement
  parserInserted*: bool
FormEncodingType = enum
  fetUrlencoded = "application/x-www-form-urlencoded",
  fetMultipart = "multipart/form-data", fetTextPlain = "text/plain"
FormMethod = enum
  fmGet = "get", fmPost = "post", fmDialog = "dialog"
History = ref object
HTMLAnchorElement = ref object of HTMLElement
HTMLAudioElement = ref object of HTMLElement
HTMLButtonElement = ref object of FormAssociatedElement
  ctype* {.jsget: "type".}: ButtonType
HTMLElement = ref object of Element
HTMLFormElement = ref object of HTMLElement
  constructingEntryList*: bool
  firing*: bool
  controls*: seq[FormAssociatedElement]
HTMLImageElement = ref object of HTMLElement
  bitmap*: NetworkBitmap
HTMLInputElement = ref object of FormAssociatedElement
  inputType* {.jsget: "type".}: InputType
  files* {.jsget.}: seq[WebFile]
  xcoord*: int
  ycoord*: int
HTMLLabelElement = ref object of HTMLElement
HTMLLIElement = ref object of HTMLElement
HTMLLinkElement = ref object of SheetElement
HTMLOptionElement = ref object of HTMLElement
  selected* {.jsget.}: bool
HTMLScriptElement = ref object of HTMLElement
  parserDocument*: Document
  preparationTimeDocument*: Document
  forceAsync*: bool
  external*: bool
  readyForParserExec*: bool
  alreadyStarted*: bool
  scriptResult*: ScriptResult
  next*: HTMLScriptElement
HTMLStyleElement = ref object of SheetElement
HTMLTemplateElement = ref object of HTMLElement
  content* {.jsget.}: DocumentFragment
HTMLVideoElement = ref object of HTMLElement
InputType = enum
  itText = "text", itButton = "button", itCheckbox = "checkbox",
  itColor = "color", itDate = "date", itDatetimeLocal = "datetime-local",
  itEmail = "email", itFile = "file", itHidden = "hidden", itImage = "image",
  itMonth = "month", itNumber = "number", itPassword = "password",
  itRadio = "radio", itRange = "range", itReset = "reset", itSearch = "search",
  itSubmit = "submit", itTel = "tel", itTime = "time", itURL = "url",
  itWeek = "week"
MimeTypeArray = ref object
Node = ref object of EventTarget
  parentNode*: ParentNode
Notification = ref object
ParentNode = ref object of Node
Permissions = ref object
PluginArray = ref object
Screen = ref object
Storage = ref object
  map*: seq[tuple[key, value: string]]
SVGSVGElement = ref object of SVGElement
  bitmap*: NetworkBitmap
Text = ref object of CharacterData
Window = ref object of EventTarget
  bc*: RootRef
  console*: Console
  navigator* {.jsget.}: Navigator
  screen* {.jsget.}: Screen
  history* {.jsget.}: History
  localStorage* {.jsget.}: Storage
  sessionStorage* {.jsget.}: Storage
  crypto* {.jsget.}: Crypto
  event*: Event
  settings*: EnvironmentSettings
  loader*: FileLoader
  location* {.jsget.}: Location
  jsctx*: JSContext
  document* {.jsufget.}: Document
  timeouts*: TimeoutState
  importMapsAllowed*: bool
  dangerAlwaysSameOrigin*: bool
  remoteSheetNum*: uint32
  loadedSheetNum*: uint32
  remoteImageNum*: uint32
  loadedImageNum*: uint32
  svgCache*: Table[string, SVGSVGElement]
  pendingCanvasCtls*: seq[CanvasRenderingContext2D]
  imageTypes*: Table[string, string]
  userAgent*: string
  referrer* {.jsget.}: string
  performance* {.jsget.}: Performance
  weakMap*: array[WindowWeakMap, JSValue]
  customElements* {.jsget.}: CustomElementRegistry
WindowWeakMap = enum
  wwmChildren, wwmChildNodes, wwmSelectedOptions, wwmTBodies, wwmCells,
  wwmDataset, wwmAttributes

Vars

applyStyleImpl: proc (element: Element) {.nimcall, ...raises: [].}
clickImpl: proc (bc: RootRef; element: HTMLElement) {.nimcall, ...raises: [].}
ensureLayoutImpl: proc (bc: RootRef; element: Element) {.nimcall, ...raises: [].}
getClientRectsImpl: proc (element: Element; firstOnly, blockOnly: bool): seq[
    DOMRect] {.nimcall, ...raises: [].}
imageLoadedImpl: proc (bc: RootRef) {.nimcall, ...raises: [].}
matchesImpl: proc (element: Element; cxsels: SelectorList): bool {.nimcall,
    ...raises: [].}
parseDocumentWriteChunkImpl: proc (wrapper: RootRef) {.nimcall, ...raises: [].}
parseHTMLFragmentImpl: proc (element: Element; s: string): seq[Node] {.nimcall,
    ...raises: [].}
sheetLoadedImpl: proc (bc: RootRef) {.nimcall, ...raises: [].}

Consts

WindowEvents = [satError, satLoad, satFocus, satBlur]

Procs

proc action(element: Element): string {....raises: [], tags: [RootEffect],
                                        forbids: [].}
proc add(depends: var DependencyInfo; element: Element; t: DependencyType) {.
    ...raises: [], tags: [], forbids: [].}
proc addCustomElementRegistry(window: Window; rt: JSRuntime) {....raises: [],
    tags: [], forbids: [].}
proc addDOMModule(ctx: JSContext; eventTargetCID: JSClassID): Opt[void] {.
    ...raises: [], tags: [], forbids: [].}
proc applyQuirksSheet(document: Document) {....raises: [], tags: [RootEffect],
    forbids: [].}
proc applyStyleDependencies(element: Element; depends: DependencyInfo) {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc applyUASheet(document: Document) {....raises: [], tags: [RootEffect],
                                        forbids: [].}
proc applyUserSheet(document: Document; user: string) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc attr(element: Element; name: CAtom; value: sink string) {....raises: [],
    tags: [RootEffect, TimeEffect], forbids: [].}
proc attr(element: Element; name: StaticAtom; value: sink string) {....raises: [],
    tags: [RootEffect, TimeEffect], forbids: [].}
proc attr(element: Element; s: CAtom): lent string {....raises: [],
    tags: [RootEffect], forbids: [].}
proc attr(element: Element; s: StaticAtom): lent string {....raises: [],
    tags: [RootEffect], forbids: [].}
proc attrb(element: Element; at: StaticAtom): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc attrb(element: Element; s: CAtom): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc attrd(element: Element; s: StaticAtom): Opt[float64] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc attrdgz(element: Element; s: StaticAtom): Opt[float64] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc attrl(element: Element; s: StaticAtom): Opt[int32] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc attrns(element: Element; localName: CAtom; prefix: NamespacePrefix;
            namespace: Namespace; value: sink string) {....raises: [],
    tags: [RootEffect, TimeEffect], forbids: [].}
proc attrul(element: Element; s: StaticAtom): Opt[uint32] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc attrulgz(element: Element; s: StaticAtom): Opt[uint32] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc baseURL(document: Document): URL {....raises: [], tags: [RootEffect],
                                        forbids: [].}
proc body(document: Document): HTMLElement {....raises: [], tags: [RootEffect],
    forbids: [].}
proc canSubmitImplicitly(form: HTMLFormElement): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc checked(input: HTMLInputElement): bool {.inline, ...raises: [], tags: [],
    forbids: [].}
proc childTextContent(node: ParentNode): string {....raises: [],
    tags: [RootEffect], forbids: [].}
proc control(label: HTMLLabelElement): FormAssociatedElement {....raises: [],
    tags: [RootEffect], forbids: [].}
proc createComment(document: Document; data: string): Comment {....raises: [],
    tags: [], forbids: [].}
proc document(node: Node): Document {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc documentElement(document: Document): Element {....raises: [],
    tags: [RootEffect], forbids: [].}
proc elIndex(this: Element): int {....raises: [], tags: [RootEffect], forbids: [].}
proc enctype(element: Element): FormEncodingType {....raises: [],
    tags: [RootEffect], forbids: [].}
proc execute(element: HTMLScriptElement) {....raises: [], tags: [RootEffect],
    forbids: [].}
proc fetch(window: Window; input: Request; finish: FetchFinish; opaque: RootRef) {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc findAncestor(node: Node; tagType: TagType): Element {....raises: [],
    tags: [RootEffect], forbids: [].}
proc findAnchor(document: Document; id: string): Element {....raises: [],
    tags: [RootEffect], forbids: [].}
proc findAutoFocus(document: Document): Element {....raises: [],
    tags: [RootEffect], forbids: [].}
proc findFirst(document: Document; tagType: TagType): HTMLElement {....raises: [],
    tags: [RootEffect], forbids: [].}
proc findMetaRefresh(document: Document): Element {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fireEvent(window: Window; event: Event; target: EventTarget) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fireEvent(window: Window; name: StaticAtom; target: EventTarget;
               bubbles, cancelable, trusted: bool) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc firstElementChild(node: ParentNode): Element {....raises: [],
    tags: [RootEffect], forbids: [].}
proc focus(document: Document): Element {....raises: [], tags: [], forbids: [].}
proc fragmentParsingAlgorithm(element: Element; s: string): DocumentFragment {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc getBitmap(element: Element): NetworkBitmap {....raises: [], tags: [],
    forbids: [].}
proc getChildList(node: ParentNode): seq[Node] {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getComputedStyle(element: Element; pseudo: PseudoElement): CSSValues {.
    ...raises: [], tags: [], forbids: [].}
proc getComputedStyle0(ctx: JSContext; window: Window; element: Element;
                       pseudoElt: JSValueConst): Opt[CSSStyleDeclaration] {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc getContext(jctx: JSContext; this: HTMLCanvasElement; contextId: string;
                options: JSValueConst = JS_UNDEFINED): CanvasRenderingContext2D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc getElementById(document: Document; id: string): Element {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getFormMethod(element: Element): FormMethod {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getGlobal(ctx: JSContext): Window {....raises: [], tags: [], forbids: [].}
proc getProgressPosition(element: Element): float64 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getRuleMap(document: Document): CSSRuleMap {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getSrc(this: HTMLElement): tuple[src, contentType: string] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getWindow(ctx: JSContext): Window {....raises: [], tags: [], forbids: [].}
proc head(document: Document): HTMLElement {....raises: [], tags: [RootEffect],
    forbids: [].}
proc hint(element: Element): bool {....raises: [], tags: [], forbids: [].}
proc hover(element: Element): bool {....raises: [], tags: [], forbids: [].}
proc inputString(input: HTMLInputElement): RefString {....raises: [],
    tags: [RootEffect], forbids: [].}
proc inSameTree(a, b: Node): bool {....raises: [], tags: [], forbids: [].}
proc insert(parent: ParentNode; node, before: Node; suppressObservers = false) {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc invalidate(element: Element) {....raises: [], tags: [RootEffect], forbids: [].}
proc invalidate(element: Element; dep: DependencyType) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isButton(element: Element): bool {....raises: [], tags: [], forbids: [].}
proc isDefined(element: Element): bool {....raises: [], tags: [], forbids: [].}
proc isDisabled(this: Element): bool {....raises: [], tags: [RootEffect],
                                       forbids: [].}
proc isFirstVisualNode(element: Element): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isLastVisualNode(element: Element): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isPreviousSiblingOf(this, other: Element): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isSameOrigin(window: Window; origin: Origin): bool {....raises: [], tags: [],
    forbids: [].}
proc isSubmitButton(element: Element): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc lastChild(node: Node): Node {....raises: [], tags: [RootEffect], forbids: [].}
proc lastElementChild(node: ParentNode): Element {....raises: [],
    tags: [RootEffect], forbids: [].}
proc loadImage(window: Window; image: HTMLImageElement) {....raises: [],
    tags: [RootEffect, TimeEffect], forbids: [].}
proc loadSVG(window: Window; svg: SVGSVGElement) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc merge(a: var DependencyInfo; b: DependencyInfo) {....raises: [], tags: [],
    forbids: [].}
proc newDocument(url: URL): Document {....raises: [], tags: [RootEffect],
                                       forbids: [].}
proc newDocumentType(document: Document; name, publicId, systemId: sink string): DocumentType {.
    ...raises: [], tags: [], forbids: [].}
proc newElement(document: Document; localName, namespaceURI, prefix: CAtom): Element {.
    ...raises: [], tags: [], forbids: [].}
proc newElement(document: Document; localName: CAtom;
                namespace = Namespace.HTML; prefix = NO_PREFIX): Element {.
    ...raises: [], tags: [], forbids: [].}
proc newHTMLElement(document: Document; tagType: TagType): HTMLElement {.
    ...raises: [], tags: [], forbids: [].}
proc newLocation(window: Window): Location {....raises: [], tags: [], forbids: [].}
proc newText(document: Document; data: sink string): Text {....raises: [],
    tags: [], forbids: [].}
proc nextElementSibling(element: Element): Element {....raises: [], tags: [],
    forbids: [].}
proc nextSibling(node: Node): Node {....raises: [], tags: [], forbids: [].}
proc origin(location: Location): string {....raises: [], tags: [RootEffect],
    forbids: [].}
proc parentElement(node: Node): Element {....raises: [], tags: [], forbids: [].}
proc parseURL(document: Document; s: string): Opt[URL] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc parseURL0(document: Document; s: string): URL {....raises: [],
    tags: [RootEffect], forbids: [].}
proc performMicrotaskCheckpoint(window: Window) {....raises: [], tags: [],
    forbids: [].}
proc prepare(element: HTMLScriptElement) {....raises: [], tags: [RootEffect],
    forbids: [].}
proc previousElementSibling(element: Element): Element {....raises: [],
    tags: [RootEffect], forbids: [].}
proc previousSibling(node: Node): Node {....raises: [], tags: [RootEffect],
    forbids: [].}
proc reinitURL(element: Element): Opt[URL] {....raises: [], tags: [RootEffect],
    forbids: [].}
proc remove(node: Node) {....raises: [], tags: [RootEffect], forbids: [].}
proc remove(node: Node; suppressObservers: bool) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc replace(parent, child, node: Node): Err[cstring] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc reset(form: HTMLFormElement) {....raises: [], tags: [RootEffect], forbids: [].}
proc resetElement(element: Element) {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc runJSJobs(window: Window) {....raises: [], tags: [], forbids: [].}
proc scriptingEnabled(document: Document): bool {....raises: [], tags: [],
    forbids: [].}
proc select(option: HTMLOptionElement): HTMLSelectElement {....raises: [],
    tags: [RootEffect], forbids: [].}
proc selectedIndex(this: HTMLSelectElement): int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc serializeFragment(node: Node; writeShadow: bool): string {....raises: [],
    tags: [RootEffect], forbids: [].}
proc setChecked(input: HTMLInputElement; b: bool) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc setFocus(document: Document; element: Element) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc setForm(element: FormAssociatedElement; form: HTMLFormElement) {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc setHint(element: Element; hint: bool) {....raises: [], tags: [RootEffect],
    forbids: [].}
proc setHover(element: Element; hover: bool) {....raises: [], tags: [RootEffect],
    forbids: [].}
proc setLocation(ctx: JSContext; document: Document; s: string): JSValue {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc setSelected(option: HTMLOptionElement; selected: bool) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc setSelectedIndex(this: HTMLSelectElement; n: int) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc setTarget(document: Document; element: Element) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc setValue(this: HTMLInputElement; value: sink string) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc tagType(element: Element; namespace = satNamespaceHTML): TagType {.
    ...raises: [], tags: [], forbids: [].}
proc target(document: Document): Element {....raises: [], tags: [], forbids: [].}
proc textAreaString(textarea: HTMLTextAreaElement): string {....raises: [],
    tags: [RootEffect], forbids: [].}
proc textContent(node: Node): string {....raises: [], tags: [RootEffect],
                                       forbids: [].}
proc title(document: Document): string {....raises: [], tags: [RootEffect],
    forbids: [].}
proc updateSheet(this: HTMLStyleElement) {....raises: [], tags: [RootEffect],
    forbids: [].}
proc value(option: HTMLOptionElement): string {....raises: [], tags: [RootEffect],
    forbids: [].}
proc value(textarea: HTMLTextAreaElement): string {....raises: [],
    tags: [RootEffect], forbids: [].}
proc value(this: HTMLInputElement): lent string {....raises: [], tags: [],
    forbids: [].}
proc value=(textarea: HTMLTextAreaElement; s: sink string) {....raises: [],
    tags: [], forbids: [].}
proc windowChange(window: Window) {....raises: [], tags: [RootEffect], forbids: [].}

Iterators

iterator ancestors(node: Node): Element {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator branch(node: Node): Node {.inline, ...raises: [], tags: [], forbids: [].}
iterator branchElems(node: Node): Element {.inline, ...raises: [], tags: [],
    forbids: [].}
iterator childList(node: ParentNode): Node {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator descendants(node: ParentNode): Node {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator displayedElements(window: Window): Element {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator elementDescendants(node: ParentNode): Element {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator elementDescendants(node: ParentNode; tag: set[TagType]): Element {.
    inline, ...raises: [], tags: [RootEffect], forbids: [].}
iterator elementDescendants(node: ParentNode; tag: TagType): Element {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
iterator elementList(node: ParentNode): Element {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator items(tokenList: DOMTokenList): CAtom {.inline, ...raises: [], tags: [],
    forbids: [].}
iterator options(select: HTMLSelectElement): HTMLOptionElement {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
iterator precedingSiblings(node: Node): Node {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator radiogroup(input: HTMLInputElement): HTMLInputElement {.inline,
    ...raises: [], tags: [RootEffect], forbids: [].}
iterator rchildList(node: ParentNode): Node {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator relementList(node: ParentNode): Element {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator safeChildList(node: ParentNode): Node {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator shadowChildList(node: ParentNode): Node {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}
iterator subsequentSiblings(node: Node): Node {.inline, ...raises: [], tags: [],
    forbids: [].}
iterator textNodes(node: ParentNode): Text {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}