mirror of
https://github.com/nim-lang/Nim.git
synced 2026-09-20 03:48:17 +00:00
wrappers do not contain invalid identifiers
This commit is contained in:
Andreas Rumpf
@@ -3313,125 +3313,125 @@ proc g_module_name*(module: PGModule): cstring{.cdecl, dynlib: gmodulelib,
|
||||
importc: "g_module_name".}
|
||||
proc g_module_build_path*(directory: cstring, module_name: cstring): cstring{.
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
n_param_values: GUInt,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
n_param_values: GUInt,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
n_param_values: GUInt,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
|
||||
@@ -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_DRAW_DRAG_LINE_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_PIXMAP_get*(cell: pointer): PGtkCellPixmap
|
||||
#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_CLASS*(klass: pointer): bool
|
||||
proc CTREE_GET_CLASS*(obj: pointer): PCTreeClass
|
||||
proc CTREE_ROW*(`node_`: TAddress): PCTreeRow
|
||||
proc CTREE_NODE*(`node_`: TAddress): PCTreeNode
|
||||
proc CTREE_NODE_NEXT*(`nnode_`: TAddress): PCTreeNode
|
||||
proc CTREE_NODE_PREV*(`pnode_`: TAddress): PCTreeNode
|
||||
proc CTREE_FUNC*(`func_`: TAddress): TCTreeFunc
|
||||
proc CTREE_ROW*(node: TAddress): PCTreeRow
|
||||
proc CTREE_NODE*(node: TAddress): PCTreeNode
|
||||
proc CTREE_NODE_NEXT*(nnode: TAddress): PCTreeNode
|
||||
proc CTREE_NODE_PREV*(pnode: TAddress): PCTreeNode
|
||||
proc CTREE_FUNC*(fun: TAddress): TCTreeFunc
|
||||
proc TYPE_CTREE_NODE*(): GType
|
||||
proc line_style*(a: var TCTree): 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,
|
||||
is_leaf: gboolean, expanded: gboolean): PCTreeNode{.
|
||||
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".}
|
||||
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".}
|
||||
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,
|
||||
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,
|
||||
importc: "gtk_ctree_post_recursive".}
|
||||
proc ctree_post_recursive_to_depth*(ctree: PCTree, node_: PCTreeNode,
|
||||
depth: gint, func_: TCTreeFunc,
|
||||
proc ctree_post_recursive_to_depth*(ctree: PCTree, node: PCTreeNode,
|
||||
depth: gint, fun: TCTreeFunc,
|
||||
data: gpointer){.cdecl, dynlib: lib,
|
||||
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,
|
||||
importc: "gtk_ctree_pre_recursive".}
|
||||
proc ctree_pre_recursive_to_depth*(ctree: PCTree, node_: PCTreeNode,
|
||||
depth: gint, func_: TCTreeFunc,
|
||||
proc ctree_pre_recursive_to_depth*(ctree: PCTree, node: PCTreeNode,
|
||||
depth: gint, fun: TCTreeFunc,
|
||||
data: gpointer){.cdecl, dynlib: lib,
|
||||
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".}
|
||||
proc ctree_last*(ctree: PCTree, node_: PCTreeNode): PCTreeNode{.cdecl,
|
||||
proc ctree_last*(ctree: PCTree, node: PCTreeNode): PCTreeNode{.cdecl,
|
||||
dynlib: lib, importc: "gtk_ctree_last".}
|
||||
proc ctree_find_node_ptr*(ctree: PCTree, ctree_row: PCTreeRow): PCTreeNode{.
|
||||
cdecl, dynlib: lib, importc: "gtk_ctree_find_node_ptr".}
|
||||
proc ctree_node_nth*(ctree: PCTree, row: guint): PCTreeNode{.cdecl, dynlib: lib,
|
||||
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".}
|
||||
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".}
|
||||
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".}
|
||||
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,
|
||||
importc: "gtk_ctree_find_all_by_row_data".}
|
||||
proc ctree_find_by_row_data_custom*(ctree: PCTree, node_: PCTreeNode,
|
||||
data: gpointer, func_: TGCompareFunc): PCTreeNode{.
|
||||
proc ctree_find_by_row_data_custom*(ctree: PCTree, node: PCTreeNode,
|
||||
data: gpointer, fun: TGCompareFunc): PCTreeNode{.
|
||||
cdecl, dynlib: lib, importc: "gtk_ctree_find_by_row_data_custom".}
|
||||
proc ctree_find_all_by_row_data_custom*(ctree: PCTree, node_: PCTreeNode,
|
||||
data: gpointer, func_: TGCompareFunc): PGList{.
|
||||
proc ctree_find_all_by_row_data_custom*(ctree: PCTree, node: PCTreeNode,
|
||||
data: gpointer, fun: TGCompareFunc): PGList{.
|
||||
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,
|
||||
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,
|
||||
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".}
|
||||
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".}
|
||||
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".}
|
||||
proc ctree_collapse*(ctree: PCTree, node_: PCTreeNode){.cdecl, dynlib: lib,
|
||||
proc ctree_collapse*(ctree: PCTree, node: PCTreeNode){.cdecl, dynlib: lib,
|
||||
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".}
|
||||
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".}
|
||||
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".}
|
||||
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".}
|
||||
proc ctree_select*(ctree: PCTree, node_: PCTreeNode){.cdecl, dynlib: lib,
|
||||
proc ctree_select*(ctree: PCTree, node: PCTreeNode){.cdecl, dynlib: lib,
|
||||
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".}
|
||||
proc ctree_unselect*(ctree: PCTree, node_: PCTreeNode){.cdecl, dynlib: lib,
|
||||
proc ctree_unselect*(ctree: PCTree, node: PCTreeNode){.cdecl, dynlib: lib,
|
||||
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".}
|
||||
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".}
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
mask: gdk2.PBitmap){.cdecl, dynlib: lib,
|
||||
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,
|
||||
mask_closed: gdk2.PBitmap, pixmap_opened: gdk2.PPixmap,
|
||||
mask_opened: gdk2.PBitmap, is_leaf: gboolean,
|
||||
expanded: gboolean){.cdecl, dynlib: lib,
|
||||
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,
|
||||
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,
|
||||
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".}
|
||||
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".}
|
||||
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,
|
||||
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".}
|
||||
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".}
|
||||
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,
|
||||
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".}
|
||||
proc ctree_node_set_foreground*(ctree: PCTree, node_: PCTreeNode,
|
||||
proc ctree_node_set_foreground*(ctree: PCTree, node: PCTreeNode,
|
||||
color: gdk2.PColor){.cdecl, dynlib: lib,
|
||||
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,
|
||||
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".}
|
||||
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){.
|
||||
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".}
|
||||
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,
|
||||
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".}
|
||||
proc ctree_set_indent*(ctree: PCTree, indent: gint){.cdecl, dynlib: lib,
|
||||
importc: "gtk_ctree_set_indent".}
|
||||
@@ -5725,9 +5725,9 @@ proc ctree_set_expander_style*(ctree: PCTree,
|
||||
dynlib: lib, importc: "gtk_ctree_set_expander_style".}
|
||||
proc ctree_set_drag_compare_func*(ctree: PCTree, cmp_func: TCTreeCompareDragFunc){.
|
||||
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".}
|
||||
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".}
|
||||
proc ctree_set_reorderable*(t: pointer, r: bool)
|
||||
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_new*(): PMenu{.cdecl, dynlib: lib, importc: "gtk_menu_new".}
|
||||
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,
|
||||
dynlib: lib, importc: "gtk_menu_popup".}
|
||||
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,
|
||||
dynlib: lib, importc: "gtk_item_factory_popup_data_from_widget".}
|
||||
proc item_factory_set_translate_func*(ifactory: PItemFactory,
|
||||
func_: TTranslateFunc, data: gpointer,
|
||||
fun: TTranslateFunc, data: gpointer,
|
||||
notify: TDestroyNotify){.cdecl,
|
||||
dynlib: lib, importc: "gtk_item_factory_set_translate_func".}
|
||||
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".}
|
||||
proc tree_model_unref_node*(tree_model: PTreeModel, iter: PTreeIter){.cdecl,
|
||||
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,
|
||||
importc: "gtk_tree_model_foreach".}
|
||||
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".}
|
||||
proc text_tag_table_lookup*(table: PTextTagTable, name: cstring): PTextTag{.
|
||||
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,
|
||||
importc: "gtk_text_tag_table_foreach".}
|
||||
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".}
|
||||
proc toggle_segment_check_func*(segPtr: PTextLineSegment, line: PTextLine){.
|
||||
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,
|
||||
importc: "_gtk_change_node_toggle_count".}
|
||||
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,
|
||||
dynlib: lib, importc: "gtk_tree_selection_get_mode".}
|
||||
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".}
|
||||
proc tree_selection_get_user_data*(selection: PTreeSelection): gpointer{.cdecl,
|
||||
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,
|
||||
dynlib: lib, importc: "gtk_tree_selection_get_selected_rows".}
|
||||
proc tree_selection_selected_foreach*(selection: PTreeSelection,
|
||||
func_: TTreeSelectionForeachFunc,
|
||||
fun: TTreeSelectionForeachFunc,
|
||||
data: gpointer){.cdecl, dynlib: lib,
|
||||
importc: "gtk_tree_selection_selected_foreach".}
|
||||
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,
|
||||
dynlib: lib, importc: "gtk_tree_view_column_add_attribute".}
|
||||
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".}
|
||||
proc tree_view_column_clear_attributes*(tree_column: PTreeViewColumn,
|
||||
cell_renderer: PCellRenderer){.cdecl,
|
||||
@@ -10380,12 +10380,12 @@ proc flags*(a: PRBNode): guint
|
||||
proc set_flags*(a: PRBNode, `flags`: guint)
|
||||
proc parity*(a: PRBNode): guint
|
||||
proc set_parity*(a: PRBNode, `parity`: guint)
|
||||
proc RBNODE_GET_COLOR*(node_: PRBNode): guint
|
||||
proc RBNODE_SET_COLOR*(node_: PRBNode, color: guint)
|
||||
proc RBNODE_GET_HEIGHT*(node_: PRBNode): gint
|
||||
proc RBNODE_SET_FLAG*(node_: PRBNode, flag: guint16)
|
||||
proc RBNODE_UNSET_FLAG*(node_: PRBNode, flag: guint16)
|
||||
proc RBNODE_FLAG_SET*(node_: PRBNode, flag: guint): bool
|
||||
proc RBNODE_GET_COLOR*(node: PRBNode): guint
|
||||
proc RBNODE_SET_COLOR*(node: PRBNode, color: guint)
|
||||
proc RBNODE_GET_HEIGHT*(node: PRBNode): gint
|
||||
proc RBNODE_SET_FLAG*(node: PRBNode, flag: guint16)
|
||||
proc RBNODE_UNSET_FLAG*(node: PRBNode, flag: guint16)
|
||||
proc RBNODE_FLAG_SET*(node: PRBNode, flag: guint): bool
|
||||
proc rbtree_push_allocator*(allocator: PGAllocator){.cdecl, dynlib: lib,
|
||||
importc: "_gtk_rbtree_push_allocator".}
|
||||
proc rbtree_pop_allocator*(){.cdecl, dynlib: lib,
|
||||
@@ -10397,23 +10397,23 @@ proc rbtree_remove*(tree: PRBTree){.cdecl, dynlib: lib,
|
||||
importc: "_gtk_rbtree_remove".}
|
||||
proc rbtree_destroy*(tree: PRBTree){.cdecl, dynlib: lib,
|
||||
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,
|
||||
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,
|
||||
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".}
|
||||
proc rbtree_reorder*(tree: PRBTree, new_order: Pgint, length: gint){.cdecl,
|
||||
dynlib: lib, importc: "_gtk_rbtree_reorder".}
|
||||
proc rbtree_find_count*(tree: PRBTree, count: gint): PRBNode{.cdecl,
|
||||
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".}
|
||||
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".}
|
||||
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".}
|
||||
proc rbtree_column_invalid*(tree: PRBTree){.cdecl, dynlib: lib,
|
||||
importc: "_gtk_rbtree_column_invalid".}
|
||||
@@ -10421,16 +10421,16 @@ proc rbtree_mark_invalid*(tree: PRBTree){.cdecl, dynlib: lib,
|
||||
importc: "_gtk_rbtree_mark_invalid".}
|
||||
proc rbtree_set_fixed_height*(tree: PRBTree, height: gint){.cdecl, dynlib: lib,
|
||||
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".}
|
||||
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".}
|
||||
proc rbtree_traverse*(tree: PRBTree, node_: PRBNode, order: TGTraverseType,
|
||||
func_: TRBTreeTraverseFunc, data: gpointer){.cdecl,
|
||||
proc rbtree_traverse*(tree: PRBTree, node: PRBNode, order: TGTraverseType,
|
||||
fun: TRBTreeTraverseFunc, data: gpointer){.cdecl,
|
||||
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".}
|
||||
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".}
|
||||
proc rbtree_get_depth*(tree: PRBTree): gint{.cdecl, dynlib: lib,
|
||||
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 set_disable_popdown*(a: var TTreeViewPrivate, `disable_popdown`: guint)
|
||||
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".}
|
||||
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".}
|
||||
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".}
|
||||
proc tree_view_child_move_resize*(tree_view: PTreeView, widget: PWidget,
|
||||
x: gint, y: gint, width: gint, height: gint){.
|
||||
cdecl, dynlib: lib, importc: "_gtk_tree_view_child_move_resize".}
|
||||
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".}
|
||||
proc tree_view_column_realize_button*(column: PTreeViewColumn){.cdecl,
|
||||
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".}
|
||||
proc tree_view_insert_column_with_data_func*(tree_view: PTreeView,
|
||||
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".}
|
||||
proc tree_view_get_column*(tree_view: PTreeView, n: gint): PTreeViewColumn{.
|
||||
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{.
|
||||
cdecl, dynlib: lib, importc: "gtk_tree_view_get_expander_column".}
|
||||
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".}
|
||||
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".}
|
||||
@@ -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{.
|
||||
cdecl, dynlib: lib, importc: "gtk_tree_view_collapse_row".}
|
||||
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".}
|
||||
proc tree_view_row_expanded*(tree_view: PTreeView, path: PTreePath): gboolean{.
|
||||
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,
|
||||
dynlib: lib, importc: "gtk_tree_view_set_search_equal_func".}
|
||||
proc tree_view_set_destroy_count_func*(tree_view: PTreeView,
|
||||
func_: TTreeDestroyCountFunc,
|
||||
fun: TTreeDestroyCountFunc,
|
||||
data: gpointer, destroy: TDestroyNotify){.
|
||||
cdecl, dynlib: lib, importc: "gtk_tree_view_set_destroy_count_func".}
|
||||
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 =
|
||||
result = ((CLIST_FLAGS(clist)) and cint(CLIST_DRAW_DRAG_RECT)) != 0'i32
|
||||
|
||||
proc CLIST_ROW_get*(`glist_`: PGList): PCListRow =
|
||||
result = cast[PCListRow](`glist_`.data)
|
||||
proc CLIST_ROW_get*(glist: PGList): PCListRow =
|
||||
result = cast[PCListRow](glist.data)
|
||||
|
||||
when false:
|
||||
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 =
|
||||
result = cast[PCTreeClass](CHECK_GET_CLASS(obj, TYPE_CTREE()))
|
||||
|
||||
proc CTREE_ROW*(`node_`: TAddress): PCTreeRow =
|
||||
result = cast[PCTreeRow]((cast[PGList](`node_`)).data)
|
||||
proc CTREE_ROW*(node: TAddress): PCTreeRow =
|
||||
result = cast[PCTreeRow]((cast[PGList](node)).data)
|
||||
|
||||
proc CTREE_NODE*(`node_`: TAddress): PCTreeNode =
|
||||
result = cast[PCTreeNode](`node_`)
|
||||
proc CTREE_NODE*(node: TAddress): PCTreeNode =
|
||||
result = cast[PCTreeNode](node)
|
||||
|
||||
proc CTREE_NODE_NEXT*(`nnode_`: TAddress): PCTreeNode =
|
||||
result = cast[PCTreeNode]((cast[PGList](`nnode_`)).next)
|
||||
proc CTREE_NODE_NEXT*(nnode: TAddress): PCTreeNode =
|
||||
result = cast[PCTreeNode]((cast[PGList](nnode)).next)
|
||||
|
||||
proc CTREE_NODE_PREV*(`pnode_`: TAddress): PCTreeNode =
|
||||
result = cast[PCTreeNode]((cast[PGList](`pnode_`)).prev)
|
||||
proc CTREE_NODE_PREV*(pnode: TAddress): PCTreeNode =
|
||||
result = cast[PCTreeNode]((cast[PGList](pnode)).prev)
|
||||
|
||||
proc CTREE_FUNC*(`func_`: TAddress): TCTreeFunc =
|
||||
result = cast[TCTreeFunc](`func_`)
|
||||
proc CTREE_FUNC*(fun: TAddress): TCTreeFunc =
|
||||
result = cast[TCTreeFunc](fun)
|
||||
|
||||
proc TYPE_CTREE_NODE*(): GType =
|
||||
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) =
|
||||
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,
|
||||
unknown2: pointer, unknown3, unknown4: int): gulong{.
|
||||
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){.
|
||||
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 =
|
||||
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 =
|
||||
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,
|
||||
func_: TSignalFunc, slot_object: gpointer): gulong =
|
||||
result = signal_connect_full(anObject, name, func_, nil, slot_object, nil, 1,
|
||||
fun: TSignalFunc, slot_object: gpointer): gulong =
|
||||
result = signal_connect_full(anObject, name, fun, nil, slot_object, nil, 1,
|
||||
0)
|
||||
|
||||
proc signal_connect_object_after*(anObject: PObject, name: cstring,
|
||||
func_: TSignalFunc, slot_object: gpointer): gulong =
|
||||
result = signal_connect_full(anObject, name, func_, nil, slot_object, nil, 1,
|
||||
fun: TSignalFunc, slot_object: gpointer): gulong =
|
||||
result = signal_connect_full(anObject, name, fun, nil, slot_object, nil, 1,
|
||||
1)
|
||||
|
||||
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) =
|
||||
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) =
|
||||
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)
|
||||
|
||||
proc signal_handler_block_by_func*(anObject: PObject, func_: TSignalFunc,
|
||||
proc signal_handler_block_by_func*(anObject: PObject, fun: TSignalFunc,
|
||||
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)
|
||||
|
||||
proc signal_handler_block_by_data*(anObject: PObject, data: gpointer) =
|
||||
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) =
|
||||
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)
|
||||
|
||||
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,
|
||||
may_be_blocked: gboolean,
|
||||
func_: TSignalFunc, data: gpointer): gboolean =
|
||||
fun: TSignalFunc, data: gpointer): gboolean =
|
||||
var t: TGSignalMatchType
|
||||
t = cast[TGSignalMatchType](G_SIGNAL_MATCH_ID or G_SIGNAL_MATCH_FUNC or
|
||||
G_SIGNAL_MATCH_DATA)
|
||||
if not may_be_blocked:
|
||||
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
|
||||
|
||||
proc TYPE_SIZE_GROUP*(): GType =
|
||||
@@ -16221,37 +16221,37 @@ proc set_parity*(a: PRBNode, `parity`: guint) =
|
||||
a.flag0 = a.flag0 or
|
||||
(int16(`parity` shl bp_TGtkRBNode_parity) and bm_TGtkRBNode_parity)
|
||||
|
||||
proc RBNODE_GET_COLOR*(node_: PRBNode): guint =
|
||||
if node_ == nil:
|
||||
proc RBNODE_GET_COLOR*(node: PRBNode): guint =
|
||||
if node == nil:
|
||||
Result = RBNODE_BLACK
|
||||
elif (int(flags(node_)) and RBNODE_RED) == RBNODE_RED:
|
||||
elif (int(flags(node)) and RBNODE_RED) == RBNODE_RED:
|
||||
Result = RBNODE_RED
|
||||
else:
|
||||
Result = RBNODE_BLACK
|
||||
|
||||
proc RBNODE_SET_COLOR*(node_: PRBNode, color: guint) =
|
||||
if node_ == nil:
|
||||
proc RBNODE_SET_COLOR*(node: PRBNode, color: guint) =
|
||||
if node == nil:
|
||||
return
|
||||
if ((flags(node_) and (color)) != color):
|
||||
set_flags(node_, flags(node_) xor cint(RBNODE_RED or RBNODE_BLACK))
|
||||
if ((flags(node) and (color)) != color):
|
||||
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
|
||||
if node_.children != nil:
|
||||
if_local1 = node_.children.root.offset
|
||||
if node.children != nil:
|
||||
if_local1 = node.children.root.offset
|
||||
else:
|
||||
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 RBNODE_FLAG_SET*(node_: PRBNode, flag: guint): bool =
|
||||
result = (node_ != nil) and ((flags(node_) and (flag)) == flag)
|
||||
proc RBNODE_FLAG_SET*(node: PRBNode, flag: guint): bool =
|
||||
result = (node != nil) and ((flags(node) and (flag)) == flag)
|
||||
|
||||
proc RBNODE_SET_FLAG*(node_: PRBNode, flag: guint16) =
|
||||
set_flags(node_, (flag) or flags(node_))
|
||||
proc RBNODE_SET_FLAG*(node: PRBNode, flag: guint16) =
|
||||
set_flags(node, (flag) or flags(node))
|
||||
|
||||
proc RBNODE_UNSET_FLAG*(node_: PRBNode, flag: guint16) =
|
||||
set_flags(node_, (not (flag)) and flags(node_))
|
||||
proc RBNODE_UNSET_FLAG*(node: PRBNode, flag: guint16) =
|
||||
set_flags(node, (not (flag)) and flags(node))
|
||||
|
||||
proc TREE_VIEW_FLAG_SET*(tree_view: PTreeView, flag: guint): bool =
|
||||
result = ((tree_view.priv.flags) and (flag)) == flag
|
||||
|
||||
@@ -38,28 +38,28 @@ type
|
||||
Preg* = ptr Treg
|
||||
|
||||
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,
|
||||
dynlib: LIB_NAME, importc: "luaL_register".}
|
||||
dynlib: lua.LIB_NAME, importc: "luaL_register".}
|
||||
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,
|
||||
dynlib: LIB_NAME, importc: "luaL_callmeta".}
|
||||
proc typerror*(L: PState, narg: int, tname: cstring): int{.cdecl,
|
||||
dynlib: LIB_NAME, importc: "luaL_typerror".}
|
||||
proc argerror*(L: PState, numarg: int, extramsg: cstring): int{.cdecl,
|
||||
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".}
|
||||
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".}
|
||||
proc checknumber*(L: PState, numArg: int): lua_Number{.cdecl,
|
||||
proc checknumber*(L: PState, numArg: int): Number{.cdecl,
|
||||
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".}
|
||||
proc checkinteger*(L: PState, numArg: int): lua_Integer{.cdecl,
|
||||
proc checkinteger*(L: PState, numArg: int): Integer{.cdecl,
|
||||
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".}
|
||||
proc checkstack*(L: PState, sz: int, msg: cstring){.cdecl,
|
||||
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".}
|
||||
proc checkoption*(L: PState, narg: int, def: cstring, lst: cstringArray): int{.
|
||||
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".}
|
||||
proc unref*(L: PState, t, theref: int){.cdecl, dynlib: LIB_NAME,
|
||||
importc: "luaL_unref".}
|
||||
proc loadfile*(L: PState, filename: cstring): int{.cdecl,
|
||||
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".}
|
||||
proc loadstring*(L: PState, s: cstring): int{.cdecl, dynlib: LIB_NAME,
|
||||
importc: "luaL_loadstring".}
|
||||
proc newstate*(): PState{.cdecl, dynlib: LIB_NAME,
|
||||
importc: "luaL_newstate".}
|
||||
proc lua_open*(): PState
|
||||
proc open*(): PState
|
||||
# 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 optint*(L: PState, n: int, d: float64): int
|
||||
proc optlong*(L: PState, n: int, d: float64): int32
|
||||
proc typename*(L: PState, i: int): cstring
|
||||
proc lua_dofile*(L: PState, filename: cstring): int
|
||||
proc lua_dostring*(L: PState, str: cstring): int
|
||||
proc lua_Lgetmetatable*(L: PState, tname: cstring)
|
||||
proc dofile*(L: PState, filename: cstring): int
|
||||
proc dostring*(L: PState, str: cstring): int
|
||||
proc getmetatable*(L: PState, tname: cstring)
|
||||
# not translated:
|
||||
# #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".}
|
||||
proc prepbuffer*(B: PBuffer): cstring{.cdecl, dynlib: LIB_NAME,
|
||||
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".}
|
||||
proc addstring*(B: PBuffer, s: cstring){.cdecl, dynlib: LIB_NAME,
|
||||
importc: "luaL_addstring".}
|
||||
@@ -151,42 +150,39 @@ proc findtable*(L: PState, idx: int, fname: cstring, szhint: int): cstring{.
|
||||
# compatibility with ref system
|
||||
# pre-defined references
|
||||
const
|
||||
LUA_NOREF* = - 2
|
||||
LUA_REFNIL* = - 1
|
||||
NOREF* = - 2
|
||||
REFNIL* = - 1
|
||||
|
||||
proc lua_unref*(L: PState, theref: int)
|
||||
proc lua_getref*(L: PState, theref: int)
|
||||
proc unref*(L: PState, theref: int)
|
||||
proc getref*(L: PState, theref: int)
|
||||
#
|
||||
#** Compatibility macros and functions
|
||||
#
|
||||
# implementation
|
||||
|
||||
proc lua_pushstring(L: PState, s: string) =
|
||||
lua_pushlstring(L, cstring(s), len(s))
|
||||
proc pushstring(L: PState, s: string) =
|
||||
pushlstring(L, cstring(s), len(s))
|
||||
|
||||
proc getn(L: PState, n: int): int =
|
||||
Result = lua_objlen(L, n)
|
||||
Result = objlen(L, n)
|
||||
|
||||
proc setn(L: PState, t, n: int) =
|
||||
# does nothing as this operation is deprecated
|
||||
nil
|
||||
|
||||
proc lua_open(): PState =
|
||||
proc open(): PState =
|
||||
Result = newstate()
|
||||
|
||||
proc typename(L: PState, i: int): cstring =
|
||||
Result = lua_typename(L, lua_type(L, i))
|
||||
|
||||
proc lua_dofile(L: PState, filename: cstring): int =
|
||||
proc dofile(L: PState, filename: cstring): int =
|
||||
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)
|
||||
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) =
|
||||
lua_getfield(L, LUA_REGISTRYINDEX, tname)
|
||||
proc getmetatable(L: PState, tname: cstring) =
|
||||
getfield(L, REGISTRYINDEX, tname)
|
||||
|
||||
proc argcheck(L: PState, cond: bool, numarg: int, extramsg: cstring) =
|
||||
if not cond:
|
||||
@@ -222,8 +218,8 @@ proc putchar(B: PBuffer, c: Char) =
|
||||
proc addsize(B: PBuffer, n: int) =
|
||||
B.p = cast[cstring](cast[int](B.p) + n)
|
||||
|
||||
proc lua_unref(L: PState, theref: int) =
|
||||
unref(L, LUA_REGISTRYINDEX, theref)
|
||||
proc unref(L: PState, theref: int) =
|
||||
unref(L, REGISTRYINDEX, theref)
|
||||
|
||||
proc lua_getref(L: PState, theref: int) =
|
||||
lua_rawgeti(L, LUA_REGISTRYINDEX, theref)
|
||||
proc getref(L: PState, theref: int) =
|
||||
rawgeti(L, REGISTRYINDEX, theref)
|
||||
|
||||
@@ -159,7 +159,7 @@ proc pushnumber*(L: PState, n: Number){.cdecl, dynlib: NAME,
|
||||
importc: "lua_pushnumber".}
|
||||
proc pushinteger*(L: PState, n: Integer){.cdecl, dynlib: NAME,
|
||||
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".}
|
||||
proc pushstring*(L: PState, s: cstring){.cdecl, dynlib: NAME,
|
||||
importc: "lua_pushstring".}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#
|
||||
#
|
||||
# Nimrod's Runtime Library
|
||||
# (c) Copyright 2009 Andreas Rumpf
|
||||
# (c) Copyright 2010 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
@@ -45,7 +45,7 @@ const
|
||||
SERVICENAME* = "MySQL"
|
||||
|
||||
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_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS, COM_PROCESS_INFO,
|
||||
COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING, COM_TIME,
|
||||
@@ -144,8 +144,8 @@ const
|
||||
MAX_BLOB_WIDTH* = 8192 # Default width for blob
|
||||
|
||||
type
|
||||
Pst_net* = ptr st_net
|
||||
st_net*{.final.} = object
|
||||
Pst_net* = ptr Tst_net
|
||||
Tst_net*{.final.} = object
|
||||
vio*: PVio
|
||||
buff*: cstring
|
||||
buff_end*: cstring
|
||||
@@ -185,14 +185,14 @@ type
|
||||
report_error*: my_bool # We should report error (we have unreported error)
|
||||
return_errno*: my_bool
|
||||
|
||||
NET* = st_net
|
||||
PNET* = ptr NET
|
||||
TNET* = Tst_net
|
||||
PNET* = ptr TNET
|
||||
|
||||
const
|
||||
packet_error* = - 1
|
||||
|
||||
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_NULL, TYPE_TIMESTAMP, TYPE_LONGLONG, TYPE_INT24, TYPE_DATE, TYPE_TIME,
|
||||
TYPE_DATETIME, TYPE_YEAR, TYPE_NEWDATE, TYPE_VARCHAR, TYPE_BIT,
|
||||
@@ -238,18 +238,17 @@ const
|
||||
SHUTDOWN_KILLABLE_UPDATE* = chr(1 shl 3)
|
||||
|
||||
type
|
||||
enum_shutdown_level* = enum
|
||||
Tenum_shutdown_level* = enum
|
||||
SHUTDOWN_DEFAULT = 0, SHUTDOWN_WAIT_CONNECTIONS = 1,
|
||||
SHUTDOWN_WAIT_TRANSACTIONS = 2, SHUTDOWN_WAIT_UPDATES = 8,
|
||||
SHUTDOWN_WAIT_ALL_BUFFERS = 16, SHUTDOWN_WAIT_CRITICAL_BUFFERS = 17,
|
||||
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_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
|
||||
|
||||
proc net_new_transaction*(net: st_net): st_net
|
||||
proc my_net_init*(net: PNET, vio: PVio): my_bool{.cdecl, dynlib: lib,
|
||||
importc: "my_net_init".}
|
||||
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
|
||||
# Currently it's used internally by manager.c
|
||||
type
|
||||
Psockaddr* = ptr sockaddr
|
||||
sockaddr*{.final.} = object # undefined structure
|
||||
Psockaddr* = ptr Tsockaddr
|
||||
Tsockaddr*{.final.} = object # undefined structure
|
||||
|
||||
proc my_connect*(s: my_socket, name: Psockaddr, namelen: cuint, timeout: cuint): cint{.
|
||||
cdecl, dynlib: lib, importc: "my_connect".}
|
||||
type
|
||||
Prand_struct* = ptr rand_struct
|
||||
rand_struct*{.final.} = object # The following is for user defined functions
|
||||
Prand_struct* = ptr Trand_struct
|
||||
Trand_struct*{.final.} = object # The following is for user defined functions
|
||||
seed1*: int
|
||||
seed2*: int
|
||||
max_value*: int
|
||||
max_value_dbl*: cdouble
|
||||
|
||||
Item_result* = enum
|
||||
TItem_result* = enum
|
||||
STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT, DECIMAL_RESULT
|
||||
PItem_result* = ptr Item_result
|
||||
Pst_udf_args* = ptr st_udf_args
|
||||
st_udf_args*{.final.} = object
|
||||
PItem_result* = ptr TItem_result
|
||||
Pst_udf_args* = ptr Tst_udf_args
|
||||
Tst_udf_args*{.final.} = object
|
||||
arg_count*: cuint # Number of arguments
|
||||
arg_type*: PItem_result # Pointer to item_results
|
||||
args*: cstringArray # Pointer to item_results
|
||||
@@ -296,18 +295,18 @@ type
|
||||
attributes*: cstringArray # Pointer to attribute name
|
||||
attribute_lengths*: ptr int # Length of attribute arguments
|
||||
|
||||
UDF_ARGS* = st_udf_args
|
||||
PUDF_ARGS* = ptr UDF_ARGS # This holds information about the result
|
||||
Pst_udf_init* = ptr st_udf_init
|
||||
st_udf_init*{.final.} = object
|
||||
TUDF_ARGS* = Tst_udf_args
|
||||
PUDF_ARGS* = ptr TUDF_ARGS # This holds information about the result
|
||||
Pst_udf_init* = ptr Tst_udf_init
|
||||
Tst_udf_init*{.final.} = object
|
||||
maybe_null*: my_bool # 1 if function can return NULL
|
||||
decimals*: cuint # for real functions
|
||||
max_length*: int # For string functions
|
||||
theptr*: cstring # free pointer for function data
|
||||
const_item*: my_bool # free pointer for function data
|
||||
|
||||
UDF_INIT* = st_udf_init
|
||||
PUDF_INIT* = ptr UDF_INIT # Constants when using compression
|
||||
TUDF_INIT* = Tst_udf_init
|
||||
PUDF_INIT* = ptr TUDF_INIT # Constants when using compression
|
||||
|
||||
const
|
||||
NET_HEADER_SIZE* = 4 # standard header size
|
||||
@@ -381,8 +380,8 @@ const
|
||||
CLIENT_NET_WRITE_TIMEOUT* = 365 * 24 * 3600 # Timeout on write
|
||||
|
||||
type
|
||||
Pst_mysql_field* = ptr st_mysql_field
|
||||
st_mysql_field*{.final.} = object
|
||||
Pst_mysql_field* = ptr Tst_mysql_field
|
||||
Tst_mysql_field*{.final.} = object
|
||||
name*: cstring # Name of column
|
||||
org_name*: cstring # Original column name, if an alias
|
||||
table*: cstring # Table of column if column was a field
|
||||
@@ -402,19 +401,19 @@ type
|
||||
flags*: cuint # Div flags
|
||||
decimals*: cuint # Number of decimals in field
|
||||
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
|
||||
PFIELD* = ptr FIELD
|
||||
PROW* = ptr ROW # return data as array of strings
|
||||
ROW* = cstringArray
|
||||
PFIELD_OFFSET* = ptr FIELD_OFFSET # offset to current field
|
||||
FIELD_OFFSET* = cuint
|
||||
TFIELD* = Tst_mysql_field
|
||||
PFIELD* = ptr TFIELD
|
||||
PROW* = ptr TROW # return data as array of strings
|
||||
TROW* = cstringArray
|
||||
PFIELD_OFFSET* = ptr TFIELD_OFFSET # offset to current field
|
||||
TFIELD_OFFSET* = cuint
|
||||
|
||||
proc IS_PRI_KEY*(n: int32): bool
|
||||
proc IS_NOT_NULL*(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 IS_NUM_FIELD*(f: Pst_mysql_field): bool
|
||||
type
|
||||
@@ -425,33 +424,32 @@ const
|
||||
COUNT_ERROR* = not (my_ulonglong(0))
|
||||
|
||||
type
|
||||
Pst_mysql_rows* = ptr st_mysql_rows
|
||||
st_mysql_rows*{.final.} = object
|
||||
Pst_mysql_rows* = ptr Tst_mysql_rows
|
||||
Tst_mysql_rows*{.final.} = object
|
||||
next*: Pst_mysql_rows # list of rows
|
||||
data*: ROW
|
||||
data*: TROW
|
||||
len*: int
|
||||
|
||||
ROWS* = st_mysql_rows
|
||||
PROWS* = ptr ROWS
|
||||
PROW_OFFSET* = ptr ROW_OFFSET # offset to current row
|
||||
ROW_OFFSET* = ROWS # ------------ Start of declaration in "my_alloc.h" --------------------
|
||||
# $include "my_alloc.h"
|
||||
|
||||
TROWS* = Tst_mysql_rows
|
||||
PROWS* = ptr TROWS
|
||||
PROW_OFFSET* = ptr TROW_OFFSET # offset to current row
|
||||
TROW_OFFSET* = TROWS
|
||||
|
||||
const
|
||||
ALLOC_MAX_BLOCK_TO_DROP* = 4096
|
||||
ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP* = 10 # struct for once_alloc (block)
|
||||
|
||||
type
|
||||
Pst_used_mem* = ptr st_used_mem
|
||||
st_used_mem*{.final.} = object
|
||||
Pst_used_mem* = ptr Tst_used_mem
|
||||
Tst_used_mem*{.final.} = object
|
||||
next*: Pst_used_mem # Next block in use
|
||||
left*: cuint # memory left in block
|
||||
size*: cuint # size of block
|
||||
|
||||
USED_MEM* = st_used_mem
|
||||
PUSED_MEM* = ptr USED_MEM
|
||||
Pst_mem_root* = ptr st_mem_root
|
||||
st_mem_root*{.final.} = object
|
||||
TUSED_MEM* = Tst_used_mem
|
||||
PUSED_MEM* = ptr TUSED_MEM
|
||||
Pst_mem_root* = ptr Tst_mem_root
|
||||
Tst_mem_root*{.final.} = object
|
||||
free*: PUSED_MEM # blocks with free memory in it
|
||||
used*: PUSED_MEM # blocks almost without free memory
|
||||
pre_alloc*: PUSED_MEM # preallocated block
|
||||
@@ -463,21 +461,21 @@ type
|
||||
first_block_usage*: cuint
|
||||
error_handler*: proc (){.cdecl.}
|
||||
|
||||
MEM_ROOT* = st_mem_root
|
||||
PMEM_ROOT* = ptr MEM_ROOT # ------------ Stop of declaration in "my_alloc.h" ----------------------
|
||||
TMEM_ROOT* = Tst_mem_root
|
||||
PMEM_ROOT* = ptr TMEM_ROOT # ------------ Stop of declaration in "my_alloc.h" ----------------------
|
||||
|
||||
type
|
||||
Pst_mysql_data* = ptr st_mysql_data
|
||||
st_mysql_data*{.final.} = object
|
||||
Pst_mysql_data* = ptr Tst_mysql_data
|
||||
Tst_mysql_data*{.final.} = object
|
||||
rows*: my_ulonglong
|
||||
fields*: cuint
|
||||
data*: PROWS
|
||||
alloc*: MEM_ROOT
|
||||
alloc*: TMEM_ROOT
|
||||
prev_ptr*: ptr PROWS
|
||||
|
||||
DATA* = st_mysql_data
|
||||
PDATA* = ptr DATA
|
||||
option* = enum
|
||||
TDATA* = Tst_mysql_data
|
||||
PDATA* = ptr TDATA
|
||||
Toption* = enum
|
||||
OPT_CONNECT_TIMEOUT, OPT_COMPRESS, OPT_NAMED_PIPE, INIT_COMMAND,
|
||||
READ_DEFAULT_FILE, READ_DEFAULT_GROUP, SET_CHARSET_DIR, SET_CHARSET_NAME,
|
||||
OPT_LOCAL_INFILE, OPT_PROTOCOL, SHARED_MEMORY_BASE_NAME, OPT_READ_TIMEOUT,
|
||||
@@ -495,17 +493,17 @@ const
|
||||
MANAGER_INTERNAL_ERR* = 500
|
||||
|
||||
type
|
||||
st_dynamic_array*{.final.} = object
|
||||
Tst_dynamic_array*{.final.} = object
|
||||
buffer*: cstring
|
||||
elements*: cuint
|
||||
max_element*: cuint
|
||||
alloc_increment*: cuint
|
||||
size_of_element*: cuint
|
||||
|
||||
DYNAMIC_ARRAY* = st_dynamic_array
|
||||
Pst_dynamic_array* = ptr st_dynamic_array
|
||||
Pst_mysql_options* = ptr st_mysql_options
|
||||
st_mysql_options*{.final.} = object
|
||||
TDYNAMIC_ARRAY* = Tst_dynamic_array
|
||||
Pst_dynamic_array* = ptr Tst_dynamic_array
|
||||
Pst_mysql_options* = ptr Tst_mysql_options
|
||||
Tst_mysql_options*{.final.} = object
|
||||
connect_timeout*: cuint
|
||||
read_timeout*: cuint
|
||||
write_timeout*: cuint
|
||||
@@ -539,7 +537,7 @@ type
|
||||
# a read that is replication-aware
|
||||
no_master_reads*: my_bool
|
||||
separate_thread*: my_bool
|
||||
methods_to_use*: option
|
||||
methods_to_use*: Toption
|
||||
client_ip*: cstring
|
||||
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)
|
||||
@@ -551,16 +549,16 @@ type
|
||||
local_infile_error*: proc (para1: pointer, para2: cstring, para3: cuint): cint
|
||||
local_infile_userdata*: pointer
|
||||
|
||||
status* = enum
|
||||
Tstatus* = enum
|
||||
STATUS_READY, STATUS_GET_RESULT, STATUS_USE_RESULT
|
||||
protocol_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
|
||||
# type which must happen on the pivot connectioin
|
||||
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
|
||||
# type which must happen on the pivot connectioin
|
||||
PROTOCOL_DEFAULT, PROTOCOL_TCP, PROTOCOL_SOCKET, PROTOCOL_PIPE,
|
||||
PROTOCOL_MEMORY
|
||||
rpl_type* = enum
|
||||
Trpl_type* = enum
|
||||
RPL_MASTER, RPL_SLAVE, RPL_ADMIN
|
||||
charset_info_st*{.final.} = object
|
||||
Tcharset_info_st*{.final.} = object
|
||||
number*: cuint
|
||||
primary_number*: cuint
|
||||
binary_number*: cuint
|
||||
@@ -588,10 +586,10 @@ type
|
||||
cset*: pointer # was ^MY_CHARSET_HANDLER
|
||||
coll*: pointer # was ^MY_COLLATION_HANDLER;
|
||||
|
||||
CHARSET_INFO* = charset_info_st
|
||||
Pcharset_info_st* = ptr charset_info_st
|
||||
Pcharacter_set* = ptr character_set
|
||||
character_set*{.final.} = object
|
||||
TCHARSET_INFO* = Tcharset_info_st
|
||||
Pcharset_info_st* = ptr Tcharset_info_st
|
||||
Pcharacter_set* = ptr Tcharacter_set
|
||||
Tcharacter_set*{.final.} = object
|
||||
number*: cuint
|
||||
state*: cuint
|
||||
csname*: cstring
|
||||
@@ -601,12 +599,12 @@ type
|
||||
mbminlen*: cuint
|
||||
mbmaxlen*: cuint
|
||||
|
||||
MY_CHARSET_INFO* = character_set
|
||||
PMY_CHARSET_INFO* = ptr MY_CHARSET_INFO
|
||||
Pst_mysql_methods* = ptr st_mysql_methods
|
||||
Pst_mysql* = ptr st_mysql
|
||||
st_mysql*{.final.} = object
|
||||
net*: NET # Communication parameters
|
||||
TMY_CHARSET_INFO* = Tcharacter_set
|
||||
PMY_CHARSET_INFO* = ptr TMY_CHARSET_INFO
|
||||
Pst_mysql_methods* = ptr Tst_mysql_methods
|
||||
Pst_mysql* = ptr Tst_mysql
|
||||
Tst_mysql*{.final.} = object
|
||||
net*: TNET # Communication parameters
|
||||
connector_fd*: gptr # ConnectorFd for SSL
|
||||
host*: cstring
|
||||
user*: cstring
|
||||
@@ -618,7 +616,7 @@ type
|
||||
db*: cstring
|
||||
charset*: Pcharset_info_st
|
||||
fields*: PFIELD
|
||||
field_alloc*: MEM_ROOT
|
||||
field_alloc*: TMEM_ROOT
|
||||
affected_rows*: my_ulonglong
|
||||
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
|
||||
@@ -632,8 +630,8 @@ type
|
||||
server_status*: cuint
|
||||
server_language*: cuint
|
||||
warning_count*: cuint
|
||||
options*: st_mysql_options
|
||||
status*: status
|
||||
options*: Tst_mysql_options
|
||||
status*: Tstatus
|
||||
free_me*: my_bool # If free in mysql_close
|
||||
reconnect*: my_bool # set to 1 if automatic reconnect
|
||||
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.
|
||||
unbuffered_fetch_owner*: Pmy_bool
|
||||
|
||||
* = st_mysql
|
||||
P* = ptr
|
||||
Pst_mysql_res* = ptr st_mysql_res
|
||||
st_mysql_res*{.final.} = object
|
||||
TMySQL* = Tst_mysql
|
||||
PMySQL* = ptr TMySQL
|
||||
Pst_mysql_res* = ptr Tst_mysql_res
|
||||
Tst_mysql_res*{.final.} = object
|
||||
row_count*: my_ulonglong
|
||||
fields*: PFIELD
|
||||
data*: PDATA
|
||||
data_cursor*: PROWS
|
||||
lengths*: ptr int # column lengths of current row
|
||||
handle*: P # for unbuffered reads
|
||||
field_alloc*: MEM_ROOT
|
||||
handle*: PMySQL # for unbuffered reads
|
||||
field_alloc*: TMEM_ROOT
|
||||
field_count*: cuint
|
||||
current_field*: cuint
|
||||
row*: ROW # If unbuffered read
|
||||
current_row*: ROW # buffer to current row
|
||||
row*: TROW # If unbuffered read
|
||||
current_row*: TROW # buffer to current row
|
||||
eof*: my_bool # Used by mysql_fetch_row
|
||||
unbuffered_fetch_cancelled*: my_bool # mysql_stmt_close() had to cancel this result
|
||||
methods*: Pst_mysql_methods
|
||||
|
||||
RES* = st_mysql_res
|
||||
PRES* = ptr RES
|
||||
Pst_mysql_stmt* = ptr st_mysql_stmt
|
||||
PSTMT* = ptr STMT
|
||||
st_mysql_methods*{.final.} = object
|
||||
read_query_result*: proc (: P): my_bool{.cdecl.}
|
||||
advanced_command*: proc (: P, command: enum_server_command, header: cstring,
|
||||
TRES* = Tst_mysql_res
|
||||
PRES* = ptr TRES
|
||||
Pst_mysql_stmt* = ptr Tst_mysql_stmt
|
||||
PSTMT* = ptr TSTMT
|
||||
Tst_mysql_methods*{.final.} = object
|
||||
read_query_result*: proc (MySQL: PMySQL): my_bool{.cdecl.}
|
||||
advanced_command*: proc (MySQL: PMySQL, command: Tenum_server_command, header: cstring,
|
||||
header_length: int, arg: cstring, arg_length: int,
|
||||
skip_check: my_bool): my_bool
|
||||
read_rows*: proc (: P, fields: PFIELD, fields: cuint): PDATA
|
||||
use_result*: proc (: P): PRES
|
||||
fetch_lengths*: proc (fto: ptr int, column: ROW, field_count: cuint)
|
||||
flush_use_result*: proc (: P)
|
||||
list_fields*: proc (: P): PFIELD
|
||||
read_prepare_result*: proc (: P, stmt: PSTMT): my_bool
|
||||
read_rows*: proc (MySQL: PMySQL, fields: PFIELD, fields_count: cuint): PDATA
|
||||
use_result*: proc (MySQL: PMySQL): PRES
|
||||
fetch_lengths*: proc (fto: ptr int, column: TROW, field_count: cuint)
|
||||
flush_use_result*: proc (MySQL: PMySQL)
|
||||
list_fields*: proc (MySQL: PMySQL): PFIELD
|
||||
read_prepare_result*: proc (MySQL: PMySQL, stmt: PSTMT): my_bool
|
||||
stmt_execute*: proc (stmt: PSTMT): cint
|
||||
read_binary_rows*: proc (stmt: PSTMT): cint
|
||||
unbuffered_fetch*: proc (: P, row: cstringArray): cint
|
||||
free_embedded_thd*: proc (: P)
|
||||
read_statistics*: proc (: P): cstring
|
||||
next_result*: proc (: P): my_bool
|
||||
read_change_user_result*: proc (: P, buff: cstring, passwd: cstring): cint
|
||||
unbuffered_fetch*: proc (MySQL: PMySQL, row: cstringArray): cint
|
||||
free_embedded_thd*: proc (MySQL: PMySQL)
|
||||
read_statistics*: proc (MySQL: PMySQL): cstring
|
||||
next_result*: proc (MySQL: PMySQL): my_bool
|
||||
read_change_user_result*: proc (MySQL: PMySQL, buff: cstring, passwd: cstring): cint
|
||||
read_rowsfrom_cursor*: proc (stmt: PSTMT): cint
|
||||
|
||||
METHODS* = st_mysql_methods
|
||||
PMETHODS* = ptr METHODS
|
||||
Pst_mysql_manager* = ptr st_mysql_manager
|
||||
st_mysql_manager*{.final.} = object
|
||||
net*: NET
|
||||
TMETHODS* = Tst_mysql_methods
|
||||
PMETHODS* = ptr TMETHODS
|
||||
Pst_mysql_manager* = ptr Tst_mysql_manager
|
||||
Tst_mysql_manager*{.final.} = object
|
||||
net*: TNET
|
||||
host*: cstring
|
||||
user*: cstring
|
||||
passwd*: cstring
|
||||
@@ -713,24 +711,24 @@ type
|
||||
net_buf_size*: cint
|
||||
last_error*: array[0..(MAX_MYSQL_MANAGER_ERR) - 1, char]
|
||||
|
||||
MANAGER* = st_mysql_manager
|
||||
PMANAGER* = ptr MANAGER
|
||||
Pst_mysql_parameters* = ptr st_mysql_parameters
|
||||
st_mysql_parameters*{.final.} = object
|
||||
TMANAGER* = Tst_mysql_manager
|
||||
PMANAGER* = ptr TMANAGER
|
||||
Pst_mysql_parameters* = ptr Tst_mysql_parameters
|
||||
Tst_mysql_parameters*{.final.} = object
|
||||
p_max_allowed_packet*: ptr int
|
||||
p_net_buffer_length*: ptr int
|
||||
|
||||
PARAMETERS* = st_mysql_parameters
|
||||
PPARAMETERS* = ptr PARAMETERS
|
||||
enum_mysql_stmt_state* = enum
|
||||
TPARAMETERS* = Tst_mysql_parameters
|
||||
PPARAMETERS* = ptr TPARAMETERS
|
||||
Tenum_mysql_stmt_state* = enum
|
||||
STMT_INIT_DONE = 1, STMT_PREPARE_DONE, STMT_EXECUTE_DONE, STMT_FETCH_DONE
|
||||
Pst_mysql_bind* = ptr st_mysql_bind
|
||||
st_mysql_bind*{.final.} = object
|
||||
Pst_mysql_bind* = ptr Tst_mysql_bind
|
||||
Tst_mysql_bind*{.final.} = object
|
||||
len*: int # output length pointer
|
||||
is_null*: Pmy_bool # Pointer to null indicator
|
||||
buffer*: pointer # buffer to get/put data
|
||||
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
|
||||
# Following are for internal use. Set by mysql_stmt_bind_param
|
||||
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)
|
||||
skip_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte)
|
||||
|
||||
BIND* = st_mysql_bind
|
||||
PBIND* = ptr BIND # statement handler
|
||||
st_mysql_stmt*{.final.} = object
|
||||
mem_root*: MEM_ROOT # root allocations
|
||||
*: P # connection handle
|
||||
TBIND* = Tst_mysql_bind
|
||||
PBIND* = ptr TBIND # statement handler
|
||||
Tst_mysql_stmt*{.final.} = object
|
||||
mem_root*: TMEM_ROOT # root allocations
|
||||
mysql*: PMySQL # connection handle
|
||||
params*: PBIND # input parameters
|
||||
`bind`*: PBIND # input parameters
|
||||
fields*: PFIELD # result set metadata
|
||||
result*: DATA # cached result set
|
||||
result*: TDATA # cached result set
|
||||
data_cursor*: PROWS # current row in cached result
|
||||
affected_rows*: my_ulonglong # copy of mysql->affected_rows after statement execution
|
||||
insert_id*: my_ulonglong
|
||||
@@ -767,7 +765,7 @@ type
|
||||
last_errno*: cuint # error code
|
||||
param_count*: cuint # input parameter count
|
||||
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
|
||||
sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char]
|
||||
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
|
||||
update_max_length*: my_bool
|
||||
|
||||
STMT* = st_mysql_stmt # When doing mysql_stmt_store_result calculate max_length attribute
|
||||
# of statement metadata. This is to be consistent with the old API,
|
||||
# where this was done automatically.
|
||||
# In the new API we do that only by request because it slows down
|
||||
# mysql_stmt_store_result sufficiently.
|
||||
enum_stmt_attr_type* = enum
|
||||
TSTMT* = Tst_mysql_stmt
|
||||
|
||||
Tenum_stmt_attr_type* = enum
|
||||
STMT_ATTR_UPDATE_MAX_LENGTH, STMT_ATTR_CURSOR_TYPE, STMT_ATTR_PREFETCH_ROWS
|
||||
|
||||
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".}
|
||||
proc fetch_fields*(res: PRES): PFIELD{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc field_tell*(res: PRES): FIELD_OFFSET{.stdcall, dynlib: lib,
|
||||
proc field_tell*(res: PRES): TFIELD_OFFSET{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc affected_rows*(: P): my_ulonglong{.stdcall, dynlib: lib,
|
||||
proc affected_rows*(MySQL: PMySQL): my_ulonglong{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc errno*(: P): cuint{.stdcall, dynlib: lib, importc: "mysql_errno".}
|
||||
proc error*(: P): cstring{.stdcall, dynlib: lib, importc: "mysql_error".}
|
||||
proc sqlstate*(: P): cstring{.stdcall, dynlib: lib, importc: "mysql_sqlstate".}
|
||||
proc warning_count*(: P): cuint{.stdcall, dynlib: lib,
|
||||
proc errno*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib, importc: "mysql_errno".}
|
||||
proc error*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_error".}
|
||||
proc sqlstate*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_sqlstate".}
|
||||
proc warning_count*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib,
|
||||
importc: "mysql_warning_count".}
|
||||
proc info*(: P): cstring{.stdcall, dynlib: lib, importc: "mysql_info".}
|
||||
proc thread_id*(: P): int{.stdcall, dynlib: lib, importc: "mysql_thread_id".}
|
||||
proc character_set_name*(: P): cstring{.stdcall, dynlib: lib,
|
||||
proc info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_info".}
|
||||
proc thread_id*(MySQL: PMySQL): int{.stdcall, dynlib: lib, importc: "mysql_thread_id".}
|
||||
proc character_set_name*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc init*(: P): P{.stdcall, dynlib: lib, importc: "mysql_init".}
|
||||
proc ssl_set*(: P, key: cstring, cert: cstring, ca: cstring, capath: cstring,
|
||||
proc init*(MySQL: PMySQL): PMySQL{.stdcall, dynlib: lib, importc: "mysql_init".}
|
||||
proc ssl_set*(MySQL: PMySQL, key: cstring, cert: cstring, ca: cstring, capath: cstring,
|
||||
cipher: cstring): my_bool{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
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,
|
||||
clientflag: int): P{.stdcall, dynlib: lib,
|
||||
clientflag: int): PMySQL{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc query*(: P, q: cstring): cint{.stdcall, dynlib: lib, importc: "mysql_query".}
|
||||
proc send_query*(: P, q: cstring, len: int): cint{.stdcall, dynlib: lib,
|
||||
proc query*(MySQL: PMySQL, q: cstring): cint{.stdcall, dynlib: lib, importc: "mysql_query".}
|
||||
proc send_query*(MySQL: PMySQL, q: cstring, len: int): cint{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc store_result*(: P): PRES{.stdcall, dynlib: lib,
|
||||
proc store_result*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib,
|
||||
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
|
||||
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".}
|
||||
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".}
|
||||
# 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".}
|
||||
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".}
|
||||
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".}
|
||||
# local infile support
|
||||
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
|
||||
# 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".}
|
||||
# enable/disable parsing of all queries to decide if they go on master or
|
||||
# slave
|
||||
proc enable_rpl_parse*(: P){.stdcall, dynlib: lib,
|
||||
proc enable_rpl_parse*(MySQL: PMySQL){.stdcall, dynlib: lib,
|
||||
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".}
|
||||
# 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".}
|
||||
# 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".}
|
||||
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
|
||||
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".}
|
||||
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".}
|
||||
# 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
|
||||
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".}
|
||||
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".}
|
||||
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".}
|
||||
proc dump_debug_info*(: P): cint{.stdcall, dynlib: lib,
|
||||
proc dump_debug_info*(MySQL: PMySQL): cint{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc kill*(: P, pid: int): cint{.stdcall, dynlib: lib, importc: "mysql_kill".}
|
||||
proc set_server_option*(: P, option: enum_mysql_set_option): cint{.stdcall,
|
||||
proc kill*(MySQL: PMySQL, pid: int): cint{.stdcall, dynlib: lib, importc: "mysql_kill".}
|
||||
proc set_server_option*(MySQL: PMySQL, option: Tenum_mysql_set_option): cint{.stdcall,
|
||||
dynlib: lib, importc: "mysql_set_server_option".}
|
||||
proc ping*(: P): cint{.stdcall, dynlib: lib, importc: "mysql_ping".}
|
||||
proc stat*(: P): cstring{.stdcall, dynlib: lib, importc: "mysql_stat".}
|
||||
proc get_server_info*(: P): cstring{.stdcall, dynlib: lib,
|
||||
proc ping*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_ping".}
|
||||
proc stat*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_stat".}
|
||||
proc get_server_info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib,
|
||||
importc: "mysql_get_server_info".}
|
||||
proc get_client_info*(): cstring{.stdcall, dynlib: lib,
|
||||
importc: "mysql_get_client_info".}
|
||||
proc get_client_version*(): int{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc get_server_version*(: P): int{.stdcall, dynlib: lib,
|
||||
proc get_server_version*(MySQL: PMySQL): int{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
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".}
|
||||
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".}
|
||||
proc list_processes*(: P): PRES{.stdcall, dynlib: lib,
|
||||
proc list_processes*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc free_result*(result: PRES){.stdcall, dynlib: lib,
|
||||
importc: "mysql_free_result".}
|
||||
proc data_seek*(result: PRES, offset: my_ulonglong){.stdcall, dynlib: lib,
|
||||
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".}
|
||||
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".}
|
||||
proc fetch_row*(result: PRES): ROW{.stdcall, dynlib: lib,
|
||||
proc fetch_row*(result: PRES): TROW{.stdcall, dynlib: lib,
|
||||
importc: "mysql_fetch_row".}
|
||||
proc fetch_lengths*(result: PRES): ptr int{.stdcall, dynlib: lib,
|
||||
importc: "mysql_fetch_lengths".}
|
||||
proc fetch_field*(result: PRES): PFIELD{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc escape_string*(fto: cstring, `from`: cstring, from_length: int): int{.
|
||||
stdcall, dynlib: lib, importc: "mysql_escape_string".}
|
||||
proc hex_string*(fto: cstring, `from`: cstring, from_length: int): int{.stdcall,
|
||||
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".}
|
||||
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;
|
||||
# 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".}
|
||||
proc thread_safe*(): cuint{.stdcall, dynlib: lib, importc: "mysql_thread_safe".}
|
||||
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".}
|
||||
proc manager_fetch_line*(con: PMANAGER, res_buf: cstring, res_buf_size: cint): cint{.
|
||||
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".}
|
||||
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,
|
||||
dynlib: lib, importc: "mysql_stmt_prepare".}
|
||||
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".}
|
||||
proc stmt_param_count*(stmt: PSTMT): int{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
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".}
|
||||
proc stmt_bind_param*(stmt: PSTMT, bnd: PBIND): my_bool{.stdcall, dynlib: lib,
|
||||
importc: "mysql_stmt_bind_param".}
|
||||
@@ -1016,9 +1011,9 @@ proc stmt_error*(stmt: PSTMT): cstring{.stdcall, dynlib: lib,
|
||||
importc: "mysql_stmt_error".}
|
||||
proc stmt_sqlstate*(stmt: PSTMT): cstring{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
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".}
|
||||
proc stmt_data_seek*(stmt: PSTMT, offset: my_ulonglong){.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc stmt_field_count*(stmt: PSTMT): cuint{.stdcall, dynlib: lib,
|
||||
importc: "mysql_stmt_field_count".}
|
||||
proc commit*(: P): my_bool{.stdcall, dynlib: lib, importc: "mysql_commit".}
|
||||
proc rollback*(: P): my_bool{.stdcall, dynlib: lib, importc: "mysql_rollback".}
|
||||
proc autocommit*(: P, auto_mode: my_bool): my_bool{.stdcall, dynlib: lib,
|
||||
proc commit*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_commit".}
|
||||
proc rollback*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_rollback".}
|
||||
proc autocommit*(MySQL: PMySQL, auto_mode: my_bool): my_bool{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc next_result*(: P): cint{.stdcall, dynlib: lib, importc: "mysql_next_result".}
|
||||
proc close*(sock: P){.stdcall, dynlib: lib, importc: "mysql_close".}
|
||||
proc next_result*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_next_result".}
|
||||
proc close*(sock: PMySQL){.stdcall, dynlib: lib, importc: "mysql_close".}
|
||||
# status return codes
|
||||
const
|
||||
NO_DATA* = 100
|
||||
DATA_TRUNCATED* = 101
|
||||
|
||||
proc reload*(: P): cint
|
||||
proc reload*(MySQL: PMySQL): cint
|
||||
when defined(USE_OLD_FUNCTIONS):
|
||||
proc connect*(: P, host: cstring, user: cstring, passwd: cstring): P{.stdcall,
|
||||
dynlib: External_library, importc: "mysql_connect".}
|
||||
proc create_db*(: P, DB: cstring): cint{.stdcall, dynlib: External_library,
|
||||
proc connect*(MySQL: PMySQL, host: cstring, user: cstring, passwd: cstring): PMySQL{.stdcall,
|
||||
dynlib: lib, importc: "mysql_connect".}
|
||||
proc create_db*(MySQL: PMySQL, DB: cstring): cint{.stdcall, dynlib: lib,
|
||||
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".}
|
||||
proc net_safe_read*(: P): 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 net_safe_read*(MySQL: PMySQL): cuint{.cdecl, dynlib: lib, importc: "net_safe_read".}
|
||||
|
||||
proc IS_PRI_KEY(n: int32): bool =
|
||||
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 =
|
||||
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
|
||||
(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_YEAR)
|
||||
|
||||
proc reload(: P): cint =
|
||||
result = refresh(, REFRESH_GRANT)
|
||||
proc reload(mysql: PMySQL): cint =
|
||||
result = refresh(mysql, REFRESH_GRANT)
|
||||
|
||||
@@ -205,7 +205,7 @@ type #music_cmd.h types
|
||||
TMidiEvent*{.final.} = object
|
||||
time*: int32
|
||||
channel*: uint8
|
||||
type_*: uint8
|
||||
typ*: uint8
|
||||
a*: uint8
|
||||
b*: uint8
|
||||
|
||||
|
||||
@@ -57,7 +57,7 @@ type #music_cmd.h types
|
||||
TMidiEvent*{.final.} = object
|
||||
time*: int32
|
||||
channel*: uint8
|
||||
type_*: uint8
|
||||
typ*: uint8
|
||||
a*: uint8
|
||||
b*: uint8
|
||||
|
||||
@@ -116,7 +116,7 @@ type #music_cmd.h types
|
||||
MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG
|
||||
PMusic* = ptr TMusic
|
||||
TMusic*{.final.} = object
|
||||
type_*: TMusicType
|
||||
typ*: TMusicType
|
||||
|
||||
TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{.
|
||||
cdecl.} # This macro can be used to fill a version structure with the compile-time
|
||||
|
||||
@@ -257,7 +257,7 @@ proc setdisplay*(mpeg: PSMPEG, dst: PSurface, surfLock: Pmutex,
|
||||
callback: TDisplayCallback){.cdecl,
|
||||
importc: "SMPEG_setdisplay", dynlib: SmpegLibName.}
|
||||
# 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.}
|
||||
# Scale pixel display on an SMPEG object
|
||||
proc scaleXY*(mpeg: PSMPEG, width, height: int){.cdecl,
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#
|
||||
#
|
||||
# Nimrod's Runtime Library
|
||||
# (c) Copyright 2009 Andreas Rumpf
|
||||
# (c) Copyright 2010 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
@@ -48,52 +48,52 @@ const
|
||||
TCL_RETURN* = 2
|
||||
TCL_BREAK* = 3
|
||||
TCL_CONTINUE* = 4
|
||||
TCL_RESULT_SIZE* = 200
|
||||
RESULT_SIZE* = 200
|
||||
MAX_ARGV* = 0x00007FFF
|
||||
TCL_VERSION_MAJOR* = 0
|
||||
TCL_VERSION_MINOR* = 0
|
||||
TCL_NO_EVAL* = 0x00010000
|
||||
TCL_EVAL_GLOBAL* = 0x00020000 # Flag values passed to variable-related procedures. *
|
||||
TCL_GLOBAL_ONLY* = 1
|
||||
TCL_NAMESPACE_ONLY* = 2
|
||||
TCL_APPEND_VALUE* = 4
|
||||
TCL_LIST_ELEMENT* = 8
|
||||
TCL_TRACE_READS* = 0x00000010
|
||||
TCL_TRACE_WRITES* = 0x00000020
|
||||
TCL_TRACE_UNSETS* = 0x00000040
|
||||
TCL_TRACE_DESTROYED* = 0x00000080
|
||||
TCL_INTERP_DESTROYED* = 0x00000100
|
||||
TCL_LEAVE_ERR_MSG* = 0x00000200
|
||||
TCL_PARSE_PART1* = 0x00000400 # Types for linked variables: *
|
||||
TCL_LINK_INT* = 1
|
||||
TCL_LINK_DOUBLE* = 2
|
||||
TCL_LINK_BOOLEAN* = 3
|
||||
TCL_LINK_STRING* = 4
|
||||
TCL_LINK_READ_ONLY* = 0x00000080
|
||||
TCL_SMALL_HASH_TABLE* = 4 # Hash Table *
|
||||
TCL_STRING_KEYS* = 0
|
||||
TCL_ONE_WORD_KEYS* = 1 # Const/enums Tcl_QueuePosition *
|
||||
# typedef enum {
|
||||
TCL_QUEUE_TAIL* = 0
|
||||
TCL_QUEUE_HEAD* = 1
|
||||
TCL_QUEUE_MARK* = 2 #} Tcl_QueuePosition;
|
||||
# Event Flags
|
||||
TCL_DONT_WAIT* = 1 shl 1
|
||||
TCL_WINDOW_EVENTS* = 1 shl 2
|
||||
TCL_FILE_EVENTS* = 1 shl 3
|
||||
TCL_TIMER_EVENTS* = 1 shl 4
|
||||
TCL_IDLE_EVENTS* = 1 shl 5 # WAS 0x10 ???? *
|
||||
TCL_ALL_EVENTS* = not TCL_DONT_WAIT
|
||||
TCL_VOLATILE* = 1
|
||||
TCL_STATIC* = 0
|
||||
TCL_DYNAMIC* = 3 # Channel
|
||||
VERSION_MAJOR* = 0
|
||||
VERSION_MINOR* = 0
|
||||
NO_EVAL* = 0x00010000
|
||||
EVAL_GLOBAL* = 0x00020000 # Flag values passed to variable-related proc
|
||||
GLOBAL_ONLY* = 1
|
||||
NAMESPACE_ONLY* = 2
|
||||
APPEND_VALUE* = 4
|
||||
LIST_ELEMENT* = 8
|
||||
TRACE_READS* = 0x00000010
|
||||
TRACE_WRITES* = 0x00000020
|
||||
TRACE_UNSETS* = 0x00000040
|
||||
TRACE_DESTROYED* = 0x00000080
|
||||
INTERP_DESTROYED* = 0x00000100
|
||||
LEAVE_ERR_MSG* = 0x00000200
|
||||
PARSE_PART1* = 0x00000400 # Types for linked variables: *
|
||||
LINK_INT* = 1
|
||||
LINK_DOUBLE* = 2
|
||||
LINK_BOOLEAN* = 3
|
||||
LINK_STRING* = 4
|
||||
LINK_READ_ONLY* = 0x00000080
|
||||
SMALL_HASH_TABLE* = 4 # Hash Table *
|
||||
STRING_KEYS* = 0
|
||||
ONE_WORD_KEYS* = 1 # Const/enums Tcl_QueuePosition *
|
||||
|
||||
QUEUE_TAIL* = 0
|
||||
QUEUE_HEAD* = 1
|
||||
QUEUE_MARK* = 2 # Tcl_QueuePosition;
|
||||
# Event Flags
|
||||
DONT_WAIT* = 1 shl 1
|
||||
WINDOW_EVENTS* = 1 shl 2
|
||||
FILE_EVENTS* = 1 shl 3
|
||||
TIMER_EVENTS* = 1 shl 4
|
||||
IDLE_EVENTS* = 1 shl 5 # WAS 0x10 ???? *
|
||||
ALL_EVENTS* = not DONT_WAIT
|
||||
VOLATILE* = 1
|
||||
STATIC* = 0
|
||||
DYNAMIC* = 3 # Channel
|
||||
TCL_STDIN* = 1 shl 1
|
||||
TCL_STDOUT* = 1 shl 2
|
||||
TCL_STDERR* = 1 shl 3
|
||||
TCL_ENFORCE_MODE* = 1 shl 4
|
||||
TCL_READABLE* = 1 shl 1
|
||||
TCL_WRITABLE* = 1 shl 2
|
||||
TCL_EXCEPTION* = 1 shl 3 # POSIX *
|
||||
ENFORCE_MODE* = 1 shl 4
|
||||
READABLE* = 1 shl 1
|
||||
WRITABLE* = 1 shl 2
|
||||
EXCEPTION* = 1 shl 3 # POSIX *
|
||||
EPERM* = 1 # Operation not permitted; only the owner of the file (or other
|
||||
# resource) or processes with special privileges can perform the
|
||||
# operation.
|
||||
@@ -367,112 +367,110 @@ const
|
||||
#
|
||||
|
||||
type
|
||||
Tcl_Argv* = cstringArray
|
||||
Tcl_ClientData* = pointer
|
||||
Tcl_FreeProc* = proc (theBlock: pointer){.cdecl.}
|
||||
PInterp* = ptr Tcl_Interp
|
||||
Tcl_Interp*{.final.} = object # Event Definitions *
|
||||
TArgv* = cstringArray
|
||||
TClientData* = pointer
|
||||
TFreeProc* = proc (theBlock: pointer){.cdecl.}
|
||||
PInterp* = ptr TInterp
|
||||
TInterp*{.final.} = object # Event Definitions
|
||||
result*: cstring # Do not access this directly. Use
|
||||
# * Tcl_GetStringResult since result
|
||||
# * may be pointing to an object
|
||||
# *
|
||||
freeProc*: Tcl_FreeProc
|
||||
# Tcl_GetStringResult since result
|
||||
# may be pointing to an object
|
||||
#
|
||||
freeProc*: TFreeProc
|
||||
errorLine*: int
|
||||
|
||||
TEventSetupProc* = proc (clientData: Tcl_ClientData, flags: int){.cdecl.}
|
||||
TEventSetupProc* = proc (clientData: TClientData, flags: int){.cdecl.}
|
||||
TEventCheckProc* = TEventSetupProc
|
||||
PEvent* = ptr Tcl_Event
|
||||
PEvent* = ptr TEvent
|
||||
TEventProc* = proc (evPtr: PEvent, flags: int): int{.cdecl.}
|
||||
Tcl_Event*{.final.} = object
|
||||
TEvent*{.final.} = object
|
||||
prc*: TEventProc
|
||||
nextPtr*: PEvent
|
||||
ClientData*: TObject # ClientData is just pointer.*
|
||||
|
||||
PTime* = ptr Tcl_Time
|
||||
Tcl_Time*{.final.} = object
|
||||
PTime* = ptr TTime
|
||||
TTime*{.final.} = object
|
||||
sec*: int32 # Seconds. *
|
||||
usec*: int32 # Microseconds. *
|
||||
|
||||
Tcl_TimerToken* = pointer
|
||||
TTimerToken* = pointer
|
||||
PInteger* = ptr int
|
||||
PHashTable* = pointer
|
||||
PHashEntry* = ptr Tcl_HashEntry
|
||||
PPTcl_HashEntry* = ptr PHashEntry
|
||||
Tcl_HashEntry*{.final.} = object
|
||||
PHashTable* = ptr THashTable
|
||||
PHashEntry* = ptr THashEntry
|
||||
PPHashEntry* = ptr PHashEntry
|
||||
THashEntry*{.final.} = object
|
||||
nextPtr*: PHashEntry
|
||||
tablePtr*: PHashTable
|
||||
bucketPtr*: PPTcl_HashEntry
|
||||
clientData*: Tcl_ClientData
|
||||
bucketPtr*: PPHashEntry
|
||||
clientData*: TClientData
|
||||
key*: cstring
|
||||
|
||||
Tcl_HashFindProc* = proc (tablePtr: PHashTable, key: cstring): PHashEntry{.
|
||||
THashFindProc* = proc (tablePtr: PHashTable, key: cstring): PHashEntry{.
|
||||
cdecl.}
|
||||
Tcl_HashCreateProc* = proc (tablePtr: PHashTable, key: cstring,
|
||||
THashCreateProc* = proc (tablePtr: PHashTable, key: cstring,
|
||||
newPtr: PInteger): PHashEntry{.cdecl.}
|
||||
PHashTable* = ptr Tcl_HashTable
|
||||
Tcl_HashTable*{.final.} = object
|
||||
buckets*: ppTcl_HashEntry
|
||||
staticBuckets*: array[0..TCL_SMALL_HASH_TABLE - 1, PHashEntry]
|
||||
THashTable*{.final.} = object
|
||||
buckets*: ppHashEntry
|
||||
staticBuckets*: array[0..SMALL_HASH_TABLE - 1, PHashEntry]
|
||||
numBuckets*: int
|
||||
numEntries*: int
|
||||
rebuildSize*: int
|
||||
downShift*: int
|
||||
mask*: int
|
||||
keyType*: int
|
||||
findProc*: Tcl_HashFindProc
|
||||
createProc*: Tcl_HashCreateProc
|
||||
findProc*: THashFindProc
|
||||
createProc*: THashCreateProc
|
||||
|
||||
PHashSearch* = ptr Tcl_HashSearch
|
||||
Tcl_HashSearch*{.final.} = object
|
||||
PHashSearch* = ptr THashSearch
|
||||
THashSearch*{.final.} = object
|
||||
tablePtr*: PHashTable
|
||||
nextIndex*: int
|
||||
nextEntryPtr*: PHashEntry
|
||||
|
||||
TAppInitProc* = proc (interp: pInterp): int{.cdecl.}
|
||||
TPackageInitProc* = proc (interp: pInterp): int{.cdecl.}
|
||||
TCmdProc* = proc (clientData: Tcl_ClientData, interp: pInterp, argc: int,
|
||||
argv: Tcl_Argv): int{.cdecl.}
|
||||
TVarTraceProc* = proc (clientData: Tcl_ClientData, interp: pInterp,
|
||||
TCmdProc* = proc (clientData: TClientData, interp: pInterp, argc: int,
|
||||
argv: TArgv): int{.cdecl.}
|
||||
TVarTraceProc* = proc (clientData: TClientData, interp: pInterp,
|
||||
varName: cstring, elemName: cstring, flags: int): cstring{.
|
||||
cdecl.}
|
||||
TFreeProc* = proc (theBlock: pointer){.cdecl.}
|
||||
TInterpDeleteProc* = proc (clientData: Tcl_ClientData, interp: pInterp){.cdecl.}
|
||||
TCmdDeleteProc* = proc (clientData: Tcl_ClientData){.cdecl.}
|
||||
TNamespaceDeleteProc* = proc (clientData: Tcl_ClientData){.cdecl.}
|
||||
TInterpDeleteProc* = proc (clientData: TClientData, interp: pInterp){.cdecl.}
|
||||
TCmdDeleteProc* = proc (clientData: TClientData){.cdecl.}
|
||||
TNamespaceDeleteProc* = proc (clientData: TClientData){.cdecl.}
|
||||
|
||||
const
|
||||
TCL_DSTRING_STATIC_SIZE* = 200
|
||||
DSTRING_STATIC_SIZE* = 200
|
||||
|
||||
type
|
||||
PDString* = ptr Tcl_DString
|
||||
Tcl_DString*{.final.} = object
|
||||
PDString* = ptr TDString
|
||||
TDString*{.final.} = object
|
||||
str*: cstring
|
||||
len*: int
|
||||
spaceAvl*: int
|
||||
staticSpace*: array[0..TCL_DSTRING_STATIC_SIZE - 1, char]
|
||||
staticSpace*: array[0..DSTRING_STATIC_SIZE - 1, char]
|
||||
|
||||
PChannel* = ptr Tcl_Channel
|
||||
Tcl_Channel*{.final.} = object
|
||||
TDriverBlockModeProc* = proc (instanceData: Tcl_ClientData, mode: int): int{.
|
||||
PChannel* = ptr TChannel
|
||||
TChannel*{.final.} = object
|
||||
TDriverBlockModeProc* = proc (instanceData: TClientData, mode: int): int{.
|
||||
cdecl.}
|
||||
TDriverCloseProc* = proc (instanceData: Tcl_ClientData, interp: PInterp): int{.
|
||||
TDriverCloseProc* = proc (instanceData: TClientData, interp: PInterp): int{.
|
||||
cdecl.}
|
||||
TDriverInputProc* = proc (instanceData: Tcl_ClientData, buf: cstring,
|
||||
TDriverInputProc* = proc (instanceData: TClientData, buf: cstring,
|
||||
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.}
|
||||
TDriverSeekProc* = proc (instanceData: Tcl_ClientData, offset: int32,
|
||||
TDriverSeekProc* = proc (instanceData: TClientData, offset: int32,
|
||||
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.}
|
||||
TDriverGetOptionProc* = proc (instanceData: Tcl_ClientData, interp: pInterp,
|
||||
TDriverGetOptionProc* = proc (instanceData: TClientData, interp: pInterp,
|
||||
optionName: cstring, dsPtr: PDString): int{.
|
||||
cdecl.}
|
||||
TDriverWatchProc* = proc (instanceData: Tcl_ClientData, mask: int){.cdecl.}
|
||||
TDriverGetHandleProc* = proc (instanceData: Tcl_ClientData, direction: int,
|
||||
handlePtr: var Tcl_ClientData): int{.cdecl.}
|
||||
PChannelType* = ptr Tcl_ChannelType
|
||||
Tcl_ChannelType*{.final.} = object
|
||||
TDriverWatchProc* = proc (instanceData: TClientData, mask: int){.cdecl.}
|
||||
TDriverGetHandleProc* = proc (instanceData: TClientData, direction: int,
|
||||
handlePtr: var TClientData): int{.cdecl.}
|
||||
PChannelType* = ptr TChannelType
|
||||
TChannelType*{.final.} = object
|
||||
typeName*: cstring
|
||||
blockModeProc*: TDriverBlockModeProc
|
||||
closeProc*: TDriverCloseProc
|
||||
@@ -484,24 +482,24 @@ type
|
||||
watchProc*: TDriverWatchProc
|
||||
getHandleProc*: TDriverGetHandleProc
|
||||
|
||||
TChannelProc* = proc (clientData: Tcl_ClientData, mask: int){.cdecl.}
|
||||
PObj* = ptr Tcl_Obj
|
||||
PPTcl_Obj* = ptr PObj
|
||||
Tcl_Obj*{.final.} = object
|
||||
TChannelProc* = proc (clientData: TClientData, mask: int){.cdecl.}
|
||||
PObj* = ptr TObj
|
||||
PPObj* = ptr PObj
|
||||
TObj*{.final.} = object
|
||||
refCount*: int # ...
|
||||
|
||||
TObjCmdProc* = proc (clientData: Tcl_ClientData, interp: PInterp, objc: int,
|
||||
PPObj: PPTcl_Obj): int{.cdecl.}
|
||||
PNamespace* = ptr Tcl_Namespace
|
||||
Tcl_Namespace*{.final.} = object
|
||||
TObjCmdProc* = proc (clientData: TClientData, interp: PInterp, objc: int,
|
||||
PPObj: PPObj): int{.cdecl.}
|
||||
PNamespace* = ptr TNamespace
|
||||
TNamespace*{.final.} = object
|
||||
name*: cstring
|
||||
fullName*: cstring
|
||||
clientData*: Tcl_ClientData
|
||||
clientData*: TClientData
|
||||
deleteProc*: TNamespaceDeleteProc
|
||||
parentPtr*: PNamespace
|
||||
|
||||
PCallFrame* = ptr Tcl_CallFrame
|
||||
Tcl_CallFrame*{.final.} = object
|
||||
PCallFrame* = ptr TCallFrame
|
||||
TCallFrame*{.final.} = object
|
||||
nsPtr*: PNamespace
|
||||
dummy1*: int
|
||||
dummy2*: int
|
||||
@@ -514,19 +512,19 @@ type
|
||||
dummy9*: int
|
||||
dummy10*: cstring
|
||||
|
||||
PCmdInfo* = ptr Tcl_CmdInfo
|
||||
Tcl_CmdInfo*{.final.} = object
|
||||
PCmdInfo* = ptr TCmdInfo
|
||||
TCmdInfo*{.final.} = object
|
||||
isNativeObjectProc*: int
|
||||
objProc*: TObjCmdProc
|
||||
objClientData*: Tcl_ClientData
|
||||
objClientData*: TClientData
|
||||
prc*: TCmdProc
|
||||
clientData*: Tcl_ClientData
|
||||
clientData*: TClientData
|
||||
deleteProc*: TCmdDeleteProc
|
||||
deleteData*: Tcl_ClientData
|
||||
deleteData*: TClientData
|
||||
namespacePtr*: pNamespace
|
||||
|
||||
pCommand* = ptr Tcl_Command
|
||||
Tcl_Command*{.final.} = object # hPtr : pTcl_HashEntry;
|
||||
pCommand* = ptr TCommand
|
||||
TCommand*{.final.} = object # hPtr : pTcl_HashEntry;
|
||||
# nsPtr : pTcl_Namespace;
|
||||
# refCount : integer;
|
||||
# isCmdEpoch : integer;
|
||||
@@ -544,196 +542,196 @@ type
|
||||
type
|
||||
TPanicProc* = proc (fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8: cstring){.
|
||||
cdecl.} # 1/15/97 orig. Tcl style
|
||||
TClientDataProc* = proc (clientData: Tcl_ClientData){.cdecl.}
|
||||
TIdleProc* = proc (clientData: Tcl_ClientData){.cdecl.}
|
||||
TClientDataProc* = proc (clientData: TClientData){.cdecl.}
|
||||
TIdleProc* = proc (clientData: TClientData){.cdecl.}
|
||||
TTimerProc* = TIdleProc
|
||||
TCreateCloseHandler* = proc (channel: pChannel, prc: TClientDataProc,
|
||||
clientData: Tcl_ClientData){.cdecl.}
|
||||
clientData: TClientData){.cdecl.}
|
||||
TDeleteCloseHandler* = TCreateCloseHandler
|
||||
TEventDeleteProc* = proc (evPtr: pEvent, clientData: Tcl_ClientData): int{.
|
||||
TEventDeleteProc* = proc (evPtr: pEvent, clientData: TClientData): int{.
|
||||
cdecl.}
|
||||
|
||||
proc Tcl_Alloc*(size: int): cstring{.cdecl, dynlib: dllName,
|
||||
proc Alloc*(size: int): cstring{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_Alloc".}
|
||||
proc Tcl_CreateInterp*(): pInterp{.cdecl, dynlib: dllName,
|
||||
proc CreateInterp*(): pInterp{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_CreateInterp".}
|
||||
proc Tcl_DeleteInterp*(interp: pInterp){.cdecl, dynlib: dllName,
|
||||
proc DeleteInterp*(interp: pInterp){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_DeleteInterp".}
|
||||
proc Tcl_ResetResult*(interp: pInterp){.cdecl, dynlib: dllName,
|
||||
proc ResetResult*(interp: pInterp){.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
proc Tcl_EvalFile*(interp: pInterp, filename: cstring): int{.cdecl,
|
||||
proc EvalFile*(interp: pInterp, filename: cstring): int{.cdecl,
|
||||
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".}
|
||||
proc Tcl_BackgroundError*(interp: pInterp){.cdecl, dynlib: dllName,
|
||||
proc BackgroundError*(interp: pInterp){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_BackgroundError".}
|
||||
proc Tcl_CreateCommand*(interp: pInterp, name: cstring, cmdProc: TCmdProc,
|
||||
clientData: Tcl_ClientData, deleteProc: TCmdDeleteProc): pCommand{.
|
||||
proc CreateCommand*(interp: pInterp, name: cstring, cmdProc: TCmdProc,
|
||||
clientData: TClientData, deleteProc: TCmdDeleteProc): pCommand{.
|
||||
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".}
|
||||
proc Tcl_CallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc,
|
||||
clientData: Tcl_ClientData){.cdecl, dynlib: dllName,
|
||||
proc CallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc,
|
||||
clientData: TClientData){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_CallWhenDeleted".}
|
||||
proc Tcl_DontCallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc,
|
||||
clientData: Tcl_ClientData){.cdecl,
|
||||
proc DontCallWhenDeleted*(interp: pInterp, prc: TInterpDeleteProc,
|
||||
clientData: TClientData){.cdecl,
|
||||
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".}
|
||||
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".}
|
||||
proc Tcl_UnlinkVar*(interp: pInterp, varName: cstring){.cdecl, dynlib: dllName,
|
||||
proc UnlinkVar*(interp: pInterp, varName: cstring){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_UnlinkVar".}
|
||||
proc Tcl_TraceVar*(interp: pInterp, varName: cstring, flags: int,
|
||||
prc: TVarTraceProc, clientData: Tcl_ClientData): int{.cdecl,
|
||||
proc TraceVar*(interp: pInterp, varName: cstring, flags: int,
|
||||
prc: TVarTraceProc, clientData: TClientData): int{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_TraceVar".}
|
||||
proc Tcl_TraceVar2*(interp: pInterp, varName: cstring, elemName: cstring,
|
||||
flags: int, prc: TVarTraceProc, clientData: Tcl_ClientData): int{.
|
||||
proc TraceVar2*(interp: pInterp, varName: cstring, elemName: cstring,
|
||||
flags: int, prc: TVarTraceProc, clientData: TClientData): int{.
|
||||
cdecl, dynlib: dllName, importc: "Tcl_TraceVar2".}
|
||||
proc Tcl_UntraceVar*(interp: pInterp, varName: cstring, flags: int,
|
||||
prc: TVarTraceProc, clientData: Tcl_ClientData){.cdecl,
|
||||
proc UntraceVar*(interp: pInterp, varName: cstring, flags: int,
|
||||
prc: TVarTraceProc, clientData: TClientData){.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_UntraceVar".}
|
||||
proc Tcl_UntraceVar2*(interp: pInterp, varName: cstring, elemName: cstring,
|
||||
flags: int, prc: TVarTraceProc, clientData: Tcl_ClientData){.
|
||||
proc UntraceVar2*(interp: pInterp, varName: cstring, elemName: cstring,
|
||||
flags: int, prc: TVarTraceProc, clientData: TClientData){.
|
||||
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".}
|
||||
proc Tcl_GetVar2*(interp: pInterp, varName: cstring, elemName: cstring,
|
||||
proc GetVar2*(interp: pInterp, varName: cstring, elemName: cstring,
|
||||
flags: int): cstring{.cdecl, dynlib: dllName,
|
||||
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,
|
||||
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,
|
||||
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".}
|
||||
proc Tcl_UnsetVar2*(interp: pInterp, varName: cstring, elemName: cstring,
|
||||
proc UnsetVar2*(interp: pInterp, varName: cstring, elemName: cstring,
|
||||
flags: int): int{.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
proc Tcl_FirstHashEntry*(hashTbl: pHashTable, searchInfo: var Tcl_HashSearch): pHashEntry{.
|
||||
proc FirstHashEntry*(hashTbl: pHashTable, searchInfo: var THashSearch): pHashEntry{.
|
||||
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".}
|
||||
proc Tcl_InitHashTable*(hashTbl: pHashTable, keyType: int){.cdecl,
|
||||
proc InitHashTable*(hashTbl: pHashTable, keyType: int){.cdecl,
|
||||
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".}
|
||||
proc Tcl_GetErrno*(): int{.cdecl, dynlib: dllName, importc: "Tcl_GetErrno".}
|
||||
proc Tcl_SetErrno*(val: int){.cdecl, dynlib: dllName, importc: "Tcl_SetErrno".}
|
||||
proc Tcl_SetPanicProc*(prc: TPanicProc){.cdecl, dynlib: dllName,
|
||||
proc GetErrno*(): int{.cdecl, dynlib: dllName, importc: "Tcl_GetErrno".}
|
||||
proc SetErrno*(val: int){.cdecl, dynlib: dllName, importc: "Tcl_SetErrno".}
|
||||
proc SetPanicProc*(prc: TPanicProc){.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
proc Tcl_StaticPackage*(interp: pInterp, pkgName: cstring,
|
||||
proc StaticPackage*(interp: pInterp, pkgName: cstring,
|
||||
initProc: TPackageInitProc,
|
||||
safeInitProc: TPackageInitProc){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_StaticPackage".}
|
||||
proc Tcl_CreateEventSource*(setupProc: TEventSetupProc,
|
||||
proc CreateEventSource*(setupProc: TEventSetupProc,
|
||||
checkProc: TEventCheckProc,
|
||||
clientData: Tcl_ClientData){.cdecl, dynlib: dllName,
|
||||
clientData: TClientData){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_CreateEventSource".}
|
||||
proc Tcl_DeleteEventSource*(setupProc: TEventSetupProc,
|
||||
proc DeleteEventSource*(setupProc: TEventSetupProc,
|
||||
checkProc: TEventCheckProc,
|
||||
clientData: Tcl_ClientData){.cdecl, dynlib: dllName,
|
||||
clientData: TClientData){.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
proc Tcl_SetMaxBlockTime*(timePtr: pTime){.cdecl, dynlib: dllName,
|
||||
proc SetMaxBlockTime*(timePtr: pTime){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_SetMaxBlockTime".}
|
||||
proc Tcl_DeleteEvents*(prc: TEventDeleteProc, clientData: Tcl_ClientData){.
|
||||
proc DeleteEvents*(prc: TEventDeleteProc, clientData: TClientData){.
|
||||
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".}
|
||||
proc Tcl_DoWhenIdle*(prc: TIdleProc, clientData: Tcl_ClientData){.cdecl,
|
||||
proc DoWhenIdle*(prc: TIdleProc, clientData: TClientData){.cdecl,
|
||||
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".}
|
||||
proc Tcl_CreateTimerHandler*(milliseconds: int, prc: TTimerProc,
|
||||
clientData: Tcl_ClientData): Tcl_TimerToken{.cdecl,
|
||||
proc CreateTimerHandler*(milliseconds: int, prc: TTimerProc,
|
||||
clientData: TClientData): TTimerToken{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_CreateTimerHandler".}
|
||||
proc Tcl_DeleteTimerHandler*(token: Tcl_TimerToken){.cdecl, dynlib: dllName,
|
||||
proc DeleteTimerHandler*(token: TTimerToken){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_DeleteTimerHandler".}
|
||||
# procedure Tcl_CreateModalTimeout(milliseconds: integer; 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,
|
||||
argvPtr: var Tcl_Argv): int{.cdecl, dynlib: dllName,
|
||||
proc SplitList*(interp: pInterp, list: cstring, argcPtr: var int,
|
||||
argvPtr: var TArgv): int{.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
proc Tcl_Free*(p: cstring){.cdecl, dynlib: dllName, importc: "Tcl_Free".}
|
||||
proc Tcl_Init*(interp: pInterp): int{.cdecl, dynlib: dllName,
|
||||
proc Free*(p: cstring){.cdecl, dynlib: dllName, importc: "Tcl_Free".}
|
||||
proc Init*(interp: pInterp): int{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_Init".}
|
||||
# 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".}
|
||||
proc Tcl_DeleteAssocData*(interp: pInterp, key: cstring){.cdecl,
|
||||
proc DeleteAssocData*(interp: pInterp, key: cstring){.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_DeleteAssocData".}
|
||||
proc Tcl_SetAssocData*(interp: pInterp, key: cstring, prc: TInterpDeleteProc,
|
||||
clientData: Tcl_ClientData){.cdecl, dynlib: dllName,
|
||||
proc SetAssocData*(interp: pInterp, key: cstring, prc: TInterpDeleteProc,
|
||||
clientData: TClientData){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_SetAssocData".}
|
||||
proc Tcl_IsSafe*(interp: pInterp): int{.cdecl, dynlib: dllName,
|
||||
proc IsSafe*(interp: pInterp): int{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_IsSafe".}
|
||||
proc Tcl_MakeSafe*(interp: pInterp): int{.cdecl, dynlib: dllName,
|
||||
proc MakeSafe*(interp: pInterp): int{.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
proc Tcl_GetSlave*(interp: pInterp, slaveName: cstring): pInterp{.cdecl,
|
||||
proc GetSlave*(interp: pInterp, slaveName: cstring): pInterp{.cdecl,
|
||||
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".}
|
||||
proc Tcl_GetInterpPath*(askingInterp: pInterp, slaveInterp: pInterp): int{.
|
||||
proc GetInterpPath*(askingInterp: pInterp, slaveInterp: pInterp): int{.
|
||||
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,
|
||||
argv: Tcl_Argv): int{.cdecl, dynlib: dllName,
|
||||
argv: TArgv): int{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_CreateAlias".}
|
||||
proc Tcl_GetAlias*(interp: pInterp, srcCmd: cstring, targetInterp: var pInterp,
|
||||
targetCmd: var cstring, argc: var int, argv: var Tcl_Argv): int{.
|
||||
proc GetAlias*(interp: pInterp, srcCmd: cstring, targetInterp: var pInterp,
|
||||
targetCmd: var cstring, argc: var int, argv: var TArgv): int{.
|
||||
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,
|
||||
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".}
|
||||
proc Tcl_EventuallyFree*(clientData: Tcl_ClientData, freeProc: TFreeProc){.
|
||||
proc EventuallyFree*(clientData: TClientData, freeProc: TFreeProc){.
|
||||
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".}
|
||||
proc Tcl_Release*(clientData: Tcl_ClientData){.cdecl, dynlib: dllName,
|
||||
proc Release*(clientData: TClientData){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_Release".}
|
||||
proc Tcl_InterpDeleted*(interp: pInterp): int{.cdecl, dynlib: dllName,
|
||||
proc InterpDeleted*(interp: pInterp): int{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_InterpDeleted".}
|
||||
proc Tcl_GetCommandInfo*(interp: pInterp, cmdName: cstring,
|
||||
info: var Tcl_CmdInfo): int{.cdecl, dynlib: dllName,
|
||||
proc GetCommandInfo*(interp: pInterp, cmdName: cstring,
|
||||
info: var TCmdInfo): int{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_GetCommandInfo".}
|
||||
proc Tcl_SetCommandInfo*(interp: pInterp, cmdName: cstring,
|
||||
info: var Tcl_CmdInfo): int{.cdecl, dynlib: dllName,
|
||||
proc SetCommandInfo*(interp: pInterp, cmdName: cstring,
|
||||
info: var TCmdInfo): int{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_SetCommandInfo".}
|
||||
proc Tcl_FindExecutable*(path: cstring){.cdecl, dynlib: dllName,
|
||||
proc FindExecutable*(path: cstring){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_FindExecutable".}
|
||||
proc Tcl_GetStringResult*(interp: pInterp): cstring{.cdecl, dynlib: dllName,
|
||||
proc GetStringResult*(interp: pInterp): cstring{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_GetStringResult".}
|
||||
#v1.0
|
||||
proc Tcl_FindCommand*(interp: pInterp, cmdName: cstring,
|
||||
contextNsPtr: pNamespace, flags: int): Tcl_Command{.cdecl,
|
||||
proc FindCommand*(interp: pInterp, cmdName: cstring,
|
||||
contextNsPtr: pNamespace, flags: int): TCommand{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_FindCommand".}
|
||||
#v1.0
|
||||
proc Tcl_DeleteCommandFromToken*(interp: pInterp, cmd: pCommand): int{.cdecl,
|
||||
proc DeleteCommandFromToken*(interp: pInterp, cmd: pCommand): int{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_DeleteCommandFromToken".}
|
||||
proc Tcl_CreateNamespace*(interp: pInterp, name: cstring,
|
||||
clientData: Tcl_ClientData,
|
||||
proc CreateNamespace*(interp: pInterp, name: cstring,
|
||||
clientData: TClientData,
|
||||
deleteProc: TNamespaceDeleteProc): pNamespace{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_CreateNamespace".}
|
||||
#v1.0
|
||||
proc Tcl_DeleteNamespace*(namespacePtr: pNamespace){.cdecl, dynlib: dllName,
|
||||
proc DeleteNamespace*(namespacePtr: pNamespace){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_DeleteNamespace".}
|
||||
proc Tcl_FindNamespace*(interp: pInterp, name: cstring,
|
||||
proc FindNamespace*(interp: pInterp, name: cstring,
|
||||
contextNsPtr: pNamespace, flags: int): pNamespace{.
|
||||
cdecl, dynlib: dllName, importc: "Tcl_FindNamespace".}
|
||||
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,
|
||||
allowOverwrite: int): int{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_Import".}
|
||||
proc Tcl_GetCurrentNamespace*(interp: pInterp): pNamespace{.cdecl,
|
||||
proc GetCurrentNamespace*(interp: pInterp): pNamespace{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_GetCurrentNamespace".}
|
||||
proc Tcl_GetGlobalNamespace*(interp: pInterp): pNamespace{.cdecl,
|
||||
proc GetGlobalNamespace*(interp: pInterp): pNamespace{.cdecl,
|
||||
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{.
|
||||
cdecl, dynlib: dllName, importc: "Tcl_PushCallFrame".}
|
||||
proc Tcl_PopCallFrame*(interp: pInterp){.cdecl, dynlib: dllName,
|
||||
proc PopCallFrame*(interp: pInterp){.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
# 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".}
|
||||
proc Tcl_GlobalEval*(interp: pInterp, command: cstring): int{.cdecl,
|
||||
proc GlobalEval*(interp: pInterp, command: cstring): int{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_GlobalEval".}
|
||||
proc Tcl_DStringFree*(dsPtr: pDString){.cdecl, dynlib: dllName,
|
||||
proc DStringFree*(dsPtr: pDString){.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
proc Tcl_DStringAppendElement*(dsPtr: pDString, str: cstring): cstring{.cdecl,
|
||||
proc DStringAppendElement*(dsPtr: pDString, str: cstring): cstring{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_DStringAppendElement".}
|
||||
proc Tcl_DStringInit*(dsPtr: pDString){.cdecl, dynlib: dllName,
|
||||
proc DStringInit*(dsPtr: pDString){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_DStringInit".}
|
||||
proc Tcl_AppendResult*(interp: pInterp){.cdecl, varargs, dynlib: dllName,
|
||||
proc AppendResult*(interp: pInterp){.cdecl, varargs, dynlib: dllName,
|
||||
importc: "Tcl_AppendResult".}
|
||||
# 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".}
|
||||
proc Tcl_SetChannelOption*(interp: pInterp, chan: pChannel, optionName: cstring,
|
||||
proc SetChannelOption*(interp: pInterp, chan: pChannel, optionName: cstring,
|
||||
newValue: cstring): int{.cdecl, dynlib: dllName,
|
||||
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,
|
||||
importc: "Tcl_GetChannelOption".}
|
||||
proc Tcl_CreateChannel*(typePtr: pChannelType, chanName: cstring,
|
||||
instanceData: Tcl_ClientData, mask: int): pChannel{.
|
||||
proc CreateChannel*(typePtr: pChannelType, chanName: cstring,
|
||||
instanceData: TClientData, mask: int): pChannel{.
|
||||
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".}
|
||||
proc Tcl_UnregisterChannel*(interp: pInterp, channel: pChannel): int{.cdecl,
|
||||
proc UnregisterChannel*(interp: pInterp, channel: pChannel): int{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_UnregisterChannel".}
|
||||
proc Tcl_CreateChannelHandler*(chan: pChannel, mask: int, prc: TChannelProc,
|
||||
clientData: Tcl_ClientData){.cdecl,
|
||||
proc CreateChannelHandler*(chan: pChannel, mask: int, prc: TChannelProc,
|
||||
clientData: TClientData){.cdecl,
|
||||
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".}
|
||||
proc Tcl_GetStdChannel*(typ: int): pChannel{.cdecl, dynlib: dllName,
|
||||
proc GetStdChannel*(typ: int): pChannel{.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
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".}
|
||||
proc Tcl_Flush*(chan: pChannel): int{.cdecl, dynlib: dllName,
|
||||
proc Flush*(chan: pChannel): int{.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_Flush".}
|
||||
# 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".}
|
||||
proc Tcl_DeleteExitHandler*(prc: TClientDataProc, clientData: Tcl_ClientData){.
|
||||
proc DeleteExitHandler*(prc: TClientDataProc, clientData: TClientData){.
|
||||
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".}
|
||||
proc Tcl_CreateObjCommand*(interp: pInterp, name: cstring, cmdProc: TObjCmdProc,
|
||||
clientData: Tcl_ClientData,
|
||||
proc CreateObjCommand*(interp: pInterp, name: cstring, cmdProc: TObjCmdProc,
|
||||
clientData: TClientData,
|
||||
deleteProc: TCmdDeleteProc): pCommand{.cdecl,
|
||||
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".}
|
||||
# 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".}
|
||||
proc Tcl_GlobalEvalObj*(interp: pInterp, pObj: pObj): int{.cdecl,
|
||||
proc GlobalEvalObj*(interp: pInterp, pObj: pObj): int{.cdecl,
|
||||
dynlib: dllName, importc: "Tcl_GlobalEvalObj".}
|
||||
proc TclRegComp*(exp: cstring): pointer{.cdecl, dynlib: dllName,
|
||||
proc RegComp*(exp: cstring): pointer{.cdecl, dynlib: dllName,
|
||||
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".}
|
||||
proc TclRegError*(msg: cstring){.cdecl, dynlib: dllName, importc: "TclRegError".}
|
||||
proc TclGetRegError*(): cstring{.cdecl, dynlib: dllName,
|
||||
importc: "TclGetRegError".}
|
||||
proc Tcl_RegExpRange*(prog: pointer, index: int, head: var cstring,
|
||||
|
||||
proc RegError*(msg: cstring){.cdecl, dynlib: dllName, importc: "TclRegError".}
|
||||
|
||||
proc GetRegError*(): cstring{.cdecl, dynlib: dllName,
|
||||
importc: "TclGetRegError".}
|
||||
|
||||
proc RegExpRange*(prog: pointer, index: int, head: var cstring,
|
||||
tail: var cstring){.cdecl, dynlib: dllName,
|
||||
importc: "Tcl_RegExpRange".}
|
||||
proc Tcl_GetCommandTable*(interp: pInterp): pHashTable =
|
||||
|
||||
proc GetCommandTable*(interp: pInterp): pHashTable =
|
||||
if interp != nil:
|
||||
result = cast[pHashTable](cast[int](interp) + sizeof(Tcl_Interp) +
|
||||
result = cast[pHashTable](cast[int](interp) + sizeof(Interp) +
|
||||
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)
|
||||
|
||||
proc Tcl_FindHashEntry*(tablePtr: pHashTable, key: cstring): pHashEntry =
|
||||
proc FindHashEntry*(tablePtr: pHashTable, key: cstring): pHashEntry =
|
||||
result = cast[pHashTable](tablePtr).findProc(tablePtr, key)
|
||||
|
||||
proc Tcl_SetHashValue*(h: pHashEntry, clientData: Tcl_ClientData) =
|
||||
proc SetHashValue*(h: pHashEntry, clientData: TClientData) =
|
||||
h.clientData = clientData
|
||||
|
||||
proc Tcl_GetHashValue*(h: pHashEntry): Tcl_ClientData =
|
||||
proc GetHashValue*(h: pHashEntry): TClientData =
|
||||
result = h.clientData
|
||||
|
||||
proc Tcl_IncrRefCount*(pObj: pObj) =
|
||||
proc IncrRefCount*(pObj: pObj) =
|
||||
inc(pObj.refCount)
|
||||
|
||||
proc Tcl_DecrRefCount*(pObj: pObj) =
|
||||
proc DecrRefCount*(pObj: pObj) =
|
||||
dec(pObj.refCount)
|
||||
if pObj.refCount <= 0:
|
||||
dealloc(pObj)
|
||||
|
||||
proc Tcl_IsShared*(pObj: pObj): bool =
|
||||
proc IsShared*(pObj: pObj): bool =
|
||||
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:
|
||||
result = nil
|
||||
else:
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#
|
||||
#
|
||||
# Nimrod's Runtime Library
|
||||
# (c) Copyright 2009 Andreas Rumpf
|
||||
# (c) Copyright 2010 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
@@ -170,7 +170,7 @@ iterator decodeData*(allowedMethods: set[TRequestMethod] =
|
||||
var data = getEncodedData(allowedMethods)
|
||||
if not isNil(data):
|
||||
for key, value in decodeData(data):
|
||||
yield key, value
|
||||
yield (key, value)
|
||||
|
||||
proc readData*(allowedMethods: set[TRequestMethod] =
|
||||
{methodNone, methodPost, methodGet}): PStringTable =
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#
|
||||
#
|
||||
# Nimrod's Runtime Library
|
||||
# (c) Copyright 2006 Andreas Rumpf
|
||||
# (c) Copyright 2010 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# 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_SetItemPosition32*(hwndLV: HWND, i, x, y: 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_SetTextColor*(hwnd: HWND, clrText: COLORREF): 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),
|
||||
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
|
||||
gnu_lvi.iSubItem = iSubItem_
|
||||
gnu_lvi.pszText = pszText_
|
||||
gnu_lvi.iSubItem = iSubItem
|
||||
gnu_lvi.pszText = pszText
|
||||
result = SendMessage(hwndLV, LVM_SETITEMTEXT, WPARAM(i),
|
||||
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 =
|
||||
result = SendMessage(hwnd, LVM_SETTEXTCOLOR, 0, LPARAM(clrText))
|
||||
|
||||
proc ListView_SortItems(hwndLV: HWND, pfnCompare: PFNLVCOMPARE, lPrm: LPARAM): LRESULT =
|
||||
result = SendMessage(hwndLV, LVM_SORTITEMS, WPARAM(lPrm), cast[LPARAM](pfnCompare))
|
||||
proc ListView_SortItems(hwndLV: HWND, pfnCompare: PFNLVCOMPARE,
|
||||
lPrm: LPARAM): LRESULT =
|
||||
result = SendMessage(hwndLV, LVM_SORTITEMS, WPARAM(lPrm),
|
||||
cast[LPARAM](pfnCompare))
|
||||
|
||||
proc ListView_Update(hwndLV: HWND, i: int32): LRESULT =
|
||||
result = SendMessage(hwndLV, LVM_UPDATE, WPARAM(i), 0)
|
||||
|
||||
@@ -3316,130 +3316,131 @@ proc g_module_name*(module: PGModule): cstring{.cdecl, dynlib: gmodulelib,
|
||||
importc: "g_module_name".}
|
||||
proc g_module_build_path*(directory: cstring, module_name: cstring): cstring{.
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
n_param_values: GUInt,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
n_param_values: GUInt,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
n_param_values: GUInt,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
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,
|
||||
param_values: PGValue,
|
||||
invocation_hint: GPointer,
|
||||
marshal_data: GPointer){.cdecl,
|
||||
dynlib: gliblib, importc: "g_cclosure_marshal_BOOLEAN__FLAGS".}
|
||||
|
||||
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)
|
||||
|
||||
|
||||
@@ -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_DRAW_DRAG_LINE_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_PIXMAP_get*(cell: pointer): PGtkCellPixmap
|
||||
#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_CLASS*(klass: pointer): bool
|
||||
proc GTK_CTREE_GET_CLASS*(obj: pointer): PGtkCTreeClass
|
||||
proc GTK_CTREE_ROW*(`node_`: TAddress): PGtkCTreeRow
|
||||
proc GTK_CTREE_NODE*(`node_`: TAddress): PGtkCTreeNode
|
||||
proc GTK_CTREE_NODE_NEXT*(`nnode_`: TAddress): PGtkCTreeNode
|
||||
proc GTK_CTREE_NODE_PREV*(`pnode_`: TAddress): PGtkCTreeNode
|
||||
proc GTK_CTREE_FUNC*(`func_`: TAddress): TGtkCTreeFunc
|
||||
proc GTK_CTREE_ROW*(`node`: TAddress): PGtkCTreeRow
|
||||
proc GTK_CTREE_NODE*(`node`: TAddress): PGtkCTreeNode
|
||||
proc GTK_CTREE_NODE_NEXT*(`nnode`: TAddress): PGtkCTreeNode
|
||||
proc GTK_CTREE_NODE_PREV*(`pnode`: TAddress): PGtkCTreeNode
|
||||
proc GTK_CTREE_FUNC*(`func`: TAddress): TGtkCTreeFunc
|
||||
proc GTK_TYPE_CTREE_NODE*(): GType
|
||||
proc line_style*(a: var TGtkCTree): 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,
|
||||
expanded: gboolean): PGtkCTreeNode{.cdecl,
|
||||
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".}
|
||||
proc gtk_ctree_insert_gnode*(ctree: PGtkCTree, parent: PGtkCTreeNode,
|
||||
sibling: PGtkCTreeNode, gnode: PGNode,
|
||||
func_: TGtkCTreeGNodeFunc, data: gpointer): PGtkCTreeNode{.
|
||||
fun: TGtkCTreeGNodeFunc, data: gpointer): PGtkCTreeNode{.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_ctree_insert_gnode".}
|
||||
proc gtk_ctree_export_to_gnode*(ctree: PGtkCTree, parent: PGNode,
|
||||
sibling: PGNode, node_: PGtkCTreeNode,
|
||||
func_: TGtkCTreeGNodeFunc, data: gpointer): PGNode{.
|
||||
sibling: PGNode, node: PGtkCTreeNode,
|
||||
fun: TGtkCTreeGNodeFunc, data: gpointer): PGNode{.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_ctree_export_to_gnode".}
|
||||
proc gtk_ctree_post_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode,
|
||||
func_: TGtkCTreeFunc, data: gpointer){.cdecl,
|
||||
proc gtk_ctree_post_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode,
|
||||
fun: TGtkCTreeFunc, data: gpointer){.cdecl,
|
||||
dynlib: gtklib, importc: "gtk_ctree_post_recursive".}
|
||||
proc gtk_ctree_post_recursive_to_depth*(ctree: PGtkCTree, node_: PGtkCTreeNode,
|
||||
depth: gint, func_: TGtkCTreeFunc,
|
||||
proc gtk_ctree_post_recursive_to_depth*(ctree: PGtkCTree, node: PGtkCTreeNode,
|
||||
depth: gint, fun: TGtkCTreeFunc,
|
||||
data: gpointer){.cdecl, dynlib: gtklib,
|
||||
importc: "gtk_ctree_post_recursive_to_depth".}
|
||||
proc gtk_ctree_pre_recursive*(ctree: PGtkCTree, node_: PGtkCTreeNode,
|
||||
func_: TGtkCTreeFunc, data: gpointer){.cdecl,
|
||||
proc gtk_ctree_pre_recursive*(ctree: PGtkCTree, node: PGtkCTreeNode,
|
||||
fun: TGtkCTreeFunc, data: gpointer){.cdecl,
|
||||
dynlib: gtklib, importc: "gtk_ctree_pre_recursive".}
|
||||
proc gtk_ctree_pre_recursive_to_depth*(ctree: PGtkCTree, node_: PGtkCTreeNode,
|
||||
depth: gint, func_: TGtkCTreeFunc,
|
||||
proc gtk_ctree_pre_recursive_to_depth*(ctree: PGtkCTree, node: PGtkCTreeNode,
|
||||
depth: gint, fun: TGtkCTreeFunc,
|
||||
data: gpointer){.cdecl, dynlib: gtklib,
|
||||
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".}
|
||||
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".}
|
||||
proc gtk_ctree_find_node_ptr*(ctree: PGtkCTree, ctree_row: PGtkCTreeRow): PGtkCTreeNode{.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_ctree_find_node_ptr".}
|
||||
proc gtk_ctree_node_nth*(ctree: PGtkCTree, row: guint): PGtkCTreeNode{.cdecl,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
dynlib: gtklib, importc: "gtk_ctree_find_all_by_row_data".}
|
||||
proc gtk_ctree_find_by_row_data_custom*(ctree: PGtkCTree, node_: PGtkCTreeNode,
|
||||
data: gpointer, func_: TGCompareFunc): PGtkCTreeNode{.
|
||||
proc gtk_ctree_find_by_row_data_custom*(ctree: PGtkCTree, node: PGtkCTreeNode,
|
||||
data: gpointer, fun: TGCompareFunc): PGtkCTreeNode{.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_ctree_find_by_row_data_custom".}
|
||||
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".}
|
||||
proc gtk_ctree_is_hot_spot*(ctree: PGtkCTree, x: gint, y: gint): gboolean{.
|
||||
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){.
|
||||
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".}
|
||||
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".}
|
||||
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,
|
||||
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".}
|
||||
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".}
|
||||
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,
|
||||
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".}
|
||||
proc gtk_ctree_toggle_expansion_recursive*(ctree: PGtkCTree,
|
||||
node_: PGtkCTreeNode){.cdecl, dynlib: gtklib,
|
||||
node: PGtkCTreeNode){.cdecl, dynlib: gtklib,
|
||||
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".}
|
||||
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".}
|
||||
proc gtk_ctree_unselect*(ctree: PGtkCTree, node_: PGtkCTreeNode){.cdecl,
|
||||
proc gtk_ctree_unselect*(ctree: PGtkCTree, node: PGtkCTreeNode){.cdecl,
|
||||
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".}
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
mask: PGdkBitmap){.cdecl, dynlib: gtklib,
|
||||
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,
|
||||
pixmap: PGdkPixmap, mask: PGdkBitmap){.cdecl,
|
||||
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,
|
||||
pixmap_closed: PGdkPixmap,
|
||||
mask_closed: PGdkBitmap,
|
||||
@@ -5885,50 +5885,50 @@ proc gtk_ctree_set_node_info*(ctree: PGtkCTree, node_: PGtkCTreeNode,
|
||||
mask_opened: PGdkBitmap, is_leaf: gboolean,
|
||||
expanded: gboolean){.cdecl, dynlib: gtklib,
|
||||
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){.
|
||||
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,
|
||||
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".}
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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".}
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
destroy: TGtkDestroyNotify){.cdecl,
|
||||
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".}
|
||||
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){.
|
||||
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".}
|
||||
proc gtk_ctree_set_indent*(ctree: PGtkCTree, indent: gint){.cdecl,
|
||||
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,
|
||||
cmp_func: TGtkCTreeCompareDragFunc){.
|
||||
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".}
|
||||
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".}
|
||||
proc gtk_ctree_set_reorderable*(t: pointer, r: bool)
|
||||
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".}
|
||||
proc gtk_menu_new*(): PGtkMenu {.cdecl, dynlib: gtklib, importc: "gtk_menu_new".}
|
||||
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){.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_menu_popup".}
|
||||
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{.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_item_factory_popup_data_from_widget".}
|
||||
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".}
|
||||
proc GTK_TYPE_LAYOUT*(): GType
|
||||
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){.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_tree_model_unref_node".}
|
||||
proc gtk_tree_model_foreach*(model: PGtkTreeModel,
|
||||
func_: TGtkTreeModelForeachFunc,
|
||||
fun: TGtkTreeModelForeachFunc,
|
||||
user_data: gpointer){.cdecl, dynlib: gtklib,
|
||||
importc: "gtk_tree_model_foreach".}
|
||||
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{.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_text_tag_table_lookup".}
|
||||
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".}
|
||||
proc gtk_text_tag_table_get_size*(table: PGtkTextTagTable): gint{.cdecl,
|
||||
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,
|
||||
line: PGtkTextLine){.cdecl,
|
||||
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,
|
||||
dynlib: gtklib, importc: "_gtk_change_node_toggle_count".}
|
||||
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{.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_tree_selection_get_mode".}
|
||||
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".}
|
||||
proc gtk_tree_selection_get_user_data*(selection: PGtkTreeSelection): gpointer{.
|
||||
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,
|
||||
model: PPGtkTreeModel): PGList{.cdecl, dynlib: gtklib, importc: "gtk_tree_selection_get_selected_rows".}
|
||||
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".}
|
||||
proc gtk_tree_selection_select_path*(selection: PGtkTreeSelection,
|
||||
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,
|
||||
dynlib: gtklib, importc: "gtk_tree_view_column_add_attribute".}
|
||||
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,
|
||||
importc: "gtk_tree_view_column_set_cell_data_func".}
|
||||
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 parity*(a: PGtkRBNode): guint
|
||||
proc set_parity*(a: PGtkRBNode, `parity`: guint)
|
||||
proc GTK_RBNODE_GET_COLOR*(node_: PGtkRBNode): guint
|
||||
proc GTK_RBNODE_SET_COLOR*(node_: PGtkRBNode, color: guint)
|
||||
proc GTK_RBNODE_GET_HEIGHT*(node_: PGtkRBNode): gint
|
||||
proc GTK_RBNODE_SET_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_GET_COLOR*(node: PGtkRBNode): guint
|
||||
proc GTK_RBNODE_SET_COLOR*(node: PGtkRBNode, color: guint)
|
||||
proc GTK_RBNODE_GET_HEIGHT*(node: PGtkRBNode): gint
|
||||
proc GTK_RBNODE_SET_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_rbtree_push_allocator*(allocator: PGAllocator){.cdecl,
|
||||
dynlib: gtklib, importc: "_gtk_rbtree_push_allocator".}
|
||||
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".}
|
||||
proc gtk_rbtree_destroy*(tree: PGtkRBTree){.cdecl, dynlib: gtklib,
|
||||
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{.
|
||||
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{.
|
||||
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".}
|
||||
proc gtk_rbtree_reorder*(tree: PGtkRBTree, new_order: Pgint, length: gint){.
|
||||
cdecl, dynlib: gtklib, importc: "_gtk_rbtree_reorder".}
|
||||
proc gtk_rbtree_find_count*(tree: PGtkRBTree, count: gint): PGtkRBNode{.cdecl,
|
||||
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,
|
||||
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".}
|
||||
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".}
|
||||
proc gtk_rbtree_column_invalid*(tree: PGtkRBTree){.cdecl, dynlib: gtklib,
|
||||
importc: "_gtk_rbtree_column_invalid".}
|
||||
@@ -10827,17 +10827,17 @@ proc gtk_rbtree_mark_invalid*(tree: PGtkRBTree){.cdecl, dynlib: gtklib,
|
||||
importc: "_gtk_rbtree_mark_invalid".}
|
||||
proc gtk_rbtree_set_fixed_height*(tree: PGtkRBTree, height: gint){.cdecl,
|
||||
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".}
|
||||
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".}
|
||||
proc gtk_rbtree_traverse*(tree: PGtkRBTree, node_: PGtkRBNode,
|
||||
proc gtk_rbtree_traverse*(tree: PGtkRBTree, node: PGtkRBNode,
|
||||
order: TGTraverseType,
|
||||
func_: TGtkRBTreeTraverseFunc, data: gpointer){.
|
||||
fun: TGtkRBTreeTraverseFunc, data: gpointer){.
|
||||
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".}
|
||||
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".}
|
||||
proc gtk_rbtree_get_depth*(tree: PGtkRBTree): gint{.cdecl, dynlib: gtklib,
|
||||
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 set_disable_popdown*(a: var TGtkTreeViewPrivate, `disable_popdown`: guint)
|
||||
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,
|
||||
dynlib: gtklib, importc: "_gtk_tree_selection_internal_select_node".}
|
||||
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".}
|
||||
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".}
|
||||
proc gtk_tree_view_child_move_resize*(tree_view: PGtkTreeView,
|
||||
widget: PGtkWidget, x: gint, y: gint,
|
||||
width: gint, height: gint){.cdecl,
|
||||
dynlib: gtklib, importc: "_gtk_tree_view_child_move_resize".}
|
||||
proc gtk_tree_view_queue_draw_node*(tree_view: PGtkTreeView, tree: PGtkRBTree,
|
||||
node_: PGtkRBNode,
|
||||
node: PGtkRBNode,
|
||||
clip_rect: PGdkRectangle){.cdecl,
|
||||
dynlib: gtklib, importc: "_gtk_tree_view_queue_draw_node".}
|
||||
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".}
|
||||
proc gtk_tree_view_insert_column_with_data_func*(tree_view: PGtkTreeView,
|
||||
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".}
|
||||
proc gtk_tree_view_get_column*(tree_view: PGtkTreeView, n: gint): PGtkTreeViewColumn{.
|
||||
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{.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_tree_view_get_expander_column".}
|
||||
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".}
|
||||
proc gtk_tree_view_scroll_to_point*(tree_view: PGtkTreeView, tree_x: gint,
|
||||
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{.
|
||||
cdecl, dynlib: gtklib, importc: "gtk_tree_view_collapse_row".}
|
||||
proc gtk_tree_view_map_expanded_rows*(tree_view: PGtkTreeView,
|
||||
func_: TGtkTreeViewMappingFunc,
|
||||
fun: TGtkTreeViewMappingFunc,
|
||||
data: gpointer){.cdecl, dynlib: gtklib,
|
||||
importc: "gtk_tree_view_map_expanded_rows".}
|
||||
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_destroy: TGtkDestroyNotify){.cdecl, dynlib: gtklib, importc: "gtk_tree_view_set_search_equal_func".}
|
||||
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".}
|
||||
proc GTK_TYPE_VBUTTON_BOX*(): GType
|
||||
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 =
|
||||
result = ((GTK_CLIST_FLAGS(clist)) and cint(GTK_CLIST_DRAW_DRAG_RECT)) != 0'i32
|
||||
|
||||
proc GTK_CLIST_ROW_get*(`glist_`: PGList): PGtkCListRow =
|
||||
result = cast[PGtkCListRow](`glist_` . data)
|
||||
proc GTK_CLIST_ROW_get*(glist: PGList): PGtkCListRow =
|
||||
result = cast[PGtkCListRow](glist . data)
|
||||
|
||||
when false:
|
||||
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 =
|
||||
result = cast[PGtkCTreeClass](GTK_CHECK_GET_CLASS(obj, GTK_TYPE_CTREE()))
|
||||
|
||||
proc GTK_CTREE_ROW*(`node_`: TAddress): PGtkCTreeRow =
|
||||
result = cast[PGtkCTreeRow]((cast[PGList](`node_`)) . data)
|
||||
proc GTK_CTREE_ROW*(node: TAddress): PGtkCTreeRow =
|
||||
result = cast[PGtkCTreeRow]((cast[PGList](node)) . data)
|
||||
|
||||
proc GTK_CTREE_NODE*(`node_`: TAddress): PGtkCTreeNode =
|
||||
result = cast[PGtkCTreeNode](`node_`)
|
||||
proc GTK_CTREE_NODE*(node: TAddress): PGtkCTreeNode =
|
||||
result = cast[PGtkCTreeNode](node)
|
||||
|
||||
proc GTK_CTREE_NODE_NEXT*(`nnode_`: TAddress): PGtkCTreeNode =
|
||||
result = cast[PGtkCTreeNode]((cast[PGList](`nnode_`)) . next)
|
||||
proc GTK_CTREE_NODE_NEXT*(nnode: TAddress): PGtkCTreeNode =
|
||||
result = cast[PGtkCTreeNode]((cast[PGList](nnode)) . next)
|
||||
|
||||
proc GTK_CTREE_NODE_PREV*(`pnode_`: TAddress): PGtkCTreeNode =
|
||||
result = cast[PGtkCTreeNode]((cast[PGList](`pnode_`)) . prev)
|
||||
proc GTK_CTREE_NODE_PREV*(`pnode`: TAddress): PGtkCTreeNode =
|
||||
result = cast[PGtkCTreeNode]((cast[PGList](`pnode`)) . prev)
|
||||
|
||||
proc GTK_CTREE_FUNC*(`func_`: TAddress): TGtkCTreeFunc =
|
||||
result = cast[TGtkCTreeFunc](`func_`)
|
||||
proc GTK_CTREE_FUNC*(`func`: TAddress): TGtkCTreeFunc =
|
||||
result = cast[TGtkCTreeFunc](`func`)
|
||||
|
||||
proc GTK_TYPE_CTREE_NODE*(): GType =
|
||||
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)
|
||||
|
||||
proc gtk_signal_connect_full*(anObject: PGtkObject, name: cstring,
|
||||
func_: TGtkSignalFunc, unknown1: pointer,
|
||||
fun: TGtkSignalFunc, unknown1: pointer,
|
||||
func_data: gpointer, unknown2: pointer,
|
||||
unknown3, unknown4: int): gulong {.
|
||||
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,
|
||||
u: int) {.importc, cdecl, dynlib: gtklib.}
|
||||
|
||||
proc gtk_signal_connect*(anObject: PGtkObject, name: cstring,
|
||||
func_: TGtkSignalFunc, func_data: gpointer): gulong =
|
||||
result = gtk_signal_connect_full(anObject, name, func_, nil, func_data, nil,
|
||||
fun: TGtkSignalFunc, func_data: gpointer): gulong =
|
||||
result = gtk_signal_connect_full(anObject, name, fun, nil, func_data, nil,
|
||||
0, 0)
|
||||
|
||||
proc gtk_signal_connect_after*(anObject: PGtkObject, name: cstring,
|
||||
func_: TGtkSignalFunc, func_data: gpointer): gulong =
|
||||
result = gtk_signal_connect_full(anObject, name, func_, nil, func_data, nil,
|
||||
fun: TGtkSignalFunc, func_data: gpointer): gulong =
|
||||
result = gtk_signal_connect_full(anObject, name, fun, nil, func_data, nil,
|
||||
0, 1)
|
||||
|
||||
proc gtk_signal_connect_object*(anObject: PGtkObject, name: cstring,
|
||||
func_: TGtkSignalFunc, slot_object: gpointer): gulong =
|
||||
result = gtk_signal_connect_full(anObject, name, func_, nil, slot_object, nil,
|
||||
fun: TGtkSignalFunc, slot_object: gpointer): gulong =
|
||||
result = gtk_signal_connect_full(anObject, name, fun, nil, slot_object, nil,
|
||||
1, 0)
|
||||
|
||||
proc gtk_signal_connect_object_after*(anObject: PGtkObject, name: cstring,
|
||||
func_: TGtkSignalFunc,
|
||||
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, 1)
|
||||
|
||||
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) =
|
||||
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) =
|
||||
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)
|
||||
|
||||
proc gtk_signal_handler_block_by_func*(anObject: PGtkObject,
|
||||
func_: TGtkSignalFunc, data: gpointer) =
|
||||
gtk_signal_compat_matched(anObject, func_, data, TGSignalMatchType(
|
||||
fun: TGtkSignalFunc, data: gpointer) =
|
||||
gtk_signal_compat_matched(anObject, fun, data, TGSignalMatchType(
|
||||
G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0)
|
||||
|
||||
proc gtk_signal_handler_block_by_data*(anObject: PGtkObject, data: gpointer) =
|
||||
gtk_signal_compat_matched(anObject, nil, data, G_SIGNAL_MATCH_DATA, 1)
|
||||
|
||||
proc gtk_signal_handler_unblock_by_func*(anObject: PGtkObject,
|
||||
func_: TGtkSignalFunc, data: gpointer) =
|
||||
gtk_signal_compat_matched(anObject, func_, data, cast[TGSignalMatchType](
|
||||
fun: TGtkSignalFunc, data: gpointer) =
|
||||
gtk_signal_compat_matched(anObject, fun, data, cast[TGSignalMatchType](
|
||||
G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0)
|
||||
|
||||
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)
|
||||
|
||||
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
|
||||
t = cast[TGSignalMatchType](G_SIGNAL_MATCH_ID or G_SIGNAL_MATCH_FUNC or
|
||||
G_SIGNAL_MATCH_DATA)
|
||||
if not may_be_blocked:
|
||||
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
|
||||
|
||||
proc GTK_TYPE_SIZE_GROUP*(): GType =
|
||||
@@ -16594,36 +16594,36 @@ proc set_parity*(a: PGtkRBNode, `parity`: guint) =
|
||||
a . flag0 = a .
|
||||
flag0 or (int16(`parity` shl bp_TGtkRBNode_parity) and bm_TGtkRBNode_parity)
|
||||
|
||||
proc GTK_RBNODE_GET_COLOR*(node_: PGtkRBNode): guint =
|
||||
if node_ == nil:
|
||||
proc GTK_RBNODE_GET_COLOR*(node: PGtkRBNode): guint =
|
||||
if node == nil:
|
||||
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
|
||||
else:
|
||||
Result = GTK_RBNODE_BLACK
|
||||
|
||||
proc GTK_RBNODE_SET_COLOR*(node_: PGtkRBNode, color: guint) =
|
||||
if node_ == nil:
|
||||
proc GTK_RBNODE_SET_COLOR*(node: PGtkRBNode, color: guint) =
|
||||
if node == nil:
|
||||
return
|
||||
if ((flags(node_) and (color)) != color):
|
||||
set_flags(node_, flags(node_) xor cint(GTK_RBNODE_RED or GTK_RBNODE_BLACK))
|
||||
if ((flags(node) and (color)) != color):
|
||||
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
|
||||
if node_ . children != nil:
|
||||
if_local1 = node_.children.root.offset
|
||||
if node.children != nil:
|
||||
if_local1 = node.children.root.offset
|
||||
else:
|
||||
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 =
|
||||
result = (node_ != nil) and ((flags(node_) and (flag)) == flag)
|
||||
proc GTK_RBNODE_FLAG_SET*(node: PGtkRBNode, flag: guint): bool =
|
||||
result = (node != nil) and ((flags(node) and (flag)) == flag)
|
||||
|
||||
proc GTK_RBNODE_SET_FLAG*(node_: PGtkRBNode, flag: guint16) =
|
||||
set_flags(node_, (flag) or flags(node_))
|
||||
proc GTK_RBNODE_SET_FLAG*(node: PGtkRBNode, flag: guint16) =
|
||||
set_flags(node, (flag) or flags(node))
|
||||
|
||||
proc GTK_RBNODE_UNSET_FLAG*(node_: PGtkRBNode, flag: guint16) =
|
||||
set_flags(node_, (not (flag)) and flags(node_))
|
||||
proc GTK_RBNODE_UNSET_FLAG*(node: PGtkRBNode, flag: guint16) =
|
||||
set_flags(node, (not (flag)) and flags(node))
|
||||
|
||||
proc GTK_TREE_VIEW_FLAG_SET*(tree_view: PGtkTreeView, flag: guint): bool =
|
||||
result = ((tree_view.priv.flags) and (flag)) == flag
|
||||
|
||||
@@ -48,9 +48,9 @@ proc luaL_typerror*(L: Plua_State, narg: int, tname: cstring): int{.cdecl,
|
||||
dynlib: LUA_LIB_NAME, importc.}
|
||||
proc luaL_argerror*(L: Plua_State, numarg: int, extramsg: cstring): int{.cdecl,
|
||||
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.}
|
||||
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.}
|
||||
proc luaL_checknumber*(L: Plua_State, numArg: int): lua_Number{.cdecl,
|
||||
dynlib: LUA_LIB_NAME, importc.}
|
||||
|
||||
@@ -67,7 +67,7 @@ const
|
||||
|
||||
proc lua_upvalueindex*(I: int): int
|
||||
const # thread status; 0 is OK
|
||||
LUA_YIELD_* = 1
|
||||
constLUA_YIELD* = 1
|
||||
LUA_ERRRUN* = 2
|
||||
LUA_ERRSYNTAX* = 3
|
||||
LUA_ERRMEM* = 4
|
||||
@@ -158,7 +158,7 @@ proc lua_pushnumber*(L: Plua_State, n: lua_Number){.cdecl, dynlib: LUA_NAME,
|
||||
importc.}
|
||||
proc lua_pushinteger*(L: Plua_State, n: lua_Integer){.cdecl, dynlib: LUA_NAME,
|
||||
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.}
|
||||
proc lua_pushstring*(L: Plua_State, s: cstring){.cdecl, dynlib: LUA_NAME,
|
||||
importc.}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#
|
||||
# Light-weight binding for the Python interpreter
|
||||
# (c) 2009 Andreas Rumpf
|
||||
# (c) 2010 Andreas Rumpf
|
||||
# Based on 'PythonEngine' module by Dr. Dietmar Budelsky
|
||||
#
|
||||
#
|
||||
@@ -375,7 +375,7 @@ type
|
||||
TPyGetSetDef*{.final.} = object
|
||||
name*: cstring
|
||||
get*: Tgetter
|
||||
set_*: Tsetter
|
||||
setter*: Tsetter
|
||||
doc*: cstring
|
||||
closure*: Pointer
|
||||
|
||||
|
||||
@@ -207,7 +207,7 @@ type #music_cmd.h types
|
||||
TMidiEvent*{.final.} = object
|
||||
time*: int32
|
||||
channel*: uint8
|
||||
type_*: uint8
|
||||
typ*: uint8
|
||||
a*: uint8
|
||||
b*: uint8
|
||||
|
||||
@@ -280,7 +280,7 @@ type #music_cmd.h types
|
||||
# end;
|
||||
PMix_Music* = ptr TMix_Music
|
||||
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;
|
||||
# fading : TMix_Fading;
|
||||
# fade_volume : integer;
|
||||
|
||||
@@ -61,7 +61,7 @@ type #music_cmd.h types
|
||||
TMidiEvent*{.final.} = object
|
||||
time*: int32
|
||||
channel*: uint8
|
||||
type_*: uint8
|
||||
typ*: uint8
|
||||
a*: uint8
|
||||
b*: uint8
|
||||
|
||||
@@ -122,7 +122,7 @@ type #music_cmd.h types
|
||||
MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG
|
||||
PMix_Music* = ptr TMix_Music
|
||||
TMix_Music*{.final.} = object
|
||||
type_*: TMix_MusicType
|
||||
typ*: TMix_MusicType
|
||||
|
||||
TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{.
|
||||
cdecl.} # This macro can be used to fill a version structure with the compile-time
|
||||
|
||||
@@ -251,7 +251,7 @@ proc SMPEG_setdisplay*(mpeg: PSMPEG, dst: PSDL_Surface, surfLock: PSDL_mutex,
|
||||
callback: TSMPEG_DisplayCallback){.cdecl,
|
||||
importc, dynlib: SmpegLibName.}
|
||||
# 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
|
||||
proc SMPEG_scaleXY*(mpeg: PSMPEG, width, height: int){.cdecl,
|
||||
importc, dynlib: SmpegLibName.}
|
||||
|
||||
@@ -68,7 +68,7 @@ type
|
||||
|
||||
PXGCValues* = ptr TXGCValues
|
||||
TXGCValues*{.final.} = object
|
||||
function_*: cint
|
||||
function*: cint
|
||||
plane_mask*: culong
|
||||
foreground*: culong
|
||||
background*: culong
|
||||
@@ -651,7 +651,7 @@ type
|
||||
requestor*: TWindow
|
||||
selection*: TAtom
|
||||
target*: TAtom
|
||||
property_*: TAtom
|
||||
property*: TAtom
|
||||
time*: TTime
|
||||
|
||||
PXSelectionEvent* = ptr TXSelectionEvent
|
||||
@@ -663,7 +663,7 @@ type
|
||||
requestor*: TWindow
|
||||
selection*: TAtom
|
||||
target*: TAtom
|
||||
property_*: TAtom
|
||||
property*: TAtom
|
||||
time*: TTime
|
||||
|
||||
PXColormapEvent* = ptr TXColormapEvent
|
||||
|
||||
@@ -163,7 +163,7 @@ type
|
||||
|
||||
PXRenderPictureAttributes* = ptr TXRenderPictureAttributes
|
||||
TXRenderPictureAttributes*{.final.} = object
|
||||
repeat_*: TBool
|
||||
repeat*: TBool
|
||||
alpha_map*: TPicture
|
||||
alpha_x_origin*: int32
|
||||
alpha_y_origin*: int32
|
||||
|
||||
@@ -146,7 +146,7 @@ type
|
||||
visualid*: TVisualID
|
||||
screen*: cint
|
||||
depth*: cint
|
||||
class_*: cint
|
||||
class*: cint
|
||||
red_mask*: culong
|
||||
green_mask*: culong
|
||||
blue_mask*: culong
|
||||
|
||||
@@ -169,11 +169,11 @@ proc expectDynlibNode(c: PContext, n: PNode): PNode =
|
||||
if n.kind != nkExprColonExpr: liMessage(n.info, errStringLiteralExpected)
|
||||
else:
|
||||
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:
|
||||
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) =
|
||||
if (sym == nil) or (sym.kind == skModule):
|
||||
POptionEntry(c.optionStack.tail).dynlib = getLib(c, libDynamic,
|
||||
|
||||
@@ -1,19 +1,16 @@
|
||||
# Test wether the bindings at least compile...
|
||||
|
||||
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,
|
||||
parsexml, parseopt, parsecfg,
|
||||
osproc,
|
||||
cairowin32, cairoxlib,
|
||||
gl, glut, glu, glx, glext, wingl,
|
||||
lua, lualib, lauxlib, mysql, sqlite3, python, tcl,
|
||||
sdl, smpeg, sdl_gfx, sdl_net, sdl_mixer, sdl_ttf,
|
||||
sdl_image, sdl_mixer_nosmpeg,
|
||||
gtk2, glib2, pango, gdk2
|
||||
lua, lualib, lauxlib, mysql, sqlite3,
|
||||
|
||||
|
||||
when defined(linux):
|
||||
import
|
||||
zlib, zipfiles
|
||||
|
||||
writeln(stdout, "test compilation of binding modules")
|
||||
|
||||
Reference in New Issue
Block a user