niup/inc/tree

    Dark Mode
Search:
Group by:

IUP class: Tree

NIUP type: Tree_t

constructors

proc Tree(): Tree_t

Procs

proc active(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc active(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc active(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc active=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc active=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc addexpanded(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc addexpanded(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc addexpanded(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc addexpanded=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
ADDEXPANDED ADDROOT ADDLEAF ADDBRANCH COPYNODE DELNODE EXPANDALL INSERTLEAF INSERTBRANCH MOVENODE 
proc addexpanded=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc addroot(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc bgcolor(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc bgcolor(ih: Tree_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc bgcolor(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc bgcolor=(ih: Tree_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc bgcolor=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
AUTOREDRAW BGCOLOR COUNT EXPAND FGCOLOR INDENTATION RASTERSIZE SPACING TOPITEM 
proc branchclose_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc branchclose_cb(ih: Tree_t;
                    cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc branchclose_cb=(ih: Tree_t;
                     cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc branchopen_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc branchopen_cb(ih: Tree_t;
                   cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc branchopen_cb=(ih: Tree_t;
                    cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc button_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc button_cb(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cint; arg3: cint;
                                     arg4: cint; arg5: cint; arg6: cstring): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc button_cb=(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cint; arg3: cint;
                                      arg4: cint; arg5: cint; arg6: cstring): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
BUTTON_CB BUTTON_CB Action generated when a mouse button is pressed or released. Callback int function(Ihandle* ih, int button, int pressed, int x, int y, char* status); [in C] ih:button_cb(button, pressed, x, y: number, status: string) -> (ret: number) [in Lua] ih: identifies the element that activated the event. button: identifies the activated mouse button: IUP_BUTTON1 - left mouse button (button 1); IUP_BUTTON2
  • middle mouse button (button 2); IUP_BUTTON3 - right mouse

button (button 3). pressed: indicates the state of the button: 0 - mouse button was released; 1 - mouse button was pressed. x, y: position in the canvas where the event has occurred, in pixels. status: status of the mouse buttons and some keyboard keys at the moment the event is generated. The following macros must be used for verification: iup_isshift(status) iup_iscontrol(status) iup_isbutton1(status) iup_isbutton2(status) iup_isbutton3(status) iup_isbutton4(status) iup_isbutton5(status) iup_isdouble(status) iup_isalt(status) iup_issys(status) They return 1 if the respective key or button is pressed, and 0 otherwise. These macros are also available in Lua, returning a boolean. Returns: IUP_CLOSE will be processed. On some controls if IUP_IGNORE is returned the action is ignored (this is system dependent). Notes This callback can be used to customize a button behavior. For a standard button behavior use the ACTION callback of the IupButton. For a single click the callback is called twice, one for pressed=1 and one for pressed=0. Only after both calls the ACTION callback is called. In Windows, if a dialog is shown or popup in any situation there could be unpredictable results because the native system still has processing to be done even after the callback is called. A double click is preceded by two single clicks, one for pressed=1 and one for pressed=0, and followed by a press=0, all three without the double click flag set. In GTK, it is preceded by an additional two single clicks sequence. For example, for one double click all the following calls are made: BUTTON_CB(but=1 (1), x=154, y=83 [ 1 ]) BUTTON_CB(but=1 (0), x=154, y=83 [ 1 ]) BUTTON_CB(but=1 (1), x=154, y=83 [ 1 ]) (in GTK only) BUTTON_CB(but=1 (0), x=154, y=83 [ 1 ]) (in GTK only) BUTTON_CB(but=1 (1), x=154, y=83 [ 1 D ]) BUTTON_CB(but=1 (0), x=154, y=83 [ 1 ]) Between press and release all mouse events are redirected only to this control, even if the cursor moves outside the element. So the BUTTON_CB callback when released and the MOTION_CB callback can be called with coordinates outside the element rectangle. Affects IupCanvas, IupButton, IupText, IupList, IupGLCanvas

proc canfocus(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc canfocus(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc canfocus(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc canfocus=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc canfocus=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc charsize(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc count(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc cpadding(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc cpadding(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc cpadding(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc cpadding=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc cpadding=(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc cspacing(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc cspacing(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc cspacing(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc cspacing=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc cspacing=(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc ctrl(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc destroy_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc destroy_cb(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc destroy_cb=(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
DESTROY_CB DESTROY_CB Called right before an element is destroyed. Callback int function(Ihandle *ih); [in C] ih:destroy_cb() -> (ret: number) [in Lua] ih: identifier of the element that activated the event. Notes If the dialog is visible then it is hidden before it is destroyed. The callback will be called right after it is hidden. The callback will be called before all other destroy procedures. For instance, if the element has children then it is called before the children are destroyed. For language binding implementations use the callback name "LDESTROY_CB" to release memory allocated by the binding for the element. Also the callback will be called before the language callback. Affects All. 
proc dragbegin_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc dragbegin_cb(ih: Tree_t;
                  cb: proc (ih: PIhandle; x: cint; y: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragbegin_cb=(ih: Tree_t;
                   cb: proc (ih: PIhandle; x: cint; y: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragdata_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc dragdata_cb(ih: Tree_t; cb: proc (ih: PIhandle; dragtype: cstring;
                                       data: pointer; size: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragdata_cb=(ih: Tree_t; cb: proc (ih: PIhandle; dragtype: cstring;
                                        data: pointer; size: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragdatasize_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dragdatasize_cb(ih: Tree_t;
                     cb: proc (ih: PIhandle; dragtype: cstring): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragdatasize_cb=(ih: Tree_t;
                      cb: proc (ih: PIhandle; dragtype: cstring): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragdrop(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc dragdrop(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragdrop(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragdrop=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragdrop=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragdrop_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc dragdrop_cb(ih: Tree_t; cb: proc (ih: PIhandle; drag_id, drop_id, isshift,
    iscontrol: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dragdrop_cb=(ih: Tree_t; cb: proc (ih: PIhandle; drag_id, drop_id, isshift,
    iscontrol: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dragdroptree(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc dragdroptree(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragdroptree(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragdroptree=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
DRAGDROPTREE DROPFILESTARGET DROPEQUALDRAG SHOWDRAGDROP 
proc dragdroptree=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragend_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc dragend_cb(ih: Tree_t; cb: proc (ih: PIhandle; action: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragend_cb=(ih: Tree_t;
                 cb: proc (ih: PIhandle; action: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc dragsource(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc dragsource(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragsource(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragsource=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragsource=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragsourcemove(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc dragsourcemove(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragsourcemove(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragsourcemove=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragsourcemove=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragtypes(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc dragtypes(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragtypes=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dropdata_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc dropdata_cb(ih: Tree_t; cb: proc (ih: PIhandle; dragtype: cstring;
                                       data: pointer; size, x, y: cint): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dropdata_cb=(ih: Tree_t; cb: proc (ih: PIhandle; dragtype: cstring;
                                        data: pointer; size, x, y: cint): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dropequaldrag(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc dropequaldrag(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dropequaldrag(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dropequaldrag=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
DRAGDROPTREE DROPFILESTARGET DROPEQUALDRAG SHOWDRAGDROP 
proc dropequaldrag=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dropfiles_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc dropfiles_cb(ih: Tree_t; cb: proc (Ih: PIhandle; filename: cstring;
                                        num, x, y: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dropfiles_cb=(ih: Tree_t; cb: proc (Ih: PIhandle; filename: cstring;
    num, x, y: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
DROPFILES_CB DROPFILES_CB Action called when a file is "dropped" into the control. When several files are dropped at once, the callback is called several times, once for each file. If defined after the element is mapped then the attribute DROPFILESTARGET must be set to YES. [Windows and GTK Only] (GTK 2.6) Callback int function(Ihandle *ih, const char* filename, int num, int x, int y); [in C] ih:dropfiles_cb(filename: string; num, x, y: number) -> (ret: number) [in Lua] ih: identifier of the element that activated the event. filename: Name of the dropped file. num: Number index of the dropped file. If several files are dropped, num is the index of the dropped file starting from "total-1" to "0". x: X coordinate of the point where the user released the mouse button. y: Y coordinate of the point where the user released the mouse button. Returns: If IUP_IGNORE is returned the callback will NOT be called for the next dropped files, and the processing of dropped files will be interrupted. Affects IupDialog, IupCanvas, IupGLCanvas, IupText, IupList 
proc dropfilestarget(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc dropfilestarget(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dropfilestarget(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dropfilestarget=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
DRAGDROPTREE DROPFILESTARGET DROPEQUALDRAG SHOWDRAGDROP 
proc dropfilestarget=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dropmotion_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dropmotion_cb(ih: Tree_t; cb: proc (ih: PIhandle; x, y: cint;
    status: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dropmotion_cb=(ih: Tree_t; cb: proc (ih: PIhandle; x, y: cint;
    status: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc droptarget(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc droptarget(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc droptarget(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc droptarget=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc droptarget=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc droptypes(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc droptypes(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc droptypes=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc enterwindow_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc enterwindow_cb(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc enterwindow_cb=(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
ENTERWINDOW_CB ENTERWINDOW_CB Action generated when the mouse enters the native element. Callback int function(Ihandle *ih); [in C] ih:enterwindow_cb() -> (ret: number) [in Lua] ih: identifier of the element that activated the event. Notes When the cursor is moved from one element to another, the call order in all platforms will be first the LEAVEWINDOW_CB callback of the old control followed by the ENTERWINDOW_CB callback of the new control. (since 3.14) If the mouse button is hold pressed and the cursor moves outside the element the behavior is system dependent. In Windows the LEAVEWINDOW_CB/ENTERWINDOW_CB callbacks are NOT called, in GTK the callbacks are called. Affects All controls with user interaction. See Also LEAVEWINDOW_CB 
proc executebranch_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc executebranch_cb(ih: Tree_t;
                      cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc executebranch_cb=(ih: Tree_t;
                       cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc executeleaf_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc executeleaf_cb(ih: Tree_t;
                    cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc executeleaf_cb=(ih: Tree_t;
                     cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc expand(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc expand(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc expand=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
AUTOREDRAW BGCOLOR COUNT EXPAND FGCOLOR INDENTATION RASTERSIZE SPACING TOPITEM 
proc expandall(ih: Tree_t) {.cdecl, ...raises: [], tags: [].}
proc expandall=(ih: Tree_t) {.cdecl, ...raises: [], tags: [].}
proc expandweight(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc expandweight(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc expandweight(ih: Tree_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc expandweight=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc expandweight=(ih: Tree_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc fgcolor(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc fgcolor(ih: Tree_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc fgcolor(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fgcolor=(ih: Tree_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc fgcolor=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
AUTOREDRAW BGCOLOR COUNT EXPAND FGCOLOR INDENTATION RASTERSIZE SPACING TOPITEM 
proc floating(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc floating(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc floating=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc font(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc font(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc font=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontface(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc fontface(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontface=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontsize(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc fontsize(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontsize(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc fontsize=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontsize=(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc fontstyle(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc fontstyle(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontstyle=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc getfocus_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc getfocus_cb(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc getfocus_cb=(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
GETFOCUS_CB GETFOCUS_CB Action generated when an element is given keyboard focus. This callback is called after the KILLFOCUS_CB of the element that loosed the focus. The IupGetFocus function during the callback returns the element that loosed the focus. Callback int function(Ihandle *ih); [in C] ih:getfocus_cb() -> (ret: number) [in Lua] ih: identifier of the element that received keyboard focus. Affects All elements with user interaction, except menus. See Also KILLFOCUS_CB, IupGetFocus, IupSetFocus 
proc handlename(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc handlename(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc handlename=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc help_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc help_cb(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc help_cb=(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
HELP_CB HELP_CB Action generated when the user press F1 at a control. In Motif is also activated by the Help button in some workstations keyboard. Callback void function(Ihandle *ih); [in C] ih:help_cb() -> (ret: number) [in Lua] ih: identifier of the element that activated the event. Returns: IUP_CLOSE will be processed. Affects All elements with user interaction. 
proc hidebuttons(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc hidebuttons(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc hidebuttons(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc hidebuttons=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
HIDELINES HIDEBUTTONS 
proc hidebuttons=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc hidelines(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc hidelines(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc hidelines(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc hidelines=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
HIDELINES HIDEBUTTONS 
proc hidelines=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc imagebranchcollapsed(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc imagebranchcollapsed(ih: Tree_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc imagebranchcollapsed=(ih: Tree_t;
                           handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
IMAGEIMAGEEXPANDEDIMAGELEAF IMAGEBRANCHCOLLAPSED IMAGEBRANCHEXPANDED. In Windows, IMAGELEAF, IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In other systems only IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In Windows, IMAGELEAF defines the size available for the image on all nodes. In Windows, IMAGELEAF, IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In other systems only IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In Windows, IMAGELEAF defines the size available for the image on all nodes. 
proc imagebranchexpanded(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc imagebranchexpanded(ih: Tree_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc imagebranchexpanded=(ih: Tree_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
IMAGEIMAGEEXPANDEDIMAGELEAF IMAGEBRANCHCOLLAPSED IMAGEBRANCHEXPANDED. In Windows, IMAGELEAF, IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In other systems only IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In Windows, IMAGELEAF defines the size available for the image on all nodes. In Windows, IMAGELEAF, IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In other systems only IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In Windows, IMAGELEAF defines the size available for the image on all nodes. 
proc imageleaf(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc imageleaf(ih: Tree_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc imageleaf=(ih: Tree_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
In Windows, IMAGELEAF, IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In other systems only IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In Windows, IMAGELEAF defines the size available for the image on all nodes. In Windows, IMAGELEAF, IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In other systems only IMAGEBRANCHCOLLAPSED and IMAGEBRANCHEXPANDED must have the same size. In Windows, IMAGELEAF defines the size available for the image on all nodes. 
proc indentation(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc indentation(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc indentation(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc indentation=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
AUTOREDRAW BGCOLOR COUNT EXPAND FGCOLOR INDENTATION RASTERSIZE SPACING TOPITEM 
proc indentation=(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc k_any(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc k_any(ih: Tree_t; cb: proc (ih: PIhandle; c: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc k_any=(ih: Tree_t; cb: proc (ih: PIhandle; c: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
K_ANY K_ANY Action generated when a keyboard event occurs. Callback int function(Ihandle *ih, int c); [in C] ih:k_any(c: number) -> (ret: number) [in Lua] ih: identifier of the element that activated the event. c: identifier of typed key. Please refer to the Keyboard Codes table for a list of possible values. Returns: If IUP_IGNORE is returned the key is ignored and not processed by the control and not propagated. If returns IUP_CONTINUE, the key will be processed and the event will be propagated to the parent of the element receiving it, this is the default behavior. If returns IUP_DEFAULT the key is processed but it is not propagated. IUP_CLOSE will be processed. Notes Keyboard callbacks depend on the keyboard usage of the control with the focus. So if you return IUP_IGNORE the control will usually not process the key. But be aware that sometimes the control process the key in another event so even returning IUP_IGNORE the key can get processed. Although it will not be propagated. IMPORTANT: The callbacks "K*" of the dialog or native containers depend on the IUP_CONTINUE return value to work while the control is in focus. If the callback does not exists it is automatically propagated to the parent of the element. K* callbacks All defined keys are also callbacks of any element, called when the respective key is activated. For example: "K_cC" is also a callback activated when the user press Ctrl+C, when the focus is at the element or at a children with focus. This is the way an application can create shortcut keys, also called hot keys. These callbacks are not available in IupLua. Affects All elements with keyboard interaction. 
proc killfocus_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc killfocus_cb(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc killfocus_cb=(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
KILLFOCUS_CB KILLFOCUS_CB Action generated when an element loses keyboard focus. This callback is called before the GETFOCUS_CB of the element that gets the focus. Callback int function(Ihandle *ih); [in C] ih:killfocus_cb() -> (ret: number) [in Lua] ih: identifier of the element that activated the event. Affects All elements with user interaction, except menus. In Windows, there are restrictions when using this callback. From MSDN on WM_KILLFOCUS: "While processing this message, do not make any function calls that display or activate a window. This causes the thread to yield control and can cause the application to stop responding to messages. See Also GETFOCUS_CB, IupGetFocus, IupSetFocus 
proc lastaddnode(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc ldestroy_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc ldestroy_cb(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc ldestroy_cb=(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc leavewindow_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc leavewindow_cb(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc leavewindow_cb=(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
LEAVEWINDOW_CB LEAVEWINDOW_CB Action generated when the mouse leaves the native element. Callback int function(Ihandle *ih); [in C] ih:leavewindow_cb() -> (ret: number) [in Lua] ih: identifier of the element that activated the event. Notes When the cursor is moved from one element to another, the call order in all platforms will be first the LEAVEWINDOW_CB callback of the old control followed by the ENTERWINDOW_CB callback of the new control. (since 3.14) If the mouse button is hold pressed and the cursor moves outside the element the behavior is system dependent. In Windows the LEAVEWINDOW_CB/ENTERWINDOW_CB callbacks are NOT called, in GTK the callbacks are called. Affects All controls with user interaction. See Also ENTERWINDOW_CB 
proc map_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc map_cb(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc map_cb=(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
MAP_CB MAP_CB Called right after an element is mapped and its attributes updated in IupMap. When the element is a dialog, it is called after the layout is updated. For all other elements is called before the layout is updated, so the element current size will still be 0x0 during MAP_CB (since 3.14). Callback int function(Ihandle *ih); [in C] ih:map_cb() -> (ret: number) [in Lua] ih: identifier of the element that activated the event. Affects All that have a native representation. 
proc mark(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc mark=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
MARK MARKED MARKEDNODESMARKMODE MARKSTARTMARKWHENTOGGLE 
proc markednodes(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc markednodes(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc markednodes=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc markmode(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc markmode(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc markmode=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc markstart(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc markstart(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc markstart(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc markstart=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc markstart=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc markwhentoggle(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc markwhentoggle(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc markwhentoggle(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc markwhentoggle=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc markwhentoggle=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc maxsize(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc maxsize(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc maxsize(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc maxsize=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc maxsize=(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc minsize(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc minsize(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc minsize(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc minsize=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc minsize=(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc motion_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc motion_cb(ih: Tree_t; cb: proc (ih: PIhandle; x, y: cint; status: cstring): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc motion_cb=(ih: Tree_t; cb: proc (ih: PIhandle; x, y: cint; status: cstring): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
MOTION_CB MOTION_CB Action generated when the mouse moves. Callback int function(Ihandle *ih, int x, int y, char *status); [in C] ih:motion_cb(x, y: number, status: string) -> (ret: number) [in Lua] ih: identifier of the element that activated the event. x, y: position in the canvas where the event has occurred, in pixels. status: status of mouse buttons and certain keyboard keys at the moment the event was generated. The same macros used for BUTTON_CB can be used for this status. Notes Between press and release all mouse events are redirected only to this control, even if the cursor moves outside the element. So the BUTTON_CB callback when released and the MOTION_CB callback can be called with coordinates outside the element rectangle. Affects IupCanvas, IupGLCanvas 
proc multiselection_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc multiselection_cb(ih: Tree_t; cb: proc (ih: PIhandle; arg2: ptr cint;
    arg3: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc multiselection_cb=(ih: Tree_t; cb: proc (ih: PIhandle; arg2: ptr cint;
    arg3: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc multiunselection_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc multiunselection_cb(ih: Tree_t; cb: proc (ih: PIhandle; arg2: ptr cint;
    arg3: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc multiunselection_cb=(ih: Tree_t; cb: proc (ih: PIhandle; arg2: ptr cint;
    arg3: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc name(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc name(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc name=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc naturalsize(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc noderemoved_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc noderemoved_cb(ih: Tree_t;
                    cb: proc (ih: PIhandle; arg2: cstring): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc noderemoved_cb=(ih: Tree_t;
                     cb: proc (ih: PIhandle; arg2: cstring): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc normalizergroup(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc normalizergroup(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc normalizergroup=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc ntheme(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc ntheme(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc ntheme=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc pangofontdesc(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc pangolayout(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc position(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc position(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc position(ih: Tree_t; x, y: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc position=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc position=(ih: Tree_t; x, y: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc postmessage_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc postmessage_cb(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cstring;
    arg3: cint; arg4: cdouble; arg5: pointer): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc postmessage_cb=(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cstring;
    arg3: cint; arg4: cdouble; arg5: pointer): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc propagatefocus(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc propagatefocus(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc propagatefocus(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc propagatefocus=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
VALUECANFOCUS PROPAGATEFOCUS 
proc propagatefocus=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc rastersize(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc rastersize(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc rastersize(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc rastersize=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
AUTOREDRAW BGCOLOR COUNT EXPAND FGCOLOR INDENTATION RASTERSIZE SPACING TOPITEM 
proc rastersize=(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc rename(ih: Tree_t) {.cdecl, ...raises: [], tags: [].}
proc rename=(ih: Tree_t) {.cdecl, ...raises: [], tags: [].}
proc rename_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc rename_cb(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cint; arg3: cstring): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc rename_cb=(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cint; arg3: cstring): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc renamecaret(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc renamecaret(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc renamecaret=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc renameselection(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc renameselection(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc renameselection=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc rightclick_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc rightclick_cb(ih: Tree_t;
                   cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc rightclick_cb=(ih: Tree_t;
                    cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc rootcount(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc rubberband(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc rubberband(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc rubberband=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc screenposition(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc selection_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc selection_cb(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cint; arg3: cint): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc selection_cb=(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cint; arg3: cint): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
SELECTION_CB: Action generated when an node is selected or deselected. MULTISELECTION_CB: Action generated when multiple nodes are selected with the mouse and the shift key pressed. MULTIUNSELECTION_CB: Action generated before multiple nodes are unselected in one single operation. BRANCHOPEN_CB: Action generated when a branch is expanded. BRANCHCLOSE_CB: Action generated when a branch is collapsed. EXECUTELEAF_CB: Action generated when a leaf is executed. EXECUTEBRANCH_CB: Action generated when a branch is executed. SHOWRENAME_CB: Action generated before a node is renamed. RENAME_CB: Action generated after a node is renamed. DRAGDROP_CB: Action generated when an internal drag & drop is executed. NODEREMOVED_CB: Action generated when a node is about to be removed. RIGHTCLICK_CB: Action generated when the right mouse button is pressed over a node. TOGGLEVALUE_CB: Action generated when the toggle's state was changed. The callback also receives the new toggle's state. 
proc shift(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc showdragdrop(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc showdragdrop(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc showdragdrop(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc showdragdrop=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
DRAGDROPTREE DROPFILESTARGET DROPEQUALDRAG SHOWDRAGDROP 
proc showdragdrop=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc showrename(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc showrename(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc showrename(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc showrename=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc showrename=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc showrename_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc showrename_cb(ih: Tree_t;
                   cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc showrename_cb=(ih: Tree_t;
                    cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc showtoggle(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc showtoggle(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc showtoggle(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc showtoggle=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc showtoggle=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc size(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc size(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc size(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc size=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc size=(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc spacing(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc spacing(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc spacing(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc spacing=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
AUTOREDRAW BGCOLOR COUNT EXPAND FGCOLOR INDENTATION RASTERSIZE SPACING TOPITEM 
proc spacing=(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc starting(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc theme(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc theme(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc theme=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tip(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc tip(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tip=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipbgcolor(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc tipbgcolor(ih: Tree_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc tipbgcolor(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipbgcolor=(ih: Tree_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc tipbgcolor=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipdelay(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc tipdelay(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipdelay(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc tipdelay=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipdelay=(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc tipfgcolor(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc tipfgcolor(ih: Tree_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc tipfgcolor(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipfgcolor=(ih: Tree_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc tipfgcolor=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipicon(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc tipicon(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipicon=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipmarkup(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc tipmarkup(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipmarkup=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tiprect(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc tiprect(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tiprect(ih: Tree_t; x1, y1, x2, y2: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc tiprect=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tiprect=(ih: Tree_t; x1, y1, x2, y2: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc tipvisible(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc tipvisible(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipvisible(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc tipvisible=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipvisible=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc togglevalue_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc togglevalue_cb(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cint; arg3: cint): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc togglevalue_cb=(ih: Tree_t; cb: proc (ih: PIhandle; arg2: cint; arg3: cint): cint {.
    cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc topitem(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc topitem(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc topitem=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
AUTOREDRAW BGCOLOR COUNT EXPAND FGCOLOR INDENTATION RASTERSIZE SPACING TOPITEM 
proc topitem=(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc Tree(): Tree_t {.cdecl, ...raises: [], tags: [].}
Creates a tree containing nodes of branches or leaves. Both branches and leaves can have an associated text and image. The branches can be expanded or collapsed. When a branch is expanded, its immediate children are visible, and when it is collapsed they are hidden. The leaves can generate an "executed" or "renamed" actions, branches can only generate a "renamed" action. The focus node is the node with the focus rectangle, marked nodes have their background inverted. 
proc unmap_cb(ih: Tree_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc unmap_cb(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc unmap_cb=(ih: Tree_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
UNMAP_CB UNMAP_CB Called right before an element is unmapped. Callback int function(Ihandle *ih); [in C] ih:unmap_cb() -> (ret: number) [in Lua] ih: identifier of the element that activated the event. Affects All that have a native representation. 
proc usersize(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc usersize(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc usersize(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc usersize=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc usersize=(ih: Tree_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc value(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc value(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc value(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc value=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc value=(ih: Tree_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc visible(ih: Tree_t): bool {.cdecl, ...raises: [], tags: [].}
proc visible(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc visible(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc visible=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc visible=(ih: Tree_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc wid(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc x(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc xfontid(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc y(ih: Tree_t): string {.cdecl, ...raises: [], tags: [].}
proc zorder(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc zorder=(ih: Tree_t; value: string) {.cdecl, ...raises: [], tags: [].}

Made with Nim. Generated: 2022-01-14 18:41:10 UTC