ngui

    Dark Mode
Search:
Group by:

Types

NOrientation = enum
  noHORIZONTAL, noVERTICAL
NSide = enum
  nsTop, nsBottom, nsLeft, nsRight
NAmount = enum
  naNone, naMinOne, naOne, naMultiple
NIcon = enum
  niFOLDER, niFILE, niFILE_OPEN, niEXECUTABLE
NID = uint32
NElementKind = enum
  neKindInvalid, neApp, neWindow, neContainer, neBubble, neBox, neCheckBox,
  neComboBox, neCalendar, neTab, neList, neFrame, neTable, neTools, neMenu,
  neBar, neAtom, neRadio, neLabel, neEntry, neButton, neAlert, neImage,
  neProgress, neTextArea, neSlider, neFileChoose
NElementEvent = enum
  neNONE, neCLICK, neCLICK_RELEASE, neMOVE, neENTER, neCHANGE, neOPEN,
  neFOCUS_ON, neFOCUS_OFF, neDESTROY, neSHOW, neHIDE, neKEY_PRESS, neKEY_RELEASE
NKey = enum
  nkNone, nkEsc, nkControl, nkShift, nkA, nkB, nkC, nkD, nkE, nkF, nkG, nkH,
  nkI, nkJ, nkK, nkL, nkM, nkN, nkO, nkP, nkQ, nkR, nkS, nkT, nkU, nkV, nkW,
  nkX, nkY, nkZ, nk0, nk1, nk2, nk3, nk4, nk5, nk6, nk7, nk8, nk9
NMouse = enum
  nm1, nm2, nm3
NCellKind = enum
  ckImg, ckBool, ckStr
NElement = ref object of RootObj
  id: NID
  kind: NElementKind

Container = ref object of NElement
Bubble = ref object of Container
  
Box = ref object of Container
  
Grid = ref object of Container
  
App = ref object of Container
Window = ref object of Container
  
ComboBox = ref object of Container
  
Tab = ref object of Container
  
List = ref object of Container
  
Frame = ref object of Container
  
Tools = ref object of Container
  
Table = ref object of Container
  
NTable = Table
Bar = ref object of Container
  
Menu = ref object of Container
  
Atom = ref object of NElement
CheckBox = ref object of Atom
  
Alert = ref object of Atom
  
Calendar = ref object of Atom
  
Radio = ref object of Atom
  
Entry = ref object of Atom
  
Label = ref object of Atom
  
Button = ref object of Atom
  
Progress = ref object of Atom
  
TextArea = ref object of Atom
Slider = ref object of Atom
  
FileChoose = ref object of Atom
Image = ref object of Atom
  
Bitmap = ref object
  img: seq[Pixel]
  w, h: int
  data: pointer
  path: string

Pixel = tuple[r, g, b, a: uint8]
NElementAttribute = enum
  naMinimized, naMaximized, naKind, naVisible, naHasParent, naFocus, naSize,
  naOpacity, naLen, naText, naWrap, naResizable, naValue, naOrientation,
  naIndex, naReorderable, naName, naSide, naBGColor, naModal, naTransient
Attribute = object
  case kind*: NElementAttribute
  of naKind:
    aKind*: NElementKind
  of naText:
    aText*: string
  of naName:
    aName*: string
  of naVisible:
    aVisible*: bool
  of naWrap:
    aWrap*: bool
  of naResizable:
    aResizable*: bool
  of naHasParent:
    aHasParent*: bool
  of naFocus:
    aFocus*: bool
  of naSize:
    aSize*: tuple[w, h: int]
  of naValue:
    aValue*: tuple[vInt: int, vFloat: float]
  of naOpacity:
    aOpacity*: float
  of naLen:
    aLen*: int
  of naMinimized:
    aMinimized*: bool
  of naMaximized:
    aMaximized*: bool
  of naOrientation:
    aOrientation*: NOrientation
  of naIndex:
    aIndex*: int
  of naReorderable:
    aReorderable*: bool
  of naSide:
    aSide*: NSide
  of naBGColor:
    aBGColor*: Pixel
  of naModal:
    aModal*: bool
  of naTransient:
    aTransient*: Window
  found*: bool

