jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

wrappers do not contain invalid identifiers

Browse source
This commit is contained in:
Andreas Rumpf 2010-01-17 22:19:10 +01:00
commit 8259d9d15a
24 changed files with 887 additions and 895 deletions
Download patch file Download diff file Expand all files Collapse all files

42
lib/newwrap/gtk/glib2.nim
View file

@ -3313,125 +3313,125 @@ proc g_module_name*(module: PGModule): cstring{.cdecl, dynlib: gmodulelib,
importc: "g_module_name".} importc: "g_module_name".}
proc g_module_build_path*(directory: cstring, module_name: cstring): cstring{. proc g_module_build_path*(directory: cstring, module_name: cstring): cstring{.
cdecl, dynlib: gmodulelib, importc: "g_module_build_path".} cdecl, dynlib: gmodulelib, importc: "g_module_build_path".}
proc g_cclosure_marshal_VOID__VOID*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_VOID*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__VOID".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__VOID".}
proc g_cclosure_marshal_VOID__BOOLEAN*(closure: PGClosure, proc g_cclosure_marshal_VOID_BOOLEAN*(closure: PGClosure,
return_value: PGValue, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOOLEAN".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOOLEAN".}
proc g_cclosure_marshal_VOID__CHAR*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_CHAR*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__CHAR".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__CHAR".}
proc g_cclosure_marshal_VOID__UCHAR*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_UCHAR*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UCHAR".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UCHAR".}
proc g_cclosure_marshal_VOID__INT*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_INT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, param_values: PGValue, n_param_values: GUInt, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__INT".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__INT".}
proc g_cclosure_marshal_VOID__UINT*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_UINT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT".}
proc g_cclosure_marshal_VOID__LONG*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_LONG*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__LONG".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__LONG".}
proc g_cclosure_marshal_VOID__ULONG*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_ULONG*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ULONG".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ULONG".}
proc g_cclosure_marshal_VOID__ENUM*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_ENUM*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ENUM".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ENUM".}
proc g_cclosure_marshal_VOID__FLAGS*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_FLAGS*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLAGS".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLAGS".}
proc g_cclosure_marshal_VOID__FLOAT*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_FLOAT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLOAT".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLOAT".}
proc g_cclosure_marshal_VOID__DOUBLE*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_DOUBLE*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__DOUBLE".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__DOUBLE".}
proc g_cclosure_marshal_VOID__STRING*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_STRING*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__STRING".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__STRING".}
proc g_cclosure_marshal_VOID__PARAM*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_PARAM*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__PARAM".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__PARAM".}
proc g_cclosure_marshal_VOID__BOXED*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_BOXED*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOXED".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOXED".}
proc g_cclosure_marshal_VOID__POINTER*(closure: PGClosure, proc g_cclosure_marshal_VOID_POINTER*(closure: PGClosure,
return_value: PGValue, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__POINTER".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__POINTER".}
proc g_cclosure_marshal_VOID__OBJECT*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_OBJECT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__OBJECT".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__OBJECT".}
proc g_cclosure_marshal_STRING__OBJECT_POINTER*(closure: PGClosure, proc g_cclosure_marshal_STRING_OBJECT_POINTER*(closure: PGClosure,
return_value: PGValue, n_param_values: GUInt, param_values: PGValue, return_value: PGValue, n_param_values: GUInt, param_values: PGValue,
invocation_hint: GPointer, marshal_data: GPointer){.cdecl, invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_STRING__OBJECT_POINTER".} dynlib: gobjectlib, importc: "g_cclosure_marshal_STRING__OBJECT_POINTER".}
proc g_cclosure_marshal_VOID__UINT_POINTER*(closure: PGClosure, proc g_cclosure_marshal_VOID_UINT_POINTER*(closure: PGClosure,
return_value: PGValue, n_param_values: GUInt, param_values: PGValue, return_value: PGValue, n_param_values: GUInt, param_values: PGValue,
invocation_hint: GPointer, marshal_data: GPointer){.cdecl, invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT_POINTER".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT_POINTER".}
proc g_cclosure_marshal_BOOLEAN__FLAGS*(closure: PGClosure, proc g_cclosure_marshal_BOOLEAN_FLAGS*(closure: PGClosure,
return_value: PGValue, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_BOOLEAN__FLAGS".} dynlib: gobjectlib, importc: "g_cclosure_marshal_BOOLEAN__FLAGS".}
proc g_cclosure_marshal_BOOL__FLAGS*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_BOOL_FLAGS*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,

286
lib/newwrap/gtk/gtk2.nim
View file

@ -5198,7 +5198,7 @@ proc CLIST_UNSET_FLAG*(clist: PCList, flag: guint16)
#proc GTK_CLIST_USE_DRAG_ICONS_get*(clist: pointer): bool #proc GTK_CLIST_USE_DRAG_ICONS_get*(clist: pointer): bool
#proc GTK_CLIST_DRAW_DRAG_LINE_get*(clist: pointer): bool #proc GTK_CLIST_DRAW_DRAG_LINE_get*(clist: pointer): bool
#proc GTK_CLIST_DRAW_DRAG_RECT_get*(clist: pointer): bool #proc GTK_CLIST_DRAW_DRAG_RECT_get*(clist: pointer): bool
#proc GTK_CLIST_ROW_get*(`glist_`: PGList): PGtkCListRow #proc GTK_CLIST_ROW_get*(glist: PGList): PGtkCListRow
#proc GTK_CELL_TEXT_get*(cell: pointer): PGtkCellText #proc GTK_CELL_TEXT_get*(cell: pointer): PGtkCellText
#proc GTK_CELL_PIXMAP_get*(cell: pointer): PGtkCellPixmap #proc GTK_CELL_PIXMAP_get*(cell: pointer): PGtkCellPixmap
#proc GTK_CELL_PIXTEXT_get*(cell: pointer): PGtkCellPixText #proc GTK_CELL_PIXTEXT_get*(cell: pointer): PGtkCellPixText
@ -5554,11 +5554,11 @@ proc CTREE_CLASS*(klass: pointer): PCTreeClass
proc IS_CTREE*(obj: pointer): bool proc IS_CTREE*(obj: pointer): bool
proc IS_CTREE_CLASS*(klass: pointer): bool proc IS_CTREE_CLASS*(klass: pointer): bool
proc CTREE_GET_CLASS*(obj: pointer): PCTreeClass proc CTREE_GET_CLASS*(obj: pointer): PCTreeClass
proc CTREE_ROW*(`node_`: TAddress): PCTreeRow proc CTREE_ROW*(node: TAddress): PCTreeRow
proc CTREE_NODE*(`node_`: TAddress): PCTreeNode proc CTREE_NODE*(node: TAddress): PCTreeNode
proc CTREE_NODE_NEXT*(`nnode_`: TAddress): PCTreeNode proc CTREE_NODE_NEXT*(nnode: TAddress): PCTreeNode
proc CTREE_NODE_PREV*(`pnode_`: TAddress): PCTreeNode proc CTREE_NODE_PREV*(pnode: TAddress): PCTreeNode
proc CTREE_FUNC*(`func_`: TAddress): TCTreeFunc proc CTREE_FUNC*(fun: TAddress): TCTreeFunc
proc TYPE_CTREE_NODE*(): GType proc TYPE_CTREE_NODE*(): GType
proc line_style*(a: var TCTree): guint proc line_style*(a: var TCTree): guint
proc set_line_style*(a: var TCTree, `line_style`: guint) proc set_line_style*(a: var TCTree, `line_style`: guint)
@ -5579,138 +5579,138 @@ proc ctree_insert_node*(ctree: PCTree, parent: PCTreeNode, sibling: PCTreeNode,
pixmap_opened: gdk2.PPixmap, mask_opened: gdk2.PBitmap, pixmap_opened: gdk2.PPixmap, mask_opened: gdk2.PBitmap,
is_leaf: gboolean, expanded: gboolean): PCTreeNode{. is_leaf: gboolean, expanded: gboolean): PCTreeNode{.
cdecl, dynlib: lib, importc: "gtk_ctree_insert_node".} cdecl, dynlib: lib, importc: "gtk_ctree_insert_node".}
proc ctree_remove_node*(ctree: PCTree, node_: PCTreeNode){.cdecl, dynlib: lib, proc ctree_remove_node*(ctree: PCTree, node: PCTreeNode){.cdecl, dynlib: lib,
importc: "gtk_ctree_remove_node".} importc: "gtk_ctree_remove_node".}
proc ctree_insert_gnode*(ctree: PCTree, parent: PCTreeNode, sibling: PCTreeNode, proc ctree_insert_gnode*(ctree: PCTree, parent: PCTreeNode, sibling: PCTreeNode,
gnode: PGNode, func_: TCTreeGNodeFunc, data: gpointer): PCTreeNode{. gnode: PGNode, fun: TCTreeGNodeFunc, data: gpointer): PCTreeNode{.
cdecl, dynlib: lib, importc: "gtk_ctree_insert_gnode".} cdecl, dynlib: lib, importc: "gtk_ctree_insert_gnode".}
proc ctree_export_to_gnode*(ctree: PCTree, parent: PGNode, sibling: PGNode, proc ctree_export_to_gnode*(ctree: PCTree, parent: PGNode, sibling: PGNode,
node_: PCTreeNode, func_: TCTreeGNodeFunc, node: PCTreeNode, fun: TCTreeGNodeFunc,
data: gpointer): PGNode{.cdecl, dynlib: lib, data: gpointer): PGNode{.cdecl, dynlib: lib,
importc: "gtk_ctree_export_to_gnode".} importc: "gtk_ctree_export_to_gnode".}
proc ctree_post_recursive*(ctree: PCTree, node_: PCTreeNode, func_: TCTreeFunc, proc ctree_post_recursive*(ctree: PCTree, node: PCTreeNode, fun: TCTreeFunc,
data: gpointer){.cdecl, dynlib: lib, data: gpointer){.cdecl, dynlib: lib,
importc: "gtk_ctree_post_recursive".} importc: "gtk_ctree_post_recursive".}
proc ctree_post_recursive_to_depth*(ctree: PCTree, node_: PCTreeNode, proc ctree_post_recursive_to_depth*(ctree: PCTree, node: PCTreeNode,
depth: gint, func_: TCTreeFunc, depth: gint, fun: TCTreeFunc,
data: gpointer){.cdecl, dynlib: lib, data: gpointer){.cdecl, dynlib: lib,
importc: "gtk_ctree_post_recursive_to_depth".} importc: "gtk_ctree_post_recursive_to_depth".}
proc ctree_pre_recursive*(ctree: PCTree, node_: PCTreeNode, func_: TCTreeFunc, proc ctree_pre_recursive*(ctree: PCTree, node: PCTreeNode, fun: TCTreeFunc,
data: gpointer){.cdecl, dynlib: lib, data: gpointer){.cdecl, dynlib: lib,
importc: "gtk_ctree_pre_recursive".} importc: "gtk_ctree_pre_recursive".}
proc ctree_pre_recursive_to_depth*(ctree: PCTree, node_: PCTreeNode, proc ctree_pre_recursive_to_depth*(ctree: PCTree, node: PCTreeNode,
depth: gint, func_: TCTreeFunc, depth: gint, fun: TCTreeFunc,
data: gpointer){.cdecl, dynlib: lib, data: gpointer){.cdecl, dynlib: lib,
importc: "gtk_ctree_pre_recursive_to_depth".} importc: "gtk_ctree_pre_recursive_to_depth".}
proc ctree_is_viewable*(ctree: PCTree, node_: PCTreeNode): gboolean{.cdecl, proc ctree_is_viewable*(ctree: PCTree, node: PCTreeNode): gboolean{.cdecl,
dynlib: lib, importc: "gtk_ctree_is_viewable".} dynlib: lib, importc: "gtk_ctree_is_viewable".}
proc ctree_last*(ctree: PCTree, node_: PCTreeNode): PCTreeNode{.cdecl, proc ctree_last*(ctree: PCTree, node: PCTreeNode): PCTreeNode{.cdecl,
dynlib: lib, importc: "gtk_ctree_last".} dynlib: lib, importc: "gtk_ctree_last".}
proc ctree_find_node_ptr*(ctree: PCTree, ctree_row: PCTreeRow): PCTreeNode{. proc ctree_find_node_ptr*(ctree: PCTree, ctree_row: PCTreeRow): PCTreeNode{.
cdecl, dynlib: lib, importc: "gtk_ctree_find_node_ptr".} cdecl, dynlib: lib, importc: "gtk_ctree_find_node_ptr".}
proc ctree_node_nth*(ctree: PCTree, row: guint): PCTreeNode{.cdecl, dynlib: lib, proc ctree_node_nth*(ctree: PCTree, row: guint): PCTreeNode{.cdecl, dynlib: lib,
importc: "gtk_ctree_node_nth".} importc: "gtk_ctree_node_nth".}
proc ctree_find*(ctree: PCTree, node_: PCTreeNode, child: PCTreeNode): gboolean{. proc ctree_find*(ctree: PCTree, node: PCTreeNode, child: PCTreeNode): gboolean{.
cdecl, dynlib: lib, importc: "gtk_ctree_find".} cdecl, dynlib: lib, importc: "gtk_ctree_find".}
proc ctree_is_ancestor*(ctree: PCTree, node_: PCTreeNode, child: PCTreeNode): gboolean{. proc ctree_is_ancestor*(ctree: PCTree, node: PCTreeNode, child: PCTreeNode): gboolean{.
cdecl, dynlib: lib, importc: "gtk_ctree_is_ancestor".} cdecl, dynlib: lib, importc: "gtk_ctree_is_ancestor".}
proc ctree_find_by_row_data*(ctree: PCTree, node_: PCTreeNode, data: gpointer): PCTreeNode{. proc ctree_find_by_row_data*(ctree: PCTree, node: PCTreeNode, data: gpointer): PCTreeNode{.
cdecl, dynlib: lib, importc: "gtk_ctree_find_by_row_data".} cdecl, dynlib: lib, importc: "gtk_ctree_find_by_row_data".}
proc ctree_find_all_by_row_data*(ctree: PCTree, node_: PCTreeNode, proc ctree_find_all_by_row_data*(ctree: PCTree, node: PCTreeNode,
data: gpointer): PGList{.cdecl, dynlib: lib, data: gpointer): PGList{.cdecl, dynlib: lib,
importc: "gtk_ctree_find_all_by_row_data".} importc: "gtk_ctree_find_all_by_row_data".}
proc ctree_find_by_row_data_custom*(ctree: PCTree, node_: PCTreeNode, proc ctree_find_by_row_data_custom*(ctree: PCTree, node: PCTreeNode,
data: gpointer, func_: TGCompareFunc): PCTreeNode{. data: gpointer, fun: TGCompareFunc): PCTreeNode{.
cdecl, dynlib: lib, importc: "gtk_ctree_find_by_row_data_custom".} cdecl, dynlib: lib, importc: "gtk_ctree_find_by_row_data_custom".}
proc ctree_find_all_by_row_data_custom*(ctree: PCTree, node_: PCTreeNode, proc ctree_find_all_by_row_data_custom*(ctree: PCTree, node: PCTreeNode,
data: gpointer, func_: TGCompareFunc): PGList{. data: gpointer, fun: TGCompareFunc): PGList{.
cdecl, dynlib: lib, importc: "gtk_ctree_find_all_by_row_data_custom".} cdecl, dynlib: lib, importc: "gtk_ctree_find_all_by_row_data_custom".}
proc ctree_is_hot_spot*(ctree: PCTree, x: gint, y: gint): gboolean{.cdecl, proc ctree_is_hot_spot*(ctree: PCTree, x: gint, y: gint): gboolean{.cdecl,
dynlib: lib, importc: "gtk_ctree_is_hot_spot".} dynlib: lib, importc: "gtk_ctree_is_hot_spot".}
proc ctree_move*(ctree: PCTree, node_: PCTreeNode, new_parent: PCTreeNode, proc ctree_move*(ctree: PCTree, node: PCTreeNode, new_parent: PCTreeNode,
new_sibling: PCTreeNode){.cdecl, dynlib: lib, new_sibling: PCTreeNode){.cdecl, dynlib: lib,
importc: "gtk_ctree_move".} importc: "gtk_ctree_move".}
proc ctree_expand*(ctree: PCTree, node_: PCTreeNode){.cdecl, dynlib: lib, proc ctree_expand*(ctree: PCTree, node: PCTreeNode){.cdecl, dynlib: lib,
importc: "gtk_ctree_expand".} importc: "gtk_ctree_expand".}
proc ctree_expand_recursive*(ctree: PCTree, node_: PCTreeNode){.cdecl, proc ctree_expand_recursive*(ctree: PCTree, node: PCTreeNode){.cdecl,
dynlib: lib, importc: "gtk_ctree_expand_recursive".} dynlib: lib, importc: "gtk_ctree_expand_recursive".}
proc ctree_expand_to_depth*(ctree: PCTree, node_: PCTreeNode, depth: gint){. proc ctree_expand_to_depth*(ctree: PCTree, node: PCTreeNode, depth: gint){.
cdecl, dynlib: lib, importc: "gtk_ctree_expand_to_depth".} cdecl, dynlib: lib, importc: "gtk_ctree_expand_to_depth".}
proc ctree_collapse*(ctree: PCTree, node_: PCTreeNode){.cdecl, dynlib: lib, proc ctree_collapse*(ctree: PCTree, node: PCTreeNode){.cdecl, dynlib: lib,
importc: "gtk_ctree_collapse".} importc: "gtk_ctree_collapse".}
proc ctree_collapse_recursive*(ctree: PCTree, node_: PCTreeNode){.cdecl, proc ctree_collapse_recursive*(ctree: PCTree, node: PCTreeNode){.cdecl,
dynlib: lib, importc: "gtk_ctree_collapse_recursive".} dynlib: lib, importc: "gtk_ctree_collapse_recursive".}
proc ctree_collapse_to_depth*(ctree: PCTree, node_: PCTreeNode, depth: gint){. proc ctree_collapse_to_depth*(ctree: PCTree, node: PCTreeNode, depth: gint){.
cdecl, dynlib: lib, importc: "gtk_ctree_collapse_to_depth".} cdecl, dynlib: lib, importc: "gtk_ctree_collapse_to_depth".}
proc ctree_toggle_expansion*(ctree: PCTree, node_: PCTreeNode){.cdecl, proc ctree_toggle_expansion*(ctree: PCTree, node: PCTreeNode){.cdecl,
dynlib: lib, importc: "gtk_ctree_toggle_expansion".} dynlib: lib, importc: "gtk_ctree_toggle_expansion".}
proc ctree_toggle_expansion_recursive*(ctree: PCTree, node_: PCTreeNode){.cdecl, proc ctree_toggle_expansion_recursive*(ctree: PCTree, node: PCTreeNode){.cdecl,
dynlib: lib, importc: "gtk_ctree_toggle_expansion_recursive".} dynlib: lib, importc: "gtk_ctree_toggle_expansion_recursive".}
proc ctree_select*(ctree: PCTree, node_: PCTreeNode){.cdecl, dynlib: lib, proc ctree_select*(ctree: PCTree, node: PCTreeNode){.cdecl, dynlib: lib,
importc: "gtk_ctree_select".} importc: "gtk_ctree_select".}
proc ctree_select_recursive*(ctree: PCTree, node_: PCTreeNode){.cdecl, proc ctree_select_recursive*(ctree: PCTree, node: PCTreeNode){.cdecl,
dynlib: lib, importc: "gtk_ctree_select_recursive".} dynlib: lib, importc: "gtk_ctree_select_recursive".}
proc ctree_unselect*(ctree: PCTree, node_: PCTreeNode){.cdecl, dynlib: lib, proc ctree_unselect*(ctree: PCTree, node: PCTreeNode){.cdecl, dynlib: lib,
importc: "gtk_ctree_unselect".} importc: "gtk_ctree_unselect".}
proc ctree_unselect_recursive*(ctree: PCTree, node_: PCTreeNode){.cdecl, proc ctree_unselect_recursive*(ctree: PCTree, node: PCTreeNode){.cdecl,
dynlib: lib, importc: "gtk_ctree_unselect_recursive".} dynlib: lib, importc: "gtk_ctree_unselect_recursive".}
proc ctree_real_select_recursive*(ctree: PCTree, node_: PCTreeNode, state: gint){. proc ctree_real_select_recursive*(ctree: PCTree, node: PCTreeNode, state: gint){.
cdecl, dynlib: lib, importc: "gtk_ctree_real_select_recursive".} cdecl, dynlib: lib, importc: "gtk_ctree_real_select_recursive".}
proc ctree_node_set_text*(ctree: PCTree, node_: PCTreeNode, column: gint, proc ctree_node_set_text*(ctree: PCTree, node: PCTreeNode, column: gint,
text: cstring){.cdecl, dynlib: lib, text: cstring){.cdecl, dynlib: lib,
importc: "gtk_ctree_node_set_text".} importc: "gtk_ctree_node_set_text".}
proc ctree_node_set_pixmap*(ctree: PCTree, node_: PCTreeNode, column: gint, proc ctree_node_set_pixmap*(ctree: PCTree, node: PCTreeNode, column: gint,
pixmap: gdk2.PPixmap, mask: gdk2.PBitmap){.cdecl, pixmap: gdk2.PPixmap, mask: gdk2.PBitmap){.cdecl,
dynlib: lib, importc: "gtk_ctree_node_set_pixmap".} dynlib: lib, importc: "gtk_ctree_node_set_pixmap".}
proc ctree_node_set_pixtext*(ctree: PCTree, node_: PCTreeNode, column: gint, proc ctree_node_set_pixtext*(ctree: PCTree, node: PCTreeNode, column: gint,
text: cstring, spacing: guint8, pixmap: gdk2.PPixmap, text: cstring, spacing: guint8, pixmap: gdk2.PPixmap,
mask: gdk2.PBitmap){.cdecl, dynlib: lib, mask: gdk2.PBitmap){.cdecl, dynlib: lib,
importc: "gtk_ctree_node_set_pixtext".} importc: "gtk_ctree_node_set_pixtext".}
proc ctree_set_node_info*(ctree: PCTree, node_: PCTreeNode, text: cstring, proc ctree_set_node_info*(ctree: PCTree, node: PCTreeNode, text: cstring,
spacing: guint8, pixmap_closed: gdk2.PPixmap, spacing: guint8, pixmap_closed: gdk2.PPixmap,
mask_closed: gdk2.PBitmap, pixmap_opened: gdk2.PPixmap, mask_closed: gdk2.PBitmap, pixmap_opened: gdk2.PPixmap,
mask_opened: gdk2.PBitmap, is_leaf: gboolean, mask_opened: gdk2.PBitmap, is_leaf: gboolean,
expanded: gboolean){.cdecl, dynlib: lib, expanded: gboolean){.cdecl, dynlib: lib,
importc: "gtk_ctree_set_node_info".} importc: "gtk_ctree_set_node_info".}
proc ctree_node_set_shift*(ctree: PCTree, node_: PCTreeNode, column: gint, proc ctree_node_set_shift*(ctree: PCTree, node: PCTreeNode, column: gint,
vertical: gint, horizontal: gint){.cdecl, vertical: gint, horizontal: gint){.cdecl,
dynlib: lib, importc: "gtk_ctree_node_set_shift".} dynlib: lib, importc: "gtk_ctree_node_set_shift".}
proc ctree_node_set_selectable*(ctree: PCTree, node_: PCTreeNode, proc ctree_node_set_selectable*(ctree: PCTree, node: PCTreeNode,
selectable: gboolean){.cdecl, dynlib: lib, selectable: gboolean){.cdecl, dynlib: lib,
importc: "gtk_ctree_node_set_selectable".} importc: "gtk_ctree_node_set_selectable".}
proc ctree_node_get_selectable*(ctree: PCTree, node_: PCTreeNode): gboolean{. proc ctree_node_get_selectable*(ctree: PCTree, node: PCTreeNode): gboolean{.
cdecl, dynlib: lib, importc: "gtk_ctree_node_get_selectable".} cdecl, dynlib: lib, importc: "gtk_ctree_node_get_selectable".}
proc ctree_node_get_cell_type*(ctree: PCTree, node_: PCTreeNode, column: gint): TCellType{. proc ctree_node_get_cell_type*(ctree: PCTree, node: PCTreeNode, column: gint): TCellType{.
cdecl, dynlib: lib, importc: "gtk_ctree_node_get_cell_type".} cdecl, dynlib: lib, importc: "gtk_ctree_node_get_cell_type".}
proc ctree_node_get_text*(ctree: PCTree, node_: PCTreeNode, column: gint, proc ctree_node_get_text*(ctree: PCTree, node: PCTreeNode, column: gint,
text: PPgchar): gboolean{.cdecl, dynlib: lib, text: PPgchar): gboolean{.cdecl, dynlib: lib,
importc: "gtk_ctree_node_get_text".} importc: "gtk_ctree_node_get_text".}
proc ctree_node_set_row_style*(ctree: PCTree, node_: PCTreeNode, style: PStyle){. proc ctree_node_set_row_style*(ctree: PCTree, node: PCTreeNode, style: PStyle){.
cdecl, dynlib: lib, importc: "gtk_ctree_node_set_row_style".} cdecl, dynlib: lib, importc: "gtk_ctree_node_set_row_style".}
proc ctree_node_get_row_style*(ctree: PCTree, node_: PCTreeNode): PStyle{.cdecl, proc ctree_node_get_row_style*(ctree: PCTree, node: PCTreeNode): PStyle{.cdecl,
dynlib: lib, importc: "gtk_ctree_node_get_row_style".} dynlib: lib, importc: "gtk_ctree_node_get_row_style".}
proc ctree_node_set_cell_style*(ctree: PCTree, node_: PCTreeNode, column: gint, proc ctree_node_set_cell_style*(ctree: PCTree, node: PCTreeNode, column: gint,
style: PStyle){.cdecl, dynlib: lib, style: PStyle){.cdecl, dynlib: lib,
importc: "gtk_ctree_node_set_cell_style".} importc: "gtk_ctree_node_set_cell_style".}
proc ctree_node_get_cell_style*(ctree: PCTree, node_: PCTreeNode, column: gint): PStyle{. proc ctree_node_get_cell_style*(ctree: PCTree, node: PCTreeNode, column: gint): PStyle{.
cdecl, dynlib: lib, importc: "gtk_ctree_node_get_cell_style".} cdecl, dynlib: lib, importc: "gtk_ctree_node_get_cell_style".}
proc ctree_node_set_foreground*(ctree: PCTree, node_: PCTreeNode, proc ctree_node_set_foreground*(ctree: PCTree, node: PCTreeNode,
color: gdk2.PColor){.cdecl, dynlib: lib, color: gdk2.PColor){.cdecl, dynlib: lib,
importc: "gtk_ctree_node_set_foreground".} importc: "gtk_ctree_node_set_foreground".}
proc ctree_node_set_background*(ctree: PCTree, node_: PCTreeNode, proc ctree_node_set_background*(ctree: PCTree, node: PCTreeNode,
color: gdk2.PColor){.cdecl, dynlib: lib, color: gdk2.PColor){.cdecl, dynlib: lib,
importc: "gtk_ctree_node_set_background".} importc: "gtk_ctree_node_set_background".}
proc ctree_node_set_row_data*(ctree: PCTree, node_: PCTreeNode, data: gpointer){. proc ctree_node_set_row_data*(ctree: PCTree, node: PCTreeNode, data: gpointer){.
cdecl, dynlib: lib, importc: "gtk_ctree_node_set_row_data".} cdecl, dynlib: lib, importc: "gtk_ctree_node_set_row_data".}
proc ctree_node_set_row_data_full*(ctree: PCTree, node_: PCTreeNode, proc ctree_node_set_row_data_full*(ctree: PCTree, node: PCTreeNode,
data: gpointer, destroy: TDestroyNotify){. data: gpointer, destroy: TDestroyNotify){.
cdecl, dynlib: lib, importc: "gtk_ctree_node_set_row_data_full".} cdecl, dynlib: lib, importc: "gtk_ctree_node_set_row_data_full".}
proc ctree_node_get_row_data*(ctree: PCTree, node_: PCTreeNode): gpointer{. proc ctree_node_get_row_data*(ctree: PCTree, node: PCTreeNode): gpointer{.
cdecl, dynlib: lib, importc: "gtk_ctree_node_get_row_data".} cdecl, dynlib: lib, importc: "gtk_ctree_node_get_row_data".}
proc ctree_node_moveto*(ctree: PCTree, node_: PCTreeNode, column: gint, proc ctree_node_moveto*(ctree: PCTree, node: PCTreeNode, column: gint,
row_align: gfloat, col_align: gfloat){.cdecl, row_align: gfloat, col_align: gfloat){.cdecl,
dynlib: lib, importc: "gtk_ctree_node_moveto".} dynlib: lib, importc: "gtk_ctree_node_moveto".}
proc ctree_node_is_visible*(ctree: PCTree, node_: PCTreeNode): TVisibility{. proc ctree_node_is_visible*(ctree: PCTree, node: PCTreeNode): TVisibility{.
cdecl, dynlib: lib, importc: "gtk_ctree_node_is_visible".} cdecl, dynlib: lib, importc: "gtk_ctree_node_is_visible".}
proc ctree_set_indent*(ctree: PCTree, indent: gint){.cdecl, dynlib: lib, proc ctree_set_indent*(ctree: PCTree, indent: gint){.cdecl, dynlib: lib,
importc: "gtk_ctree_set_indent".} importc: "gtk_ctree_set_indent".}
@ -5725,9 +5725,9 @@ proc ctree_set_expander_style*(ctree: PCTree,
dynlib: lib, importc: "gtk_ctree_set_expander_style".} dynlib: lib, importc: "gtk_ctree_set_expander_style".}
proc ctree_set_drag_compare_func*(ctree: PCTree, cmp_func: TCTreeCompareDragFunc){. proc ctree_set_drag_compare_func*(ctree: PCTree, cmp_func: TCTreeCompareDragFunc){.
cdecl, dynlib: lib, importc: "gtk_ctree_set_drag_compare_func".} cdecl, dynlib: lib, importc: "gtk_ctree_set_drag_compare_func".}
proc ctree_sort_node*(ctree: PCTree, node_: PCTreeNode){.cdecl, dynlib: lib, proc ctree_sort_node*(ctree: PCTree, node: PCTreeNode){.cdecl, dynlib: lib,
importc: "gtk_ctree_sort_node".} importc: "gtk_ctree_sort_node".}
proc ctree_sort_recursive*(ctree: PCTree, node_: PCTreeNode){.cdecl, proc ctree_sort_recursive*(ctree: PCTree, node: PCTreeNode){.cdecl,
dynlib: lib, importc: "gtk_ctree_sort_recursive".} dynlib: lib, importc: "gtk_ctree_sort_recursive".}
proc ctree_set_reorderable*(t: pointer, r: bool) proc ctree_set_reorderable*(t: pointer, r: bool)
proc ctree_node_get_type*(): GType{.cdecl, dynlib: lib, proc ctree_node_get_type*(): GType{.cdecl, dynlib: lib,
@ -5999,7 +5999,7 @@ proc set_lower_arrow_prelight*(a: var TMenu, `lower_arrow_prelight`: guint)
proc menu_get_type*(): TType{.cdecl, dynlib: lib, importc: "gtk_menu_get_type".} proc menu_get_type*(): TType{.cdecl, dynlib: lib, importc: "gtk_menu_get_type".}
proc menu_new*(): PMenu{.cdecl, dynlib: lib, importc: "gtk_menu_new".} proc menu_new*(): PMenu{.cdecl, dynlib: lib, importc: "gtk_menu_new".}
proc menu_popup*(menu: PMenu, parent_menu_shell: PWidget, proc menu_popup*(menu: PMenu, parent_menu_shell: PWidget,
parent_menu_item: PWidget, func_: TMenuPositionFunc, parent_menu_item: PWidget, fun: TMenuPositionFunc,
data: gpointer, button: guint, activate_time: guint32){.cdecl, data: gpointer, button: guint, activate_time: guint32){.cdecl,
dynlib: lib, importc: "gtk_menu_popup".} dynlib: lib, importc: "gtk_menu_popup".}
proc menu_reposition*(menu: PMenu){.cdecl, dynlib: lib, proc menu_reposition*(menu: PMenu){.cdecl, dynlib: lib,
@ -7262,7 +7262,7 @@ proc item_factory_popup_data*(ifactory: PItemFactory): gpointer{.cdecl,
proc item_factory_popup_data_from_widget*(widget: PWidget): gpointer{.cdecl, proc item_factory_popup_data_from_widget*(widget: PWidget): gpointer{.cdecl,
dynlib: lib, importc: "gtk_item_factory_popup_data_from_widget".} dynlib: lib, importc: "gtk_item_factory_popup_data_from_widget".}
proc item_factory_set_translate_func*(ifactory: PItemFactory, proc item_factory_set_translate_func*(ifactory: PItemFactory,
func_: TTranslateFunc, data: gpointer, fun: TTranslateFunc, data: gpointer,
notify: TDestroyNotify){.cdecl, notify: TDestroyNotify){.cdecl,
dynlib: lib, importc: "gtk_item_factory_set_translate_func".} dynlib: lib, importc: "gtk_item_factory_set_translate_func".}
proc TYPE_LAYOUT*(): GType proc TYPE_LAYOUT*(): GType
@ -7476,7 +7476,7 @@ proc tree_model_ref_node*(tree_model: PTreeModel, iter: PTreeIter){.cdecl,
dynlib: lib, importc: "gtk_tree_model_ref_node".} dynlib: lib, importc: "gtk_tree_model_ref_node".}
proc tree_model_unref_node*(tree_model: PTreeModel, iter: PTreeIter){.cdecl, proc tree_model_unref_node*(tree_model: PTreeModel, iter: PTreeIter){.cdecl,
dynlib: lib, importc: "gtk_tree_model_unref_node".} dynlib: lib, importc: "gtk_tree_model_unref_node".}
proc tree_model_foreach*(model: PTreeModel, func_: TTreeModelForeachFunc, proc tree_model_foreach*(model: PTreeModel, fun: TTreeModelForeachFunc,
user_data: gpointer){.cdecl, dynlib: lib, user_data: gpointer){.cdecl, dynlib: lib,
importc: "gtk_tree_model_foreach".} importc: "gtk_tree_model_foreach".}
proc tree_model_row_changed*(tree_model: PTreeModel, path: PTreePath, proc tree_model_row_changed*(tree_model: PTreeModel, path: PTreePath,
@ -9049,7 +9049,7 @@ proc text_tag_table_remove*(table: PTextTagTable, tag: PTextTag){.cdecl,
dynlib: lib, importc: "gtk_text_tag_table_remove".} dynlib: lib, importc: "gtk_text_tag_table_remove".}
proc text_tag_table_lookup*(table: PTextTagTable, name: cstring): PTextTag{. proc text_tag_table_lookup*(table: PTextTagTable, name: cstring): PTextTag{.
cdecl, dynlib: lib, importc: "gtk_text_tag_table_lookup".} cdecl, dynlib: lib, importc: "gtk_text_tag_table_lookup".}
proc text_tag_table_foreach*(table: PTextTagTable, func_: TTextTagTableForeach, proc text_tag_table_foreach*(table: PTextTagTable, fun: TTextTagTableForeach,
data: gpointer){.cdecl, dynlib: lib, data: gpointer){.cdecl, dynlib: lib,
importc: "gtk_text_tag_table_foreach".} importc: "gtk_text_tag_table_foreach".}
proc text_tag_table_get_size*(table: PTextTagTable): gint{.cdecl, dynlib: lib, proc text_tag_table_get_size*(table: PTextTagTable): gint{.cdecl, dynlib: lib,
@ -9336,7 +9336,7 @@ proc text_btree_spew*(tree: PTextBTree){.cdecl, dynlib: lib,
importc: "_gtk_text_btree_spew".} importc: "_gtk_text_btree_spew".}
proc toggle_segment_check_func*(segPtr: PTextLineSegment, line: PTextLine){. proc toggle_segment_check_func*(segPtr: PTextLineSegment, line: PTextLine){.
cdecl, dynlib: lib, importc: "_gtk_toggle_segment_check_func".} cdecl, dynlib: lib, importc: "_gtk_toggle_segment_check_func".}
proc change_node_toggle_count*(node_: PTextBTreeNode, info: PTextTagInfo, proc change_node_toggle_count*(node: PTextBTreeNode, info: PTextTagInfo,
delta: gint){.cdecl, dynlib: lib, delta: gint){.cdecl, dynlib: lib,
importc: "_gtk_change_node_toggle_count".} importc: "_gtk_change_node_toggle_count".}
proc text_btree_release_mark_segment*(tree: PTextBTree, proc text_btree_release_mark_segment*(tree: PTextBTree,
@ -10115,7 +10115,7 @@ proc tree_selection_set_mode*(selection: PTreeSelection, thetype: TSelectionMode
proc tree_selection_get_mode*(selection: PTreeSelection): TSelectionMode{.cdecl, proc tree_selection_get_mode*(selection: PTreeSelection): TSelectionMode{.cdecl,
dynlib: lib, importc: "gtk_tree_selection_get_mode".} dynlib: lib, importc: "gtk_tree_selection_get_mode".}
proc tree_selection_set_select_function*(selection: PTreeSelection, proc tree_selection_set_select_function*(selection: PTreeSelection,
func_: TTreeSelectionFunc, data: gpointer, destroy: TDestroyNotify){.cdecl, fun: TTreeSelectionFunc, data: gpointer, destroy: TDestroyNotify){.cdecl,
dynlib: lib, importc: "gtk_tree_selection_set_select_function".} dynlib: lib, importc: "gtk_tree_selection_set_select_function".}
proc tree_selection_get_user_data*(selection: PTreeSelection): gpointer{.cdecl, proc tree_selection_get_user_data*(selection: PTreeSelection): gpointer{.cdecl,
dynlib: lib, importc: "gtk_tree_selection_get_user_data".} dynlib: lib, importc: "gtk_tree_selection_get_user_data".}
@ -10128,7 +10128,7 @@ proc tree_selection_get_selected_rows*(selection: PTreeSelection,
model: PPGtkTreeModel): PGList{.cdecl, model: PPGtkTreeModel): PGList{.cdecl,
dynlib: lib, importc: "gtk_tree_selection_get_selected_rows".} dynlib: lib, importc: "gtk_tree_selection_get_selected_rows".}
proc tree_selection_selected_foreach*(selection: PTreeSelection, proc tree_selection_selected_foreach*(selection: PTreeSelection,
func_: TTreeSelectionForeachFunc, fun: TTreeSelectionForeachFunc,
data: gpointer){.cdecl, dynlib: lib, data: gpointer){.cdecl, dynlib: lib,
importc: "gtk_tree_selection_selected_foreach".} importc: "gtk_tree_selection_selected_foreach".}
proc tree_selection_select_path*(selection: PTreeSelection, path: PTreePath){. proc tree_selection_select_path*(selection: PTreeSelection, path: PTreePath){.
@ -10256,7 +10256,7 @@ proc tree_view_column_add_attribute*(tree_column: PTreeViewColumn,
attribute: cstring, column: gint){.cdecl, attribute: cstring, column: gint){.cdecl,
dynlib: lib, importc: "gtk_tree_view_column_add_attribute".} dynlib: lib, importc: "gtk_tree_view_column_add_attribute".}
proc tree_view_column_set_cell_data_func*(tree_column: PTreeViewColumn, proc tree_view_column_set_cell_data_func*(tree_column: PTreeViewColumn,
cell_renderer: PCellRenderer, func_: TTreeCellDataFunc, func_data: gpointer, cell_renderer: PCellRenderer, fun: TTreeCellDataFunc, func_data: gpointer,
destroy: TDestroyNotify){.cdecl, dynlib: lib, importc: "gtk_tree_view_column_set_cell_data_func".} destroy: TDestroyNotify){.cdecl, dynlib: lib, importc: "gtk_tree_view_column_set_cell_data_func".}
proc tree_view_column_clear_attributes*(tree_column: PTreeViewColumn, proc tree_view_column_clear_attributes*(tree_column: PTreeViewColumn,
cell_renderer: PCellRenderer){.cdecl, cell_renderer: PCellRenderer){.cdecl,
@ -10380,12 +10380,12 @@ proc flags*(a: PRBNode): guint
proc set_flags*(a: PRBNode, `flags`: guint) proc set_flags*(a: PRBNode, `flags`: guint)
proc parity*(a: PRBNode): guint proc parity*(a: PRBNode): guint
proc set_parity*(a: PRBNode, `parity`: guint) proc set_parity*(a: PRBNode, `parity`: guint)
proc RBNODE_GET_COLOR*(node_: PRBNode): guint proc RBNODE_GET_COLOR*(node: PRBNode): guint
proc RBNODE_SET_COLOR*(node_: PRBNode, color: guint) proc RBNODE_SET_COLOR*(node: PRBNode, color: guint)
proc RBNODE_GET_HEIGHT*(node_: PRBNode): gint proc RBNODE_GET_HEIGHT*(node: PRBNode): gint
proc RBNODE_SET_FLAG*(node_: PRBNode, flag: guint16) proc RBNODE_SET_FLAG*(node: PRBNode, flag: guint16)
proc RBNODE_UNSET_FLAG*(node_: PRBNode, flag: guint16) proc RBNODE_UNSET_FLAG*(node: PRBNode, flag: guint16)
proc RBNODE_FLAG_SET*(node_: PRBNode, flag: guint): bool proc RBNODE_FLAG_SET*(node: PRBNode, flag: guint): bool
proc rbtree_push_allocator*(allocator: PGAllocator){.cdecl, dynlib: lib, proc rbtree_push_allocator*(allocator: PGAllocator){.cdecl, dynlib: lib,
importc: "_gtk_rbtree_push_allocator".} importc: "_gtk_rbtree_push_allocator".}
proc rbtree_pop_allocator*(){.cdecl, dynlib: lib, proc rbtree_pop_allocator*(){.cdecl, dynlib: lib,
@ -10397,23 +10397,23 @@ proc rbtree_remove*(tree: PRBTree){.cdecl, dynlib: lib,
importc: "_gtk_rbtree_remove".} importc: "_gtk_rbtree_remove".}
proc rbtree_destroy*(tree: PRBTree){.cdecl, dynlib: lib, proc rbtree_destroy*(tree: PRBTree){.cdecl, dynlib: lib,
importc: "_gtk_rbtree_destroy".} importc: "_gtk_rbtree_destroy".}
proc rbtree_insert_before*(tree: PRBTree, node_: PRBNode, height: gint, proc rbtree_insert_before*(tree: PRBTree, node: PRBNode, height: gint,
valid: gboolean): PRBNode{.cdecl, dynlib: lib, valid: gboolean): PRBNode{.cdecl, dynlib: lib,
importc: "_gtk_rbtree_insert_before".} importc: "_gtk_rbtree_insert_before".}
proc rbtree_insert_after*(tree: PRBTree, node_: PRBNode, height: gint, proc rbtree_insert_after*(tree: PRBTree, node: PRBNode, height: gint,
valid: gboolean): PRBNode{.cdecl, dynlib: lib, valid: gboolean): PRBNode{.cdecl, dynlib: lib,
importc: "_gtk_rbtree_insert_after".} importc: "_gtk_rbtree_insert_after".}
proc rbtree_remove_node*(tree: PRBTree, node_: PRBNode){.cdecl, dynlib: lib, proc rbtree_remove_node*(tree: PRBTree, node: PRBNode){.cdecl, dynlib: lib,
importc: "_gtk_rbtree_remove_node".} importc: "_gtk_rbtree_remove_node".}
proc rbtree_reorder*(tree: PRBTree, new_order: Pgint, length: gint){.cdecl, proc rbtree_reorder*(tree: PRBTree, new_order: Pgint, length: gint){.cdecl,
dynlib: lib, importc: "_gtk_rbtree_reorder".} dynlib: lib, importc: "_gtk_rbtree_reorder".}
proc rbtree_find_count*(tree: PRBTree, count: gint): PRBNode{.cdecl, proc rbtree_find_count*(tree: PRBTree, count: gint): PRBNode{.cdecl,
dynlib: lib, importc: "_gtk_rbtree_find_count".} dynlib: lib, importc: "_gtk_rbtree_find_count".}
proc rbtree_node_set_height*(tree: PRBTree, node_: PRBNode, height: gint){. proc rbtree_node_set_height*(tree: PRBTree, node: PRBNode, height: gint){.
cdecl, dynlib: lib, importc: "_gtk_rbtree_node_set_height".} cdecl, dynlib: lib, importc: "_gtk_rbtree_node_set_height".}
proc rbtree_node_mark_invalid*(tree: PRBTree, node_: PRBNode){.cdecl, proc rbtree_node_mark_invalid*(tree: PRBTree, node: PRBNode){.cdecl,
dynlib: lib, importc: "_gtk_rbtree_node_mark_invalid".} dynlib: lib, importc: "_gtk_rbtree_node_mark_invalid".}
proc rbtree_node_mark_valid*(tree: PRBTree, node_: PRBNode){.cdecl, dynlib: lib, proc rbtree_node_mark_valid*(tree: PRBTree, node: PRBNode){.cdecl, dynlib: lib,
importc: "_gtk_rbtree_node_mark_valid".} importc: "_gtk_rbtree_node_mark_valid".}
proc rbtree_column_invalid*(tree: PRBTree){.cdecl, dynlib: lib, proc rbtree_column_invalid*(tree: PRBTree){.cdecl, dynlib: lib,
importc: "_gtk_rbtree_column_invalid".} importc: "_gtk_rbtree_column_invalid".}
@ -10421,16 +10421,16 @@ proc rbtree_mark_invalid*(tree: PRBTree){.cdecl, dynlib: lib,
importc: "_gtk_rbtree_mark_invalid".} importc: "_gtk_rbtree_mark_invalid".}
proc rbtree_set_fixed_height*(tree: PRBTree, height: gint){.cdecl, dynlib: lib, proc rbtree_set_fixed_height*(tree: PRBTree, height: gint){.cdecl, dynlib: lib,
importc: "_gtk_rbtree_set_fixed_height".} importc: "_gtk_rbtree_set_fixed_height".}
proc rbtree_node_find_offset*(tree: PRBTree, node_: PRBNode): gint{.cdecl, proc rbtree_node_find_offset*(tree: PRBTree, node: PRBNode): gint{.cdecl,
dynlib: lib, importc: "_gtk_rbtree_node_find_offset".} dynlib: lib, importc: "_gtk_rbtree_node_find_offset".}
proc rbtree_node_find_parity*(tree: PRBTree, node_: PRBNode): gint{.cdecl, proc rbtree_node_find_parity*(tree: PRBTree, node: PRBNode): gint{.cdecl,
dynlib: lib, importc: "_gtk_rbtree_node_find_parity".} dynlib: lib, importc: "_gtk_rbtree_node_find_parity".}
proc rbtree_traverse*(tree: PRBTree, node_: PRBNode, order: TGTraverseType, proc rbtree_traverse*(tree: PRBTree, node: PRBNode, order: TGTraverseType,
func_: TRBTreeTraverseFunc, data: gpointer){.cdecl, fun: TRBTreeTraverseFunc, data: gpointer){.cdecl,
dynlib: lib, importc: "_gtk_rbtree_traverse".} dynlib: lib, importc: "_gtk_rbtree_traverse".}
proc rbtree_next*(tree: PRBTree, node_: PRBNode): PRBNode{.cdecl, dynlib: lib, proc rbtree_next*(tree: PRBTree, node: PRBNode): PRBNode{.cdecl, dynlib: lib,
importc: "_gtk_rbtree_next".} importc: "_gtk_rbtree_next".}
proc rbtree_prev*(tree: PRBTree, node_: PRBNode): PRBNode{.cdecl, dynlib: lib, proc rbtree_prev*(tree: PRBTree, node: PRBNode): PRBNode{.cdecl, dynlib: lib,
importc: "_gtk_rbtree_prev".} importc: "_gtk_rbtree_prev".}
proc rbtree_get_depth*(tree: PRBTree): gint{.cdecl, dynlib: lib, proc rbtree_get_depth*(tree: PRBTree): gint{.cdecl, dynlib: lib,
importc: "_gtk_rbtree_get_depth".} importc: "_gtk_rbtree_get_depth".}
@ -10500,18 +10500,18 @@ proc set_enable_search*(a: var TTreeViewPrivate, `enable_search`: guint)
proc disable_popdown*(a: var TTreeViewPrivate): guint proc disable_popdown*(a: var TTreeViewPrivate): guint
proc set_disable_popdown*(a: var TTreeViewPrivate, `disable_popdown`: guint) proc set_disable_popdown*(a: var TTreeViewPrivate, `disable_popdown`: guint)
proc tree_selection_internal_select_node*(selection: PTreeSelection, proc tree_selection_internal_select_node*(selection: PTreeSelection,
node_: PRBNode, tree: PRBTree, path: PTreePath, state: gdk2.TModifierType, node: PRBNode, tree: PRBTree, path: PTreePath, state: gdk2.TModifierType,
override_browse_mode: gboolean){.cdecl, dynlib: lib, importc: "_gtk_tree_selection_internal_select_node".} override_browse_mode: gboolean){.cdecl, dynlib: lib, importc: "_gtk_tree_selection_internal_select_node".}
proc tree_view_find_node*(tree_view: PTreeView, path: PTreePath, proc tree_view_find_node*(tree_view: PTreeView, path: PTreePath,
tree: var PRBTree, node_: var PRBNode): gboolean{. tree: var PRBTree, node: var PRBNode): gboolean{.
cdecl, dynlib: lib, importc: "_gtk_tree_view_find_node".} cdecl, dynlib: lib, importc: "_gtk_tree_view_find_node".}
proc tree_view_find_path*(tree_view: PTreeView, tree: PRBTree, node_: PRBNode): PTreePath{. proc tree_view_find_path*(tree_view: PTreeView, tree: PRBTree, node: PRBNode): PTreePath{.
cdecl, dynlib: lib, importc: "_gtk_tree_view_find_path".} cdecl, dynlib: lib, importc: "_gtk_tree_view_find_path".}
proc tree_view_child_move_resize*(tree_view: PTreeView, widget: PWidget, proc tree_view_child_move_resize*(tree_view: PTreeView, widget: PWidget,
x: gint, y: gint, width: gint, height: gint){. x: gint, y: gint, width: gint, height: gint){.
cdecl, dynlib: lib, importc: "_gtk_tree_view_child_move_resize".} cdecl, dynlib: lib, importc: "_gtk_tree_view_child_move_resize".}
proc tree_view_queue_draw_node*(tree_view: PTreeView, tree: PRBTree, proc tree_view_queue_draw_node*(tree_view: PTreeView, tree: PRBTree,
node_: PRBNode, clip_rect: gdk2.PRectangle){. node: PRBNode, clip_rect: gdk2.PRectangle){.
cdecl, dynlib: lib, importc: "_gtk_tree_view_queue_draw_node".} cdecl, dynlib: lib, importc: "_gtk_tree_view_queue_draw_node".}
proc tree_view_column_realize_button*(column: PTreeViewColumn){.cdecl, proc tree_view_column_realize_button*(column: PTreeViewColumn){.cdecl,
dynlib: lib, importc: "_gtk_tree_view_column_realize_button".} dynlib: lib, importc: "_gtk_tree_view_column_realize_button".}
@ -10620,7 +10620,7 @@ proc tree_view_insert_column*(tree_view: PTreeView, column: PTreeViewColumn,
importc: "gtk_tree_view_insert_column".} importc: "gtk_tree_view_insert_column".}
proc tree_view_insert_column_with_data_func*(tree_view: PTreeView, proc tree_view_insert_column_with_data_func*(tree_view: PTreeView,
position: gint, title: cstring, cell: PCellRenderer, position: gint, title: cstring, cell: PCellRenderer,
func_: TTreeCellDataFunc, data: gpointer, dnotify: TGDestroyNotify): gint{. fun: TTreeCellDataFunc, data: gpointer, dnotify: TGDestroyNotify): gint{.
cdecl, dynlib: lib, importc: "gtk_tree_view_insert_column_with_data_func".} cdecl, dynlib: lib, importc: "gtk_tree_view_insert_column_with_data_func".}
proc tree_view_get_column*(tree_view: PTreeView, n: gint): PTreeViewColumn{. proc tree_view_get_column*(tree_view: PTreeView, n: gint): PTreeViewColumn{.
cdecl, dynlib: lib, importc: "gtk_tree_view_get_column".} cdecl, dynlib: lib, importc: "gtk_tree_view_get_column".}
@ -10635,7 +10635,7 @@ proc tree_view_set_expander_column*(tree_view: PTreeView,
proc tree_view_get_expander_column*(tree_view: PTreeView): PTreeViewColumn{. proc tree_view_get_expander_column*(tree_view: PTreeView): PTreeViewColumn{.
cdecl, dynlib: lib, importc: "gtk_tree_view_get_expander_column".} cdecl, dynlib: lib, importc: "gtk_tree_view_get_expander_column".}
proc tree_view_set_column_drag_function*(tree_view: PTreeView, proc tree_view_set_column_drag_function*(tree_view: PTreeView,
func_: TTreeViewColumnDropFunc, user_data: gpointer, destroy: TDestroyNotify){. fun: TTreeViewColumnDropFunc, user_data: gpointer, destroy: TDestroyNotify){.
cdecl, dynlib: lib, importc: "gtk_tree_view_set_column_drag_function".} cdecl, dynlib: lib, importc: "gtk_tree_view_set_column_drag_function".}
proc tree_view_scroll_to_point*(tree_view: PTreeView, tree_x: gint, tree_y: gint){. proc tree_view_scroll_to_point*(tree_view: PTreeView, tree_x: gint, tree_y: gint){.
cdecl, dynlib: lib, importc: "gtk_tree_view_scroll_to_point".} cdecl, dynlib: lib, importc: "gtk_tree_view_scroll_to_point".}
@ -10656,7 +10656,7 @@ proc tree_view_expand_row*(tree_view: PTreeView, path: PTreePath,
proc tree_view_collapse_row*(tree_view: PTreeView, path: PTreePath): gboolean{. proc tree_view_collapse_row*(tree_view: PTreeView, path: PTreePath): gboolean{.
cdecl, dynlib: lib, importc: "gtk_tree_view_collapse_row".} cdecl, dynlib: lib, importc: "gtk_tree_view_collapse_row".}
proc tree_view_map_expanded_rows*(tree_view: PTreeView, proc tree_view_map_expanded_rows*(tree_view: PTreeView,
func_: TTreeViewMappingFunc, data: gpointer){. fun: TTreeViewMappingFunc, data: gpointer){.
cdecl, dynlib: lib, importc: "gtk_tree_view_map_expanded_rows".} cdecl, dynlib: lib, importc: "gtk_tree_view_map_expanded_rows".}
proc tree_view_row_expanded*(tree_view: PTreeView, path: PTreePath): gboolean{. proc tree_view_row_expanded*(tree_view: PTreeView, path: PTreePath): gboolean{.
cdecl, dynlib: lib, importc: "gtk_tree_view_row_expanded".} cdecl, dynlib: lib, importc: "gtk_tree_view_row_expanded".}
@ -10722,7 +10722,7 @@ proc tree_view_set_search_equal_func*(tree_view: PTreeView, search_equal_func: T
search_destroy: TDestroyNotify){.cdecl, search_destroy: TDestroyNotify){.cdecl,
dynlib: lib, importc: "gtk_tree_view_set_search_equal_func".} dynlib: lib, importc: "gtk_tree_view_set_search_equal_func".}
proc tree_view_set_destroy_count_func*(tree_view: PTreeView, proc tree_view_set_destroy_count_func*(tree_view: PTreeView,
func_: TTreeDestroyCountFunc, fun: TTreeDestroyCountFunc,
data: gpointer, destroy: TDestroyNotify){. data: gpointer, destroy: TDestroyNotify){.
cdecl, dynlib: lib, importc: "gtk_tree_view_set_destroy_count_func".} cdecl, dynlib: lib, importc: "gtk_tree_view_set_destroy_count_func".}
proc TYPE_VBUTTON_BOX*(): GType proc TYPE_VBUTTON_BOX*(): GType
@ -12423,8 +12423,8 @@ proc CLIST_DRAW_DRAG_LINE_get*(clist: pointer): bool =
proc CLIST_DRAW_DRAG_RECT_get*(clist: pointer): bool = proc CLIST_DRAW_DRAG_RECT_get*(clist: pointer): bool =
result = ((CLIST_FLAGS(clist)) and cint(CLIST_DRAW_DRAG_RECT)) != 0'i32 result = ((CLIST_FLAGS(clist)) and cint(CLIST_DRAW_DRAG_RECT)) != 0'i32
proc CLIST_ROW_get*(`glist_`: PGList): PCListRow = proc CLIST_ROW_get*(glist: PGList): PCListRow =
result = cast[PCListRow](`glist_`.data) result = cast[PCListRow](glist.data)
when false: when false:
proc CELL_TEXT_get*(cell: pointer): PCellText = proc CELL_TEXT_get*(cell: pointer): PCellText =
@ -12683,20 +12683,20 @@ proc IS_CTREE_CLASS*(klass: pointer): bool =
proc CTREE_GET_CLASS*(obj: pointer): PCTreeClass = proc CTREE_GET_CLASS*(obj: pointer): PCTreeClass =
result = cast[PCTreeClass](CHECK_GET_CLASS(obj, TYPE_CTREE())) result = cast[PCTreeClass](CHECK_GET_CLASS(obj, TYPE_CTREE()))
proc CTREE_ROW*(`node_`: TAddress): PCTreeRow = proc CTREE_ROW*(node: TAddress): PCTreeRow =
result = cast[PCTreeRow]((cast[PGList](`node_`)).data) result = cast[PCTreeRow]((cast[PGList](node)).data)
proc CTREE_NODE*(`node_`: TAddress): PCTreeNode = proc CTREE_NODE*(node: TAddress): PCTreeNode =
result = cast[PCTreeNode](`node_`) result = cast[PCTreeNode](node)
proc CTREE_NODE_NEXT*(`nnode_`: TAddress): PCTreeNode = proc CTREE_NODE_NEXT*(nnode: TAddress): PCTreeNode =
result = cast[PCTreeNode]((cast[PGList](`nnode_`)).next) result = cast[PCTreeNode]((cast[PGList](nnode)).next)
proc CTREE_NODE_PREV*(`pnode_`: TAddress): PCTreeNode = proc CTREE_NODE_PREV*(pnode: TAddress): PCTreeNode =
result = cast[PCTreeNode]((cast[PGList](`pnode_`)).prev) result = cast[PCTreeNode]((cast[PGList](pnode)).prev)
proc CTREE_FUNC*(`func_`: TAddress): TCTreeFunc = proc CTREE_FUNC*(fun: TAddress): TCTreeFunc =
result = cast[TCTreeFunc](`func_`) result = cast[TCTreeFunc](fun)
proc TYPE_CTREE_NODE*(): GType = proc TYPE_CTREE_NODE*(): GType =
result = ctree_node_get_type() result = ctree_node_get_type()
@ -14679,29 +14679,29 @@ proc signal_name*(signal_id: guint): cstring =
proc signal_emit_stop*(instance: gpointer, signal_id: guint, detail: TGQuark) = proc signal_emit_stop*(instance: gpointer, signal_id: guint, detail: TGQuark) =
if detail != 0'i32: g_signal_stop_emission(instance, signal_id, 0) if detail != 0'i32: g_signal_stop_emission(instance, signal_id, 0)
proc signal_connect_full*(anObject: PObject, name: cstring, func_: TSignalFunc, proc signal_connect_full*(anObject: PObject, name: cstring, fun: TSignalFunc,
unknown1: pointer, func_data: gpointer, unknown1: pointer, func_data: gpointer,
unknown2: pointer, unknown3, unknown4: int): gulong{. unknown2: pointer, unknown3, unknown4: int): gulong{.
importc: "gtk_signal_connect_full", cdecl, dynlib: lib.} importc: "gtk_signal_connect_full", cdecl, dynlib: lib.}
proc signal_compat_matched*(anObject: PObject, func_: TSignalFunc, proc signal_compat_matched*(anObject: PObject, fun: TSignalFunc,
data: gpointer, m: TGSignalMatchType, u: int){. data: gpointer, m: TGSignalMatchType, u: int){.
importc: "gtk_signal_compat_matched", cdecl, dynlib: lib.} importc: "gtk_signal_compat_matched", cdecl, dynlib: lib.}
proc signal_connect*(anObject: PObject, name: cstring, func_: TSignalFunc, proc signal_connect*(anObject: PObject, name: cstring, fun: TSignalFunc,
func_data: gpointer): gulong = func_data: gpointer): gulong =
result = signal_connect_full(anObject, name, func_, nil, func_data, nil, 0, 0) result = signal_connect_full(anObject, name, fun, nil, func_data, nil, 0, 0)
proc signal_connect_after*(anObject: PObject, name: cstring, func_: TSignalFunc, proc signal_connect_after*(anObject: PObject, name: cstring, fun: TSignalFunc,
func_data: gpointer): gulong = func_data: gpointer): gulong =
result = signal_connect_full(anObject, name, func_, nil, func_data, nil, 0, 1) result = signal_connect_full(anObject, name, fun, nil, func_data, nil, 0, 1)
proc signal_connect_object*(anObject: PObject, name: cstring, proc signal_connect_object*(anObject: PObject, name: cstring,
func_: TSignalFunc, slot_object: gpointer): gulong = fun: TSignalFunc, slot_object: gpointer): gulong =
result = signal_connect_full(anObject, name, func_, nil, slot_object, nil, 1, result = signal_connect_full(anObject, name, fun, nil, slot_object, nil, 1,
0) 0)
proc signal_connect_object_after*(anObject: PObject, name: cstring, proc signal_connect_object_after*(anObject: PObject, name: cstring,
func_: TSignalFunc, slot_object: gpointer): gulong = fun: TSignalFunc, slot_object: gpointer): gulong =
result = signal_connect_full(anObject, name, func_, nil, slot_object, nil, 1, result = signal_connect_full(anObject, name, fun, nil, slot_object, nil, 1,
1) 1)
proc signal_disconnect*(anObject: gpointer, handler_id: gulong) = proc signal_disconnect*(anObject: gpointer, handler_id: gulong) =
@ -14716,22 +14716,22 @@ proc signal_handler_unblock*(anObject: gpointer, handler_id: gulong) =
proc signal_disconnect_by_data*(anObject: PObject, data: gpointer) = proc signal_disconnect_by_data*(anObject: PObject, data: gpointer) =
signal_compat_matched(anObject, nil, data, G_SIGNAL_MATCH_DATA, 0) signal_compat_matched(anObject, nil, data, G_SIGNAL_MATCH_DATA, 0)
proc signal_disconnect_by_func*(anObject: PObject, func_: TSignalFunc, proc signal_disconnect_by_func*(anObject: PObject, fun: TSignalFunc,
data: gpointer) = data: gpointer) =
signal_compat_matched(anObject, func_, data, cast[TGSignalMatchType](G_SIGNAL_MATCH_FUNC or signal_compat_matched(anObject, fun, data, cast[TGSignalMatchType](G_SIGNAL_MATCH_FUNC or
G_SIGNAL_MATCH_DATA), 0) G_SIGNAL_MATCH_DATA), 0)
proc signal_handler_block_by_func*(anObject: PObject, func_: TSignalFunc, proc signal_handler_block_by_func*(anObject: PObject, fun: TSignalFunc,
data: gpointer) = data: gpointer) =
signal_compat_matched(anObject, func_, data, TGSignalMatchType( signal_compat_matched(anObject, fun, data, TGSignalMatchType(
G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0) G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0)
proc signal_handler_block_by_data*(anObject: PObject, data: gpointer) = proc signal_handler_block_by_data*(anObject: PObject, data: gpointer) =
signal_compat_matched(anObject, nil, data, G_SIGNAL_MATCH_DATA, 1) signal_compat_matched(anObject, nil, data, G_SIGNAL_MATCH_DATA, 1)
proc signal_handler_unblock_by_func*(anObject: PObject, func_: TSignalFunc, proc signal_handler_unblock_by_func*(anObject: PObject, fun: TSignalFunc,
data: gpointer) = data: gpointer) =
signal_compat_matched(anObject, func_, data, cast[TGSignalMatchType](G_SIGNAL_MATCH_FUNC or signal_compat_matched(anObject, fun, data, cast[TGSignalMatchType](G_SIGNAL_MATCH_FUNC or
G_SIGNAL_MATCH_DATA), 0) G_SIGNAL_MATCH_DATA), 0)
proc signal_handler_unblock_by_data*(anObject: PObject, data: gpointer) = proc signal_handler_unblock_by_data*(anObject: PObject, data: gpointer) =
@ -14743,13 +14743,13 @@ proc signal_handler_pending*(anObject: PObject, signal_id: guint,
proc signal_handler_pending_by_func*(anObject: PObject, signal_id: guint, proc signal_handler_pending_by_func*(anObject: PObject, signal_id: guint,
may_be_blocked: gboolean, may_be_blocked: gboolean,
func_: TSignalFunc, data: gpointer): gboolean = fun: TSignalFunc, data: gpointer): gboolean =
var t: TGSignalMatchType var t: TGSignalMatchType
t = cast[TGSignalMatchType](G_SIGNAL_MATCH_ID or G_SIGNAL_MATCH_FUNC or t = cast[TGSignalMatchType](G_SIGNAL_MATCH_ID or G_SIGNAL_MATCH_FUNC or
G_SIGNAL_MATCH_DATA) G_SIGNAL_MATCH_DATA)
if not may_be_blocked: if not may_be_blocked:
t = t or cast[TGSignalMatchType](G_SIGNAL_MATCH_UNBLOCKED) t = t or cast[TGSignalMatchType](G_SIGNAL_MATCH_UNBLOCKED)
Result = g_signal_handler_find(anObject, t, signal_id, 0, nil, func_, data) != Result = g_signal_handler_find(anObject, t, signal_id, 0, nil, fun, data) !=
0 0
proc TYPE_SIZE_GROUP*(): GType = proc TYPE_SIZE_GROUP*(): GType =
@ -16221,37 +16221,37 @@ proc set_parity*(a: PRBNode, `parity`: guint) =
a.flag0 = a.flag0 or a.flag0 = a.flag0 or
(int16(`parity` shl bp_TGtkRBNode_parity) and bm_TGtkRBNode_parity) (int16(`parity` shl bp_TGtkRBNode_parity) and bm_TGtkRBNode_parity)
proc RBNODE_GET_COLOR*(node_: PRBNode): guint = proc RBNODE_GET_COLOR*(node: PRBNode): guint =
if node_ == nil: if node == nil:
Result = RBNODE_BLACK Result = RBNODE_BLACK
elif (int(flags(node_)) and RBNODE_RED) == RBNODE_RED: elif (int(flags(node)) and RBNODE_RED) == RBNODE_RED:
Result = RBNODE_RED Result = RBNODE_RED
else: else:
Result = RBNODE_BLACK Result = RBNODE_BLACK
proc RBNODE_SET_COLOR*(node_: PRBNode, color: guint) = proc RBNODE_SET_COLOR*(node: PRBNode, color: guint) =
if node_ == nil: if node == nil:
return return
if ((flags(node_) and (color)) != color): if ((flags(node) and (color)) != color):
set_flags(node_, flags(node_) xor cint(RBNODE_RED or RBNODE_BLACK)) set_flags(node, flags(node) xor cint(RBNODE_RED or RBNODE_BLACK))
proc RBNODE_GET_HEIGHT*(node_: PRBNode): gint = proc RBNODE_GET_HEIGHT*(node: PRBNode): gint =
var if_local1: gint var if_local1: gint
if node_.children != nil: if node.children != nil:
if_local1 = node_.children.root.offset if_local1 = node.children.root.offset
else: else:
if_local1 = 0 if_local1 = 0
result = node_.offset - result = node.offset -
((node_.left.offset) + node_.right.offset + if_local1) ((node.left.offset) + node.right.offset + if_local1)
proc RBNODE_FLAG_SET*(node_: PRBNode, flag: guint): bool = proc RBNODE_FLAG_SET*(node: PRBNode, flag: guint): bool =
result = (node_ != nil) and ((flags(node_) and (flag)) == flag) result = (node != nil) and ((flags(node) and (flag)) == flag)
proc RBNODE_SET_FLAG*(node_: PRBNode, flag: guint16) = proc RBNODE_SET_FLAG*(node: PRBNode, flag: guint16) =
set_flags(node_, (flag) or flags(node_)) set_flags(node, (flag) or flags(node))
proc RBNODE_UNSET_FLAG*(node_: PRBNode, flag: guint16) = proc RBNODE_UNSET_FLAG*(node: PRBNode, flag: guint16) =
set_flags(node_, (not (flag)) and flags(node_)) set_flags(node, (not (flag)) and flags(node))
proc TREE_VIEW_FLAG_SET*(tree_view: PTreeView, flag: guint): bool = proc TREE_VIEW_FLAG_SET*(tree_view: PTreeView, flag: guint): bool =
result = ((tree_view.priv.flags) and (flag)) == flag result = ((tree_view.priv.flags) and (flag)) == flag

72
lib/newwrap/lua/lauxlib.nim
View file

@ -38,28 +38,28 @@ type
Preg* = ptr Treg Preg* = ptr Treg
proc openlib*(L: PState, libname: cstring, lr: Preg, nup: int){.cdecl, proc openlib*(L: PState, libname: cstring, lr: Preg, nup: int){.cdecl,
dynlib: LIB_NAME, importc: "luaL_openlib".} dynlib: lua.LIB_NAME, importc: "luaL_openlib".}
proc register*(L: PState, libname: cstring, lr: Preg){.cdecl, proc register*(L: PState, libname: cstring, lr: Preg){.cdecl,
dynlib: LIB_NAME, importc: "luaL_register".} dynlib: lua.LIB_NAME, importc: "luaL_register".}
proc getmetafield*(L: PState, obj: int, e: cstring): int{.cdecl, proc getmetafield*(L: PState, obj: int, e: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_getmetafield".} dynlib: lua.LIB_NAME, importc: "luaL_getmetafield".}
proc callmeta*(L: PState, obj: int, e: cstring): int{.cdecl, proc callmeta*(L: PState, obj: int, e: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_callmeta".} dynlib: LIB_NAME, importc: "luaL_callmeta".}
proc typerror*(L: PState, narg: int, tname: cstring): int{.cdecl, proc typerror*(L: PState, narg: int, tname: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_typerror".} dynlib: LIB_NAME, importc: "luaL_typerror".}
proc argerror*(L: PState, numarg: int, extramsg: cstring): int{.cdecl, proc argerror*(L: PState, numarg: int, extramsg: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_argerror".} dynlib: LIB_NAME, importc: "luaL_argerror".}
proc checklstring*(L: PState, numArg: int, l_: Psize_t): cstring{.cdecl, proc checklstring*(L: PState, numArg: int, len: ptr int): cstring{.cdecl,
dynlib: LIB_NAME, importc: "luaL_checklstring".} dynlib: LIB_NAME, importc: "luaL_checklstring".}
proc optlstring*(L: PState, numArg: int, def: cstring, l_: Psize_t): cstring{. proc optlstring*(L: PState, numArg: int, def: cstring, len: ptr int): cstring{.
cdecl, dynlib: LIB_NAME, importc: "luaL_optlstring".} cdecl, dynlib: LIB_NAME, importc: "luaL_optlstring".}
proc checknumber*(L: PState, numArg: int): lua_Number{.cdecl, proc checknumber*(L: PState, numArg: int): Number{.cdecl,
dynlib: LIB_NAME, importc: "luaL_checknumber".} dynlib: LIB_NAME, importc: "luaL_checknumber".}
proc optnumber*(L: PState, nArg: int, def: lua_Number): lua_Number{.cdecl, proc optnumber*(L: PState, nArg: int, def: Number): Number{.cdecl,
dynlib: LIB_NAME, importc: "luaL_optnumber".} dynlib: LIB_NAME, importc: "luaL_optnumber".}
proc checkinteger*(L: PState, numArg: int): lua_Integer{.cdecl, proc checkinteger*(L: PState, numArg: int): Integer{.cdecl,
dynlib: LIB_NAME, importc: "luaL_checkinteger".} dynlib: LIB_NAME, importc: "luaL_checkinteger".}
proc optinteger*(L: PState, nArg: int, def: lua_Integer): lua_Integer{. proc optinteger*(L: PState, nArg: int, def: Integer): Integer{.
cdecl, dynlib: LIB_NAME, importc: "luaL_optinteger".} cdecl, dynlib: LIB_NAME, importc: "luaL_optinteger".}
proc checkstack*(L: PState, sz: int, msg: cstring){.cdecl, proc checkstack*(L: PState, sz: int, msg: cstring){.cdecl,
dynlib: LIB_NAME, importc: "luaL_checkstack".} dynlib: LIB_NAME, importc: "luaL_checkstack".}
@ -77,19 +77,19 @@ proc error*(L: PState, fmt: cstring): int{.cdecl, varargs,
dynlib: LIB_NAME, importc: "luaL_error".} dynlib: LIB_NAME, importc: "luaL_error".}
proc checkoption*(L: PState, narg: int, def: cstring, lst: cstringArray): int{. proc checkoption*(L: PState, narg: int, def: cstring, lst: cstringArray): int{.
cdecl, dynlib: LIB_NAME, importc: "luaL_checkoption".} cdecl, dynlib: LIB_NAME, importc: "luaL_checkoption".}
proc ref*(L: PState, t: int): int{.cdecl, dynlib: LIB_NAME, proc reference*(L: PState, t: int): int{.cdecl, dynlib: LIB_NAME,
importc: "luaL_ref".} importc: "luaL_ref".}
proc unref*(L: PState, t, theref: int){.cdecl, dynlib: LIB_NAME, proc unref*(L: PState, t, theref: int){.cdecl, dynlib: LIB_NAME,
importc: "luaL_unref".} importc: "luaL_unref".}
proc loadfile*(L: PState, filename: cstring): int{.cdecl, proc loadfile*(L: PState, filename: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_loadfile".} dynlib: LIB_NAME, importc: "luaL_loadfile".}
proc loadbuffer*(L: PState, buff: cstring, size: size_t, name: cstring): int{. proc loadbuffer*(L: PState, buff: cstring, size: int, name: cstring): int{.
cdecl, dynlib: LIB_NAME, importc: "luaL_loadbuffer".} cdecl, dynlib: LIB_NAME, importc: "luaL_loadbuffer".}
proc loadstring*(L: PState, s: cstring): int{.cdecl, dynlib: LIB_NAME, proc loadstring*(L: PState, s: cstring): int{.cdecl, dynlib: LIB_NAME,
importc: "luaL_loadstring".} importc: "luaL_loadstring".}
proc newstate*(): PState{.cdecl, dynlib: LIB_NAME, proc newstate*(): PState{.cdecl, dynlib: LIB_NAME,
importc: "luaL_newstate".} importc: "luaL_newstate".}
proc lua_open*(): PState proc open*(): PState
# compatibility; moved from unit lua to lauxlib because it needs luaL_newstate # compatibility; moved from unit lua to lauxlib because it needs luaL_newstate
# #
#** =============================================================== #** ===============================================================
@ -103,10 +103,9 @@ proc checkint*(L: PState, n: int): int
proc checklong*(L: PState, n: int): int32 proc checklong*(L: PState, n: int): int32
proc optint*(L: PState, n: int, d: float64): int proc optint*(L: PState, n: int, d: float64): int
proc optlong*(L: PState, n: int, d: float64): int32 proc optlong*(L: PState, n: int, d: float64): int32
proc typename*(L: PState, i: int): cstring proc dofile*(L: PState, filename: cstring): int
proc lua_dofile*(L: PState, filename: cstring): int proc dostring*(L: PState, str: cstring): int
proc lua_dostring*(L: PState, str: cstring): int proc getmetatable*(L: PState, tname: cstring)
proc lua_Lgetmetatable*(L: PState, tname: cstring)
# not translated: # not translated:
# #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) # #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
# #
@ -136,7 +135,7 @@ proc buffinit*(L: PState, B: PBuffer){.cdecl, dynlib: LIB_NAME,
importc: "luaL_buffinit".} importc: "luaL_buffinit".}
proc prepbuffer*(B: PBuffer): cstring{.cdecl, dynlib: LIB_NAME, proc prepbuffer*(B: PBuffer): cstring{.cdecl, dynlib: LIB_NAME,
importc: "luaL_prepbuffer".} importc: "luaL_prepbuffer".}
proc addlstring*(B: PBuffer, s: cstring, L: size_t){.cdecl, proc addlstring*(B: PBuffer, s: cstring, L: int){.cdecl,
dynlib: LIB_NAME, importc: "luaL_addlstring".} dynlib: LIB_NAME, importc: "luaL_addlstring".}
proc addstring*(B: PBuffer, s: cstring){.cdecl, dynlib: LIB_NAME, proc addstring*(B: PBuffer, s: cstring){.cdecl, dynlib: LIB_NAME,
importc: "luaL_addstring".} importc: "luaL_addstring".}
@ -151,42 +150,39 @@ proc findtable*(L: PState, idx: int, fname: cstring, szhint: int): cstring{.
# compatibility with ref system # compatibility with ref system
# pre-defined references # pre-defined references
const const
LUA_NOREF* = - 2 NOREF* = - 2
LUA_REFNIL* = - 1 REFNIL* = - 1
proc lua_unref*(L: PState, theref: int) proc unref*(L: PState, theref: int)
proc lua_getref*(L: PState, theref: int) proc getref*(L: PState, theref: int)
# #
#** Compatibility macros and functions #** Compatibility macros and functions
# #
# implementation # implementation
proc lua_pushstring(L: PState, s: string) = proc pushstring(L: PState, s: string) =
lua_pushlstring(L, cstring(s), len(s)) pushlstring(L, cstring(s), len(s))
proc getn(L: PState, n: int): int = proc getn(L: PState, n: int): int =
Result = lua_objlen(L, n) Result = objlen(L, n)
proc setn(L: PState, t, n: int) = proc setn(L: PState, t, n: int) =
# does nothing as this operation is deprecated # does nothing as this operation is deprecated
nil nil
proc lua_open(): PState = proc open(): PState =
Result = newstate() Result = newstate()
proc typename(L: PState, i: int): cstring = proc dofile(L: PState, filename: cstring): int =
Result = lua_typename(L, lua_type(L, i))
proc lua_dofile(L: PState, filename: cstring): int =
Result = loadfile(L, filename) Result = loadfile(L, filename)
if Result == 0: Result = lua_pcall(L, 0, LUA_MULTRET, 0) if Result == 0: Result = pcall(L, 0, MULTRET, 0)
proc lua_dostring(L: PState, str: cstring): int = proc dostring(L: PState, str: cstring): int =
Result = loadstring(L, str) Result = loadstring(L, str)
if Result == 0: Result = lua_pcall(L, 0, LUA_MULTRET, 0) if Result == 0: Result = pcall(L, 0, MULTRET, 0)
proc lua_Lgetmetatable(L: PState, tname: cstring) = proc getmetatable(L: PState, tname: cstring) =
lua_getfield(L, LUA_REGISTRYINDEX, tname) getfield(L, REGISTRYINDEX, tname)
proc argcheck(L: PState, cond: bool, numarg: int, extramsg: cstring) = proc argcheck(L: PState, cond: bool, numarg: int, extramsg: cstring) =
if not cond: if not cond:
@ -222,8 +218,8 @@ proc putchar(B: PBuffer, c: Char) =
proc addsize(B: PBuffer, n: int) = proc addsize(B: PBuffer, n: int) =
B.p = cast[cstring](cast[int](B.p) + n) B.p = cast[cstring](cast[int](B.p) + n)
proc lua_unref(L: PState, theref: int) = proc unref(L: PState, theref: int) =
unref(L, LUA_REGISTRYINDEX, theref) unref(L, REGISTRYINDEX, theref)
proc lua_getref(L: PState, theref: int) = proc getref(L: PState, theref: int) =
lua_rawgeti(L, LUA_REGISTRYINDEX, theref) rawgeti(L, REGISTRYINDEX, theref)

2
lib/newwrap/lua/lua.nim
View file

@ -159,7 +159,7 @@ proc pushnumber*(L: PState, n: Number){.cdecl, dynlib: NAME,
importc: "lua_pushnumber".} importc: "lua_pushnumber".}
proc pushinteger*(L: PState, n: Integer){.cdecl, dynlib: NAME, proc pushinteger*(L: PState, n: Integer){.cdecl, dynlib: NAME,
importc: "lua_pushinteger".} importc: "lua_pushinteger".}
proc pushlstring*(L: PState, s: cstring, l_: int){.cdecl, dynlib: NAME, proc pushlstring*(L: PState, s: cstring, len: int){.cdecl, dynlib: NAME,
importc: "lua_pushlstring".} importc: "lua_pushlstring".}
proc pushstring*(L: PState, s: cstring){.cdecl, dynlib: NAME, proc pushstring*(L: PState, s: cstring){.cdecl, dynlib: NAME,
importc: "lua_pushstring".} importc: "lua_pushstring".}

431
lib/newwrap/mysql.nim
View file

@ -1,7 +1,7 @@
# #
# #
# Nimrod's Runtime Library # Nimrod's Runtime Library
# (c) Copyright 2009 Andreas Rumpf # (c) Copyright 2010 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
@ -45,7 +45,7 @@ const
SERVICENAME* = "MySQL" SERVICENAME* = "MySQL"
type type
enum_server_command* = enum Tenum_server_command* = enum
COM_SLEEP, COM_QUIT, COM_INIT_DB, COM_QUERY, COM_FIELD_LIST, COM_CREATE_DB, COM_SLEEP, COM_QUIT, COM_INIT_DB, COM_QUERY, COM_FIELD_LIST, COM_CREATE_DB,
COM_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS, COM_PROCESS_INFO, COM_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS, COM_PROCESS_INFO,
COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING, COM_TIME, COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING, COM_TIME,
@ -144,8 +144,8 @@ const
MAX_BLOB_WIDTH* = 8192 # Default width for blob MAX_BLOB_WIDTH* = 8192 # Default width for blob
type type
Pst_net* = ptr st_net Pst_net* = ptr Tst_net
st_net*{.final.} = object Tst_net*{.final.} = object
vio*: PVio vio*: PVio
buff*: cstring buff*: cstring
buff_end*: cstring buff_end*: cstring
@ -185,14 +185,14 @@ type
report_error*: my_bool # We should report error (we have unreported error) report_error*: my_bool # We should report error (we have unreported error)
return_errno*: my_bool return_errno*: my_bool
NET* = st_net TNET* = Tst_net
PNET* = ptr NET PNET* = ptr TNET
const const
packet_error* = - 1 packet_error* = - 1
type type
enum_field_types* = enum # For backward compatibility Tenum_field_types* = enum # For backward compatibility
TYPE_DECIMAL, TYPE_TINY, TYPE_SHORT, TYPE_LONG, TYPE_FLOAT, TYPE_DOUBLE, TYPE_DECIMAL, TYPE_TINY, TYPE_SHORT, TYPE_LONG, TYPE_FLOAT, TYPE_DOUBLE,
TYPE_NULL, TYPE_TIMESTAMP, TYPE_LONGLONG, TYPE_INT24, TYPE_DATE, TYPE_TIME, TYPE_NULL, TYPE_TIMESTAMP, TYPE_LONGLONG, TYPE_INT24, TYPE_DATE, TYPE_TIME,
TYPE_DATETIME, TYPE_YEAR, TYPE_NEWDATE, TYPE_VARCHAR, TYPE_BIT, TYPE_DATETIME, TYPE_YEAR, TYPE_NEWDATE, TYPE_VARCHAR, TYPE_BIT,
@ -238,18 +238,17 @@ const
SHUTDOWN_KILLABLE_UPDATE* = chr(1 shl 3) SHUTDOWN_KILLABLE_UPDATE* = chr(1 shl 3)
type type
enum_shutdown_level* = enum Tenum_shutdown_level* = enum
SHUTDOWN_DEFAULT = 0, SHUTDOWN_WAIT_CONNECTIONS = 1, SHUTDOWN_DEFAULT = 0, SHUTDOWN_WAIT_CONNECTIONS = 1,
SHUTDOWN_WAIT_TRANSACTIONS = 2, SHUTDOWN_WAIT_UPDATES = 8, SHUTDOWN_WAIT_TRANSACTIONS = 2, SHUTDOWN_WAIT_UPDATES = 8,
SHUTDOWN_WAIT_ALL_BUFFERS = 16, SHUTDOWN_WAIT_CRITICAL_BUFFERS = 17, SHUTDOWN_WAIT_ALL_BUFFERS = 16, SHUTDOWN_WAIT_CRITICAL_BUFFERS = 17,
KILL_QUERY = 254, KILL_CONNECTION = 255 KILL_QUERY = 254, KILL_CONNECTION = 255
enum_cursor_type* = enum # options for mysql_set_option Tenum_cursor_type* = enum # options for mysql_set_option
CURSOR_TYPE_NO_CURSOR = 0, CURSOR_TYPE_READ_ONLY = 1, CURSOR_TYPE_NO_CURSOR = 0, CURSOR_TYPE_READ_ONLY = 1,
CURSOR_TYPE_FOR_UPDATE = 2, CURSOR_TYPE_SCROLLABLE = 4 CURSOR_TYPE_FOR_UPDATE = 2, CURSOR_TYPE_SCROLLABLE = 4
enum_mysql_set_option* = enum Tenum_mysql_set_option* = enum
OPTION_MULTI_STATEMENTS_ON, OPTION_MULTI_STATEMENTS_OFF OPTION_MULTI_STATEMENTS_ON, OPTION_MULTI_STATEMENTS_OFF
proc net_new_transaction*(net: st_net): st_net
proc my_net_init*(net: PNET, vio: PVio): my_bool{.cdecl, dynlib: lib, proc my_net_init*(net: PNET, vio: PVio): my_bool{.cdecl, dynlib: lib,
importc: "my_net_init".} importc: "my_net_init".}
proc my_net_local_init*(net: PNET){.cdecl, dynlib: lib, proc my_net_local_init*(net: PNET){.cdecl, dynlib: lib,
@ -270,24 +269,24 @@ proc my_net_read*(net: PNET): int{.cdecl, dynlib: lib, importc: "my_net_read".}
# The following function is not meant for normal usage # The following function is not meant for normal usage
# Currently it's used internally by manager.c # Currently it's used internally by manager.c
type type
Psockaddr* = ptr sockaddr Psockaddr* = ptr Tsockaddr
sockaddr*{.final.} = object # undefined structure Tsockaddr*{.final.} = object # undefined structure
proc my_connect*(s: my_socket, name: Psockaddr, namelen: cuint, timeout: cuint): cint{. proc my_connect*(s: my_socket, name: Psockaddr, namelen: cuint, timeout: cuint): cint{.
cdecl, dynlib: lib, importc: "my_connect".} cdecl, dynlib: lib, importc: "my_connect".}
type type
Prand_struct* = ptr rand_struct Prand_struct* = ptr Trand_struct
rand_struct*{.final.} = object # The following is for user defined functions Trand_struct*{.final.} = object # The following is for user defined functions
seed1*: int seed1*: int
seed2*: int seed2*: int
max_value*: int max_value*: int
max_value_dbl*: cdouble max_value_dbl*: cdouble
Item_result* = enum TItem_result* = enum
STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT, DECIMAL_RESULT STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT, DECIMAL_RESULT
PItem_result* = ptr Item_result PItem_result* = ptr TItem_result
Pst_udf_args* = ptr st_udf_args Pst_udf_args* = ptr Tst_udf_args
st_udf_args*{.final.} = object Tst_udf_args*{.final.} = object
arg_count*: cuint # Number of arguments arg_count*: cuint # Number of arguments
arg_type*: PItem_result # Pointer to item_results arg_type*: PItem_result # Pointer to item_results
args*: cstringArray # Pointer to item_results args*: cstringArray # Pointer to item_results
@ -296,18 +295,18 @@ type
attributes*: cstringArray # Pointer to attribute name attributes*: cstringArray # Pointer to attribute name
attribute_lengths*: ptr int # Length of attribute arguments attribute_lengths*: ptr int # Length of attribute arguments
UDF_ARGS* = st_udf_args TUDF_ARGS* = Tst_udf_args
PUDF_ARGS* = ptr UDF_ARGS # This holds information about the result PUDF_ARGS* = ptr TUDF_ARGS # This holds information about the result
Pst_udf_init* = ptr st_udf_init Pst_udf_init* = ptr Tst_udf_init
st_udf_init*{.final.} = object Tst_udf_init*{.final.} = object
maybe_null*: my_bool # 1 if function can return NULL maybe_null*: my_bool # 1 if function can return NULL
decimals*: cuint # for real functions decimals*: cuint # for real functions
max_length*: int # For string functions max_length*: int # For string functions
theptr*: cstring # free pointer for function data theptr*: cstring # free pointer for function data
const_item*: my_bool # free pointer for function data const_item*: my_bool # free pointer for function data
UDF_INIT* = st_udf_init TUDF_INIT* = Tst_udf_init
PUDF_INIT* = ptr UDF_INIT # Constants when using compression PUDF_INIT* = ptr TUDF_INIT # Constants when using compression
const const
NET_HEADER_SIZE* = 4 # standard header size NET_HEADER_SIZE* = 4 # standard header size
@ -381,8 +380,8 @@ const
CLIENT_NET_WRITE_TIMEOUT* = 365 * 24 * 3600 # Timeout on write CLIENT_NET_WRITE_TIMEOUT* = 365 * 24 * 3600 # Timeout on write
type type
Pst_mysql_field* = ptr st_mysql_field Pst_mysql_field* = ptr Tst_mysql_field
st_mysql_field*{.final.} = object Tst_mysql_field*{.final.} = object
name*: cstring # Name of column name*: cstring # Name of column
org_name*: cstring # Original column name, if an alias org_name*: cstring # Original column name, if an alias
table*: cstring # Table of column if column was a field table*: cstring # Table of column if column was a field
@ -402,19 +401,19 @@ type
flags*: cuint # Div flags flags*: cuint # Div flags
decimals*: cuint # Number of decimals in field decimals*: cuint # Number of decimals in field
charsetnr*: cuint # Character set charsetnr*: cuint # Character set
ftype*: enum_field_types # Type of field. See mysql_com.h for types ftype*: Tenum_field_types # Type of field. See mysql_com.h for types
FIELD* = st_mysql_field TFIELD* = Tst_mysql_field
PFIELD* = ptr FIELD PFIELD* = ptr TFIELD
PROW* = ptr ROW # return data as array of strings PROW* = ptr TROW # return data as array of strings
ROW* = cstringArray TROW* = cstringArray
PFIELD_OFFSET* = ptr FIELD_OFFSET # offset to current field PFIELD_OFFSET* = ptr TFIELD_OFFSET # offset to current field
FIELD_OFFSET* = cuint TFIELD_OFFSET* = cuint
proc IS_PRI_KEY*(n: int32): bool proc IS_PRI_KEY*(n: int32): bool
proc IS_NOT_NULL*(n: int32): bool proc IS_NOT_NULL*(n: int32): bool
proc IS_BLOB*(n: int32): bool proc IS_BLOB*(n: int32): bool
proc IS_NUM*(t: enum_field_types): bool proc IS_NUM*(t: Tenum_field_types): bool
proc INTERNAL_NUM_FIELD*(f: Pst_mysql_field): bool proc INTERNAL_NUM_FIELD*(f: Pst_mysql_field): bool
proc IS_NUM_FIELD*(f: Pst_mysql_field): bool proc IS_NUM_FIELD*(f: Pst_mysql_field): bool
type type
@ -425,33 +424,32 @@ const
COUNT_ERROR* = not (my_ulonglong(0)) COUNT_ERROR* = not (my_ulonglong(0))
type type
Pst_mysql_rows* = ptr st_mysql_rows Pst_mysql_rows* = ptr Tst_mysql_rows
st_mysql_rows*{.final.} = object Tst_mysql_rows*{.final.} = object
next*: Pst_mysql_rows # list of rows next*: Pst_mysql_rows # list of rows
data*: ROW data*: TROW
len*: int len*: int
ROWS* = st_mysql_rows TROWS* = Tst_mysql_rows
PROWS* = ptr ROWS PROWS* = ptr TROWS
PROW_OFFSET* = ptr ROW_OFFSET # offset to current row PROW_OFFSET* = ptr TROW_OFFSET # offset to current row
ROW_OFFSET* = ROWS # ------------ Start of declaration in "my_alloc.h" -------------------- TROW_OFFSET* = TROWS
# $include "my_alloc.h"
const const
ALLOC_MAX_BLOCK_TO_DROP* = 4096 ALLOC_MAX_BLOCK_TO_DROP* = 4096
ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP* = 10 # struct for once_alloc (block) ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP* = 10 # struct for once_alloc (block)
type type
Pst_used_mem* = ptr st_used_mem Pst_used_mem* = ptr Tst_used_mem
st_used_mem*{.final.} = object Tst_used_mem*{.final.} = object
next*: Pst_used_mem # Next block in use next*: Pst_used_mem # Next block in use
left*: cuint # memory left in block left*: cuint # memory left in block
size*: cuint # size of block size*: cuint # size of block
USED_MEM* = st_used_mem TUSED_MEM* = Tst_used_mem
PUSED_MEM* = ptr USED_MEM PUSED_MEM* = ptr TUSED_MEM
Pst_mem_root* = ptr st_mem_root Pst_mem_root* = ptr Tst_mem_root
st_mem_root*{.final.} = object Tst_mem_root*{.final.} = object
free*: PUSED_MEM # blocks with free memory in it free*: PUSED_MEM # blocks with free memory in it
used*: PUSED_MEM # blocks almost without free memory used*: PUSED_MEM # blocks almost without free memory
pre_alloc*: PUSED_MEM # preallocated block pre_alloc*: PUSED_MEM # preallocated block
@ -463,21 +461,21 @@ type
first_block_usage*: cuint first_block_usage*: cuint
error_handler*: proc (){.cdecl.} error_handler*: proc (){.cdecl.}
MEM_ROOT* = st_mem_root TMEM_ROOT* = Tst_mem_root
PMEM_ROOT* = ptr MEM_ROOT # ------------ Stop of declaration in "my_alloc.h" ---------------------- PMEM_ROOT* = ptr TMEM_ROOT # ------------ Stop of declaration in "my_alloc.h" ----------------------
type type
Pst_mysql_data* = ptr st_mysql_data Pst_mysql_data* = ptr Tst_mysql_data
st_mysql_data*{.final.} = object Tst_mysql_data*{.final.} = object
rows*: my_ulonglong rows*: my_ulonglong
fields*: cuint fields*: cuint
data*: PROWS data*: PROWS
alloc*: MEM_ROOT alloc*: TMEM_ROOT
prev_ptr*: ptr PROWS prev_ptr*: ptr PROWS
DATA* = st_mysql_data TDATA* = Tst_mysql_data
PDATA* = ptr DATA PDATA* = ptr TDATA
option* = enum Toption* = enum
OPT_CONNECT_TIMEOUT, OPT_COMPRESS, OPT_NAMED_PIPE, INIT_COMMAND, OPT_CONNECT_TIMEOUT, OPT_COMPRESS, OPT_NAMED_PIPE, INIT_COMMAND,
READ_DEFAULT_FILE, READ_DEFAULT_GROUP, SET_CHARSET_DIR, SET_CHARSET_NAME, READ_DEFAULT_FILE, READ_DEFAULT_GROUP, SET_CHARSET_DIR, SET_CHARSET_NAME,
OPT_LOCAL_INFILE, OPT_PROTOCOL, SHARED_MEMORY_BASE_NAME, OPT_READ_TIMEOUT, OPT_LOCAL_INFILE, OPT_PROTOCOL, SHARED_MEMORY_BASE_NAME, OPT_READ_TIMEOUT,
@ -495,17 +493,17 @@ const
MANAGER_INTERNAL_ERR* = 500 MANAGER_INTERNAL_ERR* = 500
type type
st_dynamic_array*{.final.} = object Tst_dynamic_array*{.final.} = object
buffer*: cstring buffer*: cstring
elements*: cuint elements*: cuint
max_element*: cuint max_element*: cuint
alloc_increment*: cuint alloc_increment*: cuint
size_of_element*: cuint size_of_element*: cuint
DYNAMIC_ARRAY* = st_dynamic_array TDYNAMIC_ARRAY* = Tst_dynamic_array
Pst_dynamic_array* = ptr st_dynamic_array Pst_dynamic_array* = ptr Tst_dynamic_array
Pst_mysql_options* = ptr st_mysql_options Pst_mysql_options* = ptr Tst_mysql_options
st_mysql_options*{.final.} = object Tst_mysql_options*{.final.} = object
connect_timeout*: cuint connect_timeout*: cuint
read_timeout*: cuint read_timeout*: cuint
write_timeout*: cuint write_timeout*: cuint
@ -539,7 +537,7 @@ type
# a read that is replication-aware # a read that is replication-aware
no_master_reads*: my_bool no_master_reads*: my_bool
separate_thread*: my_bool separate_thread*: my_bool
methods_to_use*: option methods_to_use*: Toption
client_ip*: cstring client_ip*: cstring
secure_auth*: my_bool # Refuse client connecting to server if it uses old (pre-4.1.1) protocol secure_auth*: my_bool # Refuse client connecting to server if it uses old (pre-4.1.1) protocol
report_data_truncation*: my_bool # 0 - never report, 1 - always report (default) report_data_truncation*: my_bool # 0 - never report, 1 - always report (default)
@ -551,16 +549,16 @@ type
local_infile_error*: proc (para1: pointer, para2: cstring, para3: cuint): cint local_infile_error*: proc (para1: pointer, para2: cstring, para3: cuint): cint
local_infile_userdata*: pointer local_infile_userdata*: pointer
status* = enum Tstatus* = enum
STATUS_READY, STATUS_GET_RESULT, STATUS_USE_RESULT STATUS_READY, STATUS_GET_RESULT, STATUS_USE_RESULT
protocol_type* = enum # There are three types of queries - the ones that have to go to Tprotocol_type* = enum # There are three types of queries - the ones that have to go to
# the master, the ones that go to a slave, and the adminstrative # the master, the ones that go to a slave, and the adminstrative
# type which must happen on the pivot connectioin # type which must happen on the pivot connectioin
PROTOCOL_DEFAULT, PROTOCOL_TCP, PROTOCOL_SOCKET, PROTOCOL_PIPE, PROTOCOL_DEFAULT, PROTOCOL_TCP, PROTOCOL_SOCKET, PROTOCOL_PIPE,
PROTOCOL_MEMORY PROTOCOL_MEMORY
rpl_type* = enum Trpl_type* = enum
RPL_MASTER, RPL_SLAVE, RPL_ADMIN RPL_MASTER, RPL_SLAVE, RPL_ADMIN
charset_info_st*{.final.} = object Tcharset_info_st*{.final.} = object
number*: cuint number*: cuint
primary_number*: cuint primary_number*: cuint
binary_number*: cuint binary_number*: cuint
@ -588,10 +586,10 @@ type
cset*: pointer # was ^MY_CHARSET_HANDLER cset*: pointer # was ^MY_CHARSET_HANDLER
coll*: pointer # was ^MY_COLLATION_HANDLER; coll*: pointer # was ^MY_COLLATION_HANDLER;
CHARSET_INFO* = charset_info_st TCHARSET_INFO* = Tcharset_info_st
Pcharset_info_st* = ptr charset_info_st Pcharset_info_st* = ptr Tcharset_info_st
Pcharacter_set* = ptr character_set Pcharacter_set* = ptr Tcharacter_set
character_set*{.final.} = object Tcharacter_set*{.final.} = object
number*: cuint number*: cuint
state*: cuint state*: cuint
csname*: cstring csname*: cstring
@ -601,12 +599,12 @@ type
mbminlen*: cuint mbminlen*: cuint
mbmaxlen*: cuint mbmaxlen*: cuint
MY_CHARSET_INFO* = character_set TMY_CHARSET_INFO* = Tcharacter_set
PMY_CHARSET_INFO* = ptr MY_CHARSET_INFO PMY_CHARSET_INFO* = ptr TMY_CHARSET_INFO
Pst_mysql_methods* = ptr st_mysql_methods Pst_mysql_methods* = ptr Tst_mysql_methods
Pst_mysql* = ptr st_mysql Pst_mysql* = ptr Tst_mysql
st_mysql*{.final.} = object Tst_mysql*{.final.} = object
net*: NET # Communication parameters net*: TNET # Communication parameters
connector_fd*: gptr # ConnectorFd for SSL connector_fd*: gptr # ConnectorFd for SSL
host*: cstring host*: cstring
user*: cstring user*: cstring
@ -618,7 +616,7 @@ type
db*: cstring db*: cstring
charset*: Pcharset_info_st charset*: Pcharset_info_st
fields*: PFIELD fields*: PFIELD
field_alloc*: MEM_ROOT field_alloc*: TMEM_ROOT
affected_rows*: my_ulonglong affected_rows*: my_ulonglong
insert_id*: my_ulonglong # id if insert on table with NEXTNR insert_id*: my_ulonglong # id if insert on table with NEXTNR
extra_info*: my_ulonglong # Used by mysqlshow, not used by mysql 5.0 and up extra_info*: my_ulonglong # Used by mysqlshow, not used by mysql 5.0 and up
@ -632,8 +630,8 @@ type
server_status*: cuint server_status*: cuint
server_language*: cuint server_language*: cuint
warning_count*: cuint warning_count*: cuint
options*: st_mysql_options options*: Tst_mysql_options
status*: status status*: Tstatus
free_me*: my_bool # If free in mysql_close free_me*: my_bool # If free in mysql_close
reconnect*: my_bool # set to 1 if automatic reconnect reconnect*: my_bool # set to 1 if automatic reconnect
scramble*: array[0..(SCRAMBLE_LENGTH + 1) - 1, char] # session-wide random string scramble*: array[0..(SCRAMBLE_LENGTH + 1) - 1, char] # session-wide random string
@ -651,54 +649,54 @@ type
# from mysql_stmt_close if close had to cancel result set of this object. # from mysql_stmt_close if close had to cancel result set of this object.
unbuffered_fetch_owner*: Pmy_bool unbuffered_fetch_owner*: Pmy_bool
* = st_mysql TMySQL* = Tst_mysql
P* = ptr PMySQL* = ptr TMySQL
Pst_mysql_res* = ptr st_mysql_res Pst_mysql_res* = ptr Tst_mysql_res
st_mysql_res*{.final.} = object Tst_mysql_res*{.final.} = object
row_count*: my_ulonglong row_count*: my_ulonglong
fields*: PFIELD fields*: PFIELD
data*: PDATA data*: PDATA
data_cursor*: PROWS data_cursor*: PROWS
lengths*: ptr int # column lengths of current row lengths*: ptr int # column lengths of current row
handle*: P # for unbuffered reads handle*: PMySQL # for unbuffered reads
field_alloc*: MEM_ROOT field_alloc*: TMEM_ROOT
field_count*: cuint field_count*: cuint
current_field*: cuint current_field*: cuint
row*: ROW # If unbuffered read row*: TROW # If unbuffered read
current_row*: ROW # buffer to current row current_row*: TROW # buffer to current row
eof*: my_bool # Used by mysql_fetch_row eof*: my_bool # Used by mysql_fetch_row
unbuffered_fetch_cancelled*: my_bool # mysql_stmt_close() had to cancel this result unbuffered_fetch_cancelled*: my_bool # mysql_stmt_close() had to cancel this result
methods*: Pst_mysql_methods methods*: Pst_mysql_methods
RES* = st_mysql_res TRES* = Tst_mysql_res
PRES* = ptr RES PRES* = ptr TRES
Pst_mysql_stmt* = ptr st_mysql_stmt Pst_mysql_stmt* = ptr Tst_mysql_stmt
PSTMT* = ptr STMT PSTMT* = ptr TSTMT
st_mysql_methods*{.final.} = object Tst_mysql_methods*{.final.} = object
read_query_result*: proc (: P): my_bool{.cdecl.} read_query_result*: proc (MySQL: PMySQL): my_bool{.cdecl.}
advanced_command*: proc (: P, command: enum_server_command, header: cstring, advanced_command*: proc (MySQL: PMySQL, command: Tenum_server_command, header: cstring,
header_length: int, arg: cstring, arg_length: int, header_length: int, arg: cstring, arg_length: int,
skip_check: my_bool): my_bool skip_check: my_bool): my_bool
read_rows*: proc (: P, fields: PFIELD, fields: cuint): PDATA read_rows*: proc (MySQL: PMySQL, fields: PFIELD, fields_count: cuint): PDATA
use_result*: proc (: P): PRES use_result*: proc (MySQL: PMySQL): PRES
fetch_lengths*: proc (fto: ptr int, column: ROW, field_count: cuint) fetch_lengths*: proc (fto: ptr int, column: TROW, field_count: cuint)
flush_use_result*: proc (: P) flush_use_result*: proc (MySQL: PMySQL)
list_fields*: proc (: P): PFIELD list_fields*: proc (MySQL: PMySQL): PFIELD
read_prepare_result*: proc (: P, stmt: PSTMT): my_bool read_prepare_result*: proc (MySQL: PMySQL, stmt: PSTMT): my_bool
stmt_execute*: proc (stmt: PSTMT): cint stmt_execute*: proc (stmt: PSTMT): cint
read_binary_rows*: proc (stmt: PSTMT): cint read_binary_rows*: proc (stmt: PSTMT): cint
unbuffered_fetch*: proc (: P, row: cstringArray): cint unbuffered_fetch*: proc (MySQL: PMySQL, row: cstringArray): cint
free_embedded_thd*: proc (: P) free_embedded_thd*: proc (MySQL: PMySQL)
read_statistics*: proc (: P): cstring read_statistics*: proc (MySQL: PMySQL): cstring
next_result*: proc (: P): my_bool next_result*: proc (MySQL: PMySQL): my_bool
read_change_user_result*: proc (: P, buff: cstring, passwd: cstring): cint read_change_user_result*: proc (MySQL: PMySQL, buff: cstring, passwd: cstring): cint
read_rowsfrom_cursor*: proc (stmt: PSTMT): cint read_rowsfrom_cursor*: proc (stmt: PSTMT): cint
METHODS* = st_mysql_methods TMETHODS* = Tst_mysql_methods
PMETHODS* = ptr METHODS PMETHODS* = ptr TMETHODS
Pst_mysql_manager* = ptr st_mysql_manager Pst_mysql_manager* = ptr Tst_mysql_manager
st_mysql_manager*{.final.} = object Tst_mysql_manager*{.final.} = object
net*: NET net*: TNET
host*: cstring host*: cstring
user*: cstring user*: cstring
passwd*: cstring passwd*: cstring
@ -713,24 +711,24 @@ type
net_buf_size*: cint net_buf_size*: cint
last_error*: array[0..(MAX_MYSQL_MANAGER_ERR) - 1, char] last_error*: array[0..(MAX_MYSQL_MANAGER_ERR) - 1, char]
MANAGER* = st_mysql_manager TMANAGER* = Tst_mysql_manager
PMANAGER* = ptr MANAGER PMANAGER* = ptr TMANAGER
Pst_mysql_parameters* = ptr st_mysql_parameters Pst_mysql_parameters* = ptr Tst_mysql_parameters
st_mysql_parameters*{.final.} = object Tst_mysql_parameters*{.final.} = object
p_max_allowed_packet*: ptr int p_max_allowed_packet*: ptr int
p_net_buffer_length*: ptr int p_net_buffer_length*: ptr int
PARAMETERS* = st_mysql_parameters TPARAMETERS* = Tst_mysql_parameters
PPARAMETERS* = ptr PARAMETERS PPARAMETERS* = ptr TPARAMETERS
enum_mysql_stmt_state* = enum Tenum_mysql_stmt_state* = enum
STMT_INIT_DONE = 1, STMT_PREPARE_DONE, STMT_EXECUTE_DONE, STMT_FETCH_DONE STMT_INIT_DONE = 1, STMT_PREPARE_DONE, STMT_EXECUTE_DONE, STMT_FETCH_DONE
Pst_mysql_bind* = ptr st_mysql_bind Pst_mysql_bind* = ptr Tst_mysql_bind
st_mysql_bind*{.final.} = object Tst_mysql_bind*{.final.} = object
len*: int # output length pointer len*: int # output length pointer
is_null*: Pmy_bool # Pointer to null indicator is_null*: Pmy_bool # Pointer to null indicator
buffer*: pointer # buffer to get/put data buffer*: pointer # buffer to get/put data
error*: pmy_bool # set this if you want to track data truncations happened during fetch error*: pmy_bool # set this if you want to track data truncations happened during fetch
buffer_type*: enum_field_types # buffer type buffer_type*: Tenum_field_types # buffer type
buffer_length*: int # buffer length, must be set for str/binary buffer_length*: int # buffer length, must be set for str/binary
# Following are for internal use. Set by mysql_stmt_bind_param # Following are for internal use. Set by mysql_stmt_bind_param
row_ptr*: ptr byte # for the current data position row_ptr*: ptr byte # for the current data position
@ -746,15 +744,15 @@ type
fetch_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte) fetch_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte)
skip_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte) skip_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte)
BIND* = st_mysql_bind TBIND* = Tst_mysql_bind
PBIND* = ptr BIND # statement handler PBIND* = ptr TBIND # statement handler
st_mysql_stmt*{.final.} = object Tst_mysql_stmt*{.final.} = object
mem_root*: MEM_ROOT # root allocations mem_root*: TMEM_ROOT # root allocations
*: P # connection handle mysql*: PMySQL # connection handle
params*: PBIND # input parameters params*: PBIND # input parameters
`bind`*: PBIND # input parameters `bind`*: PBIND # input parameters
fields*: PFIELD # result set metadata fields*: PFIELD # result set metadata
result*: DATA # cached result set result*: TDATA # cached result set
data_cursor*: PROWS # current row in cached result data_cursor*: PROWS # current row in cached result
affected_rows*: my_ulonglong # copy of mysql->affected_rows after statement execution affected_rows*: my_ulonglong # copy of mysql->affected_rows after statement execution
insert_id*: my_ulonglong insert_id*: my_ulonglong
@ -767,7 +765,7 @@ type
last_errno*: cuint # error code last_errno*: cuint # error code
param_count*: cuint # input parameter count param_count*: cuint # input parameter count
field_count*: cuint # number of columns in result set field_count*: cuint # number of columns in result set
state*: enum_mysql_stmt_state # statement state state*: Tenum_mysql_stmt_state # statement state
last_error*: array[0..(ERRMSG_SIZE) - 1, char] # error message last_error*: array[0..(ERRMSG_SIZE) - 1, char] # error message
sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char] sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char]
send_types_to_server*: my_bool # Types of input parameters should be sent to server send_types_to_server*: my_bool # Types of input parameters should be sent to server
@ -776,12 +774,9 @@ type
unbuffered_fetch_cancelled*: my_bool unbuffered_fetch_cancelled*: my_bool
update_max_length*: my_bool update_max_length*: my_bool
STMT* = st_mysql_stmt # When doing mysql_stmt_store_result calculate max_length attribute TSTMT* = Tst_mysql_stmt
# of statement metadata. This is to be consistent with the old API,
# where this was done automatically. Tenum_stmt_attr_type* = enum
# In the new API we do that only by request because it slows down
# mysql_stmt_store_result sufficiently.
enum_stmt_attr_type* = enum
STMT_ATTR_UPDATE_MAX_LENGTH, STMT_ATTR_CURSOR_TYPE, STMT_ATTR_PREFETCH_ROWS STMT_ATTR_UPDATE_MAX_LENGTH, STMT_ATTR_CURSOR_TYPE, STMT_ATTR_PREFETCH_ROWS
proc server_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{. proc server_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{.
@ -816,58 +811,58 @@ proc fetch_field_direct*(res: PRES, fieldnr: cuint): PFIELD{.stdcall,
dynlib: lib, importc: "mysql_fetch_field_direct".} dynlib: lib, importc: "mysql_fetch_field_direct".}
proc fetch_fields*(res: PRES): PFIELD{.stdcall, dynlib: lib, proc fetch_fields*(res: PRES): PFIELD{.stdcall, dynlib: lib,
importc: "mysql_fetch_fields".} importc: "mysql_fetch_fields".}
proc row_tell*(res: PRES): ROW_OFFSET{.stdcall, dynlib: lib, proc row_tell*(res: PRES): TROW_OFFSET{.stdcall, dynlib: lib,
importc: "mysql_row_tell".} importc: "mysql_row_tell".}
proc field_tell*(res: PRES): FIELD_OFFSET{.stdcall, dynlib: lib, proc field_tell*(res: PRES): TFIELD_OFFSET{.stdcall, dynlib: lib,
importc: "mysql_field_tell".} importc: "mysql_field_tell".}
proc field_count*(: P): cuint{.stdcall, dynlib: lib, proc field_count*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib,
importc: "mysql_field_count".} importc: "mysql_field_count".}
proc affected_rows*(: P): my_ulonglong{.stdcall, dynlib: lib, proc affected_rows*(MySQL: PMySQL): my_ulonglong{.stdcall, dynlib: lib,
importc: "mysql_affected_rows".} importc: "mysql_affected_rows".}
proc insert_id*(: P): my_ulonglong{.stdcall, dynlib: lib, proc insert_id*(MySQL: PMySQL): my_ulonglong{.stdcall, dynlib: lib,
importc: "mysql_insert_id".} importc: "mysql_insert_id".}
proc errno*(: P): cuint{.stdcall, dynlib: lib, importc: "mysql_errno".} proc errno*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib, importc: "mysql_errno".}
proc error*(: P): cstring{.stdcall, dynlib: lib, importc: "mysql_error".} proc error*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_error".}
proc sqlstate*(: P): cstring{.stdcall, dynlib: lib, importc: "mysql_sqlstate".} proc sqlstate*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_sqlstate".}
proc warning_count*(: P): cuint{.stdcall, dynlib: lib, proc warning_count*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib,
importc: "mysql_warning_count".} importc: "mysql_warning_count".}
proc info*(: P): cstring{.stdcall, dynlib: lib, importc: "mysql_info".} proc info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_info".}
proc thread_id*(: P): int{.stdcall, dynlib: lib, importc: "mysql_thread_id".} proc thread_id*(MySQL: PMySQL): int{.stdcall, dynlib: lib, importc: "mysql_thread_id".}
proc character_set_name*(: P): cstring{.stdcall, dynlib: lib, proc character_set_name*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib,
importc: "mysql_character_set_name".} importc: "mysql_character_set_name".}
proc set_character_set*(: P, csname: cstring): int32{.stdcall, dynlib: lib, proc set_character_set*(MySQL: PMySQL, csname: cstring): int32{.stdcall, dynlib: lib,
importc: "mysql_set_character_set".} importc: "mysql_set_character_set".}
proc init*(: P): P{.stdcall, dynlib: lib, importc: "mysql_init".} proc init*(MySQL: PMySQL): PMySQL{.stdcall, dynlib: lib, importc: "mysql_init".}
proc ssl_set*(: P, key: cstring, cert: cstring, ca: cstring, capath: cstring, proc ssl_set*(MySQL: PMySQL, key: cstring, cert: cstring, ca: cstring, capath: cstring,
cipher: cstring): my_bool{.stdcall, dynlib: lib, cipher: cstring): my_bool{.stdcall, dynlib: lib,
importc: "mysql_ssl_set".} importc: "mysql_ssl_set".}
proc change_user*(: P, user: cstring, passwd: cstring, db: cstring): my_bool{. proc change_user*(MySQL: PMySQL, user: cstring, passwd: cstring, db: cstring): my_bool{.
stdcall, dynlib: lib, importc: "mysql_change_user".} stdcall, dynlib: lib, importc: "mysql_change_user".}
proc real_connect*(: P, host: cstring, user: cstring, passwd: cstring, proc real_connect*(MySQL: PMySQL, host: cstring, user: cstring, passwd: cstring,
db: cstring, port: cuint, unix_socket: cstring, db: cstring, port: cuint, unix_socket: cstring,
clientflag: int): P{.stdcall, dynlib: lib, clientflag: int): PMySQL{.stdcall, dynlib: lib,
importc: "mysql_real_connect".} importc: "mysql_real_connect".}
proc select_db*(: P, db: cstring): cint{.stdcall, dynlib: lib, proc select_db*(MySQL: PMySQL, db: cstring): cint{.stdcall, dynlib: lib,
importc: "mysql_select_db".} importc: "mysql_select_db".}
proc query*(: P, q: cstring): cint{.stdcall, dynlib: lib, importc: "mysql_query".} proc query*(MySQL: PMySQL, q: cstring): cint{.stdcall, dynlib: lib, importc: "mysql_query".}
proc send_query*(: P, q: cstring, len: int): cint{.stdcall, dynlib: lib, proc send_query*(MySQL: PMySQL, q: cstring, len: int): cint{.stdcall, dynlib: lib,
importc: "mysql_send_query".} importc: "mysql_send_query".}
proc real_query*(: P, q: cstring, len: int): cint{.stdcall, dynlib: lib, proc real_query*(MySQL: PMySQL, q: cstring, len: int): cint{.stdcall, dynlib: lib,
importc: "mysql_real_query".} importc: "mysql_real_query".}
proc store_result*(: P): PRES{.stdcall, dynlib: lib, proc store_result*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib,
importc: "mysql_store_result".} importc: "mysql_store_result".}
proc use_result*(: P): PRES{.stdcall, dynlib: lib, importc: "mysql_use_result".} proc use_result*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib, importc: "mysql_use_result".}
# perform query on master # perform query on master
proc master_query*(: P, q: cstring, len: int): my_bool{.stdcall, dynlib: lib, proc master_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall, dynlib: lib,
importc: "mysql_master_query".} importc: "mysql_master_query".}
proc master_send_query*(: P, q: cstring, len: int): my_bool{.stdcall, proc master_send_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall,
dynlib: lib, importc: "mysql_master_send_query".} dynlib: lib, importc: "mysql_master_send_query".}
# perform query on slave # perform query on slave
proc slave_query*(: P, q: cstring, len: int): my_bool{.stdcall, dynlib: lib, proc slave_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall, dynlib: lib,
importc: "mysql_slave_query".} importc: "mysql_slave_query".}
proc slave_send_query*(: P, q: cstring, len: int): my_bool{.stdcall, proc slave_send_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall,
dynlib: lib, importc: "mysql_slave_send_query".} dynlib: lib, importc: "mysql_slave_send_query".}
proc get_character_set_info*(: P, charset: PMY_CHARSET_INFO){.stdcall, proc get_character_set_info*(MySQL: PMySQL, charset: PMY_CHARSET_INFO){.stdcall,
dynlib: lib, importc: "mysql_get_character_set_info".} dynlib: lib, importc: "mysql_get_character_set_info".}
# local infile support # local infile support
const const
@ -876,90 +871,90 @@ const
# procedure mysql_set_local_infile_handler(mysql:PMYSQL; local_infile_init:function (para1:Ppointer; para2:Pchar; para3:pointer):longint; local_infile_read:function (para1:pointer; para2:Pchar; para3:dword):longint; local_infile_end:procedure (_pa # procedure mysql_set_local_infile_handler(mysql:PMYSQL; local_infile_init:function (para1:Ppointer; para2:Pchar; para3:pointer):longint; local_infile_read:function (para1:pointer; para2:Pchar; para3:dword):longint; local_infile_end:procedure (_pa
# para6:pointer);cdecl;external mysqllib name 'mysql_set_local_infile_handler'; # para6:pointer);cdecl;external mysqllib name 'mysql_set_local_infile_handler';
proc set_local_infile_default*(: P){.cdecl, dynlib: lib, proc set_local_infile_default*(MySQL: PMySQL){.cdecl, dynlib: lib,
importc: "mysql_set_local_infile_default".} importc: "mysql_set_local_infile_default".}
# enable/disable parsing of all queries to decide if they go on master or # enable/disable parsing of all queries to decide if they go on master or
# slave # slave
proc enable_rpl_parse*(: P){.stdcall, dynlib: lib, proc enable_rpl_parse*(MySQL: PMySQL){.stdcall, dynlib: lib,
importc: "mysql_enable_rpl_parse".} importc: "mysql_enable_rpl_parse".}
proc disable_rpl_parse*(: P){.stdcall, dynlib: lib, proc disable_rpl_parse*(MySQL: PMySQL){.stdcall, dynlib: lib,
importc: "mysql_disable_rpl_parse".} importc: "mysql_disable_rpl_parse".}
# get the value of the parse flag # get the value of the parse flag
proc rpl_parse_enabled*(: P): cint{.stdcall, dynlib: lib, proc rpl_parse_enabled*(MySQL: PMySQL): cint{.stdcall, dynlib: lib,
importc: "mysql_rpl_parse_enabled".} importc: "mysql_rpl_parse_enabled".}
# enable/disable reads from master # enable/disable reads from master
proc enable_reads_from_master*(: P){.stdcall, dynlib: lib, proc enable_reads_from_master*(MySQL: PMySQL){.stdcall, dynlib: lib,
importc: "mysql_enable_reads_from_master".} importc: "mysql_enable_reads_from_master".}
proc disable_reads_from_master*(: P){.stdcall, dynlib: lib, importc: "mysql_disable_reads_from_master".} proc disable_reads_from_master*(MySQL: PMySQL){.stdcall, dynlib: lib, importc: "mysql_disable_reads_from_master".}
# get the value of the master read flag # get the value of the master read flag
proc reads_from_master_enabled*(: P): my_bool{.stdcall, dynlib: lib, proc reads_from_master_enabled*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib,
importc: "mysql_reads_from_master_enabled".} importc: "mysql_reads_from_master_enabled".}
proc rpl_query_type*(q: cstring, length: cint): rpl_type{.stdcall, dynlib: lib, proc rpl_query_type*(q: cstring, length: cint): Trpl_type{.stdcall, dynlib: lib,
importc: "mysql_rpl_query_type".} importc: "mysql_rpl_query_type".}
# discover the master and its slaves # discover the master and its slaves
proc rpl_probe*(: P): my_bool{.stdcall, dynlib: lib, importc: "mysql_rpl_probe".} proc rpl_probe*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_rpl_probe".}
# set the master, close/free the old one, if it is not a pivot # set the master, close/free the old one, if it is not a pivot
proc set_master*(: P, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{. proc set_master*(MySQL: PMySQL, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{.
stdcall, dynlib: lib, importc: "mysql_set_master".} stdcall, dynlib: lib, importc: "mysql_set_master".}
proc add_slave*(: P, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{. proc add_slave*(MySQL: PMySQL, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{.
stdcall, dynlib: lib, importc: "mysql_add_slave".} stdcall, dynlib: lib, importc: "mysql_add_slave".}
proc shutdown*(: P, shutdown_level: enum_shutdown_level): cint{.stdcall, proc shutdown*(MySQL: PMySQL, shutdown_level: Tenum_shutdown_level): cint{.stdcall,
dynlib: lib, importc: "mysql_shutdown".} dynlib: lib, importc: "mysql_shutdown".}
proc dump_debug_info*(: P): cint{.stdcall, dynlib: lib, proc dump_debug_info*(MySQL: PMySQL): cint{.stdcall, dynlib: lib,
importc: "mysql_dump_debug_info".} importc: "mysql_dump_debug_info".}
proc refresh*(: P, refresh_options: cuint): cint{.stdcall, dynlib: lib, proc refresh*(MySQL: PMySQL, refresh_options: cuint): cint{.stdcall, dynlib: lib,
importc: "mysql_refresh".} importc: "mysql_refresh".}
proc kill*(: P, pid: int): cint{.stdcall, dynlib: lib, importc: "mysql_kill".} proc kill*(MySQL: PMySQL, pid: int): cint{.stdcall, dynlib: lib, importc: "mysql_kill".}
proc set_server_option*(: P, option: enum_mysql_set_option): cint{.stdcall, proc set_server_option*(MySQL: PMySQL, option: Tenum_mysql_set_option): cint{.stdcall,
dynlib: lib, importc: "mysql_set_server_option".} dynlib: lib, importc: "mysql_set_server_option".}
proc ping*(: P): cint{.stdcall, dynlib: lib, importc: "mysql_ping".} proc ping*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_ping".}
proc stat*(: P): cstring{.stdcall, dynlib: lib, importc: "mysql_stat".} proc stat*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_stat".}
proc get_server_info*(: P): cstring{.stdcall, dynlib: lib, proc get_server_info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib,
importc: "mysql_get_server_info".} importc: "mysql_get_server_info".}
proc get_client_info*(): cstring{.stdcall, dynlib: lib, proc get_client_info*(): cstring{.stdcall, dynlib: lib,
importc: "mysql_get_client_info".} importc: "mysql_get_client_info".}
proc get_client_version*(): int{.stdcall, dynlib: lib, proc get_client_version*(): int{.stdcall, dynlib: lib,
importc: "mysql_get_client_version".} importc: "mysql_get_client_version".}
proc get_host_info*(: P): cstring{.stdcall, dynlib: lib, proc get_host_info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib,
importc: "mysql_get_host_info".} importc: "mysql_get_host_info".}
proc get_server_version*(: P): int{.stdcall, dynlib: lib, proc get_server_version*(MySQL: PMySQL): int{.stdcall, dynlib: lib,
importc: "mysql_get_server_version".} importc: "mysql_get_server_version".}
proc get_proto_info*(: P): cuint{.stdcall, dynlib: lib, proc get_proto_info*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib,
importc: "mysql_get_proto_info".} importc: "mysql_get_proto_info".}
proc list_dbs*(: P, wild: cstring): PRES{.stdcall, dynlib: lib, proc list_dbs*(MySQL: PMySQL, wild: cstring): PRES{.stdcall, dynlib: lib,
importc: "mysql_list_dbs".} importc: "mysql_list_dbs".}
proc list_tables*(: P, wild: cstring): PRES{.stdcall, dynlib: lib, proc list_tables*(MySQL: PMySQL, wild: cstring): PRES{.stdcall, dynlib: lib,
importc: "mysql_list_tables".} importc: "mysql_list_tables".}
proc list_processes*(: P): PRES{.stdcall, dynlib: lib, proc list_processes*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib,
importc: "mysql_list_processes".} importc: "mysql_list_processes".}
proc options*(: P, option: option, arg: cstring): cint{.stdcall, dynlib: lib, proc options*(MySQL: PMySQL, option: Toption, arg: cstring): cint{.stdcall, dynlib: lib,
importc: "mysql_options".} importc: "mysql_options".}
proc free_result*(result: PRES){.stdcall, dynlib: lib, proc free_result*(result: PRES){.stdcall, dynlib: lib,
importc: "mysql_free_result".} importc: "mysql_free_result".}
proc data_seek*(result: PRES, offset: my_ulonglong){.stdcall, dynlib: lib, proc data_seek*(result: PRES, offset: my_ulonglong){.stdcall, dynlib: lib,
importc: "mysql_data_seek".} importc: "mysql_data_seek".}
proc row_seek*(result: PRES, offset: ROW_OFFSET): ROW_OFFSET{.stdcall, proc row_seek*(result: PRES, offset: TROW_OFFSET): TROW_OFFSET{.stdcall,
dynlib: lib, importc: "mysql_row_seek".} dynlib: lib, importc: "mysql_row_seek".}
proc field_seek*(result: PRES, offset: FIELD_OFFSET): FIELD_OFFSET{.stdcall, proc field_seek*(result: PRES, offset: TFIELD_OFFSET): TFIELD_OFFSET{.stdcall,
dynlib: lib, importc: "mysql_field_seek".} dynlib: lib, importc: "mysql_field_seek".}
proc fetch_row*(result: PRES): ROW{.stdcall, dynlib: lib, proc fetch_row*(result: PRES): TROW{.stdcall, dynlib: lib,
importc: "mysql_fetch_row".} importc: "mysql_fetch_row".}
proc fetch_lengths*(result: PRES): ptr int{.stdcall, dynlib: lib, proc fetch_lengths*(result: PRES): ptr int{.stdcall, dynlib: lib,
importc: "mysql_fetch_lengths".} importc: "mysql_fetch_lengths".}
proc fetch_field*(result: PRES): PFIELD{.stdcall, dynlib: lib, proc fetch_field*(result: PRES): PFIELD{.stdcall, dynlib: lib,
importc: "mysql_fetch_field".} importc: "mysql_fetch_field".}
proc list_fields*(: P, table: cstring, wild: cstring): PRES{.stdcall, proc list_fields*(MySQL: PMySQL, table: cstring, wild: cstring): PRES{.stdcall,
dynlib: lib, importc: "mysql_list_fields".} dynlib: lib, importc: "mysql_list_fields".}
proc escape_string*(fto: cstring, `from`: cstring, from_length: int): int{. proc escape_string*(fto: cstring, `from`: cstring, from_length: int): int{.
stdcall, dynlib: lib, importc: "mysql_escape_string".} stdcall, dynlib: lib, importc: "mysql_escape_string".}
proc hex_string*(fto: cstring, `from`: cstring, from_length: int): int{.stdcall, proc hex_string*(fto: cstring, `from`: cstring, from_length: int): int{.stdcall,
dynlib: lib, importc: "mysql_hex_string".} dynlib: lib, importc: "mysql_hex_string".}
proc real_escape_string*(: P, fto: cstring, `from`: cstring, len: int): int{. proc real_escape_string*(MySQL: PMySQL, fto: cstring, `from`: cstring, len: int): int{.
stdcall, dynlib: lib, importc: "mysql_real_escape_string".} stdcall, dynlib: lib, importc: "mysql_real_escape_string".}
proc debug*(debug: cstring){.stdcall, dynlib: lib, importc: "mysql_debug".} proc debug*(debug: cstring){.stdcall, dynlib: lib, importc: "mysql_debug".}
# function mysql_odbc_escape_string(mysql:PMYSQL; fto:Pchar; to_length:dword; from:Pchar; from_length:dword; # function mysql_odbc_escape_string(mysql:PMYSQL; fto:Pchar; to_length:dword; from:Pchar; from_length:dword;
# param:pointer; extend_buffer:function (para1:pointer; to:Pchar; length:Pdword):Pchar):Pchar;stdcall;external mysqllib name 'mysql_odbc_escape_string'; # param:pointer; extend_buffer:function (para1:pointer; to:Pchar; length:Pdword):Pchar):Pchar;stdcall;external mysqllib name 'mysql_odbc_escape_string';
proc myodbc_remove_escape*(: P, name: cstring){.stdcall, dynlib: lib, proc myodbc_remove_escape*(MySQL: PMySQL, name: cstring){.stdcall, dynlib: lib,
importc: "myodbc_remove_escape".} importc: "myodbc_remove_escape".}
proc thread_safe*(): cuint{.stdcall, dynlib: lib, importc: "mysql_thread_safe".} proc thread_safe*(): cuint{.stdcall, dynlib: lib, importc: "mysql_thread_safe".}
proc embedded*(): my_bool{.stdcall, dynlib: lib, importc: "mysql_embedded".} proc embedded*(): my_bool{.stdcall, dynlib: lib, importc: "mysql_embedded".}
@ -974,9 +969,9 @@ proc manager_command*(con: PMANAGER, cmd: cstring, cmd_len: cint): cint{.
stdcall, dynlib: lib, importc: "mysql_manager_command".} stdcall, dynlib: lib, importc: "mysql_manager_command".}
proc manager_fetch_line*(con: PMANAGER, res_buf: cstring, res_buf_size: cint): cint{. proc manager_fetch_line*(con: PMANAGER, res_buf: cstring, res_buf_size: cint): cint{.
stdcall, dynlib: lib, importc: "mysql_manager_fetch_line".} stdcall, dynlib: lib, importc: "mysql_manager_fetch_line".}
proc read_query_result*(: P): my_bool{.stdcall, dynlib: lib, proc read_query_result*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib,
importc: "mysql_read_query_result".} importc: "mysql_read_query_result".}
proc stmt_init*(: P): PSTMT{.stdcall, dynlib: lib, importc: "mysql_stmt_init".} proc stmt_init*(MySQL: PMySQL): PSTMT{.stdcall, dynlib: lib, importc: "mysql_stmt_init".}
proc stmt_prepare*(stmt: PSTMT, query: cstring, len: int): cint{.stdcall, proc stmt_prepare*(stmt: PSTMT, query: cstring, len: int): cint{.stdcall,
dynlib: lib, importc: "mysql_stmt_prepare".} dynlib: lib, importc: "mysql_stmt_prepare".}
proc stmt_execute*(stmt: PSTMT): cint{.stdcall, dynlib: lib, proc stmt_execute*(stmt: PSTMT): cint{.stdcall, dynlib: lib,
@ -989,9 +984,9 @@ proc stmt_store_result*(stmt: PSTMT): cint{.stdcall, dynlib: lib,
importc: "mysql_stmt_store_result".} importc: "mysql_stmt_store_result".}
proc stmt_param_count*(stmt: PSTMT): int{.stdcall, dynlib: lib, proc stmt_param_count*(stmt: PSTMT): int{.stdcall, dynlib: lib,
importc: "mysql_stmt_param_count".} importc: "mysql_stmt_param_count".}
proc stmt_attr_set*(stmt: PSTMT, attr_type: enum_stmt_attr_type, attr: pointer): my_bool{. proc stmt_attr_set*(stmt: PSTMT, attr_type: Tenum_stmt_attr_type, attr: pointer): my_bool{.
stdcall, dynlib: lib, importc: "mysql_stmt_attr_set".} stdcall, dynlib: lib, importc: "mysql_stmt_attr_set".}
proc stmt_attr_get*(stmt: PSTMT, attr_type: enum_stmt_attr_type, attr: pointer): my_bool{. proc stmt_attr_get*(stmt: PSTMT, attr_type: Tenum_stmt_attr_type, attr: pointer): my_bool{.
stdcall, dynlib: lib, importc: "mysql_stmt_attr_get".} stdcall, dynlib: lib, importc: "mysql_stmt_attr_get".}
proc stmt_bind_param*(stmt: PSTMT, bnd: PBIND): my_bool{.stdcall, dynlib: lib, proc stmt_bind_param*(stmt: PSTMT, bnd: PBIND): my_bool{.stdcall, dynlib: lib,
importc: "mysql_stmt_bind_param".} importc: "mysql_stmt_bind_param".}
@ -1016,9 +1011,9 @@ proc stmt_error*(stmt: PSTMT): cstring{.stdcall, dynlib: lib,
importc: "mysql_stmt_error".} importc: "mysql_stmt_error".}
proc stmt_sqlstate*(stmt: PSTMT): cstring{.stdcall, dynlib: lib, proc stmt_sqlstate*(stmt: PSTMT): cstring{.stdcall, dynlib: lib,
importc: "mysql_stmt_sqlstate".} importc: "mysql_stmt_sqlstate".}
proc stmt_row_seek*(stmt: PSTMT, offset: ROW_OFFSET): ROW_OFFSET{.stdcall, proc stmt_row_seek*(stmt: PSTMT, offset: TROW_OFFSET): TROW_OFFSET{.stdcall,
dynlib: lib, importc: "mysql_stmt_row_seek".} dynlib: lib, importc: "mysql_stmt_row_seek".}
proc stmt_row_tell*(stmt: PSTMT): ROW_OFFSET{.stdcall, dynlib: lib, proc stmt_row_tell*(stmt: PSTMT): TROW_OFFSET{.stdcall, dynlib: lib,
importc: "mysql_stmt_row_tell".} importc: "mysql_stmt_row_tell".}
proc stmt_data_seek*(stmt: PSTMT, offset: my_ulonglong){.stdcall, dynlib: lib, proc stmt_data_seek*(stmt: PSTMT, offset: my_ulonglong){.stdcall, dynlib: lib,
importc: "mysql_stmt_data_seek".} importc: "mysql_stmt_data_seek".}
@ -1030,32 +1025,28 @@ proc stmt_insert_id*(stmt: PSTMT): my_ulonglong{.stdcall, dynlib: lib,
importc: "mysql_stmt_insert_id".} importc: "mysql_stmt_insert_id".}
proc stmt_field_count*(stmt: PSTMT): cuint{.stdcall, dynlib: lib, proc stmt_field_count*(stmt: PSTMT): cuint{.stdcall, dynlib: lib,
importc: "mysql_stmt_field_count".} importc: "mysql_stmt_field_count".}
proc commit*(: P): my_bool{.stdcall, dynlib: lib, importc: "mysql_commit".} proc commit*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_commit".}
proc rollback*(: P): my_bool{.stdcall, dynlib: lib, importc: "mysql_rollback".} proc rollback*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_rollback".}
proc autocommit*(: P, auto_mode: my_bool): my_bool{.stdcall, dynlib: lib, proc autocommit*(MySQL: PMySQL, auto_mode: my_bool): my_bool{.stdcall, dynlib: lib,
importc: "mysql_autocommit".} importc: "mysql_autocommit".}
proc more_results*(: P): my_bool{.stdcall, dynlib: lib, proc more_results*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib,
importc: "mysql_more_results".} importc: "mysql_more_results".}
proc next_result*(: P): cint{.stdcall, dynlib: lib, importc: "mysql_next_result".} proc next_result*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_next_result".}
proc close*(sock: P){.stdcall, dynlib: lib, importc: "mysql_close".} proc close*(sock: PMySQL){.stdcall, dynlib: lib, importc: "mysql_close".}
# status return codes # status return codes
const const
NO_DATA* = 100 NO_DATA* = 100
DATA_TRUNCATED* = 101 DATA_TRUNCATED* = 101
proc reload*(: P): cint proc reload*(MySQL: PMySQL): cint
when defined(USE_OLD_FUNCTIONS): when defined(USE_OLD_FUNCTIONS):
proc connect*(: P, host: cstring, user: cstring, passwd: cstring): P{.stdcall, proc connect*(MySQL: PMySQL, host: cstring, user: cstring, passwd: cstring): PMySQL{.stdcall,
dynlib: External_library, importc: "mysql_connect".} dynlib: lib, importc: "mysql_connect".}
proc create_db*(: P, DB: cstring): cint{.stdcall, dynlib: External_library, proc create_db*(MySQL: PMySQL, DB: cstring): cint{.stdcall, dynlib: lib,
importc: "mysql_create_db".} importc: "mysql_create_db".}
proc drop_db*(: P, DB: cstring): cint{.stdcall, dynlib: External_library, proc drop_db*(MySQL: PMySQL, DB: cstring): cint{.stdcall, dynlib: lib,
importc: "mysql_drop_db".} importc: "mysql_drop_db".}
proc net_safe_read*(: P): cuint{.cdecl, dynlib: lib, importc: "net_safe_read".} proc net_safe_read*(MySQL: PMySQL): cuint{.cdecl, dynlib: lib, importc: "net_safe_read".}
proc net_new_transaction(net: st_net): st_net =
assert false
#net.pkt_nr = 0
result = net
proc IS_PRI_KEY(n: int32): bool = proc IS_PRI_KEY(n: int32): bool =
result = (n and PRI_KEY_FLAG) != 0 result = (n and PRI_KEY_FLAG) != 0
@ -1069,7 +1060,7 @@ proc IS_BLOB(n: int32): bool =
proc IS_NUM_FIELD(f: pst_mysql_field): bool = proc IS_NUM_FIELD(f: pst_mysql_field): bool =
result = (f.flags and NUM_FLAG) != 0 result = (f.flags and NUM_FLAG) != 0
proc IS_NUM(t: enum_field_types): bool = proc IS_NUM(t: Tenum_field_types): bool =
result = (t <= FIELD_TYPE_INT24) or (t == FIELD_TYPE_YEAR) or result = (t <= FIELD_TYPE_INT24) or (t == FIELD_TYPE_YEAR) or
(t == FIELD_TYPE_NEWDECIMAL) (t == FIELD_TYPE_NEWDECIMAL)
@ -1078,5 +1069,5 @@ proc INTERNAL_NUM_FIELD(f: Pst_mysql_field): bool =
((f.ftype != FIELD_TYPE_TIMESTAMP) or (f.len == 14) or (f.len == 8)) or ((f.ftype != FIELD_TYPE_TIMESTAMP) or (f.len == 14) or (f.len == 8)) or
(f.ftype == FIELD_TYPE_YEAR) (f.ftype == FIELD_TYPE_YEAR)
proc reload(: P): cint = proc reload(mysql: PMySQL): cint =
result = refresh(, REFRESH_GRANT) result = refresh(mysql, REFRESH_GRANT)

2
lib/newwrap/sdl/sdl_mixer.nim
View file

@ -205,7 +205,7 @@ type #music_cmd.h types
TMidiEvent*{.final.} = object TMidiEvent*{.final.} = object
time*: int32 time*: int32
channel*: uint8 channel*: uint8
type_*: uint8 typ*: uint8
a*: uint8 a*: uint8
b*: uint8 b*: uint8

4
lib/newwrap/sdl/sdl_mixer_nosmpeg.nim
View file

@ -57,7 +57,7 @@ type #music_cmd.h types
TMidiEvent*{.final.} = object TMidiEvent*{.final.} = object
time*: int32 time*: int32
channel*: uint8 channel*: uint8
type_*: uint8 typ*: uint8
a*: uint8 a*: uint8
b*: uint8 b*: uint8
@ -116,7 +116,7 @@ type #music_cmd.h types
MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG
PMusic* = ptr TMusic PMusic* = ptr TMusic
TMusic*{.final.} = object TMusic*{.final.} = object
type_*: TMusicType typ*: TMusicType
TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{. TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{.
cdecl.} # This macro can be used to fill a version structure with the compile-time cdecl.} # This macro can be used to fill a version structure with the compile-time

2
lib/newwrap/sdl/smpeg.nim
View file

@ -257,7 +257,7 @@ proc setdisplay*(mpeg: PSMPEG, dst: PSurface, surfLock: Pmutex,
callback: TDisplayCallback){.cdecl, callback: TDisplayCallback){.cdecl,
importc: "SMPEG_setdisplay", dynlib: SmpegLibName.} importc: "SMPEG_setdisplay", dynlib: SmpegLibName.}
# Set or clear looping play on an SMPEG object # Set or clear looping play on an SMPEG object
proc loop*(mpeg: PSMPEG, repeat_: int){.cdecl, importc: "SMPEG_loop", proc loop*(mpeg: PSMPEG, repeat: int){.cdecl, importc: "SMPEG_loop",
dynlib: SmpegLibName.} dynlib: SmpegLibName.}
# Scale pixel display on an SMPEG object # Scale pixel display on an SMPEG object
proc scaleXY*(mpeg: PSMPEG, width, height: int){.cdecl, proc scaleXY*(mpeg: PSMPEG, width, height: int){.cdecl,

528
lib/newwrap/tcl.nim
View file

@ -1,7 +1,7 @@
# #
# #
# Nimrod's Runtime Library # Nimrod's Runtime Library
# (c) Copyright 2009 Andreas Rumpf # (c) Copyright 2010 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
@ -48,52 +48,52 @@ const
TCL_RETURN* = 2 TCL_RETURN* = 2
TCL_BREAK* = 3 TCL_BREAK* = 3
TCL_CONTINUE* = 4 TCL_CONTINUE* = 4
TCL_RESULT_SIZE* = 200 RESULT_SIZE* = 200
MAX_ARGV* = 0x00007FFF MAX_ARGV* = 0x00007FFF
TCL_VERSION_MAJOR* = 0 VERSION_MAJOR* = 0
TCL_VERSION_MINOR* = 0 VERSION_MINOR* = 0
TCL_NO_EVAL* = 0x00010000 NO_EVAL* = 0x00010000
TCL_EVAL_GLOBAL* = 0x00020000 # Flag values passed to variable-related procedures. * EVAL_GLOBAL* = 0x00020000 # Flag values passed to variable-related proc
TCL_GLOBAL_ONLY* = 1 GLOBAL_ONLY* = 1
TCL_NAMESPACE_ONLY* = 2 NAMESPACE_ONLY* = 2
TCL_APPEND_VALUE* = 4 APPEND_VALUE* = 4
TCL_LIST_ELEMENT* = 8 LIST_ELEMENT* = 8
TCL_TRACE_READS* = 0x00000010 TRACE_READS* = 0x00000010
TCL_TRACE_WRITES* = 0x00000020 TRACE_WRITES* = 0x00000020
TCL_TRACE_UNSETS* = 0x00000040 TRACE_UNSETS* = 0x00000040
TCL_TRACE_DESTROYED* = 0x00000080 TRACE_DESTROYED* = 0x00000080
TCL_INTERP_DESTROYED* = 0x00000100 INTERP_DESTROYED* = 0x00000100
TCL_LEAVE_ERR_MSG* = 0x00000200 LEAVE_ERR_MSG* = 0x00000200
TCL_PARSE_PART1* = 0x00000400 # Types for linked variables: * PARSE_PART1* = 0x00000400 # Types for linked variables: *
TCL_LINK_INT* = 1 LINK_INT* = 1
TCL_LINK_DOUBLE* = 2 LINK_DOUBLE* = 2
TCL_LINK_BOOLEAN* = 3 LINK_BOOLEAN* = 3
TCL_LINK_STRING* = 4 LINK_STRING* = 4
TCL_LINK_READ_ONLY* = 0x00000080 LINK_READ_ONLY* = 0x00000080
TCL_SMALL_HASH_TABLE* = 4 # Hash Table * SMALL_HASH_TABLE* = 4 # Hash Table *
TCL_STRING_KEYS* = 0 STRING_KEYS* = 0
TCL_ONE_WORD_KEYS* = 1 # Const/enums Tcl_QueuePosition * ONE_WORD_KEYS* = 1 # Const/enums Tcl_QueuePosition *
# typedef enum {
TCL_QUEUE_TAIL* = 0 QUEUE_TAIL* = 0
TCL_QUEUE_HEAD* = 1 QUEUE_HEAD* = 1
TCL_QUEUE_MARK* = 2 #} Tcl_QueuePosition; QUEUE_MARK* = 2 # Tcl_QueuePosition;
# Event Flags # Event Flags
TCL_DONT_WAIT* = 1 shl 1 DONT_WAIT* = 1 shl 1
TCL_WINDOW_EVENTS* = 1 shl 2 WINDOW_EVENTS* = 1 shl 2
TCL_FILE_EVENTS* = 1 shl 3 FILE_EVENTS* = 1 shl 3
TCL_TIMER_EVENTS* = 1 shl 4 TIMER_EVENTS* = 1 shl 4
TCL_IDLE_EVENTS* = 1 shl 5 # WAS 0x10 ???? * IDLE_EVENTS* = 1 shl 5 # WAS 0x10 ???? *
TCL_ALL_EVENTS* = not TCL_DONT_WAIT ALL_EVENTS* = not DONT_WAIT
TCL_VOLATILE* = 1 VOLATILE* = 1
TCL_STATIC* = 0 STATIC* = 0
TCL_DYNAMIC* = 3 # Channel DYNAMIC* = 3 # Channel
TCL_STDIN* = 1 shl 1 TCL_STDIN* = 1 shl 1
TCL_STDOUT* = 1 shl 2 TCL_STDOUT* = 1 shl 2
TCL_STDERR* = 1 shl 3 TCL_STDERR* = 1 shl 3
TCL_ENFORCE_MODE* = 1 shl 4 ENFORCE_MODE* = 1 shl 4
TCL_READABLE* = 1 shl 1 READABLE* = 1 shl 1
TCL_WRITABLE* = 1 shl 2 WRITABLE* = 1 shl 2
TCL_EXCEPTION* = 1 shl 3 # POSIX * EXCEPTION* = 1 shl 3 # POSIX *
EPERM* = 1 # Operation not permitted; only the owner of the file (or other EPERM* = 1 # Operation not permitted; only the owner of the file (or other
# resource) or processes with special privileges can perform the # resource) or processes with special privileges can perform the
# operation. # operation.
@ -367,112 +367,110 @@ const
# #
type type
Tcl_Argv* = cstringArray TArgv* = cstringArray
Tcl_ClientData* = pointer TClientData* = pointer
Tcl_FreeProc* = proc (theBlock: pointer){.cdecl.} TFreeProc* = proc (theBlock: pointer){.cdecl.}
PInterp* = ptr Tcl_Interp PInterp* = ptr TInterp
Tcl_Interp*{.final.} = object # Event Definitions * TInterp*{.final.} = object # Event Definitions
result*: cstring # Do not access this directly. Use result*: cstring # Do not access this directly. Use
# * Tcl_GetStringResult since result # Tcl_GetStringResult since result
# * may be pointing to an object # may be pointing to an object
# * #
freeProc*: Tcl_FreeProc freeProc*: TFreeProc
errorLine*: int errorLine*: int
TEventSetupProc* = proc (clientData: Tcl_ClientData, flags: int){.cdecl.} TEventSetupProc* = proc (clientData: TClientData, flags: int){.cdecl.}
TEventCheckProc* = TEventSetupProc TEventCheckProc* = TEventSetupProc
PEvent* = ptr Tcl_Event PEvent* = ptr TEvent
TEventProc* = proc (evPtr: PEvent, flags: int): int{.cdecl.} TEventProc* = proc (evPtr: PEvent, flags: int): int{.cdecl.}
Tcl_Event*{.final.} = object TEvent*{.final.} = object
prc*: TEventProc prc*: TEventProc
nextPtr*: PEvent nextPtr*: PEvent
ClientData*: TObject # ClientData is just pointer.* ClientData*: TObject # ClientData is just pointer.*
PTime* = ptr Tcl_Time PTime* = ptr TTime
Tcl_Time*{.final.} = object TTime*{.final.} = object
sec*: int32 # Seconds. * sec*: int32 # Seconds. *
usec*: int32 # Microseconds. * usec*: int32 # Microseconds. *
Tcl_TimerToken* = pointer TTimerToken* = pointer
PInteger* = ptr int PInteger* = ptr int
PHashTable* = pointer PHashTable* = ptr THashTable
PHashEntry* = ptr Tcl_HashEntry PHashEntry* = ptr THashEntry
PPTcl_HashEntry* = ptr PHashEntry PPHashEntry* = ptr PHashEntry
Tcl_HashEntry*{.final.} = object THashEntry*{.final.} = object
nextPtr*: PHashEntry nextPtr*: PHashEntry
tablePtr*: PHashTable tablePtr*: PHashTable
bucketPtr*: PPTcl_HashEntry bucketPtr*: PPHashEntry
clientData*: Tcl_ClientData clientData*: TClientData
key*: cstring key*: cstring
Tcl_HashFindProc* = proc (tablePtr: PHashTable, key: cstring): PHashEntry{. THashFindProc* = proc (tablePtr: PHashTable, key: cstring): PHashEntry{.
cdecl.} cdecl.}
Tcl_HashCreateProc* = proc (tablePtr: PHashTable, key: cstring, THashCreateProc* = proc (tablePtr: PHashTable, key: cstring,
newPtr: PInteger): PHashEntry{.cdecl.} newPtr: PInteger): PHashEntry{.cdecl.}
PHashTable* = ptr Tcl_HashTable THashTable*{.final.} = object
Tcl_HashTable*{.final.} = object buckets*: ppHashEntry
buckets*: ppTcl_HashEntry staticBuckets*: array[0..SMALL_HASH_TABLE - 1, PHashEntry]
staticBuckets*: array[0..TCL_SMALL_HASH_TABLE - 1, PHashEntry]
numBuckets*: int numBuckets*: int
numEntries*: int numEntries*: int
rebuildSize*: int rebuildSize*: int
downShift*: int downShift*: int
mask*: int mask*: int
keyType*: int keyType*: int
findProc*: Tcl_HashFindProc findProc*: THashFindProc
createProc*: Tcl_HashCreateProc createProc*: THashCreateProc
PHashSearch* = ptr Tcl_HashSearch PHashSearch* = ptr THashSearch
Tcl_HashSearch*{.final.} = object THashSearch*{.final.} = object
tablePtr*: PHashTable tablePtr*: PHashTable
nextIndex*: int nextIndex*: int
nextEntryPtr*: PHashEntry nextEntryPtr*: PHashEntry
TAppInitProc* = proc (interp: pInterp): int{.cdecl.} TAppInitProc* = proc (interp: pInterp): int{.cdecl.}
TPackageInitProc* = proc (interp: pInterp): int{.cdecl.} TPackageInitProc* = proc (interp: pInterp): int{.cdecl.}
TCmdProc* = proc (clientData: Tcl_ClientData, interp: pInterp, argc: int, TCmdProc* = proc (clientData: TClientData, interp: pInterp, argc: int,
argv: Tcl_Argv): int{.cdecl.} argv: TArgv): int{.cdecl.}
TVarTraceProc* = proc (clientData: Tcl_ClientData, interp: pInterp, TVarTraceProc* = proc (clientData: TClientData, interp: pInterp,
varName: cstring, elemName: cstring, flags: int): cstring{. varName: cstring, elemName: cstring, flags: int): cstring{.
cdecl.} cdecl.}
TFreeProc* = proc (theBlock: pointer){.cdecl.} TInterpDeleteProc* = proc (clientData: TClientData, interp: pInterp){.cdecl.}
TInterpDeleteProc* = proc (clientData: Tcl_ClientData, interp: pInterp){.cdecl.} TCmdDeleteProc* = proc (clientData: TClientData){.cdecl.}
TCmdDeleteProc* = proc (clientData: Tcl_ClientData){.cdecl.} TNamespaceDeleteProc* = proc (clientData: TClientData){.cdecl.}
TNamespaceDeleteProc* = proc (clientData: Tcl_ClientData){.cdecl.}
const const
TCL_DSTRING_STATIC_SIZE* = 200 DSTRING_STATIC_SIZE* = 200
type type
PDString* = ptr Tcl_DString PDString* = ptr TDString
Tcl_DString*{.final.} = object TDString*{.final.} = object
str*: cstring str*: cstring
len*: int len*: int
spaceAvl*: int spaceAvl*: int
staticSpace*: array[0..TCL_DSTRING_STATIC_SIZE - 1, char] staticSpace*: array[0..DSTRING_STATIC_SIZE - 1, char]
PChannel* = ptr Tcl_Channel PChannel* = ptr TChannel
Tcl_Channel*{.final.} = object TChannel*{.final.} = object
TDriverBlockModeProc* = proc (instanceData: Tcl_ClientData, mode: int): int{. TDriverBlockModeProc* = proc (instanceData: TClientData, mode: int): int{.
cdecl.} cdecl.}
TDriverCloseProc* = proc (instanceData: Tcl_ClientData, interp: PInterp): int{. TDriverCloseProc* = proc (instanceData: TClientData, interp: PInterp): int{.
cdecl.} cdecl.}
TDriverInputProc* = proc (instanceData: Tcl_ClientData, buf: cstring, TDriverInputProc* = proc (instanceData: TClientData, buf: cstring,
toRead: int, errorCodePtr: PInteger): int{.cdecl.} toRead: int, errorCodePtr: PInteger): int{.cdecl.}
TDriverOutputProc* = proc (instanceData: Tcl_ClientData, buf: cstring, TDriverOutputProc* = proc (instanceData: TClientData, buf: cstring,
toWrite: int, errorCodePtr: PInteger): int{.cdecl.} toWrite: int, errorCodePtr: PInteger): int{.cdecl.}
TDriverSeekProc* = proc (instanceData: Tcl_ClientData, offset: int32, TDriverSeekProc* = proc (instanceData: TClientData, offset: int32,
mode: int, errorCodePtr: PInteger): int{.cdecl.} mode: int, errorCodePtr: PInteger): int{.cdecl.}
TDriverSetOptionProc* = proc (instanceData: Tcl_ClientData, interp: PInterp, TDriverSetOptionProc* = proc (instanceData: TClientData, interp: PInterp,
optionName: cstring, value: cstring): int{.cdecl.} optionName: cstring, value: cstring): int{.cdecl.}
TDriverGetOptionProc* = proc (instanceData: Tcl_ClientData, interp: pInterp, TDriverGetOptionProc* = proc (instanceData: TClientData, interp: pInterp,
optionName: cstring, dsPtr: PDString): int{. optionName: cstring, dsPtr: PDString): int{.
cdecl.} cdecl.}
TDriverWatchProc* = proc (instanceData: Tcl_ClientData, mask: int){.cdecl.} TDriverWatchProc* = proc (instanceData: TClientData, mask: int){.cdecl.}
TDriverGetHandleProc* = proc (instanceData: Tcl_ClientData, direction: int, TDriverGetHandleProc* = proc (instanceData: TClientData, direction: int,
handlePtr: var Tcl_ClientData): int{.cdecl.} handlePtr: var TClientData): int{.cdecl.}
PChannelType* = ptr Tcl_ChannelType PChannelType* = ptr TChannelType
Tcl_ChannelType*{.final.} = object TChannelType*{.final.} = object
typeName*: cstring typeName*: cstring
blockModeProc*: TDriverBlockModeProc blockModeProc*: TDriverBlockModeProc
closeProc*: TDriverCloseProc closeProc*: TDriverCloseProc
@ -484,24 +482,24 @@ type
watchProc*: TDriverWatchProc watchProc*: TDriverWatchProc
getHandleProc*: TDriverGetHandleProc getHandleProc*: TDriverGetHandleProc
TChannelProc* = proc (clientData: Tcl_ClientData, mask: int){.cdecl.} TChannelProc* = proc (clientData: TClientData, mask: int){.cdecl.}
PObj* = ptr Tcl_Obj PObj* = ptr TObj
PPTcl_Obj* = ptr PObj PPObj* = ptr PObj
Tcl_Obj*{.final.} = object TObj*{.final.} = object
refCount*: int # ... refCount*: int # ...
TObjCmdProc* = proc (clientData: Tcl_ClientData, interp: PInterp, objc: int, TObjCmdProc* = proc (clientData: TClientData, interp: PInterp, objc: int,
PPObj: PPTcl_Obj): int{.cdecl.} PPObj: PPObj): int{.cdecl.}
PNamespace* = ptr Tcl_Namespace PNamespace* = ptr TNamespace
Tcl_Namespace*{.final.} = object TNamespace*{.final.} = object
name*: cstring name*: cstring
fullName*: cstring fullName*: cstring
clientData*: Tcl_ClientData clientData*: TClientData
deleteProc*: TNamespaceDeleteProc deleteProc*: TNamespaceDeleteProc
parentPtr*: PNamespace parentPtr*: PNamespace
PCallFrame* = ptr Tcl_CallFrame PCallFrame* = ptr TCallFrame
Tcl_CallFrame*{.final.} = object TCallFrame*{.final.} = object
nsPtr*: PNamespace nsPtr*: PNamespace
dummy1*: int dummy1*: int
dummy2*: int dummy2*: int
@ -514,19 +512,19 @@ type
dummy9*: int dummy9*: int
dummy10*: cstring dummy10*: cstring
PCmdInfo* = ptr Tcl_CmdInfo PCmdInfo* = ptr TCmdInfo
Tcl_CmdInfo*{.final.} = object TCmdInfo*{.final.} = object
isNativeObjectProc*: int isNativeObjectProc*: int
objProc*: TObjCmdProc objProc*: TObjCmdProc
objClientData*: Tcl_ClientData objClientData*: TClientData
prc*: TCmdProc prc*: TCmdProc
clientData*: Tcl_ClientData clientData*: TClientData
deleteProc*: TCmdDeleteProc deleteProc*: TCmdDeleteProc
deleteData*: Tcl_ClientData deleteData*: TClientData
namespacePtr*: pNamespace namespacePtr*: pNamespace
pCommand* = ptr Tcl_Command pCommand* = ptr TCommand
Tcl_Command*{.final.} = object # hPtr : pTcl_HashEntry; TCommand*{.final.} = object # hPtr : pTcl_HashEntry;
# nsPtr : pTcl_Namespace; # nsPtr : pTcl_Namespace;
# refCount : integer; # refCount : integer;
# isCmdEpoch : integer; # isCmdEpoch : integer;
@ -544,196 +542,196 @@ type
type type
TPanicProc* = proc (fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8: cstring){. TPanicProc* = proc (fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8: cstring){.
cdecl.} # 1/15/97 orig. Tcl style cdecl.} # 1/15/97 orig. Tcl style
TClientDataProc* = proc (clientData: Tcl_ClientData){.cdecl.} TClientDataProc* = proc (clientData: TClientData){.cdecl.}
TIdleProc* = proc (clientData: Tcl_ClientData){.cdecl.} TIdleProc* = proc (clientData: TClientData){.cdecl.}
TTimerProc* = TIdleProc TTimerProc* = TIdleProc
TCreateCloseHandler* = proc (channel: pChannel, prc: TClientDataProc, TCreateCloseHandler* = proc (channel: pChannel, prc: TClientDataProc,
clientData: Tcl_ClientData){.cdecl.} clientData: TClientData){.cdecl.}
TDeleteCloseHandler* = TCreateCloseHandler TDeleteCloseHandler* = TCreateCloseHandler
TEventDeleteProc* = proc (evPtr: pEvent, clientData: Tcl_ClientData): int{. TEventDeleteProc* = proc (evPtr: pEvent, clientData: TClientData): int{.
cdecl.} cdecl.}
proc Tcl_Alloc*(size: int): cstring{.cdecl, dynlib: dllName, proc Alloc*(size: int): cstring{.cdecl, dynlib: dllName,
importc: "Tcl_Alloc".} importc: "Tcl_Alloc".}
proc Tcl_CreateInterp*(): pInterp{.cdecl, dynlib: dllName, proc CreateInterp*(): pInterp{.cdecl, dynlib: dllName,
importc: "Tcl_CreateInterp".} importc: "Tcl_CreateInterp".}
proc Tcl_DeleteInterp*(interp: pInterp){.cdecl, dynlib: dllName, proc DeleteInterp*(interp: pInterp){.cdecl, dynlib: dllName,
importc: "Tcl_DeleteInterp".} importc: "Tcl_DeleteInterp".}
proc Tcl_ResetResult*(interp: pInterp){.cdecl, dynlib: dllName, proc ResetResult*(interp: pInterp){.cdecl, dynlib: dllName,
importc: "Tcl_ResetResult".} importc: "Tcl_ResetResult".}
proc Tcl_Eval*(interp: pInterp, script: cstring): int{.cdecl, dynlib: dllName, proc Eval*(interp: pInterp, script: cstring): int{.cdecl, dynlib: dllName,
importc: "Tcl_Eval".} importc: "Tcl_Eval".}
proc Tcl_EvalFile*(interp: pInterp, filename: cstring): int{.cdecl, proc EvalFile*(interp: pInterp, filename: cstring): int{.cdecl,
dynlib: dllName, importc: "Tcl_EvalFile".} dynlib: dllName, importc: "Tcl_EvalFile".}
proc Tcl_AddErrorInfo*(interp: pInterp, message: cstring){.cdecl, proc AddErrorInfo*(interp: pInterp, message: cstring){.cdecl,
dynlib: dllName, importc: "Tcl_AddErrorInfo".} dynlib: dllName, importc: "Tcl_AddErrorInfo".}
proc Tcl_BackgroundError*(interp: pInterp){.cdecl, dynlib: dllName, proc BackgroundError*(interp: pInterp){.cdecl, dynlib: dllName,
importc: "Tcl_BackgroundError".} importc: "Tcl_BackgroundError".}
proc Tcl_CreateCommand*(interp: pInterp, name: cstring, cmdProc: TCmdProc, proc CreateCommand*(interp: pInterp, name: cstring, cmdProc: TCmdProc,
clientData: Tcl_ClientData, deleteProc: TCmdDeleteProc): pCommand{. clientData: TClientData, deleteProc: TCmdDeleteProc): pCommand{.
cdecl, dynlib: dllName, importc: "Tcl_CreateCommand".} cdecl, dynlib: dllName, importc: "Tcl_CreateCommand".}
proc Tcl_DeleteCommand*(interp: pInterp, name: cstring): int{.cdecl, proc DeleteCommand*(interp: pInterp, name: cstring): int{.cdecl,
dynlib: dllName, importc: "Tcl_DeleteCommand".} dynlib: dllName, importc: "Tcl_DeleteCommand".}
proc Tcl_CallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc, proc CallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc,
clientData: Tcl_ClientData){.cdecl, dynlib: dllName, clientData: TClientData){.cdecl, dynlib: dllName,
importc: "Tcl_CallWhenDeleted".} importc: "Tcl_CallWhenDeleted".}
proc Tcl_DontCallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc, proc DontCallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc,
clientData: Tcl_ClientData){.cdecl, clientData: TClientData){.cdecl,
dynlib: dllName, importc: "Tcl_DontCallWhenDeleted".} dynlib: dllName, importc: "Tcl_DontCallWhenDeleted".}
proc Tcl_CommandComplete*(cmd: cstring): int{.cdecl, dynlib: dllName, proc CommandComplete*(cmd: cstring): int{.cdecl, dynlib: dllName,
importc: "Tcl_CommandComplete".} importc: "Tcl_CommandComplete".}
proc Tcl_LinkVar*(interp: pInterp, varName: cstring, varAddr: pointer, typ: int): int{. proc LinkVar*(interp: pInterp, varName: cstring, varAddr: pointer, typ: int): int{.
cdecl, dynlib: dllName, importc: "Tcl_LinkVar".} cdecl, dynlib: dllName, importc: "Tcl_LinkVar".}
proc Tcl_UnlinkVar*(interp: pInterp, varName: cstring){.cdecl, dynlib: dllName, proc UnlinkVar*(interp: pInterp, varName: cstring){.cdecl, dynlib: dllName,
importc: "Tcl_UnlinkVar".} importc: "Tcl_UnlinkVar".}
proc Tcl_TraceVar*(interp: pInterp, varName: cstring, flags: int, proc TraceVar*(interp: pInterp, varName: cstring, flags: int,
prc: TVarTraceProc, clientData: Tcl_ClientData): int{.cdecl, prc: TVarTraceProc, clientData: TClientData): int{.cdecl,
dynlib: dllName, importc: "Tcl_TraceVar".} dynlib: dllName, importc: "Tcl_TraceVar".}
proc Tcl_TraceVar2*(interp: pInterp, varName: cstring, elemName: cstring, proc TraceVar2*(interp: pInterp, varName: cstring, elemName: cstring,
flags: int, prc: TVarTraceProc, clientData: Tcl_ClientData): int{. flags: int, prc: TVarTraceProc, clientData: TClientData): int{.
cdecl, dynlib: dllName, importc: "Tcl_TraceVar2".} cdecl, dynlib: dllName, importc: "Tcl_TraceVar2".}
proc Tcl_UntraceVar*(interp: pInterp, varName: cstring, flags: int, proc UntraceVar*(interp: pInterp, varName: cstring, flags: int,
prc: TVarTraceProc, clientData: Tcl_ClientData){.cdecl, prc: TVarTraceProc, clientData: TClientData){.cdecl,
dynlib: dllName, importc: "Tcl_UntraceVar".} dynlib: dllName, importc: "Tcl_UntraceVar".}
proc Tcl_UntraceVar2*(interp: pInterp, varName: cstring, elemName: cstring, proc UntraceVar2*(interp: pInterp, varName: cstring, elemName: cstring,
flags: int, prc: TVarTraceProc, clientData: Tcl_ClientData){. flags: int, prc: TVarTraceProc, clientData: TClientData){.
cdecl, dynlib: dllName, importc: "Tcl_UntraceVar2".} cdecl, dynlib: dllName, importc: "Tcl_UntraceVar2".}
proc Tcl_GetVar*(interp: pInterp, varName: cstring, flags: int): cstring{.cdecl, proc GetVar*(interp: pInterp, varName: cstring, flags: int): cstring{.cdecl,
dynlib: dllName, importc: "Tcl_GetVar".} dynlib: dllName, importc: "Tcl_GetVar".}
proc Tcl_GetVar2*(interp: pInterp, varName: cstring, elemName: cstring, proc GetVar2*(interp: pInterp, varName: cstring, elemName: cstring,
flags: int): cstring{.cdecl, dynlib: dllName, flags: int): cstring{.cdecl, dynlib: dllName,
importc: "Tcl_GetVar2".} importc: "Tcl_GetVar2".}
proc Tcl_SetVar*(interp: pInterp, varName: cstring, newValue: cstring, proc SetVar*(interp: pInterp, varName: cstring, newValue: cstring,
flags: int): cstring{.cdecl, dynlib: dllName, flags: int): cstring{.cdecl, dynlib: dllName,
importc: "Tcl_SetVar".} importc: "Tcl_SetVar".}
proc Tcl_SetVar2*(interp: pInterp, varName: cstring, elemName: cstring, proc SetVar2*(interp: pInterp, varName: cstring, elemName: cstring,
newValue: cstring, flags: int): cstring{.cdecl, newValue: cstring, flags: int): cstring{.cdecl,
dynlib: dllName, importc: "Tcl_SetVar2".} dynlib: dllName, importc: "Tcl_SetVar2".}
proc Tcl_UnsetVar*(interp: pInterp, varName: cstring, flags: int): int{.cdecl, proc UnsetVar*(interp: pInterp, varName: cstring, flags: int): int{.cdecl,
dynlib: dllName, importc: "Tcl_UnsetVar".} dynlib: dllName, importc: "Tcl_UnsetVar".}
proc Tcl_UnsetVar2*(interp: pInterp, varName: cstring, elemName: cstring, proc UnsetVar2*(interp: pInterp, varName: cstring, elemName: cstring,
flags: int): int{.cdecl, dynlib: dllName, flags: int): int{.cdecl, dynlib: dllName,
importc: "Tcl_UnsetVar2".} importc: "Tcl_UnsetVar2".}
proc Tcl_SetResult*(interp: pInterp, newValue: cstring, freeProc: TFreeProc){. proc SetResult*(interp: pInterp, newValue: cstring, freeProc: TFreeProc){.
cdecl, dynlib: dllName, importc: "Tcl_SetResult".} cdecl, dynlib: dllName, importc: "Tcl_SetResult".}
proc Tcl_FirstHashEntry*(hashTbl: pHashTable, searchInfo: var Tcl_HashSearch): pHashEntry{. proc FirstHashEntry*(hashTbl: pHashTable, searchInfo: var THashSearch): pHashEntry{.
cdecl, dynlib: dllName, importc: "Tcl_FirstHashEntry".} cdecl, dynlib: dllName, importc: "Tcl_FirstHashEntry".}
proc Tcl_NextHashEntry*(searchInfo: var Tcl_HashSearch): pHashEntry{.cdecl, proc NextHashEntry*(searchInfo: var THashSearch): pHashEntry{.cdecl,
dynlib: dllName, importc: "Tcl_NextHashEntry".} dynlib: dllName, importc: "Tcl_NextHashEntry".}
proc Tcl_InitHashTable*(hashTbl: pHashTable, keyType: int){.cdecl, proc InitHashTable*(hashTbl: pHashTable, keyType: int){.cdecl,
dynlib: dllName, importc: "Tcl_InitHashTable".} dynlib: dllName, importc: "Tcl_InitHashTable".}
proc Tcl_StringMatch*(str: cstring, pattern: cstring): int{.cdecl, proc StringMatch*(str: cstring, pattern: cstring): int{.cdecl,
dynlib: dllName, importc: "Tcl_StringMatch".} dynlib: dllName, importc: "Tcl_StringMatch".}
proc Tcl_GetErrno*(): int{.cdecl, dynlib: dllName, importc: "Tcl_GetErrno".} proc GetErrno*(): int{.cdecl, dynlib: dllName, importc: "Tcl_GetErrno".}
proc Tcl_SetErrno*(val: int){.cdecl, dynlib: dllName, importc: "Tcl_SetErrno".} proc SetErrno*(val: int){.cdecl, dynlib: dllName, importc: "Tcl_SetErrno".}
proc Tcl_SetPanicProc*(prc: TPanicProc){.cdecl, dynlib: dllName, proc SetPanicProc*(prc: TPanicProc){.cdecl, dynlib: dllName,
importc: "Tcl_SetPanicProc".} importc: "Tcl_SetPanicProc".}
proc Tcl_PkgProvide*(interp: pInterp, name: cstring, version: cstring): int{. proc PkgProvide*(interp: pInterp, name: cstring, version: cstring): int{.
cdecl, dynlib: dllName, importc: "Tcl_PkgProvide".} cdecl, dynlib: dllName, importc: "Tcl_PkgProvide".}
proc Tcl_StaticPackage*(interp: pInterp, pkgName: cstring, proc StaticPackage*(interp: pInterp, pkgName: cstring,
initProc: TPackageInitProc, initProc: TPackageInitProc,
safeInitProc: TPackageInitProc){.cdecl, dynlib: dllName, safeInitProc: TPackageInitProc){.cdecl, dynlib: dllName,
importc: "Tcl_StaticPackage".} importc: "Tcl_StaticPackage".}
proc Tcl_CreateEventSource*(setupProc: TEventSetupProc, proc CreateEventSource*(setupProc: TEventSetupProc,
checkProc: TEventCheckProc, checkProc: TEventCheckProc,
clientData: Tcl_ClientData){.cdecl, dynlib: dllName, clientData: TClientData){.cdecl, dynlib: dllName,
importc: "Tcl_CreateEventSource".} importc: "Tcl_CreateEventSource".}
proc Tcl_DeleteEventSource*(setupProc: TEventSetupProc, proc DeleteEventSource*(setupProc: TEventSetupProc,
checkProc: TEventCheckProc, checkProc: TEventCheckProc,
clientData: Tcl_ClientData){.cdecl, dynlib: dllName, clientData: TClientData){.cdecl, dynlib: dllName,
importc: "Tcl_DeleteEventSource".} importc: "Tcl_DeleteEventSource".}
proc Tcl_QueueEvent*(evPtr: pEvent, pos: int){.cdecl, dynlib: dllName, proc QueueEvent*(evPtr: pEvent, pos: int){.cdecl, dynlib: dllName,
importc: "Tcl_QueueEvent".} importc: "Tcl_QueueEvent".}
proc Tcl_SetMaxBlockTime*(timePtr: pTime){.cdecl, dynlib: dllName, proc SetMaxBlockTime*(timePtr: pTime){.cdecl, dynlib: dllName,
importc: "Tcl_SetMaxBlockTime".} importc: "Tcl_SetMaxBlockTime".}
proc Tcl_DeleteEvents*(prc: TEventDeleteProc, clientData: Tcl_ClientData){. proc DeleteEvents*(prc: TEventDeleteProc, clientData: TClientData){.
cdecl, dynlib: dllName, importc: "Tcl_DeleteEvents".} cdecl, dynlib: dllName, importc: "Tcl_DeleteEvents".}
proc Tcl_DoOneEvent*(flags: int): int{.cdecl, dynlib: dllName, proc DoOneEvent*(flags: int): int{.cdecl, dynlib: dllName,
importc: "Tcl_DoOneEvent".} importc: "Tcl_DoOneEvent".}
proc Tcl_DoWhenIdle*(prc: TIdleProc, clientData: Tcl_ClientData){.cdecl, proc DoWhenIdle*(prc: TIdleProc, clientData: TClientData){.cdecl,
dynlib: dllName, importc: "Tcl_DoWhenIdle".} dynlib: dllName, importc: "Tcl_DoWhenIdle".}
proc Tcl_CancelIdleCall*(prc: TIdleProc, clientData: Tcl_ClientData){.cdecl, proc CancelIdleCall*(prc: TIdleProc, clientData: TClientData){.cdecl,
dynlib: dllName, importc: "Tcl_CancelIdleCall".} dynlib: dllName, importc: "Tcl_CancelIdleCall".}
proc Tcl_CreateTimerHandler*(milliseconds: int, prc: TTimerProc, proc CreateTimerHandler*(milliseconds: int, prc: TTimerProc,
clientData: Tcl_ClientData): Tcl_TimerToken{.cdecl, clientData: TClientData): TTimerToken{.cdecl,
dynlib: dllName, importc: "Tcl_CreateTimerHandler".} dynlib: dllName, importc: "Tcl_CreateTimerHandler".}
proc Tcl_DeleteTimerHandler*(token: Tcl_TimerToken){.cdecl, dynlib: dllName, proc DeleteTimerHandler*(token: TTimerToken){.cdecl, dynlib: dllName,
importc: "Tcl_DeleteTimerHandler".} importc: "Tcl_DeleteTimerHandler".}
# procedure Tcl_CreateModalTimeout(milliseconds: integer; prc: TTclTimerProc; clientData: Tcl_ClientData); cdecl; external dllName; # procedure Tcl_CreateModalTimeout(milliseconds: integer; prc: TTclTimerProc; clientData: Tcl_ClientData); cdecl; external dllName;
# procedure Tcl_DeleteModalTimeout(prc: TTclTimerProc; clientData: Tcl_ClientData); cdecl; external dllName; # procedure Tcl_DeleteModalTimeout(prc: TTclTimerProc; clientData: Tcl_ClientData); cdecl; external dllName;
proc Tcl_SplitList*(interp: pInterp, list: cstring, argcPtr: var int, proc SplitList*(interp: pInterp, list: cstring, argcPtr: var int,
argvPtr: var Tcl_Argv): int{.cdecl, dynlib: dllName, argvPtr: var TArgv): int{.cdecl, dynlib: dllName,
importc: "Tcl_SplitList".} importc: "Tcl_SplitList".}
proc Tcl_Merge*(argc: int, argv: Tcl_Argv): cstring{.cdecl, dynlib: dllName, proc Merge*(argc: int, argv: TArgv): cstring{.cdecl, dynlib: dllName,
importc: "Tcl_Merge".} importc: "Tcl_Merge".}
proc Tcl_Free*(p: cstring){.cdecl, dynlib: dllName, importc: "Tcl_Free".} proc Free*(p: cstring){.cdecl, dynlib: dllName, importc: "Tcl_Free".}
proc Tcl_Init*(interp: pInterp): int{.cdecl, dynlib: dllName, proc Init*(interp: pInterp): int{.cdecl, dynlib: dllName,
importc: "Tcl_Init".} importc: "Tcl_Init".}
# procedure Tcl_InterpDeleteProc(clientData: Tcl_ClientData; interp: pTcl_Interp); cdecl; external dllName; # procedure Tcl_InterpDeleteProc(clientData: Tcl_ClientData; interp: pTcl_Interp); cdecl; external dllName;
proc Tcl_GetAssocData*(interp: pInterp, key: cstring, prc: var TInterpDeleteProc): Tcl_ClientData{. proc GetAssocData*(interp: pInterp, key: cstring, prc: var TInterpDeleteProc): TClientData{.
cdecl, dynlib: dllName, importc: "Tcl_GetAssocData".} cdecl, dynlib: dllName, importc: "Tcl_GetAssocData".}
proc Tcl_DeleteAssocData*(interp: pInterp, key: cstring){.cdecl, proc DeleteAssocData*(interp: pInterp, key: cstring){.cdecl,
dynlib: dllName, importc: "Tcl_DeleteAssocData".} dynlib: dllName, importc: "Tcl_DeleteAssocData".}
proc Tcl_SetAssocData*(interp: pInterp, key: cstring, prc: TInterpDeleteProc, proc SetAssocData*(interp: pInterp, key: cstring, prc: TInterpDeleteProc,
clientData: Tcl_ClientData){.cdecl, dynlib: dllName, clientData: TClientData){.cdecl, dynlib: dllName,
importc: "Tcl_SetAssocData".} importc: "Tcl_SetAssocData".}
proc Tcl_IsSafe*(interp: pInterp): int{.cdecl, dynlib: dllName, proc IsSafe*(interp: pInterp): int{.cdecl, dynlib: dllName,
importc: "Tcl_IsSafe".} importc: "Tcl_IsSafe".}
proc Tcl_MakeSafe*(interp: pInterp): int{.cdecl, dynlib: dllName, proc MakeSafe*(interp: pInterp): int{.cdecl, dynlib: dllName,
importc: "Tcl_MakeSafe".} importc: "Tcl_MakeSafe".}
proc Tcl_CreateSlave*(interp: pInterp, slaveName: cstring, isSafe: int): pInterp{. proc CreateSlave*(interp: pInterp, slaveName: cstring, isSafe: int): pInterp{.
cdecl, dynlib: dllName, importc: "Tcl_CreateSlave".} cdecl, dynlib: dllName, importc: "Tcl_CreateSlave".}
proc Tcl_GetSlave*(interp: pInterp, slaveName: cstring): pInterp{.cdecl, proc GetSlave*(interp: pInterp, slaveName: cstring): pInterp{.cdecl,
dynlib: dllName, importc: "Tcl_GetSlave".} dynlib: dllName, importc: "Tcl_GetSlave".}
proc Tcl_GetMaster*(interp: pInterp): pInterp{.cdecl, dynlib: dllName, proc GetMaster*(interp: pInterp): pInterp{.cdecl, dynlib: dllName,
importc: "Tcl_GetMaster".} importc: "Tcl_GetMaster".}
proc Tcl_GetInterpPath*(askingInterp: pInterp, slaveInterp: pInterp): int{. proc GetInterpPath*(askingInterp: pInterp, slaveInterp: pInterp): int{.
cdecl, dynlib: dllName, importc: "Tcl_GetInterpPath".} cdecl, dynlib: dllName, importc: "Tcl_GetInterpPath".}
proc Tcl_CreateAlias*(slaveInterp: pInterp, srcCmd: cstring, proc CreateAlias*(slaveInterp: pInterp, srcCmd: cstring,
targetInterp: pInterp, targetCmd: cstring, argc: int, targetInterp: pInterp, targetCmd: cstring, argc: int,
argv: Tcl_Argv): int{.cdecl, dynlib: dllName, argv: TArgv): int{.cdecl, dynlib: dllName,
importc: "Tcl_CreateAlias".} importc: "Tcl_CreateAlias".}
proc Tcl_GetAlias*(interp: pInterp, srcCmd: cstring, targetInterp: var pInterp, proc GetAlias*(interp: pInterp, srcCmd: cstring, targetInterp: var pInterp,
targetCmd: var cstring, argc: var int, argv: var Tcl_Argv): int{. targetCmd: var cstring, argc: var int, argv: var TArgv): int{.
cdecl, dynlib: dllName, importc: "Tcl_GetAlias".} cdecl, dynlib: dllName, importc: "Tcl_GetAlias".}
proc Tcl_ExposeCommand*(interp: pInterp, hiddenCmdName: cstring, proc ExposeCommand*(interp: pInterp, hiddenCmdName: cstring,
cmdName: cstring): int{.cdecl, dynlib: dllName, cmdName: cstring): int{.cdecl, dynlib: dllName,
importc: "Tcl_ExposeCommand".} importc: "Tcl_ExposeCommand".}
proc Tcl_HideCommand*(interp: pInterp, cmdName: cstring, hiddenCmdName: cstring): int{. proc HideCommand*(interp: pInterp, cmdName: cstring, hiddenCmdName: cstring): int{.
cdecl, dynlib: dllName, importc: "Tcl_HideCommand".} cdecl, dynlib: dllName, importc: "Tcl_HideCommand".}
proc Tcl_EventuallyFree*(clientData: Tcl_ClientData, freeProc: TFreeProc){. proc EventuallyFree*(clientData: TClientData, freeProc: TFreeProc){.
cdecl, dynlib: dllName, importc: "Tcl_EventuallyFree".} cdecl, dynlib: dllName, importc: "Tcl_EventuallyFree".}
proc Tcl_Preserve*(clientData: Tcl_ClientData){.cdecl, dynlib: dllName, proc Preserve*(clientData: TClientData){.cdecl, dynlib: dllName,
importc: "Tcl_Preserve".} importc: "Tcl_Preserve".}
proc Tcl_Release*(clientData: Tcl_ClientData){.cdecl, dynlib: dllName, proc Release*(clientData: TClientData){.cdecl, dynlib: dllName,
importc: "Tcl_Release".} importc: "Tcl_Release".}
proc Tcl_InterpDeleted*(interp: pInterp): int{.cdecl, dynlib: dllName, proc InterpDeleted*(interp: pInterp): int{.cdecl, dynlib: dllName,
importc: "Tcl_InterpDeleted".} importc: "Tcl_InterpDeleted".}
proc Tcl_GetCommandInfo*(interp: pInterp, cmdName: cstring, proc GetCommandInfo*(interp: pInterp, cmdName: cstring,
info: var Tcl_CmdInfo): int{.cdecl, dynlib: dllName, info: var TCmdInfo): int{.cdecl, dynlib: dllName,
importc: "Tcl_GetCommandInfo".} importc: "Tcl_GetCommandInfo".}
proc Tcl_SetCommandInfo*(interp: pInterp, cmdName: cstring, proc SetCommandInfo*(interp: pInterp, cmdName: cstring,
info: var Tcl_CmdInfo): int{.cdecl, dynlib: dllName, info: var TCmdInfo): int{.cdecl, dynlib: dllName,
importc: "Tcl_SetCommandInfo".} importc: "Tcl_SetCommandInfo".}
proc Tcl_FindExecutable*(path: cstring){.cdecl, dynlib: dllName, proc FindExecutable*(path: cstring){.cdecl, dynlib: dllName,
importc: "Tcl_FindExecutable".} importc: "Tcl_FindExecutable".}
proc Tcl_GetStringResult*(interp: pInterp): cstring{.cdecl, dynlib: dllName, proc GetStringResult*(interp: pInterp): cstring{.cdecl, dynlib: dllName,
importc: "Tcl_GetStringResult".} importc: "Tcl_GetStringResult".}
#v1.0 #v1.0
proc Tcl_FindCommand*(interp: pInterp, cmdName: cstring, proc FindCommand*(interp: pInterp, cmdName: cstring,
contextNsPtr: pNamespace, flags: int): Tcl_Command{.cdecl, contextNsPtr: pNamespace, flags: int): TCommand{.cdecl,
dynlib: dllName, importc: "Tcl_FindCommand".} dynlib: dllName, importc: "Tcl_FindCommand".}
#v1.0 #v1.0
proc Tcl_DeleteCommandFromToken*(interp: pInterp, cmd: pCommand): int{.cdecl, proc DeleteCommandFromToken*(interp: pInterp, cmd: pCommand): int{.cdecl,
dynlib: dllName, importc: "Tcl_DeleteCommandFromToken".} dynlib: dllName, importc: "Tcl_DeleteCommandFromToken".}
proc Tcl_CreateNamespace*(interp: pInterp, name: cstring, proc CreateNamespace*(interp: pInterp, name: cstring,
clientData: Tcl_ClientData, clientData: TClientData,
deleteProc: TNamespaceDeleteProc): pNamespace{.cdecl, deleteProc: TNamespaceDeleteProc): pNamespace{.cdecl,
dynlib: dllName, importc: "Tcl_CreateNamespace".} dynlib: dllName, importc: "Tcl_CreateNamespace".}
#v1.0 #v1.0
proc Tcl_DeleteNamespace*(namespacePtr: pNamespace){.cdecl, dynlib: dllName, proc DeleteNamespace*(namespacePtr: pNamespace){.cdecl, dynlib: dllName,
importc: "Tcl_DeleteNamespace".} importc: "Tcl_DeleteNamespace".}
proc Tcl_FindNamespace*(interp: pInterp, name: cstring, proc FindNamespace*(interp: pInterp, name: cstring,
contextNsPtr: pNamespace, flags: int): pNamespace{. contextNsPtr: pNamespace, flags: int): pNamespace{.
cdecl, dynlib: dllName, importc: "Tcl_FindNamespace".} cdecl, dynlib: dllName, importc: "Tcl_FindNamespace".}
proc Tcl_Export*(interp: pInterp, namespacePtr: pNamespace, pattern: cstring, proc Tcl_Export*(interp: pInterp, namespacePtr: pNamespace, pattern: cstring,
@ -742,118 +740,124 @@ proc Tcl_Export*(interp: pInterp, namespacePtr: pNamespace, pattern: cstring,
proc Tcl_Import*(interp: pInterp, namespacePtr: pNamespace, pattern: cstring, proc Tcl_Import*(interp: pInterp, namespacePtr: pNamespace, pattern: cstring,
allowOverwrite: int): int{.cdecl, dynlib: dllName, allowOverwrite: int): int{.cdecl, dynlib: dllName,
importc: "Tcl_Import".} importc: "Tcl_Import".}
proc Tcl_GetCurrentNamespace*(interp: pInterp): pNamespace{.cdecl, proc GetCurrentNamespace*(interp: pInterp): pNamespace{.cdecl,
dynlib: dllName, importc: "Tcl_GetCurrentNamespace".} dynlib: dllName, importc: "Tcl_GetCurrentNamespace".}
proc Tcl_GetGlobalNamespace*(interp: pInterp): pNamespace{.cdecl, proc GetGlobalNamespace*(interp: pInterp): pNamespace{.cdecl,
dynlib: dllName, importc: "Tcl_GetGlobalNamespace".} dynlib: dllName, importc: "Tcl_GetGlobalNamespace".}
proc Tcl_PushCallFrame*(interp: pInterp, callFramePtr: var Tcl_CallFrame, proc PushCallFrame*(interp: pInterp, callFramePtr: var TCallFrame,
namespacePtr: pNamespace, isProcCallFrame: int): int{. namespacePtr: pNamespace, isProcCallFrame: int): int{.
cdecl, dynlib: dllName, importc: "Tcl_PushCallFrame".} cdecl, dynlib: dllName, importc: "Tcl_PushCallFrame".}
proc Tcl_PopCallFrame*(interp: pInterp){.cdecl, dynlib: dllName, proc PopCallFrame*(interp: pInterp){.cdecl, dynlib: dllName,
importc: "Tcl_PopCallFrame".} importc: "Tcl_PopCallFrame".}
proc Tcl_VarEval*(interp: pInterp): int{.cdecl, varargs, dynlib: dllName, proc VarEval*(interp: pInterp): int{.cdecl, varargs, dynlib: dllName,
importc: "Tcl_VarEval".} importc: "Tcl_VarEval".}
# For TkConsole.c * # For TkConsole.c *
proc Tcl_RecordAndEval*(interp: pInterp, cmd: cstring, flags: int): int{.cdecl, proc RecordAndEval*(interp: pInterp, cmd: cstring, flags: int): int{.cdecl,
dynlib: dllName, importc: "Tcl_RecordAndEval".} dynlib: dllName, importc: "Tcl_RecordAndEval".}
proc Tcl_GlobalEval*(interp: pInterp, command: cstring): int{.cdecl, proc GlobalEval*(interp: pInterp, command: cstring): int{.cdecl,
dynlib: dllName, importc: "Tcl_GlobalEval".} dynlib: dllName, importc: "Tcl_GlobalEval".}
proc Tcl_DStringFree*(dsPtr: pDString){.cdecl, dynlib: dllName, proc DStringFree*(dsPtr: pDString){.cdecl, dynlib: dllName,
importc: "Tcl_DStringFree".} importc: "Tcl_DStringFree".}
proc Tcl_DStringAppend*(dsPtr: pDString, str: cstring, length: int): cstring{. proc DStringAppend*(dsPtr: pDString, str: cstring, length: int): cstring{.
cdecl, dynlib: dllName, importc: "Tcl_DStringAppend".} cdecl, dynlib: dllName, importc: "Tcl_DStringAppend".}
proc Tcl_DStringAppendElement*(dsPtr: pDString, str: cstring): cstring{.cdecl, proc DStringAppendElement*(dsPtr: pDString, str: cstring): cstring{.cdecl,
dynlib: dllName, importc: "Tcl_DStringAppendElement".} dynlib: dllName, importc: "Tcl_DStringAppendElement".}
proc Tcl_DStringInit*(dsPtr: pDString){.cdecl, dynlib: dllName, proc DStringInit*(dsPtr: pDString){.cdecl, dynlib: dllName,
importc: "Tcl_DStringInit".} importc: "Tcl_DStringInit".}
proc Tcl_AppendResult*(interp: pInterp){.cdecl, varargs, dynlib: dllName, proc AppendResult*(interp: pInterp){.cdecl, varargs, dynlib: dllName,
importc: "Tcl_AppendResult".} importc: "Tcl_AppendResult".}
# actually a "C" var array # actually a "C" var array
proc Tcl_SetStdChannel*(channel: pChannel, typ: int){.cdecl, dynlib: dllName, proc SetStdChannel*(channel: pChannel, typ: int){.cdecl, dynlib: dllName,
importc: "Tcl_SetStdChannel".} importc: "Tcl_SetStdChannel".}
proc Tcl_SetChannelOption*(interp: pInterp, chan: pChannel, optionName: cstring, proc SetChannelOption*(interp: pInterp, chan: pChannel, optionName: cstring,
newValue: cstring): int{.cdecl, dynlib: dllName, newValue: cstring): int{.cdecl, dynlib: dllName,
importc: "Tcl_SetChannelOption".} importc: "Tcl_SetChannelOption".}
proc Tcl_GetChannelOption*(interp: pInterp, chan: pChannel, optionName: cstring, proc GetChannelOption*(interp: pInterp, chan: pChannel, optionName: cstring,
dsPtr: pDString): int{.cdecl, dynlib: dllName, dsPtr: pDString): int{.cdecl, dynlib: dllName,
importc: "Tcl_GetChannelOption".} importc: "Tcl_GetChannelOption".}
proc Tcl_CreateChannel*(typePtr: pChannelType, chanName: cstring, proc CreateChannel*(typePtr: pChannelType, chanName: cstring,
instanceData: Tcl_ClientData, mask: int): pChannel{. instanceData: TClientData, mask: int): pChannel{.
cdecl, dynlib: dllName, importc: "Tcl_CreateChannel".} cdecl, dynlib: dllName, importc: "Tcl_CreateChannel".}
proc Tcl_RegisterChannel*(interp: pInterp, channel: pChannel){.cdecl, proc RegisterChannel*(interp: pInterp, channel: pChannel){.cdecl,
dynlib: dllName, importc: "Tcl_RegisterChannel".} dynlib: dllName, importc: "Tcl_RegisterChannel".}
proc Tcl_UnregisterChannel*(interp: pInterp, channel: pChannel): int{.cdecl, proc UnregisterChannel*(interp: pInterp, channel: pChannel): int{.cdecl,
dynlib: dllName, importc: "Tcl_UnregisterChannel".} dynlib: dllName, importc: "Tcl_UnregisterChannel".}
proc Tcl_CreateChannelHandler*(chan: pChannel, mask: int, prc: TChannelProc, proc CreateChannelHandler*(chan: pChannel, mask: int, prc: TChannelProc,
clientData: Tcl_ClientData){.cdecl, clientData: TClientData){.cdecl,
dynlib: dllName, importc: "Tcl_CreateChannelHandler".} dynlib: dllName, importc: "Tcl_CreateChannelHandler".}
proc Tcl_GetChannel*(interp: pInterp, chanName: cstring, modePtr: pInteger): pChannel{. proc GetChannel*(interp: pInterp, chanName: cstring, modePtr: pInteger): pChannel{.
cdecl, dynlib: dllName, importc: "Tcl_GetChannel".} cdecl, dynlib: dllName, importc: "Tcl_GetChannel".}
proc Tcl_GetStdChannel*(typ: int): pChannel{.cdecl, dynlib: dllName, proc GetStdChannel*(typ: int): pChannel{.cdecl, dynlib: dllName,
importc: "Tcl_GetStdChannel".} importc: "Tcl_GetStdChannel".}
proc Tcl_Gets*(chan: pChannel, dsPtr: pDString): int{.cdecl, dynlib: dllName, proc Gets*(chan: pChannel, dsPtr: pDString): int{.cdecl, dynlib: dllName,
importc: "Tcl_Gets".} importc: "Tcl_Gets".}
proc Tcl_Write*(chan: pChannel, s: cstring, slen: int): int{.cdecl, proc Write*(chan: pChannel, s: cstring, slen: int): int{.cdecl,
dynlib: dllName, importc: "Tcl_Write".} dynlib: dllName, importc: "Tcl_Write".}
proc Tcl_Flush*(chan: pChannel): int{.cdecl, dynlib: dllName, proc Flush*(chan: pChannel): int{.cdecl, dynlib: dllName,
importc: "Tcl_Flush".} importc: "Tcl_Flush".}
# TclWinLoadLibrary = function(name: PChar): HMODULE; cdecl; external dllName; # TclWinLoadLibrary = function(name: PChar): HMODULE; cdecl; external dllName;
proc Tcl_CreateExitHandler*(prc: TClientDataProc, clientData: Tcl_ClientData){. proc CreateExitHandler*(prc: TClientDataProc, clientData: TClientData){.
cdecl, dynlib: dllName, importc: "Tcl_CreateExitHandler".} cdecl, dynlib: dllName, importc: "Tcl_CreateExitHandler".}
proc Tcl_DeleteExitHandler*(prc: TClientDataProc, clientData: Tcl_ClientData){. proc DeleteExitHandler*(prc: TClientDataProc, clientData: TClientData){.
cdecl, dynlib: dllName, importc: "Tcl_DeleteExitHandler".} cdecl, dynlib: dllName, importc: "Tcl_DeleteExitHandler".}
proc Tcl_GetStringFromObj*(pObj: pObj, pLen: pInteger): cstring{.cdecl, proc GetStringFromObj*(pObj: pObj, pLen: pInteger): cstring{.cdecl,
dynlib: dllName, importc: "Tcl_GetStringFromObj".} dynlib: dllName, importc: "Tcl_GetStringFromObj".}
proc Tcl_CreateObjCommand*(interp: pInterp, name: cstring, cmdProc: TObjCmdProc, proc CreateObjCommand*(interp: pInterp, name: cstring, cmdProc: TObjCmdProc,
clientData: Tcl_ClientData, clientData: TClientData,
deleteProc: TCmdDeleteProc): pCommand{.cdecl, deleteProc: TCmdDeleteProc): pCommand{.cdecl,
dynlib: dllName, importc: "Tcl_CreateObjCommand".} dynlib: dllName, importc: "Tcl_CreateObjCommand".}
proc Tcl_NewStringObj*(bytes: cstring, length: int): pObj{.cdecl, proc NewStringObj*(bytes: cstring, length: int): pObj{.cdecl,
dynlib: dllName, importc: "Tcl_NewStringObj".} dynlib: dllName, importc: "Tcl_NewStringObj".}
# procedure TclFreeObj(pObj: pTcl_Obj); cdecl; external dllName; # procedure TclFreeObj(pObj: pTcl_Obj); cdecl; external dllName;
proc Tcl_EvalObj*(interp: pInterp, pObj: pObj): int{.cdecl, dynlib: dllName, proc EvalObj*(interp: pInterp, pObj: pObj): int{.cdecl, dynlib: dllName,
importc: "Tcl_EvalObj".} importc: "Tcl_EvalObj".}
proc Tcl_GlobalEvalObj*(interp: pInterp, pObj: pObj): int{.cdecl, proc GlobalEvalObj*(interp: pInterp, pObj: pObj): int{.cdecl,
dynlib: dllName, importc: "Tcl_GlobalEvalObj".} dynlib: dllName, importc: "Tcl_GlobalEvalObj".}
proc TclRegComp*(exp: cstring): pointer{.cdecl, dynlib: dllName, proc RegComp*(exp: cstring): pointer{.cdecl, dynlib: dllName,
importc: "TclRegComp".} importc: "TclRegComp".}
proc TclRegExec*(prog: pointer, str: cstring, start: cstring): int{.cdecl,
proc RegExec*(prog: pointer, str: cstring, start: cstring): int{.cdecl,
dynlib: dllName, importc: "TclRegExec".} dynlib: dllName, importc: "TclRegExec".}
proc TclRegError*(msg: cstring){.cdecl, dynlib: dllName, importc: "TclRegError".}
proc TclGetRegError*(): cstring{.cdecl, dynlib: dllName, proc RegError*(msg: cstring){.cdecl, dynlib: dllName, importc: "TclRegError".}
proc GetRegError*(): cstring{.cdecl, dynlib: dllName,
importc: "TclGetRegError".} importc: "TclGetRegError".}
proc Tcl_RegExpRange*(prog: pointer, index: int, head: var cstring,
proc RegExpRange*(prog: pointer, index: int, head: var cstring,
tail: var cstring){.cdecl, dynlib: dllName, tail: var cstring){.cdecl, dynlib: dllName,
importc: "Tcl_RegExpRange".} importc: "Tcl_RegExpRange".}
proc Tcl_GetCommandTable*(interp: pInterp): pHashTable =
proc GetCommandTable*(interp: pInterp): pHashTable =
if interp != nil: if interp != nil:
result = cast[pHashTable](cast[int](interp) + sizeof(Tcl_Interp) + result = cast[pHashTable](cast[int](interp) + sizeof(Interp) +
sizeof(pointer)) sizeof(pointer))
proc Tcl_CreateHashEntry*(tablePtr: pHashTable, key: cstring, newPtr: pInteger): pHashEntry = proc CreateHashEntry*(tablePtr: pHashTable, key: cstring,
newPtr: pInteger): pHashEntry =
result = cast[pHashTable](tablePtr).createProc(tablePtr, key, newPtr) result = cast[pHashTable](tablePtr).createProc(tablePtr, key, newPtr)
proc Tcl_FindHashEntry*(tablePtr: pHashTable, key: cstring): pHashEntry = proc FindHashEntry*(tablePtr: pHashTable, key: cstring): pHashEntry =
result = cast[pHashTable](tablePtr).findProc(tablePtr, key) result = cast[pHashTable](tablePtr).findProc(tablePtr, key)
proc Tcl_SetHashValue*(h: pHashEntry, clientData: Tcl_ClientData) = proc SetHashValue*(h: pHashEntry, clientData: TClientData) =
h.clientData = clientData h.clientData = clientData
proc Tcl_GetHashValue*(h: pHashEntry): Tcl_ClientData = proc GetHashValue*(h: pHashEntry): TClientData =
result = h.clientData result = h.clientData
proc Tcl_IncrRefCount*(pObj: pObj) = proc IncrRefCount*(pObj: pObj) =
inc(pObj.refCount) inc(pObj.refCount)
proc Tcl_DecrRefCount*(pObj: pObj) = proc DecrRefCount*(pObj: pObj) =
dec(pObj.refCount) dec(pObj.refCount)
if pObj.refCount <= 0: if pObj.refCount <= 0:
dealloc(pObj) dealloc(pObj)
proc Tcl_IsShared*(pObj: pObj): bool = proc IsShared*(pObj: pObj): bool =
return pObj.refCount > 1 return pObj.refCount > 1
proc Tcl_GetHashKey*(hashTbl: pHashTable, hashEntry: pHashEntry): cstring = proc GetHashKey*(hashTbl: pHashTable, hashEntry: pHashEntry): cstring =
if hashTbl == nil or hashEntry == nil: if hashTbl == nil or hashEntry == nil:
result = nil result = nil
else: else:

4
lib/pure/cgi.nim
View file

@ -1,7 +1,7 @@
# #
# #
# Nimrod's Runtime Library # Nimrod's Runtime Library
# (c) Copyright 2009 Andreas Rumpf # (c) Copyright 2010 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
@ -170,7 +170,7 @@ iterator decodeData*(allowedMethods: set[TRequestMethod] =
var data = getEncodedData(allowedMethods) var data = getEncodedData(allowedMethods)
if not isNil(data): if not isNil(data):
for key, value in decodeData(data): for key, value in decodeData(data):
yield key, value yield (key, value)
proc readData*(allowedMethods: set[TRequestMethod] = proc readData*(allowedMethods: set[TRequestMethod] =
{methodNone, methodPost, methodGet}): PStringTable = {methodNone, methodPost, methodGet}): PStringTable =

17
lib/windows/windows.nim
View file

@ -1,7 +1,7 @@
# #
# #
# Nimrod's Runtime Library # Nimrod's Runtime Library
# (c) Copyright 2006 Andreas Rumpf # (c) Copyright 2010 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
@ -20445,7 +20445,7 @@ proc ListView_SetItemCount*(hwndLV: HWND, cItems: int32): LRESULT
proc ListView_SetItemPosition*(hwndLV: HWND, i, x, y: int32): LRESULT proc ListView_SetItemPosition*(hwndLV: HWND, i, x, y: int32): LRESULT
proc ListView_SetItemPosition32*(hwndLV: HWND, i, x, y: int32): LRESULT proc ListView_SetItemPosition32*(hwndLV: HWND, i, x, y: int32): LRESULT
proc ListView_SetItemState*(hwndLV: HWND, i, data, mask: int32): LRESULT proc ListView_SetItemState*(hwndLV: HWND, i, data, mask: int32): LRESULT
proc ListView_SetItemText*(hwndLV: HWND, i, iSubItem_: int32, pszText_: LPTSTR): LRESULT proc ListView_SetItemText*(hwndLV: HWND, i, iSubItem: int32, pszText: LPTSTR): LRESULT
proc ListView_SetTextBkColor*(hwnd: HWND, clrTextBk: COLORREF): LRESULT proc ListView_SetTextBkColor*(hwnd: HWND, clrTextBk: COLORREF): LRESULT
proc ListView_SetTextColor*(hwnd: HWND, clrText: COLORREF): LRESULT proc ListView_SetTextColor*(hwnd: HWND, clrText: COLORREF): LRESULT
proc ListView_SortItems*(hwndLV: HWND, pfnCompare: PFNLVCOMPARE, lPrm: LPARAM): LRESULT proc ListView_SortItems*(hwndLV: HWND, pfnCompare: PFNLVCOMPARE, lPrm: LPARAM): LRESULT
@ -23448,10 +23448,11 @@ proc ListView_SetItemState(hwndLV: HWND, i, data, mask: int32): LRESULT =
result = SendMessage(hwndLV, LVM_SETITEMSTATE, WPARAM(i), result = SendMessage(hwndLV, LVM_SETITEMSTATE, WPARAM(i),
cast[LPARAM](addr(gnu_lvi))) cast[LPARAM](addr(gnu_lvi)))
proc ListView_SetItemText(hwndLV: HWND, i, iSubItem_: int32, pszText_: LPTSTR): LRESULT = proc ListView_SetItemText(hwndLV: HWND, i, iSubItem: int32,
pszText: LPTSTR): LRESULT =
var gnu_lvi: LV_ITEM var gnu_lvi: LV_ITEM
gnu_lvi.iSubItem = iSubItem_ gnu_lvi.iSubItem = iSubItem
gnu_lvi.pszText = pszText_ gnu_lvi.pszText = pszText
result = SendMessage(hwndLV, LVM_SETITEMTEXT, WPARAM(i), result = SendMessage(hwndLV, LVM_SETITEMTEXT, WPARAM(i),
cast[LPARAM](addr(gnu_lvi))) cast[LPARAM](addr(gnu_lvi)))
@ -23461,8 +23462,10 @@ proc ListView_SetTextBkColor(hwnd: HWND, clrTextBk: COLORREF): LRESULT =
proc ListView_SetTextColor(hwnd: HWND, clrText: COLORREF): LRESULT = proc ListView_SetTextColor(hwnd: HWND, clrText: COLORREF): LRESULT =
result = SendMessage(hwnd, LVM_SETTEXTCOLOR, 0, LPARAM(clrText)) result = SendMessage(hwnd, LVM_SETTEXTCOLOR, 0, LPARAM(clrText))
proc ListView_SortItems(hwndLV: HWND, pfnCompare: PFNLVCOMPARE, lPrm: LPARAM): LRESULT = proc ListView_SortItems(hwndLV: HWND, pfnCompare: PFNLVCOMPARE,
result = SendMessage(hwndLV, LVM_SORTITEMS, WPARAM(lPrm), cast[LPARAM](pfnCompare)) lPrm: LPARAM): LRESULT =
result = SendMessage(hwndLV, LVM_SORTITEMS, WPARAM(lPrm),
cast[LPARAM](pfnCompare))
proc ListView_Update(hwndLV: HWND, i: int32): LRESULT = proc ListView_Update(hwndLV: HWND, i: int32): LRESULT =
result = SendMessage(hwndLV, LVM_UPDATE, WPARAM(i), 0) result = SendMessage(hwndLV, LVM_UPDATE, WPARAM(i), 0)

43
lib/wrappers/gtk/glib2.nim
View file

@ -3316,130 +3316,131 @@ proc g_module_name*(module: PGModule): cstring{.cdecl, dynlib: gmodulelib,
importc: "g_module_name".} importc: "g_module_name".}
proc g_module_build_path*(directory: cstring, module_name: cstring): cstring{. proc g_module_build_path*(directory: cstring, module_name: cstring): cstring{.
cdecl, dynlib: gmodulelib, importc: "g_module_build_path".} cdecl, dynlib: gmodulelib, importc: "g_module_build_path".}
proc g_cclosure_marshal_VOID__VOID*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_VOID*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__VOID".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__VOID".}
proc g_cclosure_marshal_VOID__BOOLEAN*(closure: PGClosure, proc g_cclosure_marshal_VOID_BOOLEAN*(closure: PGClosure,
return_value: PGValue, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOOLEAN".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOOLEAN".}
proc g_cclosure_marshal_VOID__CHAR*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_CHAR*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__CHAR".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__CHAR".}
proc g_cclosure_marshal_VOID__UCHAR*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_UCHAR*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UCHAR".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UCHAR".}
proc g_cclosure_marshal_VOID__INT*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_INT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, param_values: PGValue, n_param_values: GUInt, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__INT".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__INT".}
proc g_cclosure_marshal_VOID__UINT*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_UINT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT".}
proc g_cclosure_marshal_VOID__LONG*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_LONG*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__LONG".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__LONG".}
proc g_cclosure_marshal_VOID__ULONG*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_ULONG*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ULONG".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ULONG".}
proc g_cclosure_marshal_VOID__ENUM*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_ENUM*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ENUM".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ENUM".}
proc g_cclosure_marshal_VOID__FLAGS*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_FLAGS*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLAGS".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLAGS".}
proc g_cclosure_marshal_VOID__FLOAT*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_FLOAT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLOAT".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLOAT".}
proc g_cclosure_marshal_VOID__DOUBLE*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_DOUBLE*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__DOUBLE".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__DOUBLE".}
proc g_cclosure_marshal_VOID__STRING*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_STRING*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__STRING".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__STRING".}
proc g_cclosure_marshal_VOID__PARAM*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_PARAM*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__PARAM".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__PARAM".}
proc g_cclosure_marshal_VOID__BOXED*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_BOXED*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOXED".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOXED".}
proc g_cclosure_marshal_VOID__POINTER*(closure: PGClosure, proc g_cclosure_marshal_VOID_POINTER*(closure: PGClosure,
return_value: PGValue, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__POINTER".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__POINTER".}
proc g_cclosure_marshal_VOID__OBJECT*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_VOID_OBJECT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__OBJECT".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__OBJECT".}
proc g_cclosure_marshal_STRING__OBJECT_POINTER*(closure: PGClosure, proc g_cclosure_marshal_STRING_OBJECT_POINTER*(closure: PGClosure,
return_value: PGValue, n_param_values: GUInt, param_values: PGValue, return_value: PGValue, n_param_values: GUInt, param_values: PGValue,
invocation_hint: GPointer, marshal_data: GPointer){.cdecl, invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_STRING__OBJECT_POINTER".} dynlib: gobjectlib, importc: "g_cclosure_marshal_STRING__OBJECT_POINTER".}
proc g_cclosure_marshal_VOID__UINT_POINTER*(closure: PGClosure, proc g_cclosure_marshal_VOID_UINT_POINTER*(closure: PGClosure,
return_value: PGValue, n_param_values: GUInt, param_values: PGValue, return_value: PGValue, n_param_values: GUInt, param_values: PGValue,
invocation_hint: GPointer, marshal_data: GPointer){.cdecl, invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT_POINTER".} dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT_POINTER".}
proc g_cclosure_marshal_BOOLEAN__FLAGS*(closure: PGClosure, proc g_cclosure_marshal_BOOLEAN_FLAGS*(closure: PGClosure,
return_value: PGValue, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_BOOLEAN__FLAGS".} dynlib: gobjectlib, importc: "g_cclosure_marshal_BOOLEAN__FLAGS".}
proc g_cclosure_marshal_BOOL__FLAGS*(closure: PGClosure, return_value: PGValue, proc g_cclosure_marshal_BOOL_FLAGS*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, n_param_values: GUInt,
param_values: PGValue, param_values: PGValue,
invocation_hint: GPointer, invocation_hint: GPointer,
marshal_data: GPointer){.cdecl, marshal_data: GPointer){.cdecl,
dynlib: gliblib, importc: "g_cclosure_marshal_BOOLEAN__FLAGS".} dynlib: gliblib, importc: "g_cclosure_marshal_BOOLEAN__FLAGS".}
proc GUINT16_SWAP_LE_BE_CONSTANT*(val: guint16): guint16 = proc GUINT16_SWAP_LE_BE_CONSTANT*(val: guint16): guint16 =
Result = ((val and 0x00FF'i16) shl 8'i16) or ((val and 0xFF00'i16) shr 8'i16) Result = ((val and 0x00FF'i16) shl 8'i16) or ((val and 0xFF00'i16) shr 8'i16)

288
lib/wrappers/gtk/gtk2.nim
View file

@ -5377,7 +5377,7 @@ proc GTK_CLIST_UNSET_FLAG*(clist: PGtkCList, flag: guint16)
#proc GTK_CLIST_USE_DRAG_ICONS_get*(clist: pointer): bool #proc GTK_CLIST_USE_DRAG_ICONS_get*(clist: pointer): bool
#proc GTK_CLIST_DRAW_DRAG_LINE_get*(clist: pointer): bool #proc GTK_CLIST_DRAW_DRAG_LINE_get*(clist: pointer): bool
#proc GTK_CLIST_DRAW_DRAG_RECT_get*(clist: pointer): bool #proc GTK_CLIST_DRAW_DRAG_RECT_get*(clist: pointer): bool
#proc GTK_CLIST_ROW_get*(`glist_`: PGList): PGtkCListRow #proc GTK_CLIST_ROW_get*(glist: PGList): PGtkCListRow
#proc GTK_CELL_TEXT_get*(cell: pointer): PGtkCellText #proc GTK_CELL_TEXT_get*(cell: pointer): PGtkCellText
#proc GTK_CELL_PIXMAP_get*(cell: pointer): PGtkCellPixmap #proc GTK_CELL_PIXMAP_get*(cell: pointer): PGtkCellPixmap
#proc GTK_CELL_PIXTEXT_get*(cell: pointer): PGtkCellPixText #proc GTK_CELL_PIXTEXT_get*(cell: pointer): PGtkCellPixText
@ -5754,11 +5754,11 @@ proc GTK_CTREE_CLASS*(klass: pointer): PGtkCTreeClass
proc GTK_IS_CTREE*(obj: pointer): bool proc GTK_IS_CTREE*(obj: pointer): bool
proc GTK_IS_CTREE_CLASS*(klass: pointer): bool proc GTK_IS_CTREE_CLASS*(klass: pointer): bool
proc GTK_CTREE_GET_CLASS*(obj: pointer): PGtkCTreeClass proc GTK_CTREE_GET_CLASS*(obj: pointer): PGtkCTreeClass
proc GTK_CTREE_ROW*(`node_`: TAddress): PGtkCTreeRow proc GTK_CTREE_ROW*(`node`: TAddress): PGtkCTreeRow
proc GTK_CTREE_NODE*(`node_`: TAddress): PGtkCTreeNode proc GTK_CTREE_NODE*(`node`: TAddress): PGtkCTreeNode
proc GTK_CTREE_NODE_NEXT*(`nnode_`: TAddress): PGtkCTreeNode proc GTK_CTREE_NODE_NEXT*(`nnode`: TAddress): PGtkCTreeNode
proc GTK_CTREE_NODE_PREV*(`pnode_`: TAddress): PGtkCTreeNode proc GTK_CTREE_NODE_PREV*(`pnode`: TAddress): PGtkCTreeNode
proc GTK_CTREE_FUNC*(`func_`: TAddress): TGtkCTreeFunc proc GTK_CTREE_FUNC*(`func`: TAddress): TGtkCTreeFunc
proc GTK_TYPE_CTREE_NODE*(): GType proc GTK_TYPE_CTREE_NODE*(): GType
proc line_style*(a: var TGtkCTree): guint proc line_style*(a: var TGtkCTree): guint
proc set_line_style*(a: var TGtkCTree, `line_style`: guint) proc set_line_style*(a: var TGtkCTree, `line_style`: guint)
@ -5781,103 +5781,103 @@ proc gtk_ctree_insert_node*(ctree: PGtkCTree, parent: PGtkCTreeNode,
mask_opened: PGdkBitmap, is_leaf: gboolean, mask_opened: PGdkBitmap, is_leaf: gboolean,
expanded: gboolean): PGtkCTreeNode{.cdecl, expanded: gboolean): PGtkCTreeNode{.cdecl,
dynlib: gtklib, importc: "gtk_ctree_insert_node".} dynlib: gtklib, importc: "gtk_ctree_insert_node".}
proc gtk_ctree_remove_node*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_remove_node*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_remove_node".} dynlib: gtklib, importc: "gtk_ctree_remove_node".}
proc gtk_ctree_insert_gnode*(ctree: PGtkCTree, parent: PGtkCTreeNode, proc gtk_ctree_insert_gnode*(ctree: PGtkCTree, parent: PGtkCTreeNode,
sibling: PGtkCTreeNode, gnode: PGNode, sibling: PGtkCTreeNode, gnode: PGNode,
func_: TGtkCTreeGNodeFunc, data: gpointer): PGtkCTreeNode{. fun: TGtkCTreeGNodeFunc, data: gpointer): PGtkCTreeNode{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_insert_gnode".} cdecl, dynlib: gtklib, importc: "gtk_ctree_insert_gnode".}
proc gtk_ctree_export_to_gnode*(ctree: PGtkCTree, parent: PGNode, proc gtk_ctree_export_to_gnode*(ctree: PGtkCTree, parent: PGNode,
sibling: PGNode, node_: PGtkCTreeNode, sibling: PGNode, node: PGtkCTreeNode,
func_: TGtkCTreeGNodeFunc, data: gpointer): PGNode{. fun: TGtkCTreeGNodeFunc, data: gpointer): PGNode{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_export_to_gnode".} cdecl, dynlib: gtklib, importc: "gtk_ctree_export_to_gnode".}
proc gtk_ctree_post_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_post_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode,
func_: TGtkCTreeFunc, data: gpointer){.cdecl, fun: TGtkCTreeFunc, data: gpointer){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_post_recursive".} dynlib: gtklib, importc: "gtk_ctree_post_recursive".}
proc gtk_ctree_post_recursive_to_depth*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_post_recursive_to_depth*(ctree: PGtkCTree, node: PGtkCTreeNode,
depth: gint, func_: TGtkCTreeFunc, depth: gint, fun: TGtkCTreeFunc,
data: gpointer){.cdecl, dynlib: gtklib, data: gpointer){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_post_recursive_to_depth".} importc: "gtk_ctree_post_recursive_to_depth".}
proc gtk_ctree_pre_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_pre_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode,
func_: TGtkCTreeFunc, data: gpointer){.cdecl, fun: TGtkCTreeFunc, data: gpointer){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_pre_recursive".} dynlib: gtklib, importc: "gtk_ctree_pre_recursive".}
proc gtk_ctree_pre_recursive_to_depth*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_pre_recursive_to_depth*(ctree: PGtkCTree, node: PGtkCTreeNode,
depth: gint, func_: TGtkCTreeFunc, depth: gint, fun: TGtkCTreeFunc,
data: gpointer){.cdecl, dynlib: gtklib, data: gpointer){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_pre_recursive_to_depth".} importc: "gtk_ctree_pre_recursive_to_depth".}
proc gtk_ctree_is_viewable*(ctree: PGtkCTree, node_: PGtkCTreeNode): gboolean{. proc gtk_ctree_is_viewable*(ctree: PGtkCTree, node: PGtkCTreeNode): gboolean{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_is_viewable".} cdecl, dynlib: gtklib, importc: "gtk_ctree_is_viewable".}
proc gtk_ctree_last*(ctree: PGtkCTree, node_: PGtkCTreeNode): PGtkCTreeNode{. proc gtk_ctree_last*(ctree: PGtkCTree, node: PGtkCTreeNode): PGtkCTreeNode{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_last".} cdecl, dynlib: gtklib, importc: "gtk_ctree_last".}
proc gtk_ctree_find_node_ptr*(ctree: PGtkCTree, ctree_row: PGtkCTreeRow): PGtkCTreeNode{. proc gtk_ctree_find_node_ptr*(ctree: PGtkCTree, ctree_row: PGtkCTreeRow): PGtkCTreeNode{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_find_node_ptr".} cdecl, dynlib: gtklib, importc: "gtk_ctree_find_node_ptr".}
proc gtk_ctree_node_nth*(ctree: PGtkCTree, row: guint): PGtkCTreeNode{.cdecl, proc gtk_ctree_node_nth*(ctree: PGtkCTree, row: guint): PGtkCTreeNode{.cdecl,
dynlib: gtklib, importc: "gtk_ctree_node_nth".} dynlib: gtklib, importc: "gtk_ctree_node_nth".}
proc gtk_ctree_find*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_find*(ctree: PGtkCTree, node: PGtkCTreeNode,
child: PGtkCTreeNode): gboolean{.cdecl, dynlib: gtklib, child: PGtkCTreeNode): gboolean{.cdecl, dynlib: gtklib,
importc: "gtk_ctree_find".} importc: "gtk_ctree_find".}
proc gtk_ctree_is_ancestor*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_is_ancestor*(ctree: PGtkCTree, node: PGtkCTreeNode,
child: PGtkCTreeNode): gboolean{.cdecl, child: PGtkCTreeNode): gboolean{.cdecl,
dynlib: gtklib, importc: "gtk_ctree_is_ancestor".} dynlib: gtklib, importc: "gtk_ctree_is_ancestor".}
proc gtk_ctree_find_by_row_data*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_find_by_row_data*(ctree: PGtkCTree, node: PGtkCTreeNode,
data: gpointer): PGtkCTreeNode{.cdecl, data: gpointer): PGtkCTreeNode{.cdecl,
dynlib: gtklib, importc: "gtk_ctree_find_by_row_data".} dynlib: gtklib, importc: "gtk_ctree_find_by_row_data".}
proc gtk_ctree_find_all_by_row_data*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_find_all_by_row_data*(ctree: PGtkCTree, node: PGtkCTreeNode,
data: gpointer): PGList{.cdecl, data: gpointer): PGList{.cdecl,
dynlib: gtklib, importc: "gtk_ctree_find_all_by_row_data".} dynlib: gtklib, importc: "gtk_ctree_find_all_by_row_data".}
proc gtk_ctree_find_by_row_data_custom*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_find_by_row_data_custom*(ctree: PGtkCTree, node: PGtkCTreeNode,
data: gpointer, func_: TGCompareFunc): PGtkCTreeNode{. data: gpointer, fun: TGCompareFunc): PGtkCTreeNode{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_find_by_row_data_custom".} cdecl, dynlib: gtklib, importc: "gtk_ctree_find_by_row_data_custom".}
proc gtk_ctree_find_all_by_row_data_custom*(ctree: PGtkCTree, proc gtk_ctree_find_all_by_row_data_custom*(ctree: PGtkCTree,
node_: PGtkCTreeNode, data: gpointer, func_: TGCompareFunc): PGList{.cdecl, node: PGtkCTreeNode, data: gpointer, fun: TGCompareFunc): PGList{.cdecl,
dynlib: gtklib, importc: "gtk_ctree_find_all_by_row_data_custom".} dynlib: gtklib, importc: "gtk_ctree_find_all_by_row_data_custom".}
proc gtk_ctree_is_hot_spot*(ctree: PGtkCTree, x: gint, y: gint): gboolean{. proc gtk_ctree_is_hot_spot*(ctree: PGtkCTree, x: gint, y: gint): gboolean{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_is_hot_spot".} cdecl, dynlib: gtklib, importc: "gtk_ctree_is_hot_spot".}
proc gtk_ctree_move*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_move*(ctree: PGtkCTree, node: PGtkCTreeNode,
new_parent: PGtkCTreeNode, new_sibling: PGtkCTreeNode){. new_parent: PGtkCTreeNode, new_sibling: PGtkCTreeNode){.
cdecl, dynlib: gtklib, importc: "gtk_ctree_move".} cdecl, dynlib: gtklib, importc: "gtk_ctree_move".}
proc gtk_ctree_expand*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_expand*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_expand".} dynlib: gtklib, importc: "gtk_ctree_expand".}
proc gtk_ctree_expand_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_expand_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_expand_recursive".} dynlib: gtklib, importc: "gtk_ctree_expand_recursive".}
proc gtk_ctree_expand_to_depth*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_expand_to_depth*(ctree: PGtkCTree, node: PGtkCTreeNode,
depth: gint){.cdecl, dynlib: gtklib, depth: gint){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_expand_to_depth".} importc: "gtk_ctree_expand_to_depth".}
proc gtk_ctree_collapse*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_collapse*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_collapse".} dynlib: gtklib, importc: "gtk_ctree_collapse".}
proc gtk_ctree_collapse_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode){. proc gtk_ctree_collapse_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode){.
cdecl, dynlib: gtklib, importc: "gtk_ctree_collapse_recursive".} cdecl, dynlib: gtklib, importc: "gtk_ctree_collapse_recursive".}
proc gtk_ctree_collapse_to_depth*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_collapse_to_depth*(ctree: PGtkCTree, node: PGtkCTreeNode,
depth: gint){.cdecl, dynlib: gtklib, depth: gint){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_collapse_to_depth".} importc: "gtk_ctree_collapse_to_depth".}
proc gtk_ctree_toggle_expansion*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_toggle_expansion*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_toggle_expansion".} dynlib: gtklib, importc: "gtk_ctree_toggle_expansion".}
proc gtk_ctree_toggle_expansion_recursive*(ctree: PGtkCTree, proc gtk_ctree_toggle_expansion_recursive*(ctree: PGtkCTree,
node_: PGtkCTreeNode){.cdecl, dynlib: gtklib, node: PGtkCTreeNode){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_toggle_expansion_recursive".} importc: "gtk_ctree_toggle_expansion_recursive".}
proc gtk_ctree_select*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_select*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_select".} dynlib: gtklib, importc: "gtk_ctree_select".}
proc gtk_ctree_select_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_select_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_select_recursive".} dynlib: gtklib, importc: "gtk_ctree_select_recursive".}
proc gtk_ctree_unselect*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_unselect*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_unselect".} dynlib: gtklib, importc: "gtk_ctree_unselect".}
proc gtk_ctree_unselect_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode){. proc gtk_ctree_unselect_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode){.
cdecl, dynlib: gtklib, importc: "gtk_ctree_unselect_recursive".} cdecl, dynlib: gtklib, importc: "gtk_ctree_unselect_recursive".}
proc gtk_ctree_real_select_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_real_select_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode,
state: gint){.cdecl, dynlib: gtklib, state: gint){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_real_select_recursive".} importc: "gtk_ctree_real_select_recursive".}
proc gtk_ctree_node_set_text*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_text*(ctree: PGtkCTree, node: PGtkCTreeNode,
column: gint, text: cstring){.cdecl, column: gint, text: cstring){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_node_set_text".} dynlib: gtklib, importc: "gtk_ctree_node_set_text".}
proc gtk_ctree_node_set_pixmap*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_pixmap*(ctree: PGtkCTree, node: PGtkCTreeNode,
column: gint, pixmap: PGdkPixmap, column: gint, pixmap: PGdkPixmap,
mask: PGdkBitmap){.cdecl, dynlib: gtklib, mask: PGdkBitmap){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_node_set_pixmap".} importc: "gtk_ctree_node_set_pixmap".}
proc gtk_ctree_node_set_pixtext*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_pixtext*(ctree: PGtkCTree, node: PGtkCTreeNode,
column: gint, text: cstring, spacing: guint8, column: gint, text: cstring, spacing: guint8,
pixmap: PGdkPixmap, mask: PGdkBitmap){.cdecl, pixmap: PGdkPixmap, mask: PGdkBitmap){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_node_set_pixtext".} dynlib: gtklib, importc: "gtk_ctree_node_set_pixtext".}
proc gtk_ctree_set_node_info*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_set_node_info*(ctree: PGtkCTree, node: PGtkCTreeNode,
text: cstring, spacing: guint8, text: cstring, spacing: guint8,
pixmap_closed: PGdkPixmap, pixmap_closed: PGdkPixmap,
mask_closed: PGdkBitmap, mask_closed: PGdkBitmap,
@ -5885,50 +5885,50 @@ proc gtk_ctree_set_node_info*(ctree: PGtkCTree, node_: PGtkCTreeNode,
mask_opened: PGdkBitmap, is_leaf: gboolean, mask_opened: PGdkBitmap, is_leaf: gboolean,
expanded: gboolean){.cdecl, dynlib: gtklib, expanded: gboolean){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_set_node_info".} importc: "gtk_ctree_set_node_info".}
proc gtk_ctree_node_set_shift*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_shift*(ctree: PGtkCTree, node: PGtkCTreeNode,
column: gint, vertical: gint, horizontal: gint){. column: gint, vertical: gint, horizontal: gint){.
cdecl, dynlib: gtklib, importc: "gtk_ctree_node_set_shift".} cdecl, dynlib: gtklib, importc: "gtk_ctree_node_set_shift".}
proc gtk_ctree_node_set_selectable*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_selectable*(ctree: PGtkCTree, node: PGtkCTreeNode,
selectable: gboolean){.cdecl, selectable: gboolean){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_node_set_selectable".} dynlib: gtklib, importc: "gtk_ctree_node_set_selectable".}
proc gtk_ctree_node_get_selectable*(ctree: PGtkCTree, node_: PGtkCTreeNode): gboolean{. proc gtk_ctree_node_get_selectable*(ctree: PGtkCTree, node: PGtkCTreeNode): gboolean{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_node_get_selectable".} cdecl, dynlib: gtklib, importc: "gtk_ctree_node_get_selectable".}
proc gtk_ctree_node_get_cell_type*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_get_cell_type*(ctree: PGtkCTree, node: PGtkCTreeNode,
column: gint): TGtkCellType{.cdecl, column: gint): TGtkCellType{.cdecl,
dynlib: gtklib, importc: "gtk_ctree_node_get_cell_type".} dynlib: gtklib, importc: "gtk_ctree_node_get_cell_type".}
proc gtk_ctree_node_get_text*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_get_text*(ctree: PGtkCTree, node: PGtkCTreeNode,
column: gint, text: PPgchar): gboolean{.cdecl, column: gint, text: PPgchar): gboolean{.cdecl,
dynlib: gtklib, importc: "gtk_ctree_node_get_text".} dynlib: gtklib, importc: "gtk_ctree_node_get_text".}
proc gtk_ctree_node_set_row_style*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_row_style*(ctree: PGtkCTree, node: PGtkCTreeNode,
style: PGtkStyle){.cdecl, dynlib: gtklib, style: PGtkStyle){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_node_set_row_style".} importc: "gtk_ctree_node_set_row_style".}
proc gtk_ctree_node_get_row_style*(ctree: PGtkCTree, node_: PGtkCTreeNode): PGtkStyle{. proc gtk_ctree_node_get_row_style*(ctree: PGtkCTree, node: PGtkCTreeNode): PGtkStyle{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_node_get_row_style".} cdecl, dynlib: gtklib, importc: "gtk_ctree_node_get_row_style".}
proc gtk_ctree_node_set_cell_style*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_cell_style*(ctree: PGtkCTree, node: PGtkCTreeNode,
column: gint, style: PGtkStyle){.cdecl, column: gint, style: PGtkStyle){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_node_set_cell_style".} dynlib: gtklib, importc: "gtk_ctree_node_set_cell_style".}
proc gtk_ctree_node_get_cell_style*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_get_cell_style*(ctree: PGtkCTree, node: PGtkCTreeNode,
column: gint): PGtkStyle{.cdecl, column: gint): PGtkStyle{.cdecl,
dynlib: gtklib, importc: "gtk_ctree_node_get_cell_style".} dynlib: gtklib, importc: "gtk_ctree_node_get_cell_style".}
proc gtk_ctree_node_set_foreground*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_foreground*(ctree: PGtkCTree, node: PGtkCTreeNode,
color: PGdkColor){.cdecl, dynlib: gtklib, color: PGdkColor){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_node_set_foreground".} importc: "gtk_ctree_node_set_foreground".}
proc gtk_ctree_node_set_background*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_background*(ctree: PGtkCTree, node: PGtkCTreeNode,
color: PGdkColor){.cdecl, dynlib: gtklib, color: PGdkColor){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_node_set_background".} importc: "gtk_ctree_node_set_background".}
proc gtk_ctree_node_set_row_data*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_row_data*(ctree: PGtkCTree, node: PGtkCTreeNode,
data: gpointer){.cdecl, dynlib: gtklib, data: gpointer){.cdecl, dynlib: gtklib,
importc: "gtk_ctree_node_set_row_data".} importc: "gtk_ctree_node_set_row_data".}
proc gtk_ctree_node_set_row_data_full*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_set_row_data_full*(ctree: PGtkCTree, node: PGtkCTreeNode,
data: gpointer, data: gpointer,
destroy: TGtkDestroyNotify){.cdecl, destroy: TGtkDestroyNotify){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_node_set_row_data_full".} dynlib: gtklib, importc: "gtk_ctree_node_set_row_data_full".}
proc gtk_ctree_node_get_row_data*(ctree: PGtkCTree, node_: PGtkCTreeNode): gpointer{. proc gtk_ctree_node_get_row_data*(ctree: PGtkCTree, node: PGtkCTreeNode): gpointer{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_node_get_row_data".} cdecl, dynlib: gtklib, importc: "gtk_ctree_node_get_row_data".}
proc gtk_ctree_node_moveto*(ctree: PGtkCTree, node_: PGtkCTreeNode, proc gtk_ctree_node_moveto*(ctree: PGtkCTree, node: PGtkCTreeNode,
column: gint, row_align: gfloat, col_align: gfloat){. column: gint, row_align: gfloat, col_align: gfloat){.
cdecl, dynlib: gtklib, importc: "gtk_ctree_node_moveto".} cdecl, dynlib: gtklib, importc: "gtk_ctree_node_moveto".}
proc gtk_ctree_node_is_visible*(ctree: PGtkCTree, node_: PGtkCTreeNode): TGtkVisibility{. proc gtk_ctree_node_is_visible*(ctree: PGtkCTree, node: PGtkCTreeNode): TGtkVisibility{.
cdecl, dynlib: gtklib, importc: "gtk_ctree_node_is_visible".} cdecl, dynlib: gtklib, importc: "gtk_ctree_node_is_visible".}
proc gtk_ctree_set_indent*(ctree: PGtkCTree, indent: gint){.cdecl, proc gtk_ctree_set_indent*(ctree: PGtkCTree, indent: gint){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_set_indent".} dynlib: gtklib, importc: "gtk_ctree_set_indent".}
@ -5944,9 +5944,9 @@ proc gtk_ctree_set_expander_style*(ctree: PGtkCTree,
proc gtk_ctree_set_drag_compare_func*(ctree: PGtkCTree, proc gtk_ctree_set_drag_compare_func*(ctree: PGtkCTree,
cmp_func: TGtkCTreeCompareDragFunc){. cmp_func: TGtkCTreeCompareDragFunc){.
cdecl, dynlib: gtklib, importc: "gtk_ctree_set_drag_compare_func".} cdecl, dynlib: gtklib, importc: "gtk_ctree_set_drag_compare_func".}
proc gtk_ctree_sort_node*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_sort_node*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_sort_node".} dynlib: gtklib, importc: "gtk_ctree_sort_node".}
proc gtk_ctree_sort_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl, proc gtk_ctree_sort_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
dynlib: gtklib, importc: "gtk_ctree_sort_recursive".} dynlib: gtklib, importc: "gtk_ctree_sort_recursive".}
proc gtk_ctree_set_reorderable*(t: pointer, r: bool) proc gtk_ctree_set_reorderable*(t: pointer, r: bool)
proc gtk_ctree_node_get_type*(): GType{.cdecl, dynlib: gtklib, proc gtk_ctree_node_get_type*(): GType{.cdecl, dynlib: gtklib,
@ -6236,7 +6236,7 @@ proc gtk_menu_get_type*(): TGtkType{.cdecl, dynlib: gtklib,
importc: "gtk_menu_get_type".} importc: "gtk_menu_get_type".}
proc gtk_menu_new*(): PGtkMenu {.cdecl, dynlib: gtklib, importc: "gtk_menu_new".} proc gtk_menu_new*(): PGtkMenu {.cdecl, dynlib: gtklib, importc: "gtk_menu_new".}
proc gtk_menu_popup*(menu: PGtkMenu, parent_menu_shell: PGtkWidget, proc gtk_menu_popup*(menu: PGtkMenu, parent_menu_shell: PGtkWidget,
parent_menu_item: PGtkWidget, func_: TGtkMenuPositionFunc, parent_menu_item: PGtkWidget, fun: TGtkMenuPositionFunc,
data: gpointer, button: guint, activate_time: guint32){. data: gpointer, button: guint, activate_time: guint32){.
cdecl, dynlib: gtklib, importc: "gtk_menu_popup".} cdecl, dynlib: gtklib, importc: "gtk_menu_popup".}
proc gtk_menu_reposition*(menu: PGtkMenu){.cdecl, dynlib: gtklib, proc gtk_menu_reposition*(menu: PGtkMenu){.cdecl, dynlib: gtklib,
@ -7563,7 +7563,7 @@ proc gtk_item_factory_popup_data*(ifactory: PGtkItemFactory): gpointer{.cdecl,
proc gtk_item_factory_popup_data_from_widget*(widget: PGtkWidget): gpointer{. proc gtk_item_factory_popup_data_from_widget*(widget: PGtkWidget): gpointer{.
cdecl, dynlib: gtklib, importc: "gtk_item_factory_popup_data_from_widget".} cdecl, dynlib: gtklib, importc: "gtk_item_factory_popup_data_from_widget".}
proc gtk_item_factory_set_translate_func*(ifactory: PGtkItemFactory, proc gtk_item_factory_set_translate_func*(ifactory: PGtkItemFactory,
func_: TGtkTranslateFunc, data: gpointer, notify: TGtkDestroyNotify){.cdecl, fun: TGtkTranslateFunc, data: gpointer, notify: TGtkDestroyNotify){.cdecl,
dynlib: gtklib, importc: "gtk_item_factory_set_translate_func".} dynlib: gtklib, importc: "gtk_item_factory_set_translate_func".}
proc GTK_TYPE_LAYOUT*(): GType proc GTK_TYPE_LAYOUT*(): GType
proc GTK_LAYOUT*(obj: pointer): PGtkLayout proc GTK_LAYOUT*(obj: pointer): PGtkLayout
@ -7783,7 +7783,7 @@ proc gtk_tree_model_ref_node*(tree_model: PGtkTreeModel, iter: PGtkTreeIter){.
proc gtk_tree_model_unref_node*(tree_model: PGtkTreeModel, iter: PGtkTreeIter){. proc gtk_tree_model_unref_node*(tree_model: PGtkTreeModel, iter: PGtkTreeIter){.
cdecl, dynlib: gtklib, importc: "gtk_tree_model_unref_node".} cdecl, dynlib: gtklib, importc: "gtk_tree_model_unref_node".}
proc gtk_tree_model_foreach*(model: PGtkTreeModel, proc gtk_tree_model_foreach*(model: PGtkTreeModel,
func_: TGtkTreeModelForeachFunc, fun: TGtkTreeModelForeachFunc,
user_data: gpointer){.cdecl, dynlib: gtklib, user_data: gpointer){.cdecl, dynlib: gtklib,
importc: "gtk_tree_model_foreach".} importc: "gtk_tree_model_foreach".}
proc gtk_tree_model_row_changed*(tree_model: PGtkTreeModel, path: PGtkTreePath, proc gtk_tree_model_row_changed*(tree_model: PGtkTreeModel, path: PGtkTreePath,
@ -9403,7 +9403,7 @@ proc gtk_text_tag_table_remove*(table: PGtkTextTagTable, tag: PGtkTextTag){.
proc gtk_text_tag_table_lookup*(table: PGtkTextTagTable, name: cstring): PGtkTextTag{. proc gtk_text_tag_table_lookup*(table: PGtkTextTagTable, name: cstring): PGtkTextTag{.
cdecl, dynlib: gtklib, importc: "gtk_text_tag_table_lookup".} cdecl, dynlib: gtklib, importc: "gtk_text_tag_table_lookup".}
proc gtk_text_tag_table_foreach*(table: PGtkTextTagTable, proc gtk_text_tag_table_foreach*(table: PGtkTextTagTable,
func_: TGtkTextTagTableForeach, data: gpointer){. fun: TGtkTextTagTableForeach, data: gpointer){.
cdecl, dynlib: gtklib, importc: "gtk_text_tag_table_foreach".} cdecl, dynlib: gtklib, importc: "gtk_text_tag_table_foreach".}
proc gtk_text_tag_table_get_size*(table: PGtkTextTagTable): gint{.cdecl, proc gtk_text_tag_table_get_size*(table: PGtkTextTagTable): gint{.cdecl,
dynlib: gtklib, importc: "gtk_text_tag_table_get_size".} dynlib: gtklib, importc: "gtk_text_tag_table_get_size".}
@ -9700,7 +9700,7 @@ proc gtk_text_btree_spew*(tree: PGtkTextBTree){.cdecl, dynlib: gtklib,
proc gtk_toggle_segment_check_func*(segPtr: PGtkTextLineSegment, proc gtk_toggle_segment_check_func*(segPtr: PGtkTextLineSegment,
line: PGtkTextLine){.cdecl, line: PGtkTextLine){.cdecl,
dynlib: gtklib, importc: "_gtk_toggle_segment_check_func".} dynlib: gtklib, importc: "_gtk_toggle_segment_check_func".}
proc gtk_change_node_toggle_count*(node_: PGtkTextBTreeNode, proc gtk_change_node_toggle_count*(node: PGtkTextBTreeNode,
info: PGtkTextTagInfo, delta: gint){.cdecl, info: PGtkTextTagInfo, delta: gint){.cdecl,
dynlib: gtklib, importc: "_gtk_change_node_toggle_count".} dynlib: gtklib, importc: "_gtk_change_node_toggle_count".}
proc gtk_text_btree_release_mark_segment*(tree: PGtkTextBTree, proc gtk_text_btree_release_mark_segment*(tree: PGtkTextBTree,
@ -10511,7 +10511,7 @@ proc gtk_tree_selection_set_mode*(selection: PGtkTreeSelection,
proc gtk_tree_selection_get_mode*(selection: PGtkTreeSelection): TGtkSelectionMode{. proc gtk_tree_selection_get_mode*(selection: PGtkTreeSelection): TGtkSelectionMode{.
cdecl, dynlib: gtklib, importc: "gtk_tree_selection_get_mode".} cdecl, dynlib: gtklib, importc: "gtk_tree_selection_get_mode".}
proc gtk_tree_selection_set_select_function*(selection: PGtkTreeSelection, proc gtk_tree_selection_set_select_function*(selection: PGtkTreeSelection,
func_: TGtkTreeSelectionFunc, data: gpointer, destroy: TGtkDestroyNotify){. fun: TGtkTreeSelectionFunc, data: gpointer, destroy: TGtkDestroyNotify){.
cdecl, dynlib: gtklib, importc: "gtk_tree_selection_set_select_function".} cdecl, dynlib: gtklib, importc: "gtk_tree_selection_set_select_function".}
proc gtk_tree_selection_get_user_data*(selection: PGtkTreeSelection): gpointer{. proc gtk_tree_selection_get_user_data*(selection: PGtkTreeSelection): gpointer{.
cdecl, dynlib: gtklib, importc: "gtk_tree_selection_get_user_data".} cdecl, dynlib: gtklib, importc: "gtk_tree_selection_get_user_data".}
@ -10523,7 +10523,7 @@ proc gtk_tree_selection_get_selected*(selection: PGtkTreeSelection,
proc gtk_tree_selection_get_selected_rows*(selection: PGtkTreeSelection, proc gtk_tree_selection_get_selected_rows*(selection: PGtkTreeSelection,
model: PPGtkTreeModel): PGList{.cdecl, dynlib: gtklib, importc: "gtk_tree_selection_get_selected_rows".} model: PPGtkTreeModel): PGList{.cdecl, dynlib: gtklib, importc: "gtk_tree_selection_get_selected_rows".}
proc gtk_tree_selection_selected_foreach*(selection: PGtkTreeSelection, proc gtk_tree_selection_selected_foreach*(selection: PGtkTreeSelection,
func_: TGtkTreeSelectionForeachFunc, data: gpointer){.cdecl, dynlib: gtklib, fun: TGtkTreeSelectionForeachFunc, data: gpointer){.cdecl, dynlib: gtklib,
importc: "gtk_tree_selection_selected_foreach".} importc: "gtk_tree_selection_selected_foreach".}
proc gtk_tree_selection_select_path*(selection: PGtkTreeSelection, proc gtk_tree_selection_select_path*(selection: PGtkTreeSelection,
path: PGtkTreePath){.cdecl, dynlib: gtklib, path: PGtkTreePath){.cdecl, dynlib: gtklib,
@ -10656,7 +10656,7 @@ proc gtk_tree_view_column_add_attribute*(tree_column: PGtkTreeViewColumn,
cell_renderer: PGtkCellRenderer, attribute: cstring, column: gint){.cdecl, cell_renderer: PGtkCellRenderer, attribute: cstring, column: gint){.cdecl,
dynlib: gtklib, importc: "gtk_tree_view_column_add_attribute".} dynlib: gtklib, importc: "gtk_tree_view_column_add_attribute".}
proc gtk_tree_view_column_set_cell_data_func*(tree_column: PGtkTreeViewColumn, proc gtk_tree_view_column_set_cell_data_func*(tree_column: PGtkTreeViewColumn,
cell_renderer: PGtkCellRenderer, func_: TGtkTreeCellDataFunc, cell_renderer: PGtkCellRenderer, fun: TGtkTreeCellDataFunc,
func_data: gpointer, destroy: TGtkDestroyNotify){.cdecl, dynlib: gtklib, func_data: gpointer, destroy: TGtkDestroyNotify){.cdecl, dynlib: gtklib,
importc: "gtk_tree_view_column_set_cell_data_func".} importc: "gtk_tree_view_column_set_cell_data_func".}
proc gtk_tree_view_column_clear_attributes*(tree_column: PGtkTreeViewColumn, proc gtk_tree_view_column_clear_attributes*(tree_column: PGtkTreeViewColumn,
@ -10784,12 +10784,12 @@ proc flags*(a: PGtkRBNode): guint
proc set_flags*(a: PGtkRBNode, `flags`: guint) proc set_flags*(a: PGtkRBNode, `flags`: guint)
proc parity*(a: PGtkRBNode): guint proc parity*(a: PGtkRBNode): guint
proc set_parity*(a: PGtkRBNode, `parity`: guint) proc set_parity*(a: PGtkRBNode, `parity`: guint)
proc GTK_RBNODE_GET_COLOR*(node_: PGtkRBNode): guint proc GTK_RBNODE_GET_COLOR*(node: PGtkRBNode): guint
proc GTK_RBNODE_SET_COLOR*(node_: PGtkRBNode, color: guint) proc GTK_RBNODE_SET_COLOR*(node: PGtkRBNode, color: guint)
proc GTK_RBNODE_GET_HEIGHT*(node_: PGtkRBNode): gint proc GTK_RBNODE_GET_HEIGHT*(node: PGtkRBNode): gint
proc GTK_RBNODE_SET_FLAG*(node_: PGtkRBNode, flag: guint16) proc GTK_RBNODE_SET_FLAG*(node: PGtkRBNode, flag: guint16)
proc GTK_RBNODE_UNSET_FLAG*(node_: PGtkRBNode, flag: guint16) proc GTK_RBNODE_UNSET_FLAG*(node: PGtkRBNode, flag: guint16)
proc GTK_RBNODE_FLAG_SET*(node_: PGtkRBNode, flag: guint): bool proc GTK_RBNODE_FLAG_SET*(node: PGtkRBNode, flag: guint): bool
proc gtk_rbtree_push_allocator*(allocator: PGAllocator){.cdecl, proc gtk_rbtree_push_allocator*(allocator: PGAllocator){.cdecl,
dynlib: gtklib, importc: "_gtk_rbtree_push_allocator".} dynlib: gtklib, importc: "_gtk_rbtree_push_allocator".}
proc gtk_rbtree_pop_allocator*(){.cdecl, dynlib: gtklib, proc gtk_rbtree_pop_allocator*(){.cdecl, dynlib: gtklib,
@ -10802,24 +10802,24 @@ proc gtk_rbtree_remove*(tree: PGtkRBTree){.cdecl, dynlib: gtklib,
importc: "_gtk_rbtree_remove".} importc: "_gtk_rbtree_remove".}
proc gtk_rbtree_destroy*(tree: PGtkRBTree){.cdecl, dynlib: gtklib, proc gtk_rbtree_destroy*(tree: PGtkRBTree){.cdecl, dynlib: gtklib,
importc: "_gtk_rbtree_destroy".} importc: "_gtk_rbtree_destroy".}
proc gtk_rbtree_insert_before*(tree: PGtkRBTree, node_: PGtkRBNode, proc gtk_rbtree_insert_before*(tree: PGtkRBTree, node: PGtkRBNode,
height: gint, valid: gboolean): PGtkRBNode{. height: gint, valid: gboolean): PGtkRBNode{.
cdecl, dynlib: gtklib, importc: "_gtk_rbtree_insert_before".} cdecl, dynlib: gtklib, importc: "_gtk_rbtree_insert_before".}
proc gtk_rbtree_insert_after*(tree: PGtkRBTree, node_: PGtkRBNode, proc gtk_rbtree_insert_after*(tree: PGtkRBTree, node: PGtkRBNode,
height: gint, valid: gboolean): PGtkRBNode{. height: gint, valid: gboolean): PGtkRBNode{.
cdecl, dynlib: gtklib, importc: "_gtk_rbtree_insert_after".} cdecl, dynlib: gtklib, importc: "_gtk_rbtree_insert_after".}
proc gtk_rbtree_remove_node*(tree: PGtkRBTree, node_: PGtkRBNode){.cdecl, proc gtk_rbtree_remove_node*(tree: PGtkRBTree, node: PGtkRBNode){.cdecl,
dynlib: gtklib, importc: "_gtk_rbtree_remove_node".} dynlib: gtklib, importc: "_gtk_rbtree_remove_node".}
proc gtk_rbtree_reorder*(tree: PGtkRBTree, new_order: Pgint, length: gint){. proc gtk_rbtree_reorder*(tree: PGtkRBTree, new_order: Pgint, length: gint){.
cdecl, dynlib: gtklib, importc: "_gtk_rbtree_reorder".} cdecl, dynlib: gtklib, importc: "_gtk_rbtree_reorder".}
proc gtk_rbtree_find_count*(tree: PGtkRBTree, count: gint): PGtkRBNode{.cdecl, proc gtk_rbtree_find_count*(tree: PGtkRBTree, count: gint): PGtkRBNode{.cdecl,
dynlib: gtklib, importc: "_gtk_rbtree_find_count".} dynlib: gtklib, importc: "_gtk_rbtree_find_count".}
proc gtk_rbtree_node_set_height*(tree: PGtkRBTree, node_: PGtkRBNode, proc gtk_rbtree_node_set_height*(tree: PGtkRBTree, node: PGtkRBNode,
height: gint){.cdecl, dynlib: gtklib, height: gint){.cdecl, dynlib: gtklib,
importc: "_gtk_rbtree_node_set_height".} importc: "_gtk_rbtree_node_set_height".}
proc gtk_rbtree_node_mark_invalid*(tree: PGtkRBTree, node_: PGtkRBNode){. proc gtk_rbtree_node_mark_invalid*(tree: PGtkRBTree, node: PGtkRBNode){.
cdecl, dynlib: gtklib, importc: "_gtk_rbtree_node_mark_invalid".} cdecl, dynlib: gtklib, importc: "_gtk_rbtree_node_mark_invalid".}
proc gtk_rbtree_node_mark_valid*(tree: PGtkRBTree, node_: PGtkRBNode){.cdecl, proc gtk_rbtree_node_mark_valid*(tree: PGtkRBTree, node: PGtkRBNode){.cdecl,
dynlib: gtklib, importc: "_gtk_rbtree_node_mark_valid".} dynlib: gtklib, importc: "_gtk_rbtree_node_mark_valid".}
proc gtk_rbtree_column_invalid*(tree: PGtkRBTree){.cdecl, dynlib: gtklib, proc gtk_rbtree_column_invalid*(tree: PGtkRBTree){.cdecl, dynlib: gtklib,
importc: "_gtk_rbtree_column_invalid".} importc: "_gtk_rbtree_column_invalid".}
@ -10827,17 +10827,17 @@ proc gtk_rbtree_mark_invalid*(tree: PGtkRBTree){.cdecl, dynlib: gtklib,
importc: "_gtk_rbtree_mark_invalid".} importc: "_gtk_rbtree_mark_invalid".}
proc gtk_rbtree_set_fixed_height*(tree: PGtkRBTree, height: gint){.cdecl, proc gtk_rbtree_set_fixed_height*(tree: PGtkRBTree, height: gint){.cdecl,
dynlib: gtklib, importc: "_gtk_rbtree_set_fixed_height".} dynlib: gtklib, importc: "_gtk_rbtree_set_fixed_height".}
proc gtk_rbtree_node_find_offset*(tree: PGtkRBTree, node_: PGtkRBNode): gint{. proc gtk_rbtree_node_find_offset*(tree: PGtkRBTree, node: PGtkRBNode): gint{.
cdecl, dynlib: gtklib, importc: "_gtk_rbtree_node_find_offset".} cdecl, dynlib: gtklib, importc: "_gtk_rbtree_node_find_offset".}
proc gtk_rbtree_node_find_parity*(tree: PGtkRBTree, node_: PGtkRBNode): gint{. proc gtk_rbtree_node_find_parity*(tree: PGtkRBTree, node: PGtkRBNode): gint{.
cdecl, dynlib: gtklib, importc: "_gtk_rbtree_node_find_parity".} cdecl, dynlib: gtklib, importc: "_gtk_rbtree_node_find_parity".}
proc gtk_rbtree_traverse*(tree: PGtkRBTree, node_: PGtkRBNode, proc gtk_rbtree_traverse*(tree: PGtkRBTree, node: PGtkRBNode,
order: TGTraverseType, order: TGTraverseType,
func_: TGtkRBTreeTraverseFunc, data: gpointer){. fun: TGtkRBTreeTraverseFunc, data: gpointer){.
cdecl, dynlib: gtklib, importc: "_gtk_rbtree_traverse".} cdecl, dynlib: gtklib, importc: "_gtk_rbtree_traverse".}
proc gtk_rbtree_next*(tree: PGtkRBTree, node_: PGtkRBNode): PGtkRBNode{.cdecl, proc gtk_rbtree_next*(tree: PGtkRBTree, node: PGtkRBNode): PGtkRBNode{.cdecl,
dynlib: gtklib, importc: "_gtk_rbtree_next".} dynlib: gtklib, importc: "_gtk_rbtree_next".}
proc gtk_rbtree_prev*(tree: PGtkRBTree, node_: PGtkRBNode): PGtkRBNode{.cdecl, proc gtk_rbtree_prev*(tree: PGtkRBTree, node: PGtkRBNode): PGtkRBNode{.cdecl,
dynlib: gtklib, importc: "_gtk_rbtree_prev".} dynlib: gtklib, importc: "_gtk_rbtree_prev".}
proc gtk_rbtree_get_depth*(tree: PGtkRBTree): gint{.cdecl, dynlib: gtklib, proc gtk_rbtree_get_depth*(tree: PGtkRBTree): gint{.cdecl, dynlib: gtklib,
importc: "_gtk_rbtree_get_depth".} importc: "_gtk_rbtree_get_depth".}
@ -10907,21 +10907,21 @@ proc set_enable_search*(a: var TGtkTreeViewPrivate, `enable_search`: guint)
proc disable_popdown*(a: var TGtkTreeViewPrivate): guint proc disable_popdown*(a: var TGtkTreeViewPrivate): guint
proc set_disable_popdown*(a: var TGtkTreeViewPrivate, `disable_popdown`: guint) proc set_disable_popdown*(a: var TGtkTreeViewPrivate, `disable_popdown`: guint)
proc gtk_tree_selection_internal_select_node*(selection: PGtkTreeSelection, proc gtk_tree_selection_internal_select_node*(selection: PGtkTreeSelection,
node_: PGtkRBNode, tree: PGtkRBTree, path: PGtkTreePath, node: PGtkRBNode, tree: PGtkRBTree, path: PGtkTreePath,
state: TGdkModifierType, override_browse_mode: gboolean){.cdecl, state: TGdkModifierType, override_browse_mode: gboolean){.cdecl,
dynlib: gtklib, importc: "_gtk_tree_selection_internal_select_node".} dynlib: gtklib, importc: "_gtk_tree_selection_internal_select_node".}
proc gtk_tree_view_find_node*(tree_view: PGtkTreeView, path: PGtkTreePath, proc gtk_tree_view_find_node*(tree_view: PGtkTreeView, path: PGtkTreePath,
tree: var PGtkRBTree, node_: var PGtkRBNode): gboolean{. tree: var PGtkRBTree, node: var PGtkRBNode): gboolean{.
cdecl, dynlib: gtklib, importc: "_gtk_tree_view_find_node".} cdecl, dynlib: gtklib, importc: "_gtk_tree_view_find_node".}
proc gtk_tree_view_find_path*(tree_view: PGtkTreeView, tree: PGtkRBTree, proc gtk_tree_view_find_path*(tree_view: PGtkTreeView, tree: PGtkRBTree,
node_: PGtkRBNode): PGtkTreePath{.cdecl, node: PGtkRBNode): PGtkTreePath{.cdecl,
dynlib: gtklib, importc: "_gtk_tree_view_find_path".} dynlib: gtklib, importc: "_gtk_tree_view_find_path".}
proc gtk_tree_view_child_move_resize*(tree_view: PGtkTreeView, proc gtk_tree_view_child_move_resize*(tree_view: PGtkTreeView,
widget: PGtkWidget, x: gint, y: gint, widget: PGtkWidget, x: gint, y: gint,
width: gint, height: gint){.cdecl, width: gint, height: gint){.cdecl,
dynlib: gtklib, importc: "_gtk_tree_view_child_move_resize".} dynlib: gtklib, importc: "_gtk_tree_view_child_move_resize".}
proc gtk_tree_view_queue_draw_node*(tree_view: PGtkTreeView, tree: PGtkRBTree, proc gtk_tree_view_queue_draw_node*(tree_view: PGtkTreeView, tree: PGtkRBTree,
node_: PGtkRBNode, node: PGtkRBNode,
clip_rect: PGdkRectangle){.cdecl, clip_rect: PGdkRectangle){.cdecl,
dynlib: gtklib, importc: "_gtk_tree_view_queue_draw_node".} dynlib: gtklib, importc: "_gtk_tree_view_queue_draw_node".}
proc gtk_tree_view_column_realize_button*(column: PGtkTreeViewColumn){.cdecl, proc gtk_tree_view_column_realize_button*(column: PGtkTreeViewColumn){.cdecl,
@ -11033,7 +11033,7 @@ proc gtk_tree_view_insert_column*(tree_view: PGtkTreeView,
cdecl, dynlib: gtklib, importc: "gtk_tree_view_insert_column".} cdecl, dynlib: gtklib, importc: "gtk_tree_view_insert_column".}
proc gtk_tree_view_insert_column_with_data_func*(tree_view: PGtkTreeView, proc gtk_tree_view_insert_column_with_data_func*(tree_view: PGtkTreeView,
position: gint, title: cstring, cell: PGtkCellRenderer, position: gint, title: cstring, cell: PGtkCellRenderer,
func_: TGtkTreeCellDataFunc, data: gpointer, dnotify: TGDestroyNotify): gint{. fun: TGtkTreeCellDataFunc, data: gpointer, dnotify: TGDestroyNotify): gint{.
cdecl, dynlib: gtklib, importc: "gtk_tree_view_insert_column_with_data_func".} cdecl, dynlib: gtklib, importc: "gtk_tree_view_insert_column_with_data_func".}
proc gtk_tree_view_get_column*(tree_view: PGtkTreeView, n: gint): PGtkTreeViewColumn{. proc gtk_tree_view_get_column*(tree_view: PGtkTreeView, n: gint): PGtkTreeViewColumn{.
cdecl, dynlib: gtklib, importc: "gtk_tree_view_get_column".} cdecl, dynlib: gtklib, importc: "gtk_tree_view_get_column".}
@ -11049,7 +11049,7 @@ proc gtk_tree_view_set_expander_column*(tree_view: PGtkTreeView,
proc gtk_tree_view_get_expander_column*(tree_view: PGtkTreeView): PGtkTreeViewColumn{. proc gtk_tree_view_get_expander_column*(tree_view: PGtkTreeView): PGtkTreeViewColumn{.
cdecl, dynlib: gtklib, importc: "gtk_tree_view_get_expander_column".} cdecl, dynlib: gtklib, importc: "gtk_tree_view_get_expander_column".}
proc gtk_tree_view_set_column_drag_function*(tree_view: PGtkTreeView, proc gtk_tree_view_set_column_drag_function*(tree_view: PGtkTreeView,
func_: TGtkTreeViewColumnDropFunc, user_data: gpointer, fun: TGtkTreeViewColumnDropFunc, user_data: gpointer,
destroy: TGtkDestroyNotify){.cdecl, dynlib: gtklib, importc: "gtk_tree_view_set_column_drag_function".} destroy: TGtkDestroyNotify){.cdecl, dynlib: gtklib, importc: "gtk_tree_view_set_column_drag_function".}
proc gtk_tree_view_scroll_to_point*(tree_view: PGtkTreeView, tree_x: gint, proc gtk_tree_view_scroll_to_point*(tree_view: PGtkTreeView, tree_x: gint,
tree_y: gint){.cdecl, dynlib: gtklib, tree_y: gint){.cdecl, dynlib: gtklib,
@ -11072,7 +11072,7 @@ proc gtk_tree_view_expand_row*(tree_view: PGtkTreeView, path: PGtkTreePath,
proc gtk_tree_view_collapse_row*(tree_view: PGtkTreeView, path: PGtkTreePath): gboolean{. proc gtk_tree_view_collapse_row*(tree_view: PGtkTreeView, path: PGtkTreePath): gboolean{.
cdecl, dynlib: gtklib, importc: "gtk_tree_view_collapse_row".} cdecl, dynlib: gtklib, importc: "gtk_tree_view_collapse_row".}
proc gtk_tree_view_map_expanded_rows*(tree_view: PGtkTreeView, proc gtk_tree_view_map_expanded_rows*(tree_view: PGtkTreeView,
func_: TGtkTreeViewMappingFunc, fun: TGtkTreeViewMappingFunc,
data: gpointer){.cdecl, dynlib: gtklib, data: gpointer){.cdecl, dynlib: gtklib,
importc: "gtk_tree_view_map_expanded_rows".} importc: "gtk_tree_view_map_expanded_rows".}
proc gtk_tree_view_row_expanded*(tree_view: PGtkTreeView, path: PGtkTreePath): gboolean{. proc gtk_tree_view_row_expanded*(tree_view: PGtkTreeView, path: PGtkTreePath): gboolean{.
@ -11142,7 +11142,7 @@ proc gtk_tree_view_set_search_equal_func*(tree_view: PGtkTreeView,
search_equal_func: TGtkTreeViewSearchEqualFunc, search_user_data: gpointer, search_equal_func: TGtkTreeViewSearchEqualFunc, search_user_data: gpointer,
search_destroy: TGtkDestroyNotify){.cdecl, dynlib: gtklib, importc: "gtk_tree_view_set_search_equal_func".} search_destroy: TGtkDestroyNotify){.cdecl, dynlib: gtklib, importc: "gtk_tree_view_set_search_equal_func".}
proc gtk_tree_view_set_destroy_count_func*(tree_view: PGtkTreeView, proc gtk_tree_view_set_destroy_count_func*(tree_view: PGtkTreeView,
func_: TGtkTreeDestroyCountFunc, data: gpointer, destroy: TGtkDestroyNotify){. fun: TGtkTreeDestroyCountFunc, data: gpointer, destroy: TGtkDestroyNotify){.
cdecl, dynlib: gtklib, importc: "gtk_tree_view_set_destroy_count_func".} cdecl, dynlib: gtklib, importc: "gtk_tree_view_set_destroy_count_func".}
proc GTK_TYPE_VBUTTON_BOX*(): GType proc GTK_TYPE_VBUTTON_BOX*(): GType
proc GTK_VBUTTON_BOX*(obj: pointer): PGtkVButtonBox proc GTK_VBUTTON_BOX*(obj: pointer): PGtkVButtonBox
@ -12832,8 +12832,8 @@ proc GTK_CLIST_DRAW_DRAG_LINE_get*(clist: pointer): bool =
proc GTK_CLIST_DRAW_DRAG_RECT_get*(clist: pointer): bool = proc GTK_CLIST_DRAW_DRAG_RECT_get*(clist: pointer): bool =
result = ((GTK_CLIST_FLAGS(clist)) and cint(GTK_CLIST_DRAW_DRAG_RECT)) != 0'i32 result = ((GTK_CLIST_FLAGS(clist)) and cint(GTK_CLIST_DRAW_DRAG_RECT)) != 0'i32
proc GTK_CLIST_ROW_get*(`glist_`: PGList): PGtkCListRow = proc GTK_CLIST_ROW_get*(glist: PGList): PGtkCListRow =
result = cast[PGtkCListRow](`glist_` . data) result = cast[PGtkCListRow](glist . data)
when false: when false:
proc GTK_CELL_TEXT_get*(cell: pointer): PGtkCellText = proc GTK_CELL_TEXT_get*(cell: pointer): PGtkCellText =
@ -13090,20 +13090,20 @@ proc GTK_IS_CTREE_CLASS*(klass: pointer): bool =
proc GTK_CTREE_GET_CLASS*(obj: pointer): PGtkCTreeClass = proc GTK_CTREE_GET_CLASS*(obj: pointer): PGtkCTreeClass =
result = cast[PGtkCTreeClass](GTK_CHECK_GET_CLASS(obj, GTK_TYPE_CTREE())) result = cast[PGtkCTreeClass](GTK_CHECK_GET_CLASS(obj, GTK_TYPE_CTREE()))
proc GTK_CTREE_ROW*(`node_`: TAddress): PGtkCTreeRow = proc GTK_CTREE_ROW*(node: TAddress): PGtkCTreeRow =
result = cast[PGtkCTreeRow]((cast[PGList](`node_`)) . data) result = cast[PGtkCTreeRow]((cast[PGList](node)) . data)
proc GTK_CTREE_NODE*(`node_`: TAddress): PGtkCTreeNode = proc GTK_CTREE_NODE*(node: TAddress): PGtkCTreeNode =
result = cast[PGtkCTreeNode](`node_`) result = cast[PGtkCTreeNode](node)
proc GTK_CTREE_NODE_NEXT*(`nnode_`: TAddress): PGtkCTreeNode = proc GTK_CTREE_NODE_NEXT*(nnode: TAddress): PGtkCTreeNode =
result = cast[PGtkCTreeNode]((cast[PGList](`nnode_`)) . next) result = cast[PGtkCTreeNode]((cast[PGList](nnode)) . next)
proc GTK_CTREE_NODE_PREV*(`pnode_`: TAddress): PGtkCTreeNode = proc GTK_CTREE_NODE_PREV*(`pnode`: TAddress): PGtkCTreeNode =
result = cast[PGtkCTreeNode]((cast[PGList](`pnode_`)) . prev) result = cast[PGtkCTreeNode]((cast[PGList](`pnode`)) . prev)
proc GTK_CTREE_FUNC*(`func_`: TAddress): TGtkCTreeFunc = proc GTK_CTREE_FUNC*(`func`: TAddress): TGtkCTreeFunc =
result = cast[TGtkCTreeFunc](`func_`) result = cast[TGtkCTreeFunc](`func`)
proc GTK_TYPE_CTREE_NODE*(): GType = proc GTK_TYPE_CTREE_NODE*(): GType =
result = gtk_ctree_node_get_type() result = gtk_ctree_node_get_type()
@ -15080,34 +15080,34 @@ proc gtk_signal_emit_stop*(instance: gpointer, signal_id: guint, detail: TGQuark
if detail != 0'i32: g_signal_stop_emission(instance, signal_id, 0) if detail != 0'i32: g_signal_stop_emission(instance, signal_id, 0)
proc gtk_signal_connect_full*(anObject: PGtkObject, name: cstring, proc gtk_signal_connect_full*(anObject: PGtkObject, name: cstring,
func_: TGtkSignalFunc, unknown1: pointer, fun: TGtkSignalFunc, unknown1: pointer,
func_data: gpointer, unknown2: pointer, func_data: gpointer, unknown2: pointer,
unknown3, unknown4: int): gulong {. unknown3, unknown4: int): gulong {.
importc, cdecl, dynlib: gtklib.} importc, cdecl, dynlib: gtklib.}
proc gtk_signal_compat_matched*(anObject: PGtkObject, func_: TGtkSignalFunc, proc gtk_signal_compat_matched*(anObject: PGtkObject, fun: TGtkSignalFunc,
data: gpointer, m: TGSignalMatchType, data: gpointer, m: TGSignalMatchType,
u: int) {.importc, cdecl, dynlib: gtklib.} u: int) {.importc, cdecl, dynlib: gtklib.}
proc gtk_signal_connect*(anObject: PGtkObject, name: cstring, proc gtk_signal_connect*(anObject: PGtkObject, name: cstring,
func_: TGtkSignalFunc, func_data: gpointer): gulong = fun: TGtkSignalFunc, func_data: gpointer): gulong =
result = gtk_signal_connect_full(anObject, name, func_, nil, func_data, nil, result = gtk_signal_connect_full(anObject, name, fun, nil, func_data, nil,
0, 0) 0, 0)
proc gtk_signal_connect_after*(anObject: PGtkObject, name: cstring, proc gtk_signal_connect_after*(anObject: PGtkObject, name: cstring,
func_: TGtkSignalFunc, func_data: gpointer): gulong = fun: TGtkSignalFunc, func_data: gpointer): gulong =
result = gtk_signal_connect_full(anObject, name, func_, nil, func_data, nil, result = gtk_signal_connect_full(anObject, name, fun, nil, func_data, nil,
0, 1) 0, 1)
proc gtk_signal_connect_object*(anObject: PGtkObject, name: cstring, proc gtk_signal_connect_object*(anObject: PGtkObject, name: cstring,
func_: TGtkSignalFunc, slot_object: gpointer): gulong = fun: TGtkSignalFunc, slot_object: gpointer): gulong =
result = gtk_signal_connect_full(anObject, name, func_, nil, slot_object, nil, result = gtk_signal_connect_full(anObject, name, fun, nil, slot_object, nil,
1, 0) 1, 0)
proc gtk_signal_connect_object_after*(anObject: PGtkObject, name: cstring, proc gtk_signal_connect_object_after*(anObject: PGtkObject, name: cstring,
func_: TGtkSignalFunc, fun: TGtkSignalFunc,
slot_object: gpointer): gulong = slot_object: gpointer): gulong =
result = gtk_signal_connect_full(anObject, name, func_, nil, slot_object, nil, result = gtk_signal_connect_full(anObject, name, fun, nil, slot_object, nil,
1, 1) 1, 1)
proc gtk_signal_disconnect*(anObject: gpointer, handler_id: gulong) = proc gtk_signal_disconnect*(anObject: gpointer, handler_id: gulong) =
@ -15122,22 +15122,22 @@ proc gtk_signal_handler_unblock*(anObject: gpointer, handler_id: gulong) =
proc gtk_signal_disconnect_by_data*(anObject: PGtkObject, data: gpointer) = proc gtk_signal_disconnect_by_data*(anObject: PGtkObject, data: gpointer) =
gtk_signal_compat_matched(anObject, nil, data, G_SIGNAL_MATCH_DATA, 0) gtk_signal_compat_matched(anObject, nil, data, G_SIGNAL_MATCH_DATA, 0)
proc gtk_signal_disconnect_by_func*(anObject: PGtkObject, func_: TGtkSignalFunc, proc gtk_signal_disconnect_by_func*(anObject: PGtkObject, fun: TGtkSignalFunc,
data: gpointer) = data: gpointer) =
gtk_signal_compat_matched(anObject, func_, data, cast[TGSignalMatchType]( gtk_signal_compat_matched(anObject, fun, data, cast[TGSignalMatchType](
G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0) G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0)
proc gtk_signal_handler_block_by_func*(anObject: PGtkObject, proc gtk_signal_handler_block_by_func*(anObject: PGtkObject,
func_: TGtkSignalFunc, data: gpointer) = fun: TGtkSignalFunc, data: gpointer) =
gtk_signal_compat_matched(anObject, func_, data, TGSignalMatchType( gtk_signal_compat_matched(anObject, fun, data, TGSignalMatchType(
G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0) G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0)
proc gtk_signal_handler_block_by_data*(anObject: PGtkObject, data: gpointer) = proc gtk_signal_handler_block_by_data*(anObject: PGtkObject, data: gpointer) =
gtk_signal_compat_matched(anObject, nil, data, G_SIGNAL_MATCH_DATA, 1) gtk_signal_compat_matched(anObject, nil, data, G_SIGNAL_MATCH_DATA, 1)
proc gtk_signal_handler_unblock_by_func*(anObject: PGtkObject, proc gtk_signal_handler_unblock_by_func*(anObject: PGtkObject,
func_: TGtkSignalFunc, data: gpointer) = fun: TGtkSignalFunc, data: gpointer) =
gtk_signal_compat_matched(anObject, func_, data, cast[TGSignalMatchType]( gtk_signal_compat_matched(anObject, fun, data, cast[TGSignalMatchType](
G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0) G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0)
proc gtk_signal_handler_unblock_by_data*(anObject: PGtkObject, data: gpointer) = proc gtk_signal_handler_unblock_by_data*(anObject: PGtkObject, data: gpointer) =
@ -15148,13 +15148,13 @@ proc gtk_signal_handler_pending*(anObject: PGtkObject, signal_id: guint,
Result = g_signal_has_handler_pending(anObject, signal_id, 0, may_be_blocked) Result = g_signal_has_handler_pending(anObject, signal_id, 0, may_be_blocked)
proc gtk_signal_handler_pending_by_func*(anObject: PGtkObject, signal_id: guint, proc gtk_signal_handler_pending_by_func*(anObject: PGtkObject, signal_id: guint,
may_be_blocked: gboolean, func_: TGtkSignalFunc, data: gpointer): gboolean = may_be_blocked: gboolean, fun: TGtkSignalFunc, data: gpointer): gboolean =
var t: TGSignalMatchType var t: TGSignalMatchType
t = cast[TGSignalMatchType](G_SIGNAL_MATCH_ID or G_SIGNAL_MATCH_FUNC or t = cast[TGSignalMatchType](G_SIGNAL_MATCH_ID or G_SIGNAL_MATCH_FUNC or
G_SIGNAL_MATCH_DATA) G_SIGNAL_MATCH_DATA)
if not may_be_blocked: if not may_be_blocked:
t = t or cast[TGSignalMatchType](G_SIGNAL_MATCH_UNBLOCKED) t = t or cast[TGSignalMatchType](G_SIGNAL_MATCH_UNBLOCKED)
Result = g_signal_handler_find(anObject, t, signal_id, 0, nil, func_, Result = g_signal_handler_find(anObject, t, signal_id, 0, nil, fun,
data) != 0 data) != 0
proc GTK_TYPE_SIZE_GROUP*(): GType = proc GTK_TYPE_SIZE_GROUP*(): GType =
@ -16594,36 +16594,36 @@ proc set_parity*(a: PGtkRBNode, `parity`: guint) =
a . flag0 = a . a . flag0 = a .
flag0 or (int16(`parity` shl bp_TGtkRBNode_parity) and bm_TGtkRBNode_parity) flag0 or (int16(`parity` shl bp_TGtkRBNode_parity) and bm_TGtkRBNode_parity)
proc GTK_RBNODE_GET_COLOR*(node_: PGtkRBNode): guint = proc GTK_RBNODE_GET_COLOR*(node: PGtkRBNode): guint =
if node_ == nil: if node == nil:
Result = GTK_RBNODE_BLACK Result = GTK_RBNODE_BLACK
elif (int(flags(node_)) and GTK_RBNODE_RED) == GTK_RBNODE_RED: elif (int(flags(node)) and GTK_RBNODE_RED) == GTK_RBNODE_RED:
Result = GTK_RBNODE_RED Result = GTK_RBNODE_RED
else: else:
Result = GTK_RBNODE_BLACK Result = GTK_RBNODE_BLACK
proc GTK_RBNODE_SET_COLOR*(node_: PGtkRBNode, color: guint) = proc GTK_RBNODE_SET_COLOR*(node: PGtkRBNode, color: guint) =
if node_ == nil: if node == nil:
return return
if ((flags(node_) and (color)) != color): if ((flags(node) and (color)) != color):
set_flags(node_, flags(node_) xor cint(GTK_RBNODE_RED or GTK_RBNODE_BLACK)) set_flags(node, flags(node) xor cint(GTK_RBNODE_RED or GTK_RBNODE_BLACK))
proc GTK_RBNODE_GET_HEIGHT*(node_: PGtkRBNode): gint = proc GTK_RBNODE_GET_HEIGHT*(node: PGtkRBNode): gint =
var if_local1: gint var if_local1: gint
if node_ . children != nil: if node.children != nil:
if_local1 = node_.children.root.offset if_local1 = node.children.root.offset
else: else:
if_local1 = 0 if_local1 = 0
result = node_.offset - ((node_.left.offset) + node_.right.offset + if_local1) result = node.offset - ((node.left.offset) + node.right.offset + if_local1)
proc GTK_RBNODE_FLAG_SET*(node_: PGtkRBNode, flag: guint): bool = proc GTK_RBNODE_FLAG_SET*(node: PGtkRBNode, flag: guint): bool =
result = (node_ != nil) and ((flags(node_) and (flag)) == flag) result = (node != nil) and ((flags(node) and (flag)) == flag)
proc GTK_RBNODE_SET_FLAG*(node_: PGtkRBNode, flag: guint16) = proc GTK_RBNODE_SET_FLAG*(node: PGtkRBNode, flag: guint16) =
set_flags(node_, (flag) or flags(node_)) set_flags(node, (flag) or flags(node))
proc GTK_RBNODE_UNSET_FLAG*(node_: PGtkRBNode, flag: guint16) = proc GTK_RBNODE_UNSET_FLAG*(node: PGtkRBNode, flag: guint16) =
set_flags(node_, (not (flag)) and flags(node_)) set_flags(node, (not (flag)) and flags(node))
proc GTK_TREE_VIEW_FLAG_SET*(tree_view: PGtkTreeView, flag: guint): bool = proc GTK_TREE_VIEW_FLAG_SET*(tree_view: PGtkTreeView, flag: guint): bool =
result = ((tree_view.priv.flags) and (flag)) == flag result = ((tree_view.priv.flags) and (flag)) == flag

4
lib/wrappers/lua/lauxlib.nim
View file

@ -48,9 +48,9 @@ proc luaL_typerror*(L: Plua_State, narg: int, tname: cstring): int{.cdecl,
dynlib: LUA_LIB_NAME, importc.} dynlib: LUA_LIB_NAME, importc.}
proc luaL_argerror*(L: Plua_State, numarg: int, extramsg: cstring): int{.cdecl, proc luaL_argerror*(L: Plua_State, numarg: int, extramsg: cstring): int{.cdecl,
dynlib: LUA_LIB_NAME, importc.} dynlib: LUA_LIB_NAME, importc.}
proc luaL_checklstring*(L: Plua_State, numArg: int, l_: Psize_t): cstring{. proc luaL_checklstring*(L: Plua_State, numArg: int, len: Psize_t): cstring{.
cdecl, dynlib: LUA_LIB_NAME, importc.} cdecl, dynlib: LUA_LIB_NAME, importc.}
proc luaL_optlstring*(L: Plua_State, numArg: int, def: cstring, l_: Psize_t): cstring{. proc luaL_optlstring*(L: Plua_State, numArg: int, def: cstring, len: Psize_t): cstring{.
cdecl, dynlib: LUA_LIB_NAME, importc.} cdecl, dynlib: LUA_LIB_NAME, importc.}
proc luaL_checknumber*(L: Plua_State, numArg: int): lua_Number{.cdecl, proc luaL_checknumber*(L: Plua_State, numArg: int): lua_Number{.cdecl,
dynlib: LUA_LIB_NAME, importc.} dynlib: LUA_LIB_NAME, importc.}

4
lib/wrappers/lua/lua.nim
View file

@ -67,7 +67,7 @@ const
proc lua_upvalueindex*(I: int): int proc lua_upvalueindex*(I: int): int
const # thread status; 0 is OK const # thread status; 0 is OK
LUA_YIELD_* = 1 constLUA_YIELD* = 1
LUA_ERRRUN* = 2 LUA_ERRRUN* = 2
LUA_ERRSYNTAX* = 3 LUA_ERRSYNTAX* = 3
LUA_ERRMEM* = 4 LUA_ERRMEM* = 4
@ -158,7 +158,7 @@ proc lua_pushnumber*(L: Plua_State, n: lua_Number){.cdecl, dynlib: LUA_NAME,
importc.} importc.}
proc lua_pushinteger*(L: Plua_State, n: lua_Integer){.cdecl, dynlib: LUA_NAME, proc lua_pushinteger*(L: Plua_State, n: lua_Integer){.cdecl, dynlib: LUA_NAME,
importc.} importc.}
proc lua_pushlstring*(L: Plua_State, s: cstring, l_: size_t){.cdecl, proc lua_pushlstring*(L: Plua_State, s: cstring, len: size_t){.cdecl,
dynlib: LUA_NAME, importc.} dynlib: LUA_NAME, importc.}
proc lua_pushstring*(L: Plua_State, s: cstring){.cdecl, dynlib: LUA_NAME, proc lua_pushstring*(L: Plua_State, s: cstring){.cdecl, dynlib: LUA_NAME,
importc.} importc.}

4
lib/wrappers/python.nim
View file

@ -1,6 +1,6 @@
# #
# Light-weight binding for the Python interpreter # Light-weight binding for the Python interpreter
# (c) 2009 Andreas Rumpf # (c) 2010 Andreas Rumpf
# Based on 'PythonEngine' module by Dr. Dietmar Budelsky # Based on 'PythonEngine' module by Dr. Dietmar Budelsky
# #
# #
@ -375,7 +375,7 @@ type
TPyGetSetDef*{.final.} = object TPyGetSetDef*{.final.} = object
name*: cstring name*: cstring
get*: Tgetter get*: Tgetter
set_*: Tsetter setter*: Tsetter
doc*: cstring doc*: cstring
closure*: Pointer closure*: Pointer

4
lib/wrappers/sdl/sdl_mixer.nim
View file

@ -207,7 +207,7 @@ type #music_cmd.h types
TMidiEvent*{.final.} = object TMidiEvent*{.final.} = object
time*: int32 time*: int32
channel*: uint8 channel*: uint8
type_*: uint8 typ*: uint8
a*: uint8 a*: uint8
b*: uint8 b*: uint8
@ -280,7 +280,7 @@ type #music_cmd.h types
# end; # end;
PMix_Music* = ptr TMix_Music PMix_Music* = ptr TMix_Music
TMix_Music*{.final.} = object # The internal format for a music chunk interpreted via mikmod TMix_Music*{.final.} = object # The internal format for a music chunk interpreted via mikmod
type_*: TMix_MusicType # other fields are not aviable typ*: TMix_MusicType # other fields are not aviable
# data : TMusicUnion; # data : TMusicUnion;
# fading : TMix_Fading; # fading : TMix_Fading;
# fade_volume : integer; # fade_volume : integer;

4
lib/wrappers/sdl/sdl_mixer_nosmpeg.nim
View file

@ -61,7 +61,7 @@ type #music_cmd.h types
TMidiEvent*{.final.} = object TMidiEvent*{.final.} = object
time*: int32 time*: int32
channel*: uint8 channel*: uint8
type_*: uint8 typ*: uint8
a*: uint8 a*: uint8
b*: uint8 b*: uint8
@ -122,7 +122,7 @@ type #music_cmd.h types
MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG
PMix_Music* = ptr TMix_Music PMix_Music* = ptr TMix_Music
TMix_Music*{.final.} = object TMix_Music*{.final.} = object
type_*: TMix_MusicType typ*: TMix_MusicType
TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{. TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{.
cdecl.} # This macro can be used to fill a version structure with the compile-time cdecl.} # This macro can be used to fill a version structure with the compile-time

2
lib/wrappers/sdl/smpeg.nim
View file

@ -251,7 +251,7 @@ proc SMPEG_setdisplay*(mpeg: PSMPEG, dst: PSDL_Surface, surfLock: PSDL_mutex,
callback: TSMPEG_DisplayCallback){.cdecl, callback: TSMPEG_DisplayCallback){.cdecl,
importc, dynlib: SmpegLibName.} importc, dynlib: SmpegLibName.}
# Set or clear looping play on an SMPEG object # Set or clear looping play on an SMPEG object
proc SMPEG_loop*(mpeg: PSMPEG, repeat_: int){.cdecl, importc, dynlib: SmpegLibName.} proc SMPEG_loop*(mpeg: PSMPEG, repeat: int){.cdecl, importc, dynlib: SmpegLibName.}
# Scale pixel display on an SMPEG object # Scale pixel display on an SMPEG object
proc SMPEG_scaleXY*(mpeg: PSMPEG, width, height: int){.cdecl, proc SMPEG_scaleXY*(mpeg: PSMPEG, width, height: int){.cdecl,
importc, dynlib: SmpegLibName.} importc, dynlib: SmpegLibName.}

6
lib/wrappers/x11/xlib.nim
View file

@ -68,7 +68,7 @@ type
PXGCValues* = ptr TXGCValues PXGCValues* = ptr TXGCValues
TXGCValues*{.final.} = object TXGCValues*{.final.} = object
function_*: cint function*: cint
plane_mask*: culong plane_mask*: culong
foreground*: culong foreground*: culong
background*: culong background*: culong
@ -651,7 +651,7 @@ type
requestor*: TWindow requestor*: TWindow
selection*: TAtom selection*: TAtom
target*: TAtom target*: TAtom
property_*: TAtom property*: TAtom
time*: TTime time*: TTime
PXSelectionEvent* = ptr TXSelectionEvent PXSelectionEvent* = ptr TXSelectionEvent
@ -663,7 +663,7 @@ type
requestor*: TWindow requestor*: TWindow
selection*: TAtom selection*: TAtom
target*: TAtom target*: TAtom
property_*: TAtom property*: TAtom
time*: TTime time*: TTime
PXColormapEvent* = ptr TXColormapEvent PXColormapEvent* = ptr TXColormapEvent

2
lib/wrappers/x11/xrender.nim
View file

@ -163,7 +163,7 @@ type
PXRenderPictureAttributes* = ptr TXRenderPictureAttributes PXRenderPictureAttributes* = ptr TXRenderPictureAttributes
TXRenderPictureAttributes*{.final.} = object TXRenderPictureAttributes*{.final.} = object
repeat_*: TBool repeat*: TBool
alpha_map*: TPicture alpha_map*: TPicture
alpha_x_origin*: int32 alpha_x_origin*: int32
alpha_y_origin*: int32 alpha_y_origin*: int32

2
lib/wrappers/x11/xutil.nim
View file

@ -146,7 +146,7 @@ type
visualid*: TVisualID visualid*: TVisualID
screen*: cint screen*: cint
depth*: cint depth*: cint
class_*: cint class*: cint
red_mask*: culong red_mask*: culong
green_mask*: culong green_mask*: culong
blue_mask*: culong blue_mask*: culong

4
rod/pragmas.nim
View file

@ -169,10 +169,10 @@ proc expectDynlibNode(c: PContext, n: PNode): PNode =
if n.kind != nkExprColonExpr: liMessage(n.info, errStringLiteralExpected) if n.kind != nkExprColonExpr: liMessage(n.info, errStringLiteralExpected)
else: else:
result = c.semExpr(c, n.sons[1]) result = c.semExpr(c, n.sons[1])
if result.typ == nil or result.typ.kind != tyString:
liMessage(n.info, errStringLiteralExpected)
if result.kind == nkSym and result.sym.kind == skConst: if result.kind == nkSym and result.sym.kind == skConst:
result = result.sym.ast # look it up result = result.sym.ast # look it up
if result.typ == nil or result.typ.kind != tyString:
liMessage(n.info, errStringLiteralExpected)
proc processDynLib(c: PContext, n: PNode, sym: PSym) = proc processDynLib(c: PContext, n: PNode, sym: PSym) =
if (sym == nil) or (sym.kind == skModule): if (sym == nil) or (sym.kind == skModule):

13
tests/tnewlibs.nim
View file

@ -1,19 +1,16 @@
# Test wether the bindings at least compile... # Test wether the bindings at least compile...
import import
tcl,
sdl, smpeg, sdl_gfx, sdl_net, sdl_mixer, sdl_ttf,
sdl_image, sdl_mixer_nosmpeg,
gtk2, glib2, pango, gdk2,
unicode, cgi, terminal, libcurl, unicode, cgi, terminal, libcurl,
parsexml, parseopt, parsecfg, parsexml, parseopt, parsecfg,
osproc, osproc,
cairowin32, cairoxlib, cairowin32, cairoxlib,
gl, glut, glu, glx, glext, wingl, gl, glut, glu, glx, glext, wingl,
lua, lualib, lauxlib, mysql, sqlite3, python, tcl, lua, lualib, lauxlib, mysql, sqlite3,
sdl, smpeg, sdl_gfx, sdl_net, sdl_mixer, sdl_ttf,
sdl_image, sdl_mixer_nosmpeg,
gtk2, glib2, pango, gdk2
when defined(linux):
import
zlib, zipfiles
writeln(stdout, "test compilation of binding modules") writeln(stdout, "test compilation of binding modules")