ngui_backend_interface

    Dark Mode
Search:
Group by:

Procs

proc internalSetEvent(this: NElement; event: NElementEvent; action: NEventProc) {...}{.
    raises: [], tags: [].}
Attach event to this element. Cannot set more than one event per kind 
proc internalGetCurrentEvent(): NEventArgs {...}{.raises: [], tags: [].}
Get the args from the event that is currently being dispatched 
proc internalEventHandled() {...}{.raises: [], tags: [].}
Stop event propagation 
proc internalNewNElement(kind: NElementKind): NElement {...}{.raises: [], tags: [].}
Instantiate a new NElement of provided kind 
proc internalGetParent(this: NElement): Container {...}{.raises: [], tags: [].}
Get the parent of this element OR nil if it doesn't have one 
proc internalSetVisible(this: NElement; state: bool) {...}{.raises: [], tags: [].}
Set whether this element is shown or not 
proc internalGetVisible(this: NElement): bool {...}{.raises: [], tags: [].}
Get whether this element is shown or not 
proc internalGetNext(this: NElement): NElement {...}{.raises: [], tags: [].}
Get the parent's next child after this one or nil 
proc internalGetPrev(this: NElement): NElement {...}{.raises: [], tags: [].}
Get the parent's previous child before this one or nil 
proc internalGetFocus(this: NElement): bool {...}{.raises: [], tags: [].}
Get whether the element has the focus or not 
proc internalSetFocus(this: NElement) {...}{.raises: [], tags: [].}
Set the focus on this element 
proc internalGetSize(this: NElement): tuple[w, h: int] {...}{.raises: [], tags: [].}
Get the size of this element 
proc internalSetSize(this: NElement; size: tuple[w, h: int]) {...}{.raises: [],
    tags: [].}
Set the size of this element 
proc internalSetTooltip(this: NElement; text: string) {...}{.raises: [], tags: [].}
Set this element's tooltip text 
proc internalGetTooltip(this: NElement): string {...}{.raises: [], tags: [].}
Get this element's tooltip text 
proc internalSetDestroy(this: NElement) {...}{.raises: [], tags: [].}
Destroy this element, you won't be able to reuse it 
proc internalGetDestroy(this: NElement): bool {...}{.raises: [], tags: [].}
Get whether or not this element is alive 
proc internalGetBGColor(this: NElement): Pixel {...}{.raises: [], tags: [].}
Get the background color of this element 
proc internalSetBGColor(this: NElement; color: Pixel) {...}{.raises: [], tags: [].}
Set the background color of this element 
proc internalLen(this: Container): int {...}{.raises: [], tags: [].}
Get the amount of NElements on this container 
proc internalRemove(this: Container; that: NElement) {...}{.raises: [], tags: [].}
Remove element from this container. Element MUST be a child 
proc internalAdd(this: Container; that: NElement) {...}{.raises: [], tags: [].}
Add element to this container. Element MUST not have a parent 
proc internalReplace(container: Container; this, that: NElement) {...}{.raises: [],
    tags: [].}
Replace child with another element 
proc internalIndex(this: Container; that: NElement): int {...}{.raises: [], tags: [].}
Get the position of this child 
proc internalGetChild(this: Container; index: int): NElement {...}{.raises: [],
    tags: [].}
Get child by index position 
proc internalGetBorder(this: Container): int {...}{.raises: [], tags: [].}
Get the border size of this container 
proc internalSetBorder(this: Container; b: int) {...}{.raises: [], tags: [].}
Set the border size of this container 
proc internalAddSeparator(this: Container; dir: NOrientation) {...}{.raises: [],
    tags: [].}
Add a visual separator after the last added child 
proc internalGetBorderColor(this: Container): Pixel {...}{.raises: [], tags: [].}
Get the color of this container's border 
proc internalSetBorderColor(this: Container; color: Pixel) {...}{.raises: [],
    tags: [].}