Attributes = array[NElementAttribute, Attribute]
NEventArgs = object
  element*: NElement
  case kind*: NElementEvent
  of neClick, neClickRelease, neMove:
      mouse*: set[NMouse]
      x*, y*: int
      selected*: int

  of neChange:
      index*: int

  of neKeyPress, neKeyRelease:
      mods*: set[NKey]
      key*: NKey

  else:
      nil

  
NEventProc = (proc () {...}{.closure.})
NCMPPRoc = (proc (a, b: NElement): int)
NAsyncTextProc = (proc (text: string) {...}{.closure.})
NAsyncBitmapProc = (proc (bitmap: Bitmap) {...}{.closure.})
NRepeatProc = (proc (): bool {...}{.closure.})
NRepeatHandle = distinct int
NTableCell = object
  case kind: NCellKind
  of ckBool:
    vBool: bool
  of ckImg:
    vImg: Bitmap
  of ckStr:
    vStr: string
  
NTableRow = object
  list: ptr [UncheckedArray[NTableCell]]
  len: int

NguiBackEnd = enum
  beNIL, beGTK2, beGTK3, beDOC

Lets

NSEPARATOR = NElement(kind: neKindInvalid, id: 5)
Pseudoelement

Consts

version = 0
Bugs counter, nothing to see here. 
backend = beDOC
nmLEFT = nm1
Alias for nm1 
nmMIDDLE = nm2
Alias for nm2 
nmRIGHT = nm3
Alias for nm3

Procs

proc `$`(this: NElementKind): string {...}{.raises: [], tags: [].}
proc hash(this: NElement): Hash {...}{.raises: [], tags: [].}
proc hash(this: Bitmap): Hash {...}{.raises: [], tags: [].}
proc hash(this: NRepeatHandle): Hash {...}{.raises: [], tags: [].}
proc `==`(this, that: NRepeatHandle): bool {...}{.borrow.}
proc pixel(r, g, b: uint8; a: uint8 = 255): Pixel {...}{.raises: [], tags: [].}
proc pixel(r, g, b: float; a: float = 1.0): Pixel {...}{.raises: [], tags: [].}
proc tag(this: NElement; key: string): string {...}{.raises: [], tags: [].}
Return the value for this key attached to this element or "" 
proc tag=(this: NElement; tag: tuple[key, value: string]) {...}{.
    raises: [KeyError, Exception], tags: [RootEffect].}
Attach a key-value string pair to this element 
proc `[]=`(this: NElement; key, value: string) {...}{.raises: [KeyError, Exception],
    tags: [RootEffect].}
Attach a key-value string pair to this element 
proc `[]=`(this: NElement; key: string): string {...}{.raises: [], tags: [].}
proc name(this: NElement): string {...}{.raises: [], tags: [].}
Get this element's name or "" 
proc name=(this: NElement; name: string) {...}{.raises: [], tags: [].}
Set a name for this element 
proc named[N: NElement](this: N; name: string): N
Set a name for this element and return it 
proc element(name: string): NElement {...}{.raises: [], tags: [].}
Retrieves NElement by name or nil if no element with that name exists 
proc tooltip(this: NElement): string {...}{.raises: [], tags: [].}
proc tooltip=(this: NElement; text: string) {...}{.raises: [], tags: [].}
proc kind(this: NElement): NElementKind {...}{.raises: [], tags: [].}
proc id(this: NElement): int {...}{.raises: [], tags: [].}
proc parent(this: NElement): Container {...}{.raises: [], tags: [].}
proc hasParent(this: NElement): bool {...}{.raises: [], tags: [].}
proc visible(this: NElement): bool {...}{.raises: [], tags: [].}
proc visible=(this: NElement; state: bool) {...}{.raises: [], tags: [].}
proc show(this: NElement) {...}{.raises: [], tags: [].}
proc hide(this: NElement) {...}{.raises: [], tags: [].}
proc alive(this: NElement): bool {...}{.raises: [], tags: [].}
proc destroyed(this: NElement): bool {...}{.raises: [], tags: [].}
proc destroy(this: NElement) {...}{.raises: [], tags: [].}
proc tryDestroy(this: NElement): bool {...}{.discardable, raises: [], tags: [].}
Destroy and return true only if this element is still alive 
proc focused(this: NElement): bool {...}{.raises: [], tags: [].}
proc focus(this: NElement) {...}{.raises: [], tags: [].}
proc size(this: NElement): tuple[w, h: int] {...}{.raises: [], tags: [].}
proc size=(this: NElement; size: tuple[w, h: int]) {...}{.raises: [], tags: [].}
proc next(this: NElement): NElement {...}{.raises: [], tags: [].}
proc prev(this: NElement): NElement {...}{.raises: [], tags: [].}
Get the previous element in this element's parent list of children or nil 
proc index(this: NElement): int {...}{.raises: [], tags: [].}
Return the position of this element in its parent's children list or -1 If is not inside a Container 
proc bgColor(this: NElement): Pixel {...}{.raises: [], tags: [].}
proc bgColor=(this: NElement; color: Pixel) {...}{.raises: [], tags: [].}
proc supports(element: NElementKind; event: NElementEvent): bool {...}{.raises: [],
    tags: [].}
