niup/inc/flatlist

    Dark Mode
Search:
Group by:

IUP class: FlatList

NIUP type: FlatList_t

constructors

proc FlatList(): FlatList_t

Procs

proc action(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc action(ih: FlatList_t;
            cb: proc (ih: PIhandle; arg2: cfloat; arg3: cfloat): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc action=(ih: FlatList_t;
             cb: proc (ih: PIhandle; arg2: cfloat; arg3: cfloat): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
ACTION ACTION Action generated when the element is activated. Affects each element differently. Callback int function(Ihandle *ih); [in C] ih:action() -> (ret: number) [in Lua] ih: identifier of the element that activated the event. In some elements, this callback may receive more parameters, apart from ih. Please refer to each element's documentation. Affects IupButton, IupItem, IupList, IupText, IupCanvas, IupMultiline, IupToggle 
proc active(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc active(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc active(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc active=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc active=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc alignment(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc alignment(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc alignment=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
ALIGNMENT (non inheritable): horizontal and vertical alignment of the set image+text for each item. Possible values: "ALEFT", "ACENTER" and "ARIGHT", combined to "ATOP", "ACENTER" and "ABOTTOM". Default: "ALEFT:ACENTER". Partial values are also accepted, like "ARIGHT" or ":ATOP", the other value will be obtained from the default value. Alignment does not includes the padding area. 
proc appenditem(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc appenditem=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
APPENDITEM (write-only): inserts an item after the last item. Ignored if set before map. 
proc arrowimages(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc arrowimages(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc arrowimages(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc arrowimages=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc arrowimages=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc backimage(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc backimage(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc backimage=(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
BACKIMAGE (non inheritable): image name to be used as background. Use IupSetHandle or IupSetAttributeHandle to associate an image to a name. See also IupImage. 
proc backimagezoom(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc backimagezoom(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc backimagezoom(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc backimagezoom=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
BACKIMAGEZOOM (non inheritable): if set the back image will be zoomed to occupy the full background. Aspect ratio is NOT preserved. Can be Yes or No. Default: No. 
proc backimagezoom=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc backingstore(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc backingstore(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc backingstore(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc backingstore=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc backingstore=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc bgcolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc bgcolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc bgcolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc bgcolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc bgcolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
BGCOLOR: Background color of the text. Default: the global attribute TXTBGCOLOR. 
proc border(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc border(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc border(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc border=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
BORDER (creation only): the default value is "NO". This is the IupCanvas border. It is displayed around the scrollbars. 
proc border=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc bordercolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc bordercolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc bordercolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc bordercolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc bordercolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
BORDERCOLOR: color used for the internal border. Default: "50 150 255". This is for the internal border. 
proc borderwidth(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc borderwidth(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc borderwidth(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc borderwidth=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
BORDERWIDTH: line width used for the internal border. Default: "0". The internal borders are hidden by simply setting this value to 0. It is drawn inside the canvas, so inside the scrollbars. 
proc borderwidth=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc button_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc button_cb(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cint; arg3: cint;
    arg4: cint; arg5: cint; arg6: cstring): cint {.cdecl.}) {.cdecl, ...raises: [],
    tags: [].}
proc button_cb=(ih: FlatList_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: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc canfocus(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc canfocus(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc canfocus=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc canfocus=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc charsize(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc count(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc cpadding(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc cpadding(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc cpadding(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc cpadding=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
CPADDING: same as PADDING but using the units of the SIZE attribute. It will actually set the PADDING attribute. (since 3.29) 
proc cpadding=(ih: FlatList_t; width, height: int) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc cspacing(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc cspacing(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc cspacing(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc cspacing=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
CSPACING: same as SPACING but using the units of the vertical part of the SIZE attribute. It will actually set the SPACING attribute. (since 3.29) 
proc cspacing=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc cursor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc cursor(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc cursor=(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc dblclick_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dblclick_cb(ih: FlatList_t; cb: proc (ih: PIhandle; item: cint;
    text: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dblclick_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; item: cint;
    text: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
DBLCLICK_CB: Action generated when the user double click an item. int function (Ihandle *ih, int item, char *text); [in C]ih:dblclick_cb(item: number, text: string) -> (ret: number) [in Lua] 
proc destroy_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc destroy_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc destroy_cb=(ih: FlatList_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: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dragbegin_cb(ih: FlatList_t;
                  cb: proc (ih: PIhandle; x: cint; y: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragbegin_cb=(ih: FlatList_t;
                   cb: proc (ih: PIhandle; x: cint; y: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragdata_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dragdata_cb(ih: FlatList_t; cb: proc (ih: PIhandle; dragtype: cstring;
    data: pointer; size: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dragdata_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; dragtype: cstring;
    data: pointer; size: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dragdatasize_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dragdatasize_cb(ih: FlatList_t;
                     cb: proc (ih: PIhandle; dragtype: cstring): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragdatasize_cb=(ih: FlatList_t;
                      cb: proc (ih: PIhandle; dragtype: cstring): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc dragdrop(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc dragdrop(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragdrop(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragdrop=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragdrop=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragdrop_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dragdrop_cb(ih: FlatList_t; cb: proc (ih: PIhandle;
    drag_id, drop_id, isshift, iscontrol: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc dragdrop_cb=(ih: FlatList_t; cb: proc (ih: PIhandle;
    drag_id, drop_id, isshift, iscontrol: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
DRAGDROP_CB: Action generated when an internal drag and drop is executed. Only active if SHOWDRAGDROP=YES. int function(Ihandle *ih, int drag_id, int drop_id, int isshift, int iscontrol); [in C] ih:dragdrop_cb(drag_id, drop_id, isshift, iscontrol: number) -> (ret: number) [in Lua] 
proc dragdroplist(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc dragdroplist(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragdroplist(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragdroplist=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
DRAGDROPLIST (non inheritable): prepare the Drag & Drop callbacks to support drag and drop of items between lists (IupList or IupFlatList), in the same IUP application. Drag & Drop attributes still need to be set in order to activate the drag & drop support, so the application can control if this list will be source and/or target. Default: NO. 
proc dragdroplist=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragend_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dragend_cb(ih: FlatList_t;
                cb: proc (ih: PIhandle; action: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc dragend_cb=(ih: FlatList_t;
                 cb: proc (ih: PIhandle; action: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc dragsource(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc dragsource(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragsource(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragsource=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragsource=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragsourcemove(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc dragsourcemove(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragsourcemove(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragsourcemove=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc dragsourcemove=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dragtypes(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc dragtypes(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dragtypes=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawable(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawbgcolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawbgcolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc drawbgcolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawbgcolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc drawbgcolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawcolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawcolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc drawcolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawcolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc drawcolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawdriver(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawfont(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawfont(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawfont=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawlinewidth(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawlinewidth(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawlinewidth(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc drawlinewidth=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawlinewidth=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc drawmakeinactive(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc drawmakeinactive(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawmakeinactive(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc drawmakeinactive=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawmakeinactive=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc drawsize(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawstyle(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawstyle(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawstyle=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawtextalignment(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawtextalignment(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextalignment=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextclip(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc drawtextclip(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawtextclip(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc drawtextclip=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawtextclip=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc drawtextellipsis(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc drawtextellipsis(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextellipsis(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc drawtextellipsis=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextellipsis=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc drawtextlayoutcenter(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc drawtextlayoutcenter(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextlayoutcenter(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextlayoutcenter=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextlayoutcenter=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextorientation(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc drawtextorientation(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextorientation(ih: FlatList_t; x: int64) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc drawtextorientation=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc drawtextorientation=(ih: FlatList_t; x: int64) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc drawtextwrap(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc drawtextwrap(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawtextwrap(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc drawtextwrap=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc drawtextwrap=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dropdata_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dropdata_cb(ih: FlatList_t; cb: proc (ih: PIhandle; dragtype: cstring;
    data: pointer; size, x, y: cint): cint {.cdecl.}) {.cdecl, ...raises: [],
    tags: [].}
proc dropdata_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; dragtype: cstring;
    data: pointer; size, x, y: cint): cint {.cdecl.}) {.cdecl, ...raises: [],
    tags: [].}
proc dropfiles_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dropfiles_cb(ih: FlatList_t; cb: proc (Ih: PIhandle; filename: cstring;
    num, x, y: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dropfiles_cb=(ih: FlatList_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: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc dropfilestarget(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc dropfilestarget(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dropfilestarget=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
DROPFILESTARGET (non inheritable): Enable or disable the drop of files. Default: NO, but if DROPFILES_CB is defined when the element is mapped then it will be automatically enabled. 
proc dropfilestarget=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc dropmotion_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc dropmotion_cb(ih: FlatList_t; cb: proc (ih: PIhandle; x, y: cint;
    status: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc dropmotion_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; x, y: cint;
    status: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc droptarget(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc droptarget(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc droptarget(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc droptarget=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc droptarget=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc droptypes(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc droptypes(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc droptypes=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dx(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc dx(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dx(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc dx=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dx=(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc dy(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc dy(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dy(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc dy=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc dy=(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc enterwindow_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc enterwindow_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc enterwindow_cb=(ih: FlatList_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 expand(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc expand(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc expand=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc expandweight(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc expandweight(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc expandweight(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc expandweight=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc expandweight=(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc fgcolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc fgcolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc fgcolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fgcolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc fgcolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
FGCOLOR: Text color. Default: the global attribute TXTFGCOLOR. 
proc fittobackimage(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc fittobackimage(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fittobackimage(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc fittobackimage=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
FITTOBACKIMAGE (non inheritable): enable the natural size to be computed from the BACKIMAGE. If BACKIMAGE is not defined will be ignored. Can be Yes or No. Default: No. 
proc fittobackimage=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc flat_action(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc flat_action(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cstring;
    arg3: cint; arg4: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc flat_action=(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cstring;
    arg3: cint; arg4: cint): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
FLAT_ACTION: Action generated when the state of an item in the list is interactively changed. int function (Ihandle *ih, char *text, int item, int state); [in C]ih:action(text: string, item, state: number) -> (ret: number) [in Lua] 
proc flat_button_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc flat_button_cb(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cint;
    arg3: cint; arg4: cint; arg5: cint; arg6: cstring): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc flat_button_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cint;
    arg3: cint; arg4: cint; arg5: cint; arg6: cstring): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc flat_focus_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc flat_focus_cb(ih: FlatList_t;
                   cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc flat_focus_cb=(ih: FlatList_t;
                    cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc flat_leavewindow_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc flat_leavewindow_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc flat_leavewindow_cb=(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc flat_motion_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc flat_motion_cb(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cint;
    arg3: cint; arg4: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc flat_motion_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cint;
    arg3: cint; arg4: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc FlatList(): FlatList_t {.cdecl, ...raises: [], tags: [].}
Creates an interface element that displays a list of items, but it does not have native decorations. It behaves like IupList when DROPDOWN=NO and EDITBOX=NO. It inherits from IupCanvas. 
proc flatscrollbar(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc floating(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc floating(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc floating=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc floatingdelay(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc focus_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc focus_cb(ih: FlatList_t;
              cb: proc (ih: PIhandle; focus: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc focus_cb=(ih: FlatList_t;
               cb: proc (ih: PIhandle; focus: cint): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc focusfeedback(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc focusfeedback(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc focusfeedback(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc focusfeedback=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
FOCUSFEEDBACK (non inheritable): draw the focus feedback. Can be Yes or No. Default: Yes. 
proc focusfeedback=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc font(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc font(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc font=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontface(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc fontface(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontface=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontsize(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc fontsize(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontsize(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc fontsize=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontsize=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc fontstyle(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc fontstyle(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc fontstyle=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc getfocus_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc getfocus_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc getfocus_cb=(ih: FlatList_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: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc handlename(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc handlename=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc hasfocus(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc help_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc help_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc help_cb=(ih: FlatList_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 hlcolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc hlcolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc hlcolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc hlcolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc hlcolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
HLCOLOR: color of a filled box drawn over the selected item. Default: "TXTHLCOLOR". 
proc hlcoloralpha(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc hlcoloralpha(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc hlcoloralpha(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc hlcoloralpha=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
HLCOLORALPHA: the transparency used to draw the selection. Default: 128. If set to 0 the selection box is not drawn. 
proc hlcoloralpha=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc iconspacing(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc iconspacing(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc iconspacing(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc iconspacing=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
ICONSPACING (non inheritable): spacing between the image and the text. Default: "2". 
proc iconspacing=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc imageposition(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc imageposition(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc imageposition=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
IMAGEPOSITION (non inheritable): Position of the image relative to the text when both are displayed. Can be: LEFT, RIGHT, TOP, BOTTOM. Default: LEFT. 
proc k_any(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc k_any(ih: FlatList_t; cb: proc (ih: PIhandle; c: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc k_any=(ih: FlatList_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 keypress_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc keypress_cb(ih: FlatList_t;
                 cb: proc (ih: PIhandle; c, press: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc keypress_cb=(ih: FlatList_t;
                  cb: proc (ih: PIhandle; c, press: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
KEYPRESS_CB KEYPRESS_CB Action generated when a key is pressed or released. If the key is pressed and held several calls will occur. It is called after the callback K_ANY is processed. Callback int function(Ihandle *ih, int c, int press); [in C] ih:keypress_cb(c, press: 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. press: 1 is the user pressed the key or 0 otherwise. Returns: If IUP_IGNORE is returned the key is ignored by the system. IUP_CLOSE will be processed. Affects IupCanvas 
proc killfocus_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc killfocus_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc killfocus_cb=(ih: FlatList_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 ldestroy_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc ldestroy_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc ldestroy_cb=(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc leavewindow_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc leavewindow_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc leavewindow_cb=(ih: FlatList_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 linex(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc linex(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc linex(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc linex=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc linex=(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc liney(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc liney(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc liney(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc liney=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc liney=(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc map_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc map_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc map_cb=(ih: FlatList_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 maxsize(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc maxsize(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc maxsize(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc maxsize=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc maxsize=(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc minsize(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc minsize(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc minsize(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc minsize=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc minsize=(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc motion_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc motion_cb(ih: FlatList_t; cb: proc (ih: PIhandle; x, y: cint;
    status: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc motion_cb=(ih: FlatList_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 multiple(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc multiple(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc multiple(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc multiple=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
MULTIPLE (creation only): Allows selecting several items simultaneously (multiple list). Default: "NO". 
proc multiple=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc multiselect_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc multiselect_cb(ih: FlatList_t;
                    cb: proc (ih: PIhandle; value: cstring): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc multiselect_cb=(ih: FlatList_t;
                     cb: proc (ih: PIhandle; value: cstring): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
MULTISELECT_CB: Action generated when the state of an item in the multiple selection list is interactively changed. But it is called only when the interaction is over. int function (Ihandle *ih, char *value); [in C]ih:multiselect_cb(value: string) -> (ret: number) [in Lua] 
proc name(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc name(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc name=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc naturalsize(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc normalizergroup(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc normalizergroup(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc normalizergroup=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc ntheme(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc ntheme(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc ntheme=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc padding(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc padding(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc padding(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc padding=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
PADDING: internal margin of each item. Works just like the MARGIN attribute of the IupHbox and IupVbox containers, but uses a different name to avoid inheritance problems. Alignment does not includes the padding area. Default value: "2x2". 
proc padding=(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc pangofontdesc(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc pangolayout(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc position(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc position(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc position(ih: FlatList_t; x, y: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc position=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc position=(ih: FlatList_t; x, y: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc postmessage_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc postmessage_cb(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cstring;
    arg3: cint; arg4: cdouble; arg5: pointer): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc postmessage_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cstring;
    arg3: cint; arg4: cdouble; arg5: pointer): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc posx(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc posx(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc posx(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc posx=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc posx=(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc posy(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc posy(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc posy(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc posy=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc posy=(ih: FlatList_t; x: int64) {.cdecl, ...raises: [ValueError], tags: [].}
proc propagatefocus(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc propagatefocus(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc propagatefocus(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc propagatefocus=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
PROPAGATEFOCUS (non inheritable): enables the focus callback forwarding to the next native parent with FOCUS_CB defined. Default: NO. 
proc propagatefocus=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc pscolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc pscolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc pscolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc pscolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc pscolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
PSCOLOR: background color of a selected item. If not defined BACKCOLORid will be used. (since 3.30) 
proc rastersize(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc rastersize(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc rastersize(ih: FlatList_t; width, height: int) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc rastersize=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc rastersize=(ih: FlatList_t; width, height: int) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc removeitem(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc removeitem(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc removeitem=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
REMOVEITEM (write-only): removes the given value. value starts at 1. If value is NULL or "ALL" removes all the items. Different from IupList, can be set before map. 
proc removeitem=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc resize_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc resize_cb(ih: FlatList_t;
               cb: proc (ih: PIhandle; width, height: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc resize_cb=(ih: FlatList_t;
                cb: proc (ih: PIhandle; width, height: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
RESIZE_CB RESIZE_CB Action generated when the canvas or dialog size is changed. Callback int function(Ihandle *ih, int width, int height); [in C] ih:resize_cb(width, height: number) -> (ret: number) [in Lua] ih: identifier of the element that activated the event. width: the width of the internal element size in pixels not considering the decorations (client size) height: the height of the internal element size in pixels not considering the decorations (client size) Notes For the dialog, this action is also generated when the dialog is mapped, after the map and before the show. When XAUTOHIDE=Yes or YAUTOHIDE=Yes, if the canvas scrollbar is hidden/shown after changing the DX or DY attributes from inside the callback, the size of the drawing area will immediately change, so the parameters with and height will be invalid. To update the parameters consult the DRAWSIZE attribute. Also activate the drawing toolkit only after updating the DX or DY attributes. Affects IupCanvas, IupGLCanvas, IupDialog 
proc sb_backcolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_forecolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_highcolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagebottom(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagebottom(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imagebottom=(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imagebottomhighlight(ih: FlatList_t): string {.cdecl, ...raises: [],
    tags: [].}
proc sb_imagebottomhighlight(ih: FlatList_t;
                             handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagebottomhighlight=(ih: FlatList_t;
                              handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imagebottominactive(ih: FlatList_t): string {.cdecl, ...raises: [],
    tags: [].}
proc sb_imagebottominactive(ih: FlatList_t;
                            handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagebottominactive=(ih: FlatList_t;
                             handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagebottompress(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagebottompress(ih: FlatList_t;
                         handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagebottompress=(ih: FlatList_t;
                          handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imageleft(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imageleft(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imageleft=(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imagelefthighlight(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagelefthighlight(ih: FlatList_t;
                           handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagelefthighlight=(ih: FlatList_t;
                            handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imageleftinactive(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imageleftinactive(ih: FlatList_t;
                          handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imageleftinactive=(ih: FlatList_t;
                           handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imageleftpress(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imageleftpress(ih: FlatList_t;
                       handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imageleftpress=(ih: FlatList_t;
                        handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imageright(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imageright(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imageright=(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imagerighthighlight(ih: FlatList_t): string {.cdecl, ...raises: [],
    tags: [].}
proc sb_imagerighthighlight(ih: FlatList_t;
                            handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagerighthighlight=(ih: FlatList_t;
                             handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagerightinactive(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagerightinactive(ih: FlatList_t;
                           handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagerightinactive=(ih: FlatList_t;
                            handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagerightpress(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagerightpress(ih: FlatList_t;
                        handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagerightpress=(ih: FlatList_t;
                         handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagetop(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagetop(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imagetop=(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imagetophighlight(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagetophighlight(ih: FlatList_t;
                          handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagetophighlight=(ih: FlatList_t;
                           handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagetopinactive(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagetopinactive(ih: FlatList_t;
                         handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagetopinactive=(ih: FlatList_t;
                          handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_imagetoppress(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_imagetoppress(ih: FlatList_t; handle: Image_t | ImageRGB_t | ImageRGBA_t) {.
    cdecl.}
proc sb_imagetoppress=(ih: FlatList_t;
                       handle: Image_t | ImageRGB_t | ImageRGBA_t) {.cdecl.}
proc sb_presscolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc sb_resize(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc screenposition(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc scroll_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc scroll_cb(ih: FlatList_t; cb: proc (ih: PIhandle; op: cint;
    posx, posy: cfloat): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
proc scroll_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; op: cint;
    posx, posy: cfloat): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
SCROLL_CB SCROLL_CB Called when some manipulation is made to the scrollbar. The canvas is automatically redrawn only if this callback is NOT defined. (GTK 2.8) Also the POSX and POSY values will not be correctly updated for older GTK versions. In Ubuntu, when liboverlay-scrollbar is enabled (the new tiny auto-hide scrollbar) only the IUP_SBPOSV and IUP_SBPOSH codes are used. Callback int function(Ihandle *ih, int op, float posx, float posy); [in C] ih:scroll_cb(op, posx, posy: number) -> (ret: number) [in Lua] ih: identifier of the element that activated the event. op: indicates the operation performed on the scrollbar. If the manipulation was made on the vertical scrollbar, it can have the following values: IUP_SBUP - line up IUP_SBDN - line down IUP_SBPGUP - page up IUP_SBPGDN - page down IUP_SBPOSV - vertical positioning IUP_SBDRAGV - vertical drag If it was on the horizontal scrollbar, the following values are valid: IUP_SBLEFT - column left IUP_SBRIGHT - column right IUP_SBPGLEFT - page left IUP_SBPGRIGHT - page right IUP_SBPOSH - horizontal positioning IUP_SBDRAGH - horizontal drag posx, posy: the same as the ACTION canvas callback (corresponding to the values of attributes POSX and POSY). Notes IUP_SBDRAGH and IUP_SBDRAGV are not supported in GTK. During drag IUP_SBPOSH and IUP_SBPOSV are used. In Windows, after a drag when mouse is released IUP_SBPOSH or IUP_SBPOSV are called. Affects IupCanvas, IupGLCanvas, SCROLLBAR 
proc scrollbar(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc scrollbar(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc scrollbar(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc scrollbar=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
SCROLLBAR (read-only): is always "NO". So the IupCanvas native scrollbars are hidden. See the FLATSCROLLBAR attribute bellow. YAUTOHIDE and XAUTOHIDE will be always Yes. 
proc scrollbar=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc scrollbarsize(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc showarrows(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc showdragdrop(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc showdragdrop(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc showdragdrop(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc showdragdrop=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
SHOWDRAGDROP (creation only) (non inheritable): enables the internal drag and drop of items in the same list, and enables the DRAGDROP_CB callback. Default: "NO". Works only if MULTIPLE=NO. Drag & Drop attributes are NOT used. 
proc showdragdrop=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc showfloating(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc showtransparent(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc size(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc size(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc size(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc size=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
SIZE: Size of the list. The Natural Size is defined by the number of elements in the list and the with of the largest item, the default has room for 5 characters in 1 item. The Natural Size ignores the list contents if VISIBLECOLUMNS or VISIBLELINES attributes are defined. 
proc size=(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc spacing(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc spacing(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc spacing(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc spacing=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
SPACING: internal space between each item. Different from IupList, it does not affects the internal margin. Not drawn with any item background color. Default: 0 
proc spacing=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc textalignment(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc textalignment(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc textalignment=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
TEXTALIGNMENT (non inheritable): Horizontal text alignment for multiple lines. Can be: ALEFT, ARIGHT or ACENTER. Default: ALEFT. 
proc textellipsis(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc textellipsis(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc textellipsis(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc textellipsis=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
TEXTELLIPSIS (non inheritable): If the text is larger that its box, an ellipsis ("...") will be placed near the last visible part of the text and replace the invisible part. It will be ignored when TEXTWRAP=Yes. 
proc textellipsis=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc textpscolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc textpscolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc textpscolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc textpscolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc textpscolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
TEXTPSCOLOR: foreground color of a selected item. If not defined FORECOLORid will be used. (since 3.30) 
proc textwrap(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc textwrap(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc textwrap(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc textwrap=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
TEXTWRAP (non inheritable): For single line texts if the text is larger than its box the line will be automatically broken in multiple lines. Notice that this is done internally by the system, the element natural size will still use only a single line. For the remaining lines to be visible the element should use EXPAND=VERTICAL or set a SIZE/RASTERSIZE with enough height for the wrapped lines. 
proc textwrap=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc theme(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc theme(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc theme=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tip(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc tip(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tip=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipbgcolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc tipbgcolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc tipbgcolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipbgcolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc tipbgcolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipdelay(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc tipdelay(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipdelay(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc tipdelay=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipdelay=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc tipfgcolor(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc tipfgcolor(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc tipfgcolor(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipfgcolor=(ih: FlatList_t; red, green, blue: int; alpha: int = 255) {.
    cdecl, ...raises: [ValueError], tags: [].}
proc tipfgcolor=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipicon(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc tipicon(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipicon=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipmarkup(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc tipmarkup(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipmarkup=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tiprect(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc tiprect(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tiprect(ih: FlatList_t; x1, y1, x2, y2: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc tiprect=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tiprect=(ih: FlatList_t; x1, y1, x2, y2: int) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc tipvisible(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc tipvisible(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipvisible(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc tipvisible=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc tipvisible=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc topitem(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc topitem(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc topitem=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
TOPITEM (write-only): position the given item at the top of the list or near to make it visible. 
proc topitem=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc touch(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc touch(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc touch(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc touch=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc touch=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc unmap_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc unmap_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.cdecl,
    ...raises: [], tags: [].}
proc unmap_cb=(ih: FlatList_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: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc usersize(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc usersize(ih: FlatList_t; width, height: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc usersize=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc usersize=(ih: FlatList_t; width, height: int) {.cdecl,
    ...raises: [ValueError], tags: [].}
proc value(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc value(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc value=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
VALUE (non inheritable): Depends on the selection mode: MULTIPLE=YES: Sequence of '+' and '-' symbols indicating the state of each item. When setting this value, the user must provide the same amount of '+' and '-' symbols as the amount of items in the list. It can use ' ' (space) or another character so the current selection on that item will remain the same (since 3.28). MULTIPLE=NO: Integer number representing the selected item in the list (begins at 1). It returns NULL if there is no selected item. For both cases, when setting NULL all items are deselected. The non changed items marked with 'x' are simulated internally by IUP in all systems. If you add or remove items to/from the list and you count on the 'x' values, then after adding/removing items set the VALUE attribute to ensure proper 'x' values. 
proc valuechanged_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {.
    ...raises: [], tags: [].}
proc valuechanged_cb(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc valuechanged_cb=(ih: FlatList_t; cb: proc (ih: PIhandle): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
VALUECHANGED_CB: Called after the selection was interactively changed. int function(Ihandle *ih); [in C]ih:valuechanged_cb() -> (ret: number) [in Lua] 
proc valuestring(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc valuestring(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc valuestring=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
VALUESTRING (non inheritable): changes or retrieves the value attribute using a string of an item. Works only when MULTIPLE=NO. When set it will search for the first item with the same string. 
proc visible(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc visible(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc visible(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc visible=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc visible=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc visiblecolumns(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc visiblecolumns(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc visiblecolumns(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc visiblecolumns=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
VISIBLECOLUMNS: Defines the number of visible columns for the Natural Size, this means that will act also as minimum number of visible columns. It uses a wider character size then the one used for the SIZE attribute so strings will fit better without the need of extra columns. Set this attribute to speed Natural Size computation for very large lists. 
proc visiblecolumns=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc visiblelines(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc visiblelines(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc visiblelines(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc visiblelines=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
VISIBLELINES: Defines the number of visible lines for the Natural Size, this means that will act also as minimum number of visible lines. 
proc visiblelines=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError],
    tags: [].}
proc wheel_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc wheel_cb(ih: FlatList_t; cb: proc (ih: PIhandle; delta: cfloat; x, y: cint;
                                        status: cstring): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc wheel_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; delta: cfloat;
    x, y: cint; status: cstring): cint {.cdecl.}) {.cdecl, ...raises: [], tags: [].}
WHEEL_CB WHEEL_CB Action generated when the mouse wheel is rotated. If this callback is not defined the wheel will automatically scroll the canvas in the vertical direction by some lines, the SCROLL_CB callback if defined will be called with the IUP_SBDRAGV operation. Callback int function(Ihandle *ih, float delta, int x, int y, char *status); [in C] ih:wheel_cb(delta, x, y: number, status: string) -> (ret: number) [in Lua] ih: identifier of the element that activated the event. delta: the amount the wheel was rotated in notches. 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 In Motif and GTK delta is always 1 or -1. In Windows is some situations delta can reach the value of two. In the future with more precise wheels this increment can be changed. Affects IupCanvas, IupGLCanvas 
proc wheeldropfocus(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc wheeldropfocus(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc wheeldropfocus(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc wheeldropfocus=(ih: FlatList_t; value: string) {.cdecl, ...raises: [],
    tags: [].}
proc wheeldropfocus=(ih: FlatList_t; yes: bool) {.cdecl, ...raises: [], tags: [].}
proc wid(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc wom_cb(ih: FlatList_t): proc (ih: PIhandle): cint {.cdecl.} {....raises: [],
    tags: [].}
proc wom_cb(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
proc wom_cb=(ih: FlatList_t; cb: proc (ih: PIhandle; arg2: cint): cint {.cdecl.}) {.
    cdecl, ...raises: [], tags: [].}
WOM_CB WOM_CB Action generated when an audio device receives an event. [Windows Only] Callback int function(Ihandle *ih, int state); [in C] ih:wom_cb(state: number) -> (ret: number) [in Lua] ih: identifies the element that activated the event. state: can be opening=1, done=0, or closing=-1. Notes This callback is used to syncronize video playback with audio. It is sent when the audio device: Message Description opening is opened by using the waveOutOpen function. done is finished with a data block sent by using the waveOutWrite function. closing is closed by using the waveOutClose function. You must use the HWND attribute when calling waveOutOpen in the dwCallback parameter and set fdwOpen to CALLBACK_WINDOW. Affects IupDialog, IupCanvas, IupGLCanvas 
proc x(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc xautohide(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc xdisplay(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc xfontid(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc xhidden(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc xmax(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc xmax(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc xmax(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc xmax=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc xmax=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc xmin(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc xmin(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc xmin(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc xmin=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc xmin=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc xwindow(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc y(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc yautohide(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc yhidden(ih: FlatList_t): bool {.cdecl, ...raises: [], tags: [].}
proc ymax(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc ymax(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc ymax(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc ymax=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc ymax=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc ymin(ih: FlatList_t): string {.cdecl, ...raises: [], tags: [].}
proc ymin(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc ymin(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc ymin=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc ymin=(ih: FlatList_t; x: int) {.cdecl, ...raises: [ValueError], tags: [].}
proc zorder(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}
proc zorder=(ih: FlatList_t; value: string) {.cdecl, ...raises: [], tags: [].}

Made with Nim. Generated: 2022-01-14 18:40:46 UTC