Set the color of this container's border 
proc internalRun(this: App) {...}{.raises: [], tags: [].}
Start the app. Show the elements and block the thread until requested to stop 
proc internalStop(this: App) {...}{.raises: [], tags: [].}
Shutdown the App context 
proc internalSetText(this: Window; text: string) {...}{.raises: [], tags: [].}
Set this window's title 
proc internalGetText(this: Window): string {...}{.raises: [], tags: [].}
Get this window's title 
proc internalSetResizable(this: Window; state: bool) {...}{.raises: [], tags: [].}
Set whether the user can resize the window or not 
proc internalGetResizable(this: Window): bool {...}{.raises: [], tags: [].}
Get whether the user can resize the window or not 
proc internalSetPosition(this: Window; position: tuple[x, y: int]) {...}{.raises: [],
    tags: [].}
Set this window's position relative to the top left of the screen 
proc internalGetPosition(this: Window): tuple[x, y: int] {...}{.raises: [], tags: [].}
Get this window's position relative to the top left of the screen 
proc internalGetFocused(this: Window): NElement {...}{.raises: [], tags: [].}
Get the element within this window that has the focus 
proc internalGetIcon(this: Window): Bitmap {...}{.raises: [], tags: [].}
Get the icon that this window is displaying or nil 
proc internalSetIcon(this: Window; that: Bitmap) {...}{.raises: [], tags: [].}
Set the icon for this window 
proc internalGetDecorated(this: Window): bool {...}{.raises: [], tags: [].}
Get whether or not this window is displaying the border 
proc internalSetDecorated(this: Window; v: bool) {...}{.raises: [], tags: [].}
Set whether or not this window is displaying the border 
proc internalSetMinimized(this: Window; v: bool) {...}{.raises: [], tags: [].}
Set whether or not this window is minimized 
proc internalGetMinimized(this: Window): bool {...}{.raises: [], tags: [].}
Get whether or not this window is minimized 
proc internalSetMaximized(this: Window; v: bool) {...}{.raises: [], tags: [].}
Set whether or not this window is maximized 
proc internalGetMaximized(this: Window): bool {...}{.raises: [], tags: [].}
Get whether or not this window is maximized 
proc internalSetModal(this: Window; v: bool) {...}{.raises: [], tags: [].}
Set whether or not user can interact with other windows 
proc internalGetModal(this: Window): bool {...}{.raises: [], tags: [].}
Get whether or not user can interact with other windows 
proc internalSetTransient(this, that: Window) {...}{.raises: [], tags: [].}
Set a parent window. This window will appear on top of parent 
proc internalGetTransient(this: Window): Window {...}{.raises: [], tags: [].}
Return parent (transient) window if any 
proc internalGetOpacity(this: Window): float {...}{.raises: [], tags: [].}
Get Opacity of this window (0.0 .. 1.0) 
proc internalSetOpacity(this: Window; v: float) {...}{.raises: [], tags: [].}
Set Opacity of this window (0.0 .. 1.0) 
proc internalRun(this: Alert) {...}{.raises: [], tags: [].}
Show this message dialog 
proc internalSetModal(this: Alert; v: bool) {...}{.raises: [], tags: [].}
Set whether or not user can interact with other windows 
proc internalGetModal(this: Alert): bool {...}{.raises: [], tags: [].}
Get whether or not user can interact with other windows 
proc internalSetTransient(this: Alert; that: Window) {...}{.raises: [], tags: [].}
Set a parent window. This alert will appear on top of parent 
proc internalGetTransient(this: Alert): Window {...}{.raises: [], tags: [].}
Return parent (transient) window if any 
proc internalSetText(this: Alert; text: string) {...}{.raises: [], tags: [].}
Set this Alert's text content 
proc internalGetText(this: Alert): string {...}{.raises: [], tags: [].}
Get this Alert's text content 
proc internalSetTitle(this: Alert; text: string) {...}{.raises: [], tags: [].}
Set this Alert's title 
proc internalGetTitle(this: Alert): string {...}{.raises: [], tags: [].}
Get this Alert's title 
proc internalSetText(this: Label; text: string) {...}{.raises: [], tags: [].}
Set this Label's content 
proc internalGetText(this: Label): string {...}{.raises: [], tags: [].}
Get this Label's content 
proc internalSetWrap(this: Label; state: bool) {...}{.raises: [], tags: [].}
Set whether or not this element is allowed to wrap the content if it becomes too big 
proc internalGetWrap(this: Label): bool {...}{.raises: [], tags: [].}
Get whether or not this element is allowed to wrap the content if it becomes too big 
proc internalGetXAlign(this: Label): float {...}{.raises: [], tags: [].}
proc internalGetYAlign(this: Label): float {...}{.raises: [], tags: [].}
proc internalSetXAlign(this: Label; v: float) {...}{.raises: [], tags: [].}
proc internalSetYAlign(this: Label; v: float) {...}{.raises: [], tags: [].}
proc internalGetText(this: Entry): string {...}{.raises: [], tags: [].}
Get this Entry's content 
proc internalSetText(this: Entry; text: string) {...}{.raises: [], tags: [].}
Set this Entry's content 
proc internalSetText(this: CheckBox; that: string) {...}{.raises: [], tags: [].}
Set this CheckBox's text 
proc internalGetText(this: CheckBox): string {...}{.raises: [], tags: [].}
Get this CheckBox's text 
proc internalGetChecked(this: CheckBox): bool {...}{.raises: [], tags: [].}
Get whether or not this CheckBox is checked 
proc internalSetChecked(this: CheckBox; v: bool) {...}{.raises: [], tags: [].}
Set whether or not this CheckBox is checked 
proc internalSetText(this: Button; text: string) {...}{.raises: [], tags: [].}
proc internalGetText(this: Button): string {...}{.raises: [], tags: [].}
proc internalSetImage(this: Button; img: Bitmap) {...}{.raises: [], tags: [].}
proc internalGetImage(this: Button): Bitmap {...}{.raises: [], tags: [].}
proc internalSetText(this: Radio; text: string) {...}{.raises: [], tags: [].}
proc internalGetText(this: Radio): string {...}{.raises: [], tags: [].}
proc internalSetGroup(radios: openArray[Radio]) {...}{.raises: [], tags: [].}
proc internalAttach(this: Bubble; that: NElement) {...}{.raises: [], tags: [].}
proc internalGetBitmap(this: Image): Bitmap {...}{.raises: [], tags: [].}
proc internalUpdate(this: Image; that: Bitmap) {...}{.raises: [], tags: [].}
proc internalIconBitmap(name: string): Bitmap {...}{.raises: [], tags: [].}
proc internalIconBitmap(icon: NIcon): Bitmap {...}{.raises: [], tags: [].}
proc internalSetText(this: TextArea; text: string) {...}{.raises: [], tags: [].}
proc internalGetText(this: TextArea): string {...}{.raises: [], tags: [].}
proc internalGetDate(this: Calendar): DateTime {...}{.raises: [], tags: [].}
proc internalSetDate(this: Calendar; date: DateTime) {...}{.raises: [], tags: [].}
proc internalMark(this: Calendar; day: int) {...}{.raises: [], tags: [].}
proc internalUnmark(this: Calendar; day: int) {...}{.raises: [], tags: [].}
proc internalMarked(this: Calendar; day: int): bool {...}{.raises: [], tags: [].}
proc internalClear(this: Calendar) {...}{.raises: [], tags: [].}
proc internalSetDecimals(this: Slider; decimals: int) {...}{.raises: [], tags: [].}
proc internalGetDecimals(this: Slider): int {...}{.raises: [], tags: [].}
proc internalSetRange(this: Slider; range: Slice[float]) {...}{.raises: [], tags: [].}
proc internalSetStep(this: Slider; step: float) {...}{.raises: [], tags: [].}
proc internalGetValue(this: Slider): float {...}{.raises: [], tags: [].}
proc internalSetValue(this: Slider; value: float) {...}{.raises: [], tags: [].}
proc internalGetOrientation(this: Slider): NOrientation {...}{.raises: [], tags: [].}
proc internalSetOrientation(this: Slider; value: NOrientation) {...}{.raises: [],
    tags: [].}
proc internalSetMultiple(this: FileChoose; state: bool) {...}{.raises: [], tags: [].}
proc internalGetMultiple(this: FileChoose): bool {...}{.raises: [], tags: [].}
proc internalGetFiles(this: FileChoose): seq[string] {...}{.raises: [], tags: [].}
proc internalSetText(this: FileChoose; text: string) {...}{.raises: [], tags: [].}
proc internalGetText(this: FileChoose): string {...}{.raises: [], tags: [].}
proc internalSetButton(this: FileChoose; button: string; index: int) {...}{.
    raises: [], tags: [].}
proc internalRun(this: FileChoose): int {...}{.raises: [], tags: [].}
proc internalAdd(this: NElement; that: Menu) {...}{.raises: [], tags: [].}
proc internalAdd(this: Table; that: NTableRow) {...}{.raises: [], tags: [].}
proc internalSet(this: Table; that: NTableCell; x, y: int) {...}{.raises: [],
    tags: [].}
proc internalGet(this: Table; x, y: int): NTableCell {...}{.raises: [], tags: [].}
proc internalHeader(this: NTable; headers: openArray[string]) {...}{.raises: [],
    tags: [].}
proc internalHeaders(this: NTable): bool {...}{.raises: [], tags: [].}
proc internalHeaders(this: NTable; v: bool) {...}{.raises: [], tags: [].}
proc internalAdd(this: ComboBox; text: string) {...}{.raises: [], tags: [].}
proc internalSet(this: ComboBox; text: string; i: int) {...}{.raises: [], tags: [].}
proc internalGet(this: ComboBox; i: int): string {...}{.raises: [], tags: [].}
proc internalGetSelected(this: ComboBox): string {...}{.raises: [], tags: [].}
proc internalGetSelectedIndex(this: ComboBox): int {...}{.raises: [], tags: [].}
proc internalSetSelectedIndex(this: ComboBox; i: int) {...}{.raises: [], tags: [].}
proc internalValue(this: Progress): float {...}{.raises: [], tags: [].}
proc internalValue(this: Progress; v: float) {...}{.raises: [], tags: [].}
proc internalSetSpacing(this: Box; spacing: int) {...}{.raises: [], tags: [].}
proc internalGetOrientation(this: Box): NOrientation {...}{.raises: [], tags: [].}
proc internalSetOrientation(this: Box; value: NOrientation) {...}{.raises: [],
    tags: [].}
proc internalAdd(this: Tab; that: Container; label: Label) {...}{.raises: [],
    tags: [].}
proc internalSetReorderable(this: Tab; v: bool) {...}{.raises: [], tags: [].}
proc internalGetReorderable(this: Tab): bool {...}{.raises: [], tags: [].}
proc internalGetSide(this: Tab): NSide {...}{.raises: [], tags: [].}
proc internalSetSide(this: Tab; side: NSide) {...}{.raises: [], tags: [].}
proc internalGetMode(this: List): NAmount {...}{.raises: [], tags: [].}
proc internalSetMode(this: List; mode: NAmount) {...}{.raises: [], tags: [].}
proc internalSelected(this: List; that: var seq[NElement]) {...}{.raises: [],
    tags: [].}
proc internalSetText(this: Frame; text: string) {...}{.raises: [], tags: [].}
proc internalGetText(this: Frame): string {...}{.raises: [], tags: [].}
proc internalGetOrientation(this: Tools): NOrientation {...}{.raises: [], tags: [].}
proc internalSetOrientation(this: Tools; value: NOrientation) {...}{.raises: [],
    tags: [].}
proc internalRepeat(event: NRepeatProc; ms: int): NRepeatHandle {...}{.raises: [],
    tags: [].}
proc internalStop(this: NRepeatHandle) {...}{.raises: [], tags: [].}
proc internalSetTime(this: var NRepeatHandle; ms: int) {...}{.raises: [], tags: [].}
proc internalClipboardClear() {...}{.raises: [], tags: [].}
proc internalClipboardSet(text: string) {...}{.raises: [], tags: [].}
proc internalClipboardSet(img: Bitmap) {...}{.raises: [], tags: [].}
proc internalClipboardGetText(): string {...}{.raises: [], tags: [].}
proc internalClipboardGetImg(): Bitmap {...}{.raises: [], tags: [].}
proc internalClipboardAsyncGet(action: NAsyncTextProc) {...}{.raises: [], tags: [].}
proc internalClipboardAsyncGet(action: NAsyncBitmapProc) {...}{.raises: [], tags: [].}

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