proc supports(element: NElementKind; attribute: NElementAttribute): bool {...}{.
    raises: [], tags: [].}
proc currentEvent(): NEventArgs {...}{.raises: [], tags: [].}
Get current event's argument object 
proc eventHandled() {...}{.raises: [], tags: [].}
Stop propagating the event that is being currently processed 
proc onEvent(this: NElement; event: NElementEvent; action: NEventProc) {...}{.
    raises: [], tags: [].}
proc onNONE(this`gensym55: NElement; action`gensym55: NEventProc) {...}{.raises: [],
    tags: [].}
proc onCLICK(this`gensym56: NElement; action`gensym56: NEventProc) {...}{.raises: [],
    tags: [].}
proc onCLICK_RELEASE(this`gensym57: NElement; action`gensym57: NEventProc) {...}{.
    raises: [], tags: [].}
proc onMOVE(this`gensym58: NElement; action`gensym58: NEventProc) {...}{.raises: [],
    tags: [].}
proc onENTER(this`gensym59: NElement; action`gensym59: NEventProc) {...}{.raises: [],
    tags: [].}
proc onCHANGE(this`gensym60: NElement; action`gensym60: NEventProc) {...}{.
    raises: [], tags: [].}
proc onOPEN(this`gensym61: NElement; action`gensym61: NEventProc) {...}{.raises: [],
    tags: [].}
proc onFOCUS_ON(this`gensym62: NElement; action`gensym62: NEventProc) {...}{.
    raises: [], tags: [].}
proc onFOCUS_OFF(this`gensym63: NElement; action`gensym63: NEventProc) {...}{.
    raises: [], tags: [].}
proc onDESTROY(this`gensym64: NElement; action`gensym64: NEventProc) {...}{.
    raises: [], tags: [].}
proc onSHOW(this`gensym65: NElement; action`gensym65: NEventProc) {...}{.raises: [],
    tags: [].}
proc onHIDE(this`gensym66: NElement; action`gensym66: NEventProc) {...}{.raises: [],
    tags: [].}
proc onKEY_PRESS(this`gensym67: NElement; action`gensym67: NEventProc) {...}{.
    raises: [], tags: [].}
proc onKEY_RELEASE(this`gensym68: NElement; action`gensym68: NEventProc) {...}{.
    raises: [], tags: [].}
proc `of`(this: NElement; that: NElementKind): bool {...}{.raises: [], tags: [].}
proc getApp(): App {...}{.raises: [], tags: [].}
proc app(): App {...}{.raises: [], tags: [].}
Initialize the library and create the App context. This is the main container, which can contain one or more windows. You can only call this procedure once 
proc run(this: App) {...}{.raises: [], tags: [].}
Display any window and listen to user input 
proc `[]`(this: App; index: int): Window {...}{.raises: [], tags: [].}
proc `[]`(this: App; index: BackwardsIndex): Window {...}{.raises: [], tags: [].}
proc window(text: string = "NGUI"): Window {...}{.raises: [], tags: [ReadIOEffect].}
proc text(this: Window): string {...}{.raises: [], tags: [].}
proc text=(this: Window; text: string) {...}{.raises: [], tags: [].}
proc resizable(this: Window): bool {...}{.raises: [], tags: [].}
proc resizable=(this: Window; state: bool) {...}{.raises: [], tags: [].}
proc position(this: Window): tuple[x, y: int] {...}{.raises: [], tags: [].}
proc position=(this: Window; position: tuple[x, y: int]) {...}{.raises: [], tags: [].}
proc x(this: Window): int {...}{.raises: [], tags: [].}
proc y(this: Window): int {...}{.raises: [], tags: [].}
proc x=(this: Window; x: int) {...}{.raises: [], tags: [].}
proc y=(this: Window; y: int) {...}{.raises: [], tags: [].}
proc focused(this: Window): NElement {...}{.raises: [], tags: [].}
proc icon(this: Window): Bitmap {...}{.raises: [], tags: [].}
proc icon=(this: Window; that: Bitmap) {...}{.raises: [], tags: [].}
proc decorated(this: Window): bool {...}{.raises: [], tags: [].}
proc decorated=(this: Window; v: bool) {...}{.raises: [], tags: [].}
proc minimized(this: Window): bool {...}{.raises: [], tags: [].}
proc maximized(this: Window): bool {...}{.raises: [], tags: [].}
proc minimized=(this: Window; v: bool) {...}{.raises: [], tags: [].}
proc maximized=(this: Window; v: bool) {...}{.raises: [], tags: [].}
proc modal(this: Window): bool {...}{.raises: [], tags: [].}
proc modal=(this: Window; v: bool) {...}{.raises: [], tags: [].}
proc transient(this: Window): Window {...}{.raises: [], tags: [].}
proc transient=(this, that: Window) {...}{.raises: [], tags: [].}
proc opacity(this: Window): float {...}{.raises: [], tags: [].}
proc opacity=(this: Window; o: float) {...}{.raises: [], tags: [].}
proc `[]`(this: Window; index: int): Container {...}{.raises: [], tags: [].}
proc `[]`(this: Window; index: BackwardsIndex): Container {...}{.raises: [], tags: [].}
proc alert(title: string = ""; text: string = ""): Alert {...}{.raises: [], tags: [].}
proc text(this: Alert): string {...}{.raises: [], tags: [].}
proc text=(this: Alert; text: string) {...}{.raises: [], tags: [].}
proc title(this: Alert): string {...}{.raises: [], tags: [].}
proc title=(this: Alert; text: string) {...}{.raises: [], tags: [].}
proc modal(this: Alert): bool {...}{.raises: [], tags: [].}
proc modal=(this: Alert; v: bool) {...}{.raises: [], tags: [].}
proc transient(this: Alert): Window {...}{.raises: [], tags: [].}
proc transient=(this: Alert; that: Window) {...}{.raises: [], tags: [].}
proc run(this: Alert) {...}{.raises: [], tags: [].}
proc label(text: string = ""): Label {...}{.raises: [], tags: [].}
proc text(this: Label): string {...}{.raises: [], tags: [].}
proc text=(this: Label; text: string) {...}{.raises: [], tags: [].}
proc wrap(this: Label): bool {...}{.raises: [], tags: [].}
proc wrap=(this: Label; state: bool) {...}{.raises: [], tags: [].}
proc xAlign(this: Label): float {...}{.raises: [], tags: [].}
proc YAlign(this: Label): float {...}{.raises: [], tags: [].}
proc xAlign=(this: Label; v: float) {...}{.raises: [], tags: [].}
proc yAlign=(this: Label; v: float) {...}{.raises: [], tags: [].}
proc entry(text: string = ""): Entry {...}{.raises: [], tags: [].}
proc text(this: Entry): string {...}{.raises: [], tags: [].}
proc text=(this: Entry; text: string) {...}{.raises: [], tags: [].}
proc button(text: string = ""; onEventClick: NEventProc = nil): Button {...}{.
    raises: [], tags: [].}
proc button(img: Bitmap; onEventClick: NEventProc = nil): Button {...}{.raises: [],
    tags: [].}
proc button(icon: NIcon; onEventClick: NEventProc = nil): Button {...}{.raises: [],
    tags: [].}
proc text(this: Button): string {...}{.raises: [], tags: [].}
proc text=(this: Button; text: string) {...}{.raises: [], tags: [].}
proc img(this: Button): Bitmap {...}{.raises: [], tags: [].}
proc img=(this: Button; img: Bitmap) {...}{.raises: [], tags: [].}
proc radio(text: string = ""): Radio {...}{.raises: [], tags: [].}
proc text(this: Radio): string {...}{.raises: [], tags: [].}
proc text=(this: Radio; text: string) {...}{.raises: [], tags: [].}
proc group(list: varargs[Radio]) {...}{.raises: [], tags: [].}
proc bubble(text: string = ""): Bubble {...}{.raises: [Exception], tags: [RootEffect].}
proc bubble(child: NElement): Bubble {...}{.raises: [Exception], tags: [RootEffect].}
proc attach(this: Bubble; that: NElement) {...}{.raises: [], tags: [].}
proc attach(this: Bubble; that: NElement; destroyAfterMs: int) {...}{.
    raises: [Exception], tags: [RootEffect].}
proc bitmap(file: string): Bitmap {...}{.raises: [IOError], tags: [ReadIOEffect].}
proc bitmap(icon: NIcon): Bitmap {...}{.raises: [], tags: [].}
proc save(this: Bitmap; path, format: string): bool {...}{.raises: [], tags: [].}
proc save(this: Bitmap; path: string): bool {...}{.raises: [], tags: [].}
proc save(this: Bitmap): bool {...}{.raises: [], tags: [].}
proc width(this: Bitmap): int {...}{.inline, raises: [], tags: [].}
proc height(this: Bitmap): int {...}{.inline, raises: [], tags: [].}
proc size(this: Bitmap): tuple[w, h: int] {...}{.raises: [], tags: [].}
proc len(this: Bitmap): int {...}{.raises: [], tags: [].}
proc `[]`(this: Bitmap; i: int): Pixel {...}{.inline, raises: [], tags: [].}
proc `[]=`(this: Bitmap; i: int; p: Pixel) {...}{.inline, raises: [], tags: [].}
proc `[]`(this: Bitmap; x, y: int): Pixel {...}{.inline, raises: [], tags: [].}
proc `[]=`(this: Bitmap; x, y: int; p: Pixel) {...}{.inline, raises: [], tags: [].}
proc `[]`(this: Bitmap; point: tuple[x, y: int]): Pixel {...}{.inline, raises: [],
    tags: [].}
proc `[]=`(this: Bitmap; point: tuple[x, y: int]; p: Pixel) {...}{.inline,
    raises: [], tags: [].}
proc forEach(this: Bitmap; action: (proc (p: Pixel): Pixel)) {...}{.raises: [],
    tags: [].}
proc copy(this: Bitmap): Bitmap {...}{.raises: [], tags: [].}
proc image(bitmap: Bitmap = nil): Image {...}{.raises: [], tags: [].}
proc image(file: string): Image {...}{.raises: [IOError], tags: [ReadIOEffect].}
proc update(this: Image) {...}{.raises: [], tags: [].}
proc bitmap=(this: Image; that: Bitmap) {...}{.raises: [], tags: [].}
proc bitmap(this: Image): Bitmap {...}{.raises: [], tags: [].}
proc textArea(text: string = ""): TextArea {...}{.raises: [], tags: [].}
proc text(this: TextArea): string {...}{.raises: [], tags: [].}
proc text=(this: TextArea; text: string) {...}{.raises: [], tags: [].}
proc calendar(date: DateTime = now(); onChangeEvent: NEventProc = nil): Calendar {...}{.
    raises: [], tags: [].}
proc selected=(this: Calendar; date: DateTime) {...}{.raises: [], tags: [].}
proc selected(this: Calendar): DateTime {...}{.raises: [], tags: [].}
proc mark(this: Calendar; dayOfMonth: int) {...}{.raises: [], tags: [].}
proc unmark(this: Calendar; dayOfMonth: int) {...}{.raises: [], tags: [].}
proc marked(this: Calendar; dayOfMonth: int): bool {...}{.raises: [], tags: [].}
proc clear(this: Calendar) {...}{.raises: [], tags: [].}
proc slider(range: Slice[float] = 1.0 .. 100.0; value: float = 0;
            orientation: NOrientation = noHORIZONTAL; decimals: int = 0;
            step: float = 1): Slider {...}{.raises: [], tags: [].}
proc range=(this: Slider; range: Slice[float]) {...}{.raises: [], tags: [].}
proc value(this: Slider): float {...}{.raises: [], tags: [].}
proc value=(this: Slider; value: float) {...}{.raises: [], tags: [].}
proc step=(this: Slider; step: float) {...}{.raises: [], tags: [].}
proc decimals(this: Slider): int {...}{.raises: [], tags: [].}
proc decimals=(this: Slider; decimals: int) {...}{.raises: [], tags: [].}
proc orientation(this: Slider): NOrientation {...}{.raises: [], tags: [].}
proc orientation(this: Slider; value: NOrientation) {...}{.raises: [], tags: [].}
proc fileChoose(button: string; buttons: varargs[string]): FileChoose {...}{.
    raises: [], tags: [].}
proc run(this: FileChoose): int {...}{.raises: [], tags: [].}
proc multiple(this: FileChoose): bool {...}{.raises: [], tags: [].}
proc multiple=(this: FileChoose; state: bool) {...}{.raises: [], tags: [].}
proc text(this: FileChoose): string {...}{.raises: [], tags: [].}
proc text=(this: FileChoose; text: string) {...}{.raises: [], tags: [].}
proc files(this: FileChoose): seq[string] {...}{.raises: [], tags: [].}
proc file(this: FileChoose): string {...}{.raises: [], tags: [].}
proc checkbox(text: string = ""; checked: bool = false): CheckBox {...}{.raises: [],
    tags: [].}
proc text(this: CheckBox): string {...}{.raises: [], tags: [].}
proc text=(this: CheckBox; text: string) {...}{.raises: [], tags: [].}
proc checked(this: CheckBox): bool {...}{.raises: [], tags: [].}
proc checked=(this: CheckBox; v: bool) {...}{.raises: [], tags: [].}
proc len(this: Container): int {...}{.raises: [], tags: [].}
proc `[]`(this: Container; index: int): NElement {...}{.raises: [], tags: [].}
proc `[]`(this: Container; index: BackwardsIndex): NElement {...}{.raises: [],
    tags: [].}
proc addSeparator(this: Container) {...}{.raises: [], tags: [].}
proc add(this: Container; that: NElement) {...}{.raises: [KeyError, Exception],
    tags: [RootEffect, ReadIOEffect].}
Add that element to this container. Elements con only have one parent. 
proc add(this: Container; text: string) {...}{.raises: [KeyError, Exception],
    tags: [RootEffect, ReadIOEffect].}
proc add(this: Container; one, two: NElement; list: varargs[NElement]) {...}{.
    raises: [KeyError, Exception], tags: [RootEffect, ReadIOEffect].}
proc add[N: NElement](this: Container; list: openArray[N])
proc remove(this: Container; that: NElement) {...}{.raises: [], tags: [].}
Remove that element from this container. The container must be the parent of the element 
proc index(this: Container; that: NElement): int {...}{.raises: [], tags: [].}
Get the position of that element relative its parent's children list or -1 if the container is no the parent. 
proc pop(this: Container): NElement {...}{.raises: [], tags: [].}
Remove the last element from this container's children list and return it, or nil if there are no elements 
proc shift(this: Container): NElement {...}{.raises: [], tags: [].}
Remove the first element from this container's children list and return it, or nil if there are no elements 
proc border(this: Container): int {...}{.raises: [], tags: [].}
proc border=(this: Container; border: int) {...}{.raises: [], tags: [].}
proc borderColor(this: Container): Pixel {...}{.raises: [], tags: [].}
proc borderColor=(this: Container; color: Pixel) {...}{.raises: [], tags: [].}
proc bar(): Bar {...}{.raises: [], tags: [].}
proc add(this: Bar; name: string; menu: Menu) {...}{.raises: [KeyError, Exception],
    tags: [RootEffect, ReadIOEffect].}
proc menu(): Menu {...}{.raises: [], tags: [].}
proc add(this: NElement; that: Menu): NElement {...}{.discardable, raises: [],
    tags: [].}
proc add(this: ComboBox; text: string; selected: bool = false) {...}{.raises: [],
    tags: [].}
proc comboBox(textList: varargs[string]; selected: int = -1): ComboBox {...}{.
    raises: [], tags: [].}
proc `[]=`(this: ComboBox; i: int; text: string) {...}{.raises: [], tags: [].}
proc `[]`(this: ComboBox; i: int): string {...}{.raises: [], tags: [].}
proc selected(this: ComboBox): string {...}{.raises: [], tags: [].}
proc selectedIndex(this: ComboBox): int {...}{.raises: [], tags: [].}
Get the index of the selected child. 
proc progress(v: float = 0.0): Progress {...}{.raises: [], tags: [].}
proc value(this: Progress): float {...}{.raises: [], tags: [].}
proc value=(this: Progress; v: float) {...}{.raises: [], tags: [].}
proc box(elements: openArray[NElement]; orientation: NOrientation = noVERTICAL;
         spacing: int = 0): Box {...}{.raises: [KeyError, Exception],
                                  tags: [RootEffect, ReadIOEffect].}
proc box(elements: varargs[NElement]): Box {...}{.raises: [KeyError, Exception],
    tags: [RootEffect, ReadIOEffect].}
proc vbox(children: varargs[NElement]): Box {...}{.raises: [KeyError, Exception],
    tags: [RootEffect, ReadIOEffect].}
proc hbox(children: varargs[NElement]): Box {...}{.raises: [KeyError, Exception],
    tags: [RootEffect, ReadIOEffect].}
proc orientation(this: Box): NOrientation {...}{.raises: [], tags: [].}
proc orientation=(this: Box; value: NOrientation) {...}{.raises: [], tags: [].}
proc table(): NTable {...}{.raises: [], tags: [].}
proc headers(this: NTable): bool {...}{.raises: [], tags: [].}
proc headers=(this: NTable; v: bool) {...}{.raises: [], tags: [].}
proc th(this: NTable; values: varargs[string]) {...}{.raises: [], tags: [].}
proc tab(reorderable: bool = false): Tab {...}{.raises: [], tags: [].}
Creates a new Tab element (Menu of Tabs) 
proc add(this: Tab; that: Container; label: Label) {...}{.raises: [], tags: [].}
proc reorderable(this: Tab): bool {...}{.raises: [], tags: [].}
proc reorderable=(this: Tab; v: bool) {...}{.raises: [], tags: [].}
proc side(this: Tab): NSide {...}{.raises: [], tags: [].}
proc side=(this: Tab; side: NSide) {...}{.raises: [], tags: [].}
proc list(mode: NAmount = naOne): List {...}{.raises: [], tags: [].}
proc mode(this: List): NAmount {...}{.raises: [], tags: [].}
proc mode=(this: List; mode: NAmount) {...}{.raises: [], tags: [].}
proc selected(this: List; that: var seq[NElement]) {...}{.raises: [], tags: [].}
proc selected(this: List): seq[NElement] {...}{.raises: [], tags: [].}
proc frame(text: string; list: varargs[NElement]): Frame {...}{.
    raises: [KeyError, Exception], tags: [RootEffect, ReadIOEffect].}
proc frame(list: varargs[NElement]): Frame {...}{.raises: [KeyError, Exception],
    tags: [RootEffect, ReadIOEffect].}
proc text(this: Frame): string {...}{.raises: [], tags: [].}
proc text=(this: Frame; text: string) {...}{.raises: [], tags: [].}
proc tools(): Tools {...}{.raises: [], tags: [].}
proc orientation(this: Tools): NOrientation {...}{.raises: [], tags: [].}
Get the orientation of this Tools element 
proc orientation=(this: Tools; value: NOrientation) {...}{.raises: [], tags: [].}
Set the orientation of this Tools element 
proc get(this: NElement; that: NElementAttribute): Attribute {...}{.
    raises: [KeyError, Exception], tags: [RootEffect].}
Find the attribute value of this element. If attribute.found is false, then this element doesn't support it. 
proc has(this: NElement; that: NElementAttribute): bool {...}{.
    raises: [KeyError, Exception], tags: [RootEffect].}
Returns whether or not this element supports the attribute 
proc set(this: NElement; that: Attribute) {...}{.raises: [], tags: [].}
Set attribute value of this element, or do nothing if the element doesn't support it. 
proc attributes(this: NElement): Attributes {...}{.raises: [KeyError, Exception],
    tags: [RootEffect].}
Returns a list of attributes for this element. Attributes not supported will set their found field to false 
proc `$`(this: Attribute): string {...}{.raises: [Exception], tags: [RootEffect].}
proc `$`(this: NElement): string {...}{.raises: [KeyError, Exception],
                                   tags: [RootEffect].}
proc element(kind: NElementKind): NElement {...}{.raises: [KeyError, Exception],
    tags: [ReadIOEffect, RootEffect, TimeEffect].}
Create a new element of this kind. Some kinds are not valid for Initialization using this method, like abstract kinds (Atom, Container). 
proc element(this: Attributes): NElement {...}{.raises: [KeyError, Exception],
    tags: [ReadIOEffect, RootEffect, TimeEffect].}
Create a new element from this list of attributes. 
proc repeat(event: NRepeatProc; ms: int): NRepeatHandle {...}{.raises: [], tags: [].}
proc setTime(this: var NRepeatHandle; ms: int) {...}{.raises: [], tags: [].}
proc stop(this: NRepeatHandle) {...}{.raises: [], tags: [].}
proc later(event: NEventProc; ms: int) {...}{.raises: [Exception], tags: [RootEffect].}
proc clipboardClear() {...}{.raises: [], tags: [].}
proc clipboardSet(text: string) {...}{.raises: [], tags: [].}
proc clipboardSet(img: Bitmap) {...}{.raises: [], tags: [].}
proc clipboardGetText(): string {...}{.raises: [], tags: [].}
proc clipboardGetBitmap(): Bitmap {...}{.raises: [], tags: [].}
proc clipboardAsyncGet(action: NAsyncTextProc) {...}{.raises: [], tags: [].}
proc clipboardAsyncGet(action: NAsyncBitmapProc) {...}{.raises: [], tags: [].}

Iterators

iterator items(this: Bitmap): Pixel {...}{.raises: [], tags: [].}
iterator mitems(this: Bitmap): var Pixel {...}{.raises: [], tags: [].}
iterator pairs(this: Bitmap): (int, Pixel) {...}{.raises: [], tags: [].}
iterator mpairs(this: Bitmap): (int, var Pixel) {...}{.raises: [], tags: [].}
iterator items(this: Container): NElement {...}{.raises: [], tags: [].}

Macros

macro tr(this: NTable; values: varargs[typed])

Templates

template onNONEDo(e`gensym55: NElement; action`gensym55: untyped)
template onCLICKDo(e`gensym56: NElement; action`gensym56: untyped)
template onCLICK_RELEASEDo(e`gensym57: NElement; action`gensym57: untyped)
template onMOVEDo(e`gensym58: NElement; action`gensym58: untyped)
template onENTERDo(e`gensym59: NElement; action`gensym59: untyped)
template onCHANGEDo(e`gensym60: NElement; action`gensym60: untyped)
template onOPENDo(e`gensym61: NElement; action`gensym61: untyped)
template onFOCUS_ONDo(e`gensym62: NElement; action`gensym62: untyped)
template onFOCUS_OFFDo(e`gensym63: NElement; action`gensym63: untyped)
template onDESTROYDo(e`gensym64: NElement; action`gensym64: untyped)
template onSHOWDo(e`gensym65: NElement; action`gensym65: untyped)
template onHIDEDo(e`gensym66: NElement; action`gensym66: untyped)
template onKEY_PRESSDo(e`gensym67: NElement; action`gensym67: untyped)
template onKEY_RELEASEDo(e`gensym68: NElement; action`gensym68: untyped)
template button(text: string; onEventClickDo: untyped): Button
template head(this: NTable; values: varargs[string])
template row(this: NTable; values: varargs[untyped])
template `[]=`(this: NTable; x, y: int; that: typed)
template `[]=`(this: NTable; p: tuple[x, y: int]; that: typed)
template cell(this: NTable; x, y: int; body: untyped)
template cell(this: NTable; p: tuple[x, y: int]; body: untyped)
template repeatDo(ms: int; body: untyped): NRepeatHandle
template laterDo(ms: int; body: untyped)

Made with Nim. Generated: 2021-03-16 13:08:24 UTC