added missing wrappers

8 files changed, 2576 insertions, 0 deletions

diff --git a/lib/wrappers/cairo/cairoft.nim b/lib/wrappers/cairo/cairoft.nim
new file mode 100755
index 000000000..16a80e7f7
--- /dev/null
+++ b/lib/wrappers/cairo/cairoft.nim
@@ -0,0 +1,35 @@
+#
+# Translation of cairo-ft.h 
+# by Jeffrey Pohlmeyer 
+# updated to version 1.4 by Luiz Américo Pereira Câmara 2007
+#
+
+import 
+  cairo, freetypeh
+
+#todo: properly define FcPattern:
+#It will require translate FontConfig header
+
+#*
+#typedef struct _XftPattern {
+#  int		    num;
+#  int		    size;
+#  XftPatternElt   *elts;
+# } XftPattern;
+# typedef FcPattern XftPattern;
+#
+
+type 
+  FcPattern* = Pointer
+  PFcPattern* = ptr FcPattern
+
+proc ft_font_face_create_for_pattern*(pattern: PFcPattern): PFontFace{.cdecl, 
+    importc: "cairo_ft_font_face_create_for_pattern", dynlib: LIB_CAIRO.}
+proc ft_font_options_substitute*(options: PFontOptions, pattern: PFcPattern){.
+    cdecl, importc: "cairo_ft_font_options_substitute", dynlib: LIB_CAIRO.}
+proc ft_font_face_create_for_ft_face*(face: TFT_Face, load_flags: int32): PFontFace{.
+    cdecl, importc: "cairo_ft_font_face_create_for_ft_face", dynlib: LIB_CAIRO.}
+proc ft_scaled_font_lock_face*(scaled_font: PScaledFont): TFT_Face{.cdecl, 
+    importc: "cairo_ft_scaled_font_lock_face", dynlib: LIB_CAIRO.}
+proc ft_scaled_font_unlock_face*(scaled_font: PScaledFont){.cdecl, 
+    importc: "cairo_ft_scaled_font_unlock_face", dynlib: LIB_CAIRO.}
diff --git a/lib/wrappers/cairo/cairowin32.nim b/lib/wrappers/cairo/cairowin32.nim
new file mode 100755
index 000000000..cec3a5bc5
--- /dev/null
+++ b/lib/wrappers/cairo/cairowin32.nim
@@ -0,0 +1,37 @@
+#
+# Translation of cairo-win32.h version 1.4
+# by Luiz Américo Pereira Câmara 2007
+#
+
+import 
+  cairo, windows
+
+proc win32_surface_create*(hdc: HDC): PSurface{.cdecl, 
+    importc: "cairo_win32_surface_create", dynlib: LIB_CAIRO.}
+proc win32_surface_create_with_ddb*(hdc: HDC, format: TFormat, 
+                                    width, height: int32): PSurface{.cdecl, 
+    importc: "cairo_win32_surface_create_with_ddb", dynlib: LIB_CAIRO.}
+proc win32_surface_create_with_dib*(format: TFormat, width, height: int32): PSurface{.
+    cdecl, importc: "cairo_win32_surface_create_with_dib", dynlib: LIB_CAIRO.}
+proc win32_surface_get_dc*(surface: PSurface): HDC{.cdecl, 
+    importc: "cairo_win32_surface_get_dc", dynlib: LIB_CAIRO.}
+proc win32_surface_get_image*(surface: PSurface): PSurface{.cdecl, 
+    importc: "cairo_win32_surface_get_image", dynlib: LIB_CAIRO.}
+proc win32_font_face_create_for_logfontw*(logfont: pLOGFONTW): PFontFace{.cdecl, 
+    importc: "cairo_win32_font_face_create_for_logfontw", dynlib: LIB_CAIRO.}
+proc win32_font_face_create_for_hfont*(font: HFONT): PFontFace{.cdecl, 
+    importc: "cairo_win32_font_face_create_for_hfont", dynlib: LIB_CAIRO.}
+proc win32_scaled_font_select_font*(scaled_font: PScaledFont, hdc: HDC): TStatus{.
+    cdecl, importc: "cairo_win32_scaled_font_select_font", dynlib: LIB_CAIRO.}
+proc win32_scaled_font_done_font*(scaled_font: PScaledFont){.cdecl, 
+    importc: "cairo_win32_scaled_font_done_font", dynlib: LIB_CAIRO.}
+proc win32_scaled_font_get_metrics_factor*(scaled_font: PScaledFont): float64{.
+    cdecl, importc: "cairo_win32_scaled_font_get_metrics_factor", 
+    dynlib: LIB_CAIRO.}
+proc win32_scaled_font_get_logical_to_device*(scaled_font: PScaledFont, 
+    logical_to_device: PMatrix){.cdecl, importc: "cairo_win32_scaled_font_get_logical_to_device", 
+                                 dynlib: LIB_CAIRO.}
+proc win32_scaled_font_get_device_to_logical*(scaled_font: PScaledFont, 
+    device_to_logical: PMatrix){.cdecl, importc: "cairo_win32_scaled_font_get_device_to_logical", 
+                                 dynlib: LIB_CAIRO.}
+# implementation
diff --git a/lib/wrappers/cairo/cairoxlib.nim b/lib/wrappers/cairo/cairoxlib.nim
new file mode 100755
index 000000000..861c55527
--- /dev/null
+++ b/lib/wrappers/cairo/cairoxlib.nim
@@ -0,0 +1,39 @@
+#
+# Translation of cairo-xlib.h version 1.4
+# by Jeffrey Pohlmeyer 
+# updated to version 1.4 by Luiz Américo Pereira Câmara 2007
+#
+
+import 
+  cairo, x, xlib, xrender
+
+proc xlib_surface_create*(dpy: PDisplay, drawable: TDrawable, visual: PVisual, 
+                          width, height: int32): PSurface{.cdecl, 
+    importc: "cairo_xlib_surface_create", dynlib: LIB_CAIRO.}
+proc xlib_surface_create_for_bitmap*(dpy: PDisplay, bitmap: TPixmap, 
+                                     screen: PScreen, width, height: int32): PSurface{.
+    cdecl, importc: "cairo_xlib_surface_create_for_bitmap", dynlib: LIB_CAIRO.}
+proc xlib_surface_create_with_xrender_format*(dpy: PDisplay, 
+    drawable: TDrawable, screen: PScreen, format: PXRenderPictFormat, 
+    width, height: int32): PSurface{.cdecl, importc: "cairo_xlib_surface_create_with_xrender_format", 
+                                     dynlib: LIB_CAIRO.}
+proc xlib_surface_get_depth*(surface: PSurface): int32{.cdecl, 
+    importc: "cairo_xlib_surface_get_depth", dynlib: LIB_CAIRO.}
+proc xlib_surface_get_display*(surface: PSurface): PDisplay{.cdecl, 
+    importc: "cairo_xlib_surface_get_display", dynlib: LIB_CAIRO.}
+proc xlib_surface_get_drawable*(surface: PSurface): TDrawable{.cdecl, 
+    importc: "cairo_xlib_surface_get_drawable", dynlib: LIB_CAIRO.}
+proc xlib_surface_get_height*(surface: PSurface): int32{.cdecl, 
+    importc: "cairo_xlib_surface_get_height", dynlib: LIB_CAIRO.}
+proc xlib_surface_get_screen*(surface: PSurface): PScreen{.cdecl, 
+    importc: "cairo_xlib_surface_get_screen", dynlib: LIB_CAIRO.}
+proc xlib_surface_get_visual*(surface: PSurface): PVisual{.cdecl, 
+    importc: "cairo_xlib_surface_get_visual", dynlib: LIB_CAIRO.}
+proc xlib_surface_get_width*(surface: PSurface): int32{.cdecl, 
+    importc: "cairo_xlib_surface_get_width", dynlib: LIB_CAIRO.}
+proc xlib_surface_set_size*(surface: PSurface, width, height: int32){.cdecl, 
+    importc: "cairo_xlib_surface_set_size", dynlib: LIB_CAIRO.}
+proc xlib_surface_set_drawable*(surface: PSurface, drawable: TDrawable, 
+                                width, height: int32){.cdecl, 
+    importc: "cairo_xlib_surface_set_drawable", dynlib: LIB_CAIRO.}
+# implementation
diff --git a/lib/wrappers/gtk/atk.nim b/lib/wrappers/gtk/atk.nim
new file mode 100755
index 000000000..14847fdb6
--- /dev/null
+++ b/lib/wrappers/gtk/atk.nim
@@ -0,0 +1,1305 @@
+{.deadCodeElim: on.}
+import 
+  glib2
+
+when defined(windows): 
+  const 
+    lib = "libatk-1.0-0.dll"
+else: 
+  const 
+    lib = "libatk-1.0.so"
+type 
+  PImplementor* = pointer
+  PAction* = pointer
+  PComponent* = pointer
+  PDocument* = pointer
+  PEditableText* = pointer
+  PHypertext* = pointer
+  PImage* = pointer
+  PSelection* = pointer
+  PStreamableContent* = pointer
+  PTable* = pointer
+  PText* = pointer
+  PValue* = pointer
+  PRelationSet* = ptr TRelationSet
+  PStateSet* = ptr TStateSet
+  PAttributeSet* = ptr TAttributeSet
+  PCoordType* = ptr TCoordType
+  TCoordType* = enum 
+    XY_SCREEN, XY_WINDOW
+  PRole* = ptr TRole
+  TRole* = enum 
+    ROLE_INVALID, ROLE_ACCEL_LABEL, ROLE_ALERT, ROLE_ANIMATION, ROLE_ARROW, 
+    ROLE_CALENDAR, ROLE_CANVAS, ROLE_CHECK_BOX, ROLE_CHECK_MENU_ITEM, 
+    ROLE_COLOR_CHOOSER, ROLE_COLUMN_HEADER, ROLE_COMBO_BOX, ROLE_DATE_EDITOR, 
+    ROLE_DESKTOP_ICON, ROLE_DESKTOP_FRAME, ROLE_DIAL, ROLE_DIALOG, 
+    ROLE_DIRECTORY_PANE, ROLE_DRAWING_AREA, ROLE_FILE_CHOOSER, ROLE_FILLER, 
+    ROLE_FONT_CHOOSER, ROLE_FRAME, ROLE_GLASS_PANE, ROLE_HTML_CONTAINER, 
+    ROLE_ICON, ROLE_IMAGE, ROLE_INTERNAL_FRAME, ROLE_LABEL, ROLE_LAYERED_PANE, 
+    ROLE_LIST, ROLE_LIST_ITEM, ROLE_MENU, ROLE_MENU_BAR, ROLE_MENU_ITEM, 
+    ROLE_OPTION_PANE, ROLE_PAGE_TAB, ROLE_PAGE_TAB_LIST, ROLE_PANEL, 
+    ROLE_PASSWORD_TEXT, ROLE_POPUP_MENU, ROLE_PROGRESS_BAR, ROLE_PUSH_BUTTON, 
+    ROLE_RADIO_BUTTON, ROLE_RADIO_MENU_ITEM, ROLE_ROOT_PANE, ROLE_ROW_HEADER, 
+    ROLE_SCROLL_BAR, ROLE_SCROLL_PANE, ROLE_SEPARATOR, ROLE_SLIDER, 
+    ROLE_SPLIT_PANE, ROLE_SPIN_BUTTON, ROLE_STATUSBAR, ROLE_TABLE, 
+    ROLE_TABLE_CELL, ROLE_TABLE_COLUMN_HEADER, ROLE_TABLE_ROW_HEADER, 
+    ROLE_TEAR_OFF_MENU_ITEM, ROLE_TERMINAL, ROLE_TEXT, ROLE_TOGGLE_BUTTON, 
+    ROLE_TOOL_BAR, ROLE_TOOL_TIP, ROLE_TREE, ROLE_TREE_TABLE, ROLE_UNKNOWN, 
+    ROLE_VIEWPORT, ROLE_WINDOW, ROLE_LAST_DEFINED
+  PLayer* = ptr TLayer
+  TLayer* = enum 
+    LAYER_INVALID, LAYER_BACKGROUND, LAYER_CANVAS, LAYER_WIDGET, LAYER_MDI, 
+    LAYER_POPUP, LAYER_OVERLAY
+  PPropertyValues* = ptr TPropertyValues
+  TPropertyValues*{.final, pure.} = object 
+    property_name*: cstring
+    old_value*: TGValue
+    new_value*: TGValue
+
+  TFunction* = proc (data: gpointer): gboolean{.cdecl.}
+  PObject* = ptr TObject
+  PPAtkObject* = ptr PObject
+  TObject* = object of TGObject
+    description*: cstring
+    name*: cstring
+    accessible_parent*: PObject
+    role*: TRole
+    relation_set*: PRelationSet
+    layer*: TLayer
+
+  TPropertyChangeHandler* = proc (para1: PObject, para2: PPropertyValues){.cdecl.}
+  PObjectClass* = ptr TObjectClass
+  TObjectClass* = object of TGObjectClass
+    get_name*: proc (accessible: PObject): cstring{.cdecl.}
+    get_description*: proc (accessible: PObject): cstring{.cdecl.}
+    get_parent*: proc (accessible: PObject): PObject{.cdecl.}
+    get_n_children*: proc (accessible: PObject): gint{.cdecl.}
+    ref_child*: proc (accessible: PObject, i: gint): PObject{.cdecl.}
+    get_index_in_parent*: proc (accessible: PObject): gint{.cdecl.}
+    ref_relation_set*: proc (accessible: PObject): PRelationSet{.cdecl.}
+    get_role*: proc (accessible: PObject): TRole{.cdecl.}
+    get_layer*: proc (accessible: PObject): TLayer{.cdecl.}
+    get_mdi_zorder*: proc (accessible: PObject): gint{.cdecl.}
+    ref_state_set*: proc (accessible: PObject): PStateSet{.cdecl.}
+    set_name*: proc (accessible: PObject, name: cstring){.cdecl.}
+    set_description*: proc (accessible: PObject, description: cstring){.cdecl.}
+    set_parent*: proc (accessible: PObject, parent: PObject){.cdecl.}
+    set_role*: proc (accessible: PObject, role: TRole){.cdecl.}
+    connect_property_change_handler*: proc (accessible: PObject, 
+        handler: TPropertyChangeHandler): guint{.cdecl.}
+    remove_property_change_handler*: proc (accessible: PObject, 
+        handler_id: guint){.cdecl.}
+    initialize*: proc (accessible: PObject, data: gpointer){.cdecl.}
+    children_changed*: proc (accessible: PObject, change_index: guint, 
+                             changed_child: gpointer){.cdecl.}
+    focus_event*: proc (accessible: PObject, focus_in: gboolean){.cdecl.}
+    property_change*: proc (accessible: PObject, values: PPropertyValues){.cdecl.}
+    state_change*: proc (accessible: PObject, name: cstring, state_set: gboolean){.
+        cdecl.}
+    visible_data_changed*: proc (accessible: PObject){.cdecl.}
+    pad1*: TFunction
+    pad2*: TFunction
+    pad3*: TFunction
+    pad4*: TFunction
+
+  PImplementorIface* = ptr TImplementorIface
+  TImplementorIface* = object of TGTypeInterface
+    ref_accessible*: proc (implementor: PImplementor): PObject{.cdecl.}
+
+  PActionIface* = ptr TActionIface
+  TActionIface* = object of TGTypeInterface
+    do_action*: proc (action: PAction, i: gint): gboolean{.cdecl.}
+    get_n_actions*: proc (action: PAction): gint{.cdecl.}
+    get_description*: proc (action: PAction, i: gint): cstring{.cdecl.}
+    get_name*: proc (action: PAction, i: gint): cstring{.cdecl.}
+    get_keybinding*: proc (action: PAction, i: gint): cstring{.cdecl.}
+    set_description*: proc (action: PAction, i: gint, desc: cstring): gboolean{.
+        cdecl.}
+    pad1*: TFunction
+    pad2*: TFunction
+
+  TFocusHandler* = proc (para1: PObject, para2: gboolean){.cdecl.}
+  PComponentIface* = ptr TComponentIface
+  TComponentIface* = object of TGTypeInterface
+    add_focus_handler*: proc (component: PComponent, handler: TFocusHandler): guint{.
+        cdecl.}
+    contains*: proc (component: PComponent, x: gint, y: gint, 
+                     coord_type: TCoordType): gboolean{.cdecl.}
+    ref_accessible_at_point*: proc (component: PComponent, x: gint, y: gint, 
+                                    coord_type: TCoordType): PObject{.cdecl.}
+    get_extents*: proc (component: PComponent, x: Pgint, y: Pgint, width: Pgint, 
+                        height: Pgint, coord_type: TCoordType){.cdecl.}
+    get_position*: proc (component: PComponent, x: Pgint, y: Pgint, 
+                         coord_type: TCoordType){.cdecl.}
+    get_size*: proc (component: PComponent, width: Pgint, height: Pgint){.cdecl.}
+    grab_focus*: proc (component: PComponent): gboolean{.cdecl.}
+    remove_focus_handler*: proc (component: PComponent, handler_id: guint){.
+        cdecl.}
+    set_extents*: proc (component: PComponent, x: gint, y: gint, width: gint, 
+                        height: gint, coord_type: TCoordType): gboolean{.cdecl.}
+    set_position*: proc (component: PComponent, x: gint, y: gint, 
+                         coord_type: TCoordType): gboolean{.cdecl.}
+    set_size*: proc (component: PComponent, width: gint, height: gint): gboolean{.
+        cdecl.}
+    get_layer*: proc (component: PComponent): TLayer{.cdecl.}
+    get_mdi_zorder*: proc (component: PComponent): gint{.cdecl.}
+    pad1*: TFunction
+    pad2*: TFunction
+
+  PDocumentIface* = ptr TDocumentIface
+  TDocumentIface* = object of TGTypeInterface
+    get_document_type*: proc (document: PDocument): cstring{.cdecl.}
+    get_document*: proc (document: PDocument): gpointer{.cdecl.}
+    pad1*: TFunction
+    pad2*: TFunction
+    pad3*: TFunction
+    pad4*: TFunction
+    pad5*: TFunction
+    pad6*: TFunction
+    pad7*: TFunction
+    pad8*: TFunction
+
+  PEditableTextIface* = ptr TEditableTextIface
+  TEditableTextIface* = object of TGTypeInterface
+    set_run_attributes*: proc (text: PEditableText, attrib_set: PAttributeSet, 
+                               start_offset: gint, end_offset: gint): gboolean{.
+        cdecl.}
+    set_text_contents*: proc (text: PEditableText, `string`: cstring){.cdecl.}
+    insert_text*: proc (text: PEditableText, `string`: cstring, length: gint, 
+                        position: Pgint){.cdecl.}
+    copy_text*: proc (text: PEditableText, start_pos: gint, end_pos: gint){.
+        cdecl.}
+    cut_text*: proc (text: PEditableText, start_pos: gint, end_pos: gint){.cdecl.}
+    delete_text*: proc (text: PEditableText, start_pos: gint, end_pos: gint){.
+        cdecl.}
+    paste_text*: proc (text: PEditableText, position: gint){.cdecl.}
+    pad1*: TFunction
+    pad2*: TFunction
+
+  PGObjectAccessible* = ptr TGObjectAccessible
+  TGObjectAccessible* = object of TObject
+  PGObjectAccessibleClass* = ptr TGObjectAccessibleClass
+  TGObjectAccessibleClass* = object of TObjectClass
+    pad5*: TFunction
+    pad6*: TFunction
+
+  PHyperlink* = ptr THyperlink
+  THyperlink* = object of TGObject
+  PHyperlinkClass* = ptr THyperlinkClass
+  THyperlinkClass* = object of TGObjectClass
+    get_uri*: proc (link: PHyperlink, i: gint): cstring{.cdecl.}
+    get_object*: proc (link: PHyperlink, i: gint): PObject{.cdecl.}
+    get_end_index*: proc (link: PHyperlink): gint{.cdecl.}
+    get_start_index*: proc (link: PHyperlink): gint{.cdecl.}
+    is_valid*: proc (link: PHyperlink): gboolean{.cdecl.}
+    get_n_anchors*: proc (link: PHyperlink): gint{.cdecl.}
+    pad7*: TFunction
+    pad8*: TFunction
+    pad9*: TFunction
+    pad10*: TFunction
+
+  PHypertextIface* = ptr THypertextIface
+  THypertextIface* = object of TGTypeInterface
+    get_link*: proc (hypertext: PHypertext, link_index: gint): PHyperlink{.cdecl.}
+    get_n_links*: proc (hypertext: PHypertext): gint{.cdecl.}
+    get_link_index*: proc (hypertext: PHypertext, char_index: gint): gint{.cdecl.}
+    pad11*: TFunction
+    pad12*: TFunction
+    pad13*: TFunction
+    pad14*: TFunction
+
+  PImageIface* = ptr TImageIface
+  TImageIface* = object of TGTypeInterface
+    get_image_position*: proc (image: PImage, x: Pgint, y: Pgint, 
+                               coord_type: TCoordType){.cdecl.}
+    get_image_description*: proc (image: PImage): cstring{.cdecl.}
+    get_image_size*: proc (image: PImage, width: Pgint, height: Pgint){.cdecl.}
+    set_image_description*: proc (image: PImage, description: cstring): gboolean{.
+        cdecl.}
+    pad15*: TFunction
+    pad16*: TFunction
+
+  PObjectFactory* = ptr TObjectFactory
+  TObjectFactory* = object of TGObject
+  PObjectFactoryClass* = ptr TObjectFactoryClass
+  TObjectFactoryClass* = object of TGObjectClass
+    create_accessible*: proc (obj: PGObject): PObject{.cdecl.}
+    invalidate*: proc (factory: PObjectFactory){.cdecl.}
+    get_accessible_type*: proc (): GType{.cdecl.}
+    pad17*: TFunction
+    pad18*: TFunction
+
+  PRegistry* = ptr TRegistry
+  TRegistry* = object of TGObject
+    factory_type_registry*: PGHashTable
+    factory_singleton_cache*: PGHashTable
+
+  PRegistryClass* = ptr TRegistryClass
+  TRegistryClass* = object of TGObjectClass
+  PRelationType* = ptr TRelationType
+  TRelationType* = enum 
+    RELATION_NULL, RELATION_CONTROLLED_BY, RELATION_CONTROLLER_FOR, 
+    RELATION_LABEL_FOR, RELATION_LABELLED_BY, RELATION_MEMBER_OF, 
+    RELATION_NODE_CHILD_OF, RELATION_LAST_DEFINED
+  PRelation* = ptr TRelation
+  PGPtrArray = pointer
+  TRelation* = object of TGObject
+    target*: PGPtrArray
+    relationship*: TRelationType
+
+  PRelationClass* = ptr TRelationClass
+  TRelationClass* = object of TGObjectClass
+  TRelationSet* = object of TGObject
+    relations*: PGPtrArray
+
+  PRelationSetClass* = ptr TRelationSetClass
+  TRelationSetClass* = object of TGObjectClass
+    pad19*: TFunction
+    pad20*: TFunction
+
+  PSelectionIface* = ptr TSelectionIface
+  TSelectionIface* = object of TGTypeInterface
+    add_selection*: proc (selection: PSelection, i: gint): gboolean{.cdecl.}
+    clear_selection*: proc (selection: PSelection): gboolean{.cdecl.}
+    ref_selection*: proc (selection: PSelection, i: gint): PObject{.cdecl.}
+    get_selection_count*: proc (selection: PSelection): gint{.cdecl.}
+    is_child_selected*: proc (selection: PSelection, i: gint): gboolean{.cdecl.}
+    remove_selection*: proc (selection: PSelection, i: gint): gboolean{.cdecl.}
+    select_all_selection*: proc (selection: PSelection): gboolean{.cdecl.}
+    selection_changed*: proc (selection: PSelection){.cdecl.}
+    pad1*: TFunction
+    pad2*: TFunction
+
+  PStateType* = ptr TStateType
+  TStateType* = enum 
+    STATE_INVALID, STATE_ACTIVE, STATE_ARMED, STATE_BUSY, STATE_CHECKED, 
+    STATE_DEFUNCT, STATE_EDITABLE, STATE_ENABLED, STATE_EXPANDABLE, 
+    STATE_EXPANDED, STATE_FOCUSABLE, STATE_FOCUSED, STATE_HORIZONTAL, 
+    STATE_ICONIFIED, STATE_MODAL, STATE_MULTI_LINE, STATE_MULTISELECTABLE, 
+    STATE_OPAQUE, STATE_PRESSED, STATE_RESIZABLE, STATE_SELECTABLE, 
+    STATE_SELECTED, STATE_SENSITIVE, STATE_SHOWING, STATE_SINGLE_LINE, 
+    STATE_STALE, STATE_TRANSIENT, STATE_VERTICAL, STATE_VISIBLE, 
+    STATE_LAST_DEFINED
+  PState* = ptr TState
+  TState* = guint64
+  TStateSet* = object of TGObject
+  PStateSetClass* = ptr TStateSetClass
+  TStateSetClass* = object of TGObjectClass
+  PStreamableContentIface* = ptr TStreamableContentIface
+  TStreamableContentIface* = object of TGTypeInterface
+    get_n_mime_types*: proc (streamable: PStreamableContent): gint{.cdecl.}
+    get_mime_type*: proc (streamable: PStreamableContent, i: gint): cstring{.
+        cdecl.}
+    get_stream*: proc (streamable: PStreamableContent, mime_type: cstring): PGIOChannel{.
+        cdecl.}
+    pad21*: TFunction
+    pad22*: TFunction
+    pad23*: TFunction
+    pad24*: TFunction
+
+  PTableIface* = ptr TTableIface
+  TTableIface* = object of TGTypeInterface
+    ref_at*: proc (table: PTable, row: gint, column: gint): PObject{.cdecl.}
+    get_index_at*: proc (table: PTable, row: gint, column: gint): gint{.cdecl.}
+    get_column_at_index*: proc (table: PTable, index: gint): gint{.cdecl.}
+    get_row_at_index*: proc (table: PTable, index: gint): gint{.cdecl.}
+    get_n_columns*: proc (table: PTable): gint{.cdecl.}
+    get_n_rows*: proc (table: PTable): gint{.cdecl.}
+    get_column_extent_at*: proc (table: PTable, row: gint, column: gint): gint{.
+        cdecl.}
+    get_row_extent_at*: proc (table: PTable, row: gint, column: gint): gint{.
+        cdecl.}
+    get_caption*: proc (table: PTable): PObject{.cdecl.}
+    get_column_description*: proc (table: PTable, column: gint): cstring{.cdecl.}
+    get_column_header*: proc (table: PTable, column: gint): PObject{.cdecl.}
+    get_row_description*: proc (table: PTable, row: gint): cstring{.cdecl.}
+    get_row_header*: proc (table: PTable, row: gint): PObject{.cdecl.}
+    get_summary*: proc (table: PTable): PObject{.cdecl.}
+    set_caption*: proc (table: PTable, caption: PObject){.cdecl.}
+    set_column_description*: proc (table: PTable, column: gint, 
+                                   description: cstring){.cdecl.}
+    set_column_header*: proc (table: PTable, column: gint, header: PObject){.
+        cdecl.}
+    set_row_description*: proc (table: PTable, row: gint, description: cstring){.
+        cdecl.}
+    set_row_header*: proc (table: PTable, row: gint, header: PObject){.cdecl.}
+    set_summary*: proc (table: PTable, accessible: PObject){.cdecl.}
+    get_selected_columns*: proc (table: PTable, selected: PPgint): gint{.cdecl.}
+    get_selected_rows*: proc (table: PTable, selected: PPgint): gint{.cdecl.}
+    is_column_selected*: proc (table: PTable, column: gint): gboolean{.cdecl.}
+    is_row_selected*: proc (table: PTable, row: gint): gboolean{.cdecl.}
+    is_selected*: proc (table: PTable, row: gint, column: gint): gboolean{.cdecl.}
+    add_row_selection*: proc (table: PTable, row: gint): gboolean{.cdecl.}
+    remove_row_selection*: proc (table: PTable, row: gint): gboolean{.cdecl.}
+    add_column_selection*: proc (table: PTable, column: gint): gboolean{.cdecl.}
+    remove_column_selection*: proc (table: PTable, column: gint): gboolean{.
+        cdecl.}
+    row_inserted*: proc (table: PTable, row: gint, num_inserted: gint){.cdecl.}
+    column_inserted*: proc (table: PTable, column: gint, num_inserted: gint){.
+        cdecl.}
+    row_deleted*: proc (table: PTable, row: gint, num_deleted: gint){.cdecl.}
+    column_deleted*: proc (table: PTable, column: gint, num_deleted: gint){.
+        cdecl.}
+    row_reordered*: proc (table: PTable){.cdecl.}
+    column_reordered*: proc (table: PTable){.cdecl.}
+    model_changed*: proc (table: PTable){.cdecl.}
+    pad25*: TFunction
+    pad26*: TFunction
+    pad27*: TFunction
+    pad28*: TFunction
+
+  TAttributeSet* = TGSList
+  PAttribute* = ptr TAttribute
+  TAttribute*{.final, pure.} = object 
+    name*: cstring
+    value*: cstring
+
+  PTextAttribute* = ptr TTextAttribute
+  TTextAttribute* = enum 
+    TEXT_ATTR_INVALID, TEXT_ATTR_LEFT_MARGIN, TEXT_ATTR_RIGHT_MARGIN, 
+    TEXT_ATTR_INDENT, TEXT_ATTR_INVISIBLE, TEXT_ATTR_EDITABLE, 
+    TEXT_ATTR_PIXELS_ABOVE_LINES, TEXT_ATTR_PIXELS_BELOW_LINES, 
+    TEXT_ATTR_PIXELS_INSIDE_WRAP, TEXT_ATTR_BG_FULL_HEIGHT, TEXT_ATTR_RISE, 
+    TEXT_ATTR_UNDERLINE, TEXT_ATTR_STRIKETHROUGH, TEXT_ATTR_SIZE, 
+    TEXT_ATTR_SCALE, TEXT_ATTR_WEIGHT, TEXT_ATTR_LANGUAGE, 
+    TEXT_ATTR_FAMILY_NAME, TEXT_ATTR_BG_COLOR, TEXT_ATTR_FG_COLOR, 
+    TEXT_ATTR_BG_STIPPLE, TEXT_ATTR_FG_STIPPLE, TEXT_ATTR_WRAP_MODE, 
+    TEXT_ATTR_DIRECTION, TEXT_ATTR_JUSTIFICATION, TEXT_ATTR_STRETCH, 
+    TEXT_ATTR_VARIANT, TEXT_ATTR_STYLE, TEXT_ATTR_LAST_DEFINED
+  PTextBoundary* = ptr TTextBoundary
+  TTextBoundary* = enum 
+    TEXT_BOUNDARY_CHAR, TEXT_BOUNDARY_WORD_START, TEXT_BOUNDARY_WORD_END, 
+    TEXT_BOUNDARY_SENTENCE_START, TEXT_BOUNDARY_SENTENCE_END, 
+    TEXT_BOUNDARY_LINE_START, TEXT_BOUNDARY_LINE_END
+  PTextIface* = ptr TTextIface
+  TTextIface* = object of TGTypeInterface
+    get_text*: proc (text: PText, start_offset: gint, end_offset: gint): cstring{.
+        cdecl.}
+    get_text_after_offset*: proc (text: PText, offset: gint, 
+                                  boundary_type: TTextBoundary, 
+                                  start_offset: Pgint, end_offset: Pgint): cstring{.
+        cdecl.}
+    get_text_at_offset*: proc (text: PText, offset: gint, 
+                               boundary_type: TTextBoundary, 
+                               start_offset: Pgint, end_offset: Pgint): cstring{.
+        cdecl.}
+    get_character_at_offset*: proc (text: PText, offset: gint): gunichar{.cdecl.}
+    get_text_before_offset*: proc (text: PText, offset: gint, 
+                                   boundary_type: TTextBoundary, 
+                                   start_offset: Pgint, end_offset: Pgint): cstring{.
+        cdecl.}
+    get_caret_offset*: proc (text: PText): gint{.cdecl.}
+    get_run_attributes*: proc (text: PText, offset: gint, start_offset: Pgint, 
+                               end_offset: Pgint): PAttributeSet{.cdecl.}
+    get_default_attributes*: proc (text: PText): PAttributeSet{.cdecl.}
+    get_character_extents*: proc (text: PText, offset: gint, x: Pgint, y: Pgint, 
+                                  width: Pgint, height: Pgint, 
+                                  coords: TCoordType){.cdecl.}
+    get_character_count*: proc (text: PText): gint{.cdecl.}
+    get_offset_at_point*: proc (text: PText, x: gint, y: gint, 
+                                coords: TCoordType): gint{.cdecl.}
+    get_n_selections*: proc (text: PText): gint{.cdecl.}
+    get_selection*: proc (text: PText, selection_num: gint, start_offset: Pgint, 
+                          end_offset: Pgint): cstring{.cdecl.}
+    add_selection*: proc (text: PText, start_offset: gint, end_offset: gint): gboolean{.
+        cdecl.}
+    remove_selection*: proc (text: PText, selection_num: gint): gboolean{.cdecl.}
+    set_selection*: proc (text: PText, selection_num: gint, start_offset: gint, 
+                          end_offset: gint): gboolean{.cdecl.}
+    set_caret_offset*: proc (text: PText, offset: gint): gboolean{.cdecl.}
+    text_changed*: proc (text: PText, position: gint, length: gint){.cdecl.}
+    text_caret_moved*: proc (text: PText, location: gint){.cdecl.}
+    text_selection_changed*: proc (text: PText){.cdecl.}
+    pad29*: TFunction
+    pad30*: TFunction
+    pad31*: TFunction
+    pad32*: TFunction
+
+  TEventListener* = proc (para1: PObject){.cdecl.}
+  TEventListenerInitProc* = proc ()
+  TEventListenerInit* = proc (para1: TEventListenerInitProc){.cdecl.}
+  PKeyEventStruct* = ptr TKeyEventStruct
+  TKeyEventStruct*{.final, pure.} = object 
+    `type`*: gint
+    state*: guint
+    keyval*: guint
+    length*: gint
+    string*: cstring
+    keycode*: guint16
+    timestamp*: guint32
+
+  TKeySnoopFunc* = proc (event: PKeyEventStruct, func_data: gpointer): gint{.
+      cdecl.}
+  PKeyEventType* = ptr TKeyEventType
+  TKeyEventType* = enum 
+    KEY_EVENT_PRESS, KEY_EVENT_RELEASE, KEY_EVENT_LAST_DEFINED
+  PUtil* = ptr TUtil
+  TUtil* = object of TGObject
+  PUtilClass* = ptr TUtilClass
+  TUtilClass* = object of TGObjectClass
+    add_global_event_listener*: proc (listener: TGSignalEmissionHook, 
+                                      event_type: cstring): guint{.cdecl.}
+    remove_global_event_listener*: proc (listener_id: guint){.cdecl.}
+    add_key_event_listener*: proc (listener: TKeySnoopFunc, data: gpointer): guint{.
+        cdecl.}
+    remove_key_event_listener*: proc (listener_id: guint){.cdecl.}
+    get_root*: proc (): PObject{.cdecl.}
+    get_toolkit_name*: proc (): cstring{.cdecl.}
+    get_toolkit_version*: proc (): cstring{.cdecl.}
+
+  PValueIface* = ptr TValueIface
+  TValueIface* = object of TGTypeInterface
+    get_current_value*: proc (obj: PValue, value: PGValue){.cdecl.}
+    get_maximum_value*: proc (obj: PValue, value: PGValue){.cdecl.}
+    get_minimum_value*: proc (obj: PValue, value: PGValue){.cdecl.}
+    set_current_value*: proc (obj: PValue, value: PGValue): gboolean{.cdecl.}
+    pad33*: TFunction
+    pad34*: TFunction
+
+
+proc role_register*(name: cstring): TRole{.cdecl, dynlib: lib, 
+    importc: "atk_role_register".}
+proc object_get_type*(): GType{.cdecl, dynlib: lib, 
+                                importc: "atk_object_get_type".}
+proc TYPE_OBJECT*(): GType
+proc `OBJECT`*(obj: pointer): PObject
+proc OBJECT_CLASS*(klass: pointer): PObjectClass
+proc IS_OBJECT*(obj: pointer): bool
+proc IS_OBJECT_CLASS*(klass: pointer): bool
+proc OBJECT_GET_CLASS*(obj: pointer): PObjectClass
+proc TYPE_IMPLEMENTOR*(): GType
+proc IS_IMPLEMENTOR*(obj: pointer): bool
+proc IMPLEMENTOR*(obj: pointer): PImplementor
+proc IMPLEMENTOR_GET_IFACE*(obj: pointer): PImplementorIface
+proc implementor_get_type*(): GType{.cdecl, dynlib: lib, 
+                                     importc: "atk_implementor_get_type".}
+proc ref_accessible*(implementor: PImplementor): PObject{.cdecl, 
+    dynlib: lib, importc: "atk_implementor_ref_accessible".}
+proc get_name*(accessible: PObject): cstring{.cdecl, dynlib: lib, 
+    importc: "atk_object_get_name".}
+proc get_description*(accessible: PObject): cstring{.cdecl, dynlib: lib, 
+    importc: "atk_object_get_description".}
+proc get_parent*(accessible: PObject): PObject{.cdecl, dynlib: lib, 
+    importc: "atk_object_get_parent".}
+proc get_n_accessible_children*(accessible: PObject): gint{.cdecl, 
+    dynlib: lib, importc: "atk_object_get_n_accessible_children".}
+proc ref_accessible_child*(accessible: PObject, i: gint): PObject{.cdecl, 
+    dynlib: lib, importc: "atk_object_ref_accessible_child".}
+proc ref_relation_set*(accessible: PObject): PRelationSet{.cdecl, 
+    dynlib: lib, importc: "atk_object_ref_relation_set".}
+proc get_role*(accessible: PObject): TRole{.cdecl, dynlib: lib, 
+    importc: "atk_object_get_role".}
+proc get_layer*(accessible: PObject): TLayer{.cdecl, dynlib: lib, 
+    importc: "atk_object_get_layer".}
+proc get_mdi_zorder*(accessible: PObject): gint{.cdecl, dynlib: lib, 
+    importc: "atk_object_get_mdi_zorder".}
+proc ref_state_set*(accessible: PObject): PStateSet{.cdecl, dynlib: lib, 
+    importc: "atk_object_ref_state_set".}
+proc get_index_in_parent*(accessible: PObject): gint{.cdecl, dynlib: lib, 
+    importc: "atk_object_get_index_in_parent".}
+proc set_name*(accessible: PObject, name: cstring){.cdecl, dynlib: lib, 
+    importc: "atk_object_set_name".}
+proc set_description*(accessible: PObject, description: cstring){.cdecl, 
+    dynlib: lib, importc: "atk_object_set_description".}
+proc set_parent*(accessible: PObject, parent: PObject){.cdecl, 
+    dynlib: lib, importc: "atk_object_set_parent".}
+proc set_role*(accessible: PObject, role: TRole){.cdecl, dynlib: lib, 
+    importc: "atk_object_set_role".}
+proc connect_property_change_handler*(accessible: PObject, 
+    handler: TPropertyChangeHandler): guint{.cdecl, dynlib: lib, 
+    importc: "atk_object_connect_property_change_handler".}
+proc remove_property_change_handler*(accessible: PObject, 
+    handler_id: guint){.cdecl, dynlib: lib, 
+                        importc: "atk_object_remove_property_change_handler".}
+proc notify_state_change*(accessible: PObject, state: TState, 
+                                 value: gboolean){.cdecl, dynlib: lib, 
+    importc: "atk_object_notify_state_change".}
+proc initialize*(accessible: PObject, data: gpointer){.cdecl, 
+    dynlib: lib, importc: "atk_object_initialize".}
+proc role_get_name*(role: TRole): cstring{.cdecl, dynlib: lib, 
+    importc: "atk_role_get_name".}
+proc role_for_name*(name: cstring): TRole{.cdecl, dynlib: lib, 
+    importc: "atk_role_for_name".}
+proc TYPE_ACTION*(): GType
+proc IS_ACTION*(obj: pointer): bool
+proc ACTION*(obj: pointer): PAction
+proc ACTION_GET_IFACE*(obj: pointer): PActionIface
+proc action_get_type*(): GType{.cdecl, dynlib: lib, 
+                                importc: "atk_action_get_type".}
+proc do_action*(action: PAction, i: gint): gboolean{.cdecl, dynlib: lib, 
+    importc: "atk_action_do_action".}
+proc get_n_actions*(action: PAction): gint{.cdecl, dynlib: lib, 
+    importc: "atk_action_get_n_actions".}
+proc get_description*(action: PAction, i: gint): cstring{.cdecl, 
+    dynlib: lib, importc: "atk_action_get_description".}
+proc get_name*(action: PAction, i: gint): cstring{.cdecl, dynlib: lib, 
+    importc: "atk_action_get_name".}
+proc get_keybinding*(action: PAction, i: gint): cstring{.cdecl, 
+    dynlib: lib, importc: "atk_action_get_keybinding".}
+proc set_description*(action: PAction, i: gint, desc: cstring): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_action_set_description".}
+proc TYPE_COMPONENT*(): GType
+proc IS_COMPONENT*(obj: pointer): bool
+proc COMPONENT*(obj: pointer): PComponent
+proc COMPONENT_GET_IFACE*(obj: pointer): PComponentIface
+proc component_get_type*(): GType{.cdecl, dynlib: lib, 
+                                   importc: "atk_component_get_type".}
+proc add_focus_handler*(component: PComponent, handler: TFocusHandler): guint{.
+    cdecl, dynlib: lib, importc: "atk_component_add_focus_handler".}
+proc contains*(component: PComponent, x, y: gint, 
+                         coord_type: TCoordType): gboolean{.cdecl, dynlib: lib, 
+    importc: "atk_component_contains".}
+proc ref_accessible_at_point*(component: PComponent, x, y: gint, 
+                                        coord_type: TCoordType): PObject{.cdecl, 
+    dynlib: lib, importc: "atk_component_ref_accessible_at_point".}
+proc get_extents*(component: PComponent, x, y, width, height: Pgint, 
+                            coord_type: TCoordType){.cdecl, dynlib: lib, 
+    importc: "atk_component_get_extents".}
+proc get_position*(component: PComponent, x: Pgint, y: Pgint, 
+                             coord_type: TCoordType){.cdecl, dynlib: lib, 
+    importc: "atk_component_get_position".}
+proc get_size*(component: PComponent, width: Pgint, height: Pgint){.
+    cdecl, dynlib: lib, importc: "atk_component_get_size".}
+proc get_layer*(component: PComponent): TLayer{.cdecl, dynlib: lib, 
+    importc: "atk_component_get_layer".}
+proc get_mdi_zorder*(component: PComponent): gint{.cdecl, dynlib: lib, 
+    importc: "atk_component_get_mdi_zorder".}
+proc grab_focus*(component: PComponent): gboolean{.cdecl, dynlib: lib, 
+    importc: "atk_component_grab_focus".}
+proc remove_focus_handler*(component: PComponent, handler_id: guint){.
+    cdecl, dynlib: lib, importc: "atk_component_remove_focus_handler".}
+proc set_extents*(component: PComponent, x: gint, y: gint, 
+                            width: gint, height: gint, coord_type: TCoordType): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_component_set_extents".}
+proc set_position*(component: PComponent, x: gint, y: gint, 
+                             coord_type: TCoordType): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_component_set_position".}
+proc set_size*(component: PComponent, width: gint, height: gint): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_component_set_size".}
+proc TYPE_DOCUMENT*(): GType
+proc IS_DOCUMENT*(obj: pointer): bool
+proc DOCUMENT*(obj: pointer): PDocument
+proc DOCUMENT_GET_IFACE*(obj: pointer): PDocumentIface
+proc document_get_type*(): GType{.cdecl, dynlib: lib, 
+                                  importc: "atk_document_get_type".}
+proc get_document_type*(document: PDocument): cstring{.cdecl, 
+    dynlib: lib, importc: "atk_document_get_document_type".}
+proc get_document*(document: PDocument): gpointer{.cdecl, dynlib: lib, 
+    importc: "atk_document_get_document".}
+proc TYPE_EDITABLE_TEXT*(): GType
+proc IS_EDITABLE_TEXT*(obj: pointer): bool
+proc EDITABLE_TEXT*(obj: pointer): PEditableText
+proc EDITABLE_TEXT_GET_IFACE*(obj: pointer): PEditableTextIface
+proc editable_text_get_type*(): GType{.cdecl, dynlib: lib, 
+                                       importc: "atk_editable_text_get_type".}
+proc set_run_attributes*(text: PEditableText, 
+                                       attrib_set: PAttributeSet, 
+                                       start_offset: gint, end_offset: gint): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_editable_text_set_run_attributes".}
+proc set_text_contents*(text: PEditableText, string: cstring){.
+    cdecl, dynlib: lib, importc: "atk_editable_text_set_text_contents".}
+proc insert_text*(text: PEditableText, `string`: cstring, 
+                                length: gint, position: Pgint){.cdecl, 
+    dynlib: lib, importc: "atk_editable_text_insert_text".}
+proc copy_text*(text: PEditableText, start_pos: gint, 
+                              end_pos: gint){.cdecl, dynlib: lib, 
+    importc: "atk_editable_text_copy_text".}
+proc cut_text*(text: PEditableText, start_pos: gint, end_pos: gint){.
+    cdecl, dynlib: lib, importc: "atk_editable_text_cut_text".}
+proc delete_text*(text: PEditableText, start_pos: gint, 
+                                end_pos: gint){.cdecl, dynlib: lib, 
+    importc: "atk_editable_text_delete_text".}
+proc paste_text*(text: PEditableText, position: gint){.cdecl, 
+    dynlib: lib, importc: "atk_editable_text_paste_text".}
+proc TYPE_GOBJECT_ACCESSIBLE*(): GType
+proc GOBJECT_ACCESSIBLE*(obj: pointer): PGObjectAccessible
+proc GOBJECT_ACCESSIBLE_CLASS*(klass: pointer): PGObjectAccessibleClass
+proc IS_GOBJECT_ACCESSIBLE*(obj: pointer): bool
+proc IS_GOBJECT_ACCESSIBLE_CLASS*(klass: pointer): bool
+proc GOBJECT_ACCESSIBLE_GET_CLASS*(obj: pointer): PGObjectAccessibleClass
+proc gobject_accessible_get_type*(): GType{.cdecl, dynlib: lib, 
+    importc: "atk_gobject_accessible_get_type".}
+proc accessible_for_object*(obj: PGObject): PObject{.cdecl, dynlib: lib, 
+    importc: "atk_gobject_accessible_for_object".}
+proc get_object*(obj: PGObjectAccessible): PGObject{.cdecl, 
+    dynlib: lib, importc: "atk_gobject_accessible_get_object".}
+proc TYPE_HYPERLINK*(): GType
+proc HYPERLINK*(obj: pointer): PHyperlink
+proc HYPERLINK_CLASS*(klass: pointer): PHyperlinkClass
+proc IS_HYPERLINK*(obj: pointer): bool
+proc IS_HYPERLINK_CLASS*(klass: pointer): bool
+proc HYPERLINK_GET_CLASS*(obj: pointer): PHyperlinkClass
+proc hyperlink_get_type*(): GType{.cdecl, dynlib: lib, 
+                                   importc: "atk_hyperlink_get_type".}
+proc get_uri*(link: PHyperlink, i: gint): cstring{.cdecl, dynlib: lib, 
+    importc: "atk_hyperlink_get_uri".}
+proc get_object*(link: PHyperlink, i: gint): PObject{.cdecl, 
+    dynlib: lib, importc: "atk_hyperlink_get_object".}
+proc get_end_index*(link: PHyperlink): gint{.cdecl, dynlib: lib, 
+    importc: "atk_hyperlink_get_end_index".}
+proc get_start_index*(link: PHyperlink): gint{.cdecl, dynlib: lib, 
+    importc: "atk_hyperlink_get_start_index".}
+proc is_valid*(link: PHyperlink): gboolean{.cdecl, dynlib: lib, 
+    importc: "atk_hyperlink_is_valid".}
+proc get_n_anchors*(link: PHyperlink): gint{.cdecl, dynlib: lib, 
+    importc: "atk_hyperlink_get_n_anchors".}
+proc TYPE_HYPERTEXT*(): GType
+proc IS_HYPERTEXT*(obj: pointer): bool
+proc HYPERTEXT*(obj: pointer): PHypertext
+proc HYPERTEXT_GET_IFACE*(obj: pointer): PHypertextIface
+proc hypertext_get_type*(): GType{.cdecl, dynlib: lib, 
+                                   importc: "atk_hypertext_get_type".}
+proc get_link*(hypertext: PHypertext, link_index: gint): PHyperlink{.
+    cdecl, dynlib: lib, importc: "atk_hypertext_get_link".}
+proc get_n_links*(hypertext: PHypertext): gint{.cdecl, dynlib: lib, 
+    importc: "atk_hypertext_get_n_links".}
+proc get_link_index*(hypertext: PHypertext, char_index: gint): gint{.
+    cdecl, dynlib: lib, importc: "atk_hypertext_get_link_index".}
+proc TYPE_IMAGE*(): GType
+proc IS_IMAGE*(obj: pointer): bool
+proc IMAGE*(obj: pointer): PImage
+proc IMAGE_GET_IFACE*(obj: pointer): PImageIface
+proc image_get_type*(): GType{.cdecl, dynlib: lib, importc: "atk_image_get_type".}
+proc get_image_description*(image: PImage): cstring{.cdecl, dynlib: lib, 
+    importc: "atk_image_get_image_description".}
+proc get_image_size*(image: PImage, width: Pgint, height: Pgint){.cdecl, 
+    dynlib: lib, importc: "atk_image_get_image_size".}
+proc set_image_description*(image: PImage, description: cstring): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_image_set_image_description".}
+proc get_image_position*(image: PImage, x: Pgint, y: Pgint, 
+                               coord_type: TCoordType){.cdecl, dynlib: lib, 
+    importc: "atk_image_get_image_position".}
+proc TYPE_OBJECT_FACTORY*(): GType
+proc OBJECT_FACTORY*(obj: pointer): PObjectFactory
+proc OBJECT_FACTORY_CLASS*(klass: pointer): PObjectFactoryClass
+proc IS_OBJECT_FACTORY*(obj: pointer): bool
+proc IS_OBJECT_FACTORY_CLASS*(klass: pointer): bool
+proc OBJECT_FACTORY_GET_CLASS*(obj: pointer): PObjectFactoryClass
+proc object_factory_get_type*(): GType{.cdecl, dynlib: lib, 
+                                        importc: "atk_object_factory_get_type".}
+proc create_accessible*(factory: PObjectFactory, obj: PGObject): PObject{.
+    cdecl, dynlib: lib, importc: "atk_object_factory_create_accessible".}
+proc invalidate*(factory: PObjectFactory){.cdecl, dynlib: lib, 
+    importc: "atk_object_factory_invalidate".}
+proc get_accessible_type*(factory: PObjectFactory): GType{.cdecl, 
+    dynlib: lib, importc: "atk_object_factory_get_accessible_type".}
+proc TYPE_REGISTRY*(): GType
+proc REGISTRY*(obj: pointer): PRegistry
+proc REGISTRY_CLASS*(klass: pointer): PRegistryClass
+proc IS_REGISTRY*(obj: pointer): bool
+proc IS_REGISTRY_CLASS*(klass: pointer): bool
+proc REGISTRY_GET_CLASS*(obj: pointer): PRegistryClass
+proc registry_get_type*(): GType{.cdecl, dynlib: lib, 
+                                  importc: "atk_registry_get_type".}
+proc set_factory_type*(registry: PRegistry, `type`: GType, 
+                                factory_type: GType){.cdecl, dynlib: lib, 
+    importc: "atk_registry_set_factory_type".}
+proc get_factory_type*(registry: PRegistry, `type`: GType): GType{.
+    cdecl, dynlib: lib, importc: "atk_registry_get_factory_type".}
+proc get_factory*(registry: PRegistry, `type`: GType): PObjectFactory{.
+    cdecl, dynlib: lib, importc: "atk_registry_get_factory".}
+proc get_default_registry*(): PRegistry{.cdecl, dynlib: lib, 
+    importc: "atk_get_default_registry".}
+proc TYPE_RELATION*(): GType
+proc RELATION*(obj: pointer): PRelation
+proc RELATION_CLASS*(klass: pointer): PRelationClass
+proc IS_RELATION*(obj: pointer): bool
+proc IS_RELATION_CLASS*(klass: pointer): bool
+proc RELATION_GET_CLASS*(obj: pointer): PRelationClass
+proc relation_get_type*(): GType{.cdecl, dynlib: lib, 
+                                  importc: "atk_relation_get_type".}
+proc relation_type_register*(name: cstring): TRelationType{.cdecl, dynlib: lib, 
+    importc: "atk_relation_type_register".}
+proc relation_type_get_name*(`type`: TRelationType): cstring{.cdecl, 
+    dynlib: lib, importc: "atk_relation_type_get_name".}
+proc relation_type_for_name*(name: cstring): TRelationType{.cdecl, dynlib: lib, 
+    importc: "atk_relation_type_for_name".}
+proc relation_new*(targets: PPAtkObject, n_targets: gint, 
+                   relationship: TRelationType): PRelation{.cdecl, dynlib: lib, 
+    importc: "atk_relation_new".}
+proc get_relation_type*(relation: PRelation): TRelationType{.cdecl, 
+    dynlib: lib, importc: "atk_relation_get_relation_type".}
+proc get_target*(relation: PRelation): PGPtrArray{.cdecl, dynlib: lib, 
+    importc: "atk_relation_get_target".}
+proc TYPE_RELATION_SET*(): GType
+proc RELATION_SET*(obj: pointer): PRelationSet
+proc RELATION_SET_CLASS*(klass: pointer): PRelationSetClass
+proc IS_RELATION_SET*(obj: pointer): bool
+proc IS_RELATION_SET_CLASS*(klass: pointer): bool
+proc RELATION_SET_GET_CLASS*(obj: pointer): PRelationSetClass
+proc relation_set_get_type*(): GType{.cdecl, dynlib: lib, 
+                                      importc: "atk_relation_set_get_type".}
+proc relation_set_new*(): PRelationSet{.cdecl, dynlib: lib, 
+                                        importc: "atk_relation_set_new".}
+proc contains*(RelationSet: PRelationSet, 
+                            relationship: TRelationType): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_relation_set_contains".}
+proc remove*(RelationSet: PRelationSet, relation: PRelation){.
+    cdecl, dynlib: lib, importc: "atk_relation_set_remove".}
+proc add*(RelationSet: PRelationSet, relation: PRelation){.cdecl, 
+    dynlib: lib, importc: "atk_relation_set_add".}
+proc get_n_relations*(RelationSet: PRelationSet): gint{.cdecl, 
+    dynlib: lib, importc: "atk_relation_set_get_n_relations".}
+proc get_relation*(RelationSet: PRelationSet, i: gint): PRelation{.
+    cdecl, dynlib: lib, importc: "atk_relation_set_get_relation".}
+proc get_relation_by_type*(RelationSet: PRelationSet, 
+                                        relationship: TRelationType): PRelation{.
+    cdecl, dynlib: lib, importc: "atk_relation_set_get_relation_by_type".}
+proc TYPE_SELECTION*(): GType
+proc IS_SELECTION*(obj: pointer): bool
+proc SELECTION*(obj: pointer): PSelection
+proc SELECTION_GET_IFACE*(obj: pointer): PSelectionIface
+proc selection_get_type*(): GType{.cdecl, dynlib: lib, 
+                                   importc: "atk_selection_get_type".}
+proc add_selection*(selection: PSelection, i: gint): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_selection_add_selection".}
+proc clear_selection*(selection: PSelection): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_selection_clear_selection".}
+proc ref_selection*(selection: PSelection, i: gint): PObject{.cdecl, 
+    dynlib: lib, importc: "atk_selection_ref_selection".}
+proc get_selection_count*(selection: PSelection): gint{.cdecl, 
+    dynlib: lib, importc: "atk_selection_get_selection_count".}
+proc is_child_selected*(selection: PSelection, i: gint): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_selection_is_child_selected".}
+proc remove_selection*(selection: PSelection, i: gint): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_selection_remove_selection".}
+proc select_all_selection*(selection: PSelection): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_selection_select_all_selection".}
+proc state_type_register*(name: cstring): TStateType{.cdecl, dynlib: lib, 
+    importc: "atk_state_type_register".}
+proc state_type_get_name*(`type`: TStateType): cstring{.cdecl, dynlib: lib, 
+    importc: "atk_state_type_get_name".}
+proc state_type_for_name*(name: cstring): TStateType{.cdecl, dynlib: lib, 
+    importc: "atk_state_type_for_name".}
+proc TYPE_STATE_SET*(): GType
+proc STATE_SET*(obj: pointer): PStateSet
+proc STATE_SET_CLASS*(klass: pointer): PStateSetClass
+proc IS_STATE_SET*(obj: pointer): bool
+proc IS_STATE_SET_CLASS*(klass: pointer): bool
+proc STATE_SET_GET_CLASS*(obj: pointer): PStateSetClass
+proc state_set_get_type*(): GType{.cdecl, dynlib: lib, 
+                                   importc: "atk_state_set_get_type".}
+proc state_set_new*(): PStateSet{.cdecl, dynlib: lib, 
+                                  importc: "atk_state_set_new".}
+proc is_empty*(StateSet: PStateSet): gboolean{.cdecl, dynlib: lib, 
+    importc: "atk_state_set_is_empty".}
+proc add_state*(StateSet: PStateSet, `type`: TStateType): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_state_set_add_state".}
+proc add_states*(StateSet: PStateSet, types: PStateType, n_types: gint){.
+    cdecl, dynlib: lib, importc: "atk_state_set_add_states".}
+proc clear_states*(StateSet: PStateSet){.cdecl, dynlib: lib, 
+    importc: "atk_state_set_clear_states".}
+proc contains_state*(StateSet: PStateSet, `type`: TStateType): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_state_set_contains_state".}
+proc contains_states*(StateSet: PStateSet, types: PStateType, 
+                                n_types: gint): gboolean{.cdecl, dynlib: lib, 
+    importc: "atk_state_set_contains_states".}
+proc remove_state*(StateSet: PStateSet, `type`: TStateType): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_state_set_remove_state".}
+proc and_sets*(StateSet: PStateSet, compare_set: PStateSet): PStateSet{.
+    cdecl, dynlib: lib, importc: "atk_state_set_and_sets".}
+proc or_sets*(StateSet: PStateSet, compare_set: PStateSet): PStateSet{.
+    cdecl, dynlib: lib, importc: "atk_state_set_or_sets".}
+proc xor_sets*(StateSet: PStateSet, compare_set: PStateSet): PStateSet{.
+    cdecl, dynlib: lib, importc: "atk_state_set_xor_sets".}
+proc TYPE_STREAMABLE_CONTENT*(): GType
+proc IS_STREAMABLE_CONTENT*(obj: pointer): bool
+proc STREAMABLE_CONTENT*(obj: pointer): PStreamableContent
+proc STREAMABLE_CONTENT_GET_IFACE*(obj: pointer): PStreamableContentIface
+proc streamable_content_get_type*(): GType{.cdecl, dynlib: lib, 
+    importc: "atk_streamable_content_get_type".}
+proc get_n_mime_types*(streamable: PStreamableContent): gint{.
+    cdecl, dynlib: lib, importc: "atk_streamable_content_get_n_mime_types".}
+proc get_mime_type*(streamable: PStreamableContent, i: gint): cstring{.
+    cdecl, dynlib: lib, importc: "atk_streamable_content_get_mime_type".}
+proc get_stream*(streamable: PStreamableContent, 
+                                    mime_type: cstring): PGIOChannel{.cdecl, 
+    dynlib: lib, importc: "atk_streamable_content_get_stream".}
+proc TYPE_TABLE*(): GType
+proc IS_TABLE*(obj: pointer): bool
+proc TABLE*(obj: pointer): PTable
+proc TABLE_GET_IFACE*(obj: pointer): PTableIface
+proc table_get_type*(): GType{.cdecl, dynlib: lib, importc: "atk_table_get_type".}
+proc ref_at*(table: PTable, row, column: gint): PObject{.cdecl, 
+    dynlib: lib, importc: "atk_table_ref_at".}
+proc get_index_at*(table: PTable, row, column: gint): gint{.cdecl, 
+    dynlib: lib, importc: "atk_table_get_index_at".}
+proc get_column_at_index*(table: PTable, index: gint): gint{.cdecl, 
+    dynlib: lib, importc: "atk_table_get_column_at_index".}
+proc get_row_at_index*(table: PTable, index: gint): gint{.cdecl, 
+    dynlib: lib, importc: "atk_table_get_row_at_index".}
+proc get_n_columns*(table: PTable): gint{.cdecl, dynlib: lib, 
+    importc: "atk_table_get_n_columns".}
+proc get_n_rows*(table: PTable): gint{.cdecl, dynlib: lib, 
+    importc: "atk_table_get_n_rows".}
+proc get_column_extent_at*(table: PTable, row: gint, column: gint): gint{.
+    cdecl, dynlib: lib, importc: "atk_table_get_column_extent_at".}
+proc get_row_extent_at*(table: PTable, row: gint, column: gint): gint{.
+    cdecl, dynlib: lib, importc: "atk_table_get_row_extent_at".}
+proc get_caption*(table: PTable): PObject{.cdecl, dynlib: lib, 
+    importc: "atk_table_get_caption".}
+proc get_column_description*(table: PTable, column: gint): cstring{.cdecl, 
+    dynlib: lib, importc: "atk_table_get_column_description".}
+proc get_column_header*(table: PTable, column: gint): PObject{.cdecl, 
+    dynlib: lib, importc: "atk_table_get_column_header".}
+proc get_row_description*(table: PTable, row: gint): cstring{.cdecl, 
+    dynlib: lib, importc: "atk_table_get_row_description".}
+proc get_row_header*(table: PTable, row: gint): PObject{.cdecl, 
+    dynlib: lib, importc: "atk_table_get_row_header".}
+proc get_summary*(table: PTable): PObject{.cdecl, dynlib: lib, 
+    importc: "atk_table_get_summary".}
+proc set_caption*(table: PTable, caption: PObject){.cdecl, dynlib: lib, 
+    importc: "atk_table_set_caption".}
+proc set_column_description*(table: PTable, column: gint, 
+                                   description: cstring){.cdecl, dynlib: lib, 
+    importc: "atk_table_set_column_description".}
+proc set_column_header*(table: PTable, column: gint, header: PObject){.
+    cdecl, dynlib: lib, importc: "atk_table_set_column_header".}
+proc set_row_description*(table: PTable, row: gint, description: cstring){.
+    cdecl, dynlib: lib, importc: "atk_table_set_row_description".}
+proc set_row_header*(table: PTable, row: gint, header: PObject){.cdecl, 
+    dynlib: lib, importc: "atk_table_set_row_header".}
+proc set_summary*(table: PTable, accessible: PObject){.cdecl, dynlib: lib, 
+    importc: "atk_table_set_summary".}
+proc get_selected_columns*(table: PTable, selected: PPgint): gint{.cdecl, 
+    dynlib: lib, importc: "atk_table_get_selected_columns".}
+proc get_selected_rows*(table: PTable, selected: PPgint): gint{.cdecl, 
+    dynlib: lib, importc: "atk_table_get_selected_rows".}
+proc is_column_selected*(table: PTable, column: gint): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_table_is_column_selected".}
+proc is_row_selected*(table: PTable, row: gint): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_table_is_row_selected".}
+proc is_selected*(table: PTable, row: gint, column: gint): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_table_is_selected".}
+proc add_row_selection*(table: PTable, row: gint): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_table_add_row_selection".}
+proc remove_row_selection*(table: PTable, row: gint): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_table_remove_row_selection".}
+proc add_column_selection*(table: PTable, column: gint): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_table_add_column_selection".}
+proc remove_column_selection*(table: PTable, column: gint): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_table_remove_column_selection".}
+proc text_attribute_register*(name: cstring): TTextAttribute{.cdecl, 
+    dynlib: lib, importc: "atk_text_attribute_register".}
+proc TYPE_TEXT*(): GType
+proc IS_TEXT*(obj: pointer): bool
+proc TEXT*(obj: pointer): PText
+proc TEXT_GET_IFACE*(obj: pointer): PTextIface
+proc text_get_type*(): GType{.cdecl, dynlib: lib, importc: "atk_text_get_type".}
+proc get_text*(text: PText, start_offset: gint, end_offset: gint): cstring{.
+    cdecl, dynlib: lib, importc: "atk_text_get_text".}
+proc get_character_at_offset*(text: PText, offset: gint): gunichar{.cdecl, 
+    dynlib: lib, importc: "atk_text_get_character_at_offset".}
+proc get_text_after_offset*(text: PText, offset: gint, 
+                                 boundary_type: TTextBoundary, 
+                                 start_offset: Pgint, end_offset: Pgint): cstring{.
+    cdecl, dynlib: lib, importc: "atk_text_get_text_after_offset".}
+proc get_text_at_offset*(text: PText, offset: gint, 
+                              boundary_type: TTextBoundary, start_offset: Pgint, 
+                              end_offset: Pgint): cstring{.cdecl, dynlib: lib, 
+    importc: "atk_text_get_text_at_offset".}
+proc get_text_before_offset*(text: PText, offset: gint, 
+                                  boundary_type: TTextBoundary, 
+                                  start_offset: Pgint, end_offset: Pgint): cstring{.
+    cdecl, dynlib: lib, importc: "atk_text_get_text_before_offset".}
+proc get_caret_offset*(text: PText): gint{.cdecl, dynlib: lib, 
+    importc: "atk_text_get_caret_offset".}
+proc get_character_extents*(text: PText, offset: gint, x: Pgint, y: Pgint, 
+                                 width: Pgint, height: Pgint, coords: TCoordType){.
+    cdecl, dynlib: lib, importc: "atk_text_get_character_extents".}
+proc get_run_attributes*(text: PText, offset: gint, start_offset: Pgint, 
+                              end_offset: Pgint): PAttributeSet{.cdecl, 
+    dynlib: lib, importc: "atk_text_get_run_attributes".}
+proc get_default_attributes*(text: PText): PAttributeSet{.cdecl, 
+    dynlib: lib, importc: "atk_text_get_default_attributes".}
+proc get_character_count*(text: PText): gint{.cdecl, dynlib: lib, 
+    importc: "atk_text_get_character_count".}
+proc get_offset_at_point*(text: PText, x: gint, y: gint, coords: TCoordType): gint{.
+    cdecl, dynlib: lib, importc: "atk_text_get_offset_at_point".}
+proc get_n_selections*(text: PText): gint{.cdecl, dynlib: lib, 
+    importc: "atk_text_get_n_selections".}
+proc get_selection*(text: PText, selection_num: gint, start_offset: Pgint, 
+                         end_offset: Pgint): cstring{.cdecl, dynlib: lib, 
+    importc: "atk_text_get_selection".}
+proc add_selection*(text: PText, start_offset: gint, end_offset: gint): gboolean{.
+    cdecl, dynlib: lib, importc: "atk_text_add_selection".}
+proc remove_selection*(text: PText, selection_num: gint): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_text_remove_selection".}
+proc set_selection*(text: PText, selection_num: gint, start_offset: gint, 
+                         end_offset: gint): gboolean{.cdecl, dynlib: lib, 
+    importc: "atk_text_set_selection".}
+proc set_caret_offset*(text: PText, offset: gint): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_text_set_caret_offset".}
+proc free*(attrib_set: PAttributeSet){.cdecl, dynlib: lib, 
+    importc: "atk_attribute_set_free".}
+proc text_attribute_get_name*(attr: TTextAttribute): cstring{.cdecl, 
+    dynlib: lib, importc: "atk_text_attribute_get_name".}
+proc text_attribute_for_name*(name: cstring): TTextAttribute{.cdecl, 
+    dynlib: lib, importc: "atk_text_attribute_for_name".}
+proc text_attribute_get_value*(attr: TTextAttribute, index: gint): cstring{.
+    cdecl, dynlib: lib, importc: "atk_text_attribute_get_value".}
+proc TYPE_UTIL*(): GType
+proc IS_UTIL*(obj: pointer): bool
+proc UTIL*(obj: pointer): PUtil
+proc UTIL_CLASS*(klass: pointer): PUtilClass
+proc IS_UTIL_CLASS*(klass: pointer): bool
+proc UTIL_GET_CLASS*(obj: pointer): PUtilClass
+proc util_get_type*(): GType{.cdecl, dynlib: lib, importc: "atk_util_get_type".}
+proc add_focus_tracker*(focus_tracker: TEventListener): guint{.cdecl, 
+    dynlib: lib, importc: "atk_add_focus_tracker".}
+proc remove_focus_tracker*(tracker_id: guint){.cdecl, dynlib: lib, 
+    importc: "atk_remove_focus_tracker".}
+proc focus_tracker_init*(add_function: TEventListenerInit){.cdecl, dynlib: lib, 
+    importc: "atk_focus_tracker_init".}
+proc focus_tracker_notify*(anObject: PObject){.cdecl, dynlib: lib, 
+    importc: "atk_focus_tracker_notify".}
+proc add_global_event_listener*(listener: TGSignalEmissionHook, 
+                                event_type: cstring): guint{.cdecl, dynlib: lib, 
+    importc: "atk_add_global_event_listener".}
+proc remove_global_event_listener*(listener_id: guint){.cdecl, dynlib: lib, 
+    importc: "atk_remove_global_event_listener".}
+proc add_key_event_listener*(listener: TKeySnoopFunc, data: gpointer): guint{.
+    cdecl, dynlib: lib, importc: "atk_add_key_event_listener".}
+proc remove_key_event_listener*(listener_id: guint){.cdecl, dynlib: lib, 
+    importc: "atk_remove_key_event_listener".}
+proc get_root*(): PObject{.cdecl, dynlib: lib, importc: "atk_get_root".}
+proc get_toolkit_name*(): cstring{.cdecl, dynlib: lib, 
+                                   importc: "atk_get_toolkit_name".}
+proc get_toolkit_version*(): cstring{.cdecl, dynlib: lib, 
+                                      importc: "atk_get_toolkit_version".}
+proc TYPE_VALUE*(): GType
+proc IS_VALUE*(obj: pointer): bool
+proc VALUE*(obj: pointer): PValue
+proc VALUE_GET_IFACE*(obj: pointer): PValueIface
+proc value_get_type*(): GType{.cdecl, dynlib: lib, importc: "atk_value_get_type".}
+proc get_current_value*(obj: PValue, value: PGValue){.cdecl, dynlib: lib, 
+    importc: "atk_value_get_current_value".}
+proc get_maximum_value*(obj: PValue, value: PGValue){.cdecl, dynlib: lib, 
+    importc: "atk_value_get_maximum_value".}
+proc get_minimum_value*(obj: PValue, value: PGValue){.cdecl, dynlib: lib, 
+    importc: "atk_value_get_minimum_value".}
+proc set_current_value*(obj: PValue, value: PGValue): gboolean{.cdecl, 
+    dynlib: lib, importc: "atk_value_set_current_value".}
+proc TYPE_OBJECT*(): GType = 
+  result = object_get_type()
+
+proc `OBJECT`*(obj: pointer): PObject = 
+  result = cast[PObject](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_OBJECT()))
+
+proc OBJECT_CLASS*(klass: pointer): PObjectClass = 
+  result = cast[PObjectClass](G_TYPE_CHECK_CLASS_CAST(klass, TYPE_OBJECT()))
+
+proc IS_OBJECT*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_OBJECT())
+
+proc IS_OBJECT_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_OBJECT())
+
+proc OBJECT_GET_CLASS*(obj: pointer): PObjectClass = 
+  result = cast[PObjectClass](G_TYPE_INSTANCE_GET_CLASS(obj, TYPE_OBJECT()))
+
+proc TYPE_IMPLEMENTOR*(): GType = 
+  result = implementor_get_type()
+
+proc IS_IMPLEMENTOR*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_IMPLEMENTOR())
+
+proc IMPLEMENTOR*(obj: pointer): PImplementor = 
+  result = PImplementor(G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_IMPLEMENTOR()))
+
+proc IMPLEMENTOR_GET_IFACE*(obj: pointer): PImplementorIface = 
+  result = cast[PImplementorIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, 
+      TYPE_IMPLEMENTOR()))
+
+proc TYPE_ACTION*(): GType = 
+  result = action_get_type()
+
+proc IS_ACTION*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_ACTION())
+
+proc ACTION*(obj: pointer): PAction = 
+  result = PAction(G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_ACTION()))
+
+proc ACTION_GET_IFACE*(obj: pointer): PActionIface = 
+  result = cast[PActionIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, TYPE_ACTION()))
+
+proc TYPE_COMPONENT*(): GType = 
+  result = component_get_type()
+
+proc IS_COMPONENT*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_COMPONENT())
+
+proc COMPONENT*(obj: pointer): PComponent = 
+  result = PComponent(G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_COMPONENT()))
+
+proc COMPONENT_GET_IFACE*(obj: pointer): PComponentIface = 
+  result = cast[PComponentIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, 
+      TYPE_COMPONENT()))
+
+proc TYPE_DOCUMENT*(): GType = 
+  result = document_get_type()
+
+proc IS_DOCUMENT*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_DOCUMENT())
+
+proc DOCUMENT*(obj: pointer): PDocument = 
+  result = cast[PDocument](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_DOCUMENT()))
+
+proc DOCUMENT_GET_IFACE*(obj: pointer): PDocumentIface = 
+  result = cast[PDocumentIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, 
+      TYPE_DOCUMENT()))
+
+proc TYPE_EDITABLE_TEXT*(): GType = 
+  result = editable_text_get_type()
+
+proc IS_EDITABLE_TEXT*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_EDITABLE_TEXT())
+
+proc EDITABLE_TEXT*(obj: pointer): PEditableText = 
+  result = cast[PEditableText](G_TYPE_CHECK_INSTANCE_CAST(obj, 
+      TYPE_EDITABLE_TEXT()))
+
+proc EDITABLE_TEXT_GET_IFACE*(obj: pointer): PEditableTextIface = 
+  result = cast[PEditableTextIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, 
+      TYPE_EDITABLE_TEXT()))
+
+proc TYPE_GOBJECT_ACCESSIBLE*(): GType = 
+  result = gobject_accessible_get_type()
+
+proc GOBJECT_ACCESSIBLE*(obj: pointer): PGObjectAccessible = 
+  result = cast[PGObjectAccessible](G_TYPE_CHECK_INSTANCE_CAST(obj, 
+      TYPE_GOBJECT_ACCESSIBLE()))
+
+proc GOBJECT_ACCESSIBLE_CLASS*(klass: pointer): PGObjectAccessibleClass = 
+  result = cast[PGObjectAccessibleClass](G_TYPE_CHECK_CLASS_CAST(klass, 
+      TYPE_GOBJECT_ACCESSIBLE()))
+
+proc IS_GOBJECT_ACCESSIBLE*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_GOBJECT_ACCESSIBLE())
+
+proc IS_GOBJECT_ACCESSIBLE_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_GOBJECT_ACCESSIBLE())
+
+proc GOBJECT_ACCESSIBLE_GET_CLASS*(obj: pointer): PGObjectAccessibleClass = 
+  result = cast[PGObjectAccessibleClass](G_TYPE_INSTANCE_GET_CLASS(obj, 
+      TYPE_GOBJECT_ACCESSIBLE()))
+
+proc TYPE_HYPERLINK*(): GType = 
+  result = hyperlink_get_type()
+
+proc HYPERLINK*(obj: pointer): PHyperlink = 
+  result = cast[PHyperlink](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_HYPERLINK()))
+
+proc HYPERLINK_CLASS*(klass: pointer): PHyperlinkClass = 
+  result = cast[PHyperlinkClass](G_TYPE_CHECK_CLASS_CAST(klass, TYPE_HYPERLINK()))
+
+proc IS_HYPERLINK*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_HYPERLINK())
+
+proc IS_HYPERLINK_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_HYPERLINK())
+
+proc HYPERLINK_GET_CLASS*(obj: pointer): PHyperlinkClass = 
+  result = cast[PHyperlinkClass](G_TYPE_INSTANCE_GET_CLASS(obj, TYPE_HYPERLINK()))
+
+proc TYPE_HYPERTEXT*(): GType = 
+  result = hypertext_get_type()
+
+proc IS_HYPERTEXT*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_HYPERTEXT())
+
+proc HYPERTEXT*(obj: pointer): PHypertext = 
+  result = cast[PHypertext](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_HYPERTEXT()))
+
+proc HYPERTEXT_GET_IFACE*(obj: pointer): PHypertextIface = 
+  result = cast[PHypertextIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, 
+      TYPE_HYPERTEXT()))
+
+proc TYPE_IMAGE*(): GType = 
+  result = image_get_type()
+
+proc IS_IMAGE*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_IMAGE())
+
+proc IMAGE*(obj: pointer): PImage = 
+  result = cast[PImage](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_IMAGE()))
+
+proc IMAGE_GET_IFACE*(obj: pointer): PImageIface = 
+  result = cast[PImageIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, TYPE_IMAGE()))
+
+proc TYPE_OBJECT_FACTORY*(): GType = 
+  result = object_factory_get_type()
+
+proc OBJECT_FACTORY*(obj: pointer): PObjectFactory = 
+  result = cast[PObjectFactory](G_TYPE_CHECK_INSTANCE_CAST(obj, 
+      TYPE_OBJECT_FACTORY()))
+
+proc OBJECT_FACTORY_CLASS*(klass: pointer): PObjectFactoryClass = 
+  result = cast[PObjectFactoryClass](G_TYPE_CHECK_CLASS_CAST(klass, 
+      TYPE_OBJECT_FACTORY()))
+
+proc IS_OBJECT_FACTORY*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_OBJECT_FACTORY())
+
+proc IS_OBJECT_FACTORY_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_OBJECT_FACTORY())
+
+proc OBJECT_FACTORY_GET_CLASS*(obj: pointer): PObjectFactoryClass = 
+  result = cast[PObjectFactoryClass](G_TYPE_INSTANCE_GET_CLASS(obj, 
+      TYPE_OBJECT_FACTORY()))
+
+proc TYPE_REGISTRY*(): GType = 
+  result = registry_get_type()
+
+proc REGISTRY*(obj: pointer): PRegistry = 
+  result = cast[PRegistry](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_REGISTRY()))
+
+proc REGISTRY_CLASS*(klass: pointer): PRegistryClass = 
+  result = cast[PRegistryClass](G_TYPE_CHECK_CLASS_CAST(klass, TYPE_REGISTRY()))
+
+proc IS_REGISTRY*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_REGISTRY())
+
+proc IS_REGISTRY_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_REGISTRY())
+
+proc REGISTRY_GET_CLASS*(obj: pointer): PRegistryClass = 
+  result = cast[PRegistryClass](G_TYPE_INSTANCE_GET_CLASS(obj, TYPE_REGISTRY()))
+
+proc TYPE_RELATION*(): GType = 
+  result = relation_get_type()
+
+proc RELATION*(obj: pointer): PRelation = 
+  result = cast[PRelation](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_RELATION()))
+
+proc RELATION_CLASS*(klass: pointer): PRelationClass = 
+  result = cast[PRelationClass](G_TYPE_CHECK_CLASS_CAST(klass, TYPE_RELATION()))
+
+proc IS_RELATION*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_RELATION())
+
+proc IS_RELATION_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_RELATION())
+
+proc RELATION_GET_CLASS*(obj: pointer): PRelationClass = 
+  result = cast[PRelationClass](G_TYPE_INSTANCE_GET_CLASS(obj, TYPE_RELATION()))
+
+proc TYPE_RELATION_SET*(): GType = 
+  result = relation_set_get_type()
+
+proc RELATION_SET*(obj: pointer): PRelationSet = 
+  result = cast[PRelationSet](G_TYPE_CHECK_INSTANCE_CAST(obj, 
+      TYPE_RELATION_SET()))
+
+proc RELATION_SET_CLASS*(klass: pointer): PRelationSetClass = 
+  result = cast[PRelationSetClass](G_TYPE_CHECK_CLASS_CAST(klass, 
+      TYPE_RELATION_SET()))
+
+proc IS_RELATION_SET*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_RELATION_SET())
+
+proc IS_RELATION_SET_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_RELATION_SET())
+
+proc RELATION_SET_GET_CLASS*(obj: pointer): PRelationSetClass = 
+  result = cast[PRelationSetClass](G_TYPE_INSTANCE_GET_CLASS(obj, 
+      TYPE_RELATION_SET()))
+
+proc TYPE_SELECTION*(): GType = 
+  result = selection_get_type()
+
+proc IS_SELECTION*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_SELECTION())
+
+proc SELECTION*(obj: pointer): PSelection = 
+  result = cast[PSelection](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_SELECTION()))
+
+proc SELECTION_GET_IFACE*(obj: pointer): PSelectionIface = 
+  result = cast[PSelectionIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, 
+      TYPE_SELECTION()))
+
+proc TYPE_STATE_SET*(): GType = 
+  result = state_set_get_type()
+
+proc STATE_SET*(obj: pointer): PStateSet = 
+  result = cast[PStateSet](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_STATE_SET()))
+
+proc STATE_SET_CLASS*(klass: pointer): PStateSetClass = 
+  result = cast[PStateSetClass](G_TYPE_CHECK_CLASS_CAST(klass, TYPE_STATE_SET()))
+
+proc IS_STATE_SET*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_STATE_SET())
+
+proc IS_STATE_SET_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_STATE_SET())
+
+proc STATE_SET_GET_CLASS*(obj: pointer): PStateSetClass = 
+  result = cast[PStateSetClass](G_TYPE_INSTANCE_GET_CLASS(obj, TYPE_STATE_SET()))
+
+proc TYPE_STREAMABLE_CONTENT*(): GType = 
+  result = streamable_content_get_type()
+
+proc IS_STREAMABLE_CONTENT*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_STREAMABLE_CONTENT())
+
+proc STREAMABLE_CONTENT*(obj: pointer): PStreamableContent = 
+  result = cast[PStreamableContent](G_TYPE_CHECK_INSTANCE_CAST(obj, 
+      TYPE_STREAMABLE_CONTENT()))
+
+proc STREAMABLE_CONTENT_GET_IFACE*(obj: pointer): PStreamableContentIface = 
+  result = cast[PStreamableContentIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, 
+      TYPE_STREAMABLE_CONTENT()))
+
+proc TYPE_TABLE*(): GType = 
+  result = table_get_type()
+
+proc IS_TABLE*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_TABLE())
+
+proc TABLE*(obj: pointer): PTable = 
+  result = cast[PTable](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_TABLE()))
+
+proc TABLE_GET_IFACE*(obj: pointer): PTableIface = 
+  result = cast[PTableIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, TYPE_TABLE()))
+
+proc TYPE_TEXT*(): GType = 
+  result = text_get_type()
+
+proc IS_TEXT*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_TEXT())
+
+proc TEXT*(obj: pointer): PText = 
+  result = cast[PText](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_TEXT()))
+
+proc TEXT_GET_IFACE*(obj: pointer): PTextIface = 
+  result = cast[PTextIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, TYPE_TEXT()))
+
+proc TYPE_UTIL*(): GType = 
+  result = util_get_type()
+
+proc IS_UTIL*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_UTIL())
+
+proc UTIL*(obj: pointer): PUtil = 
+  result = cast[PUtil](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_UTIL()))
+
+proc UTIL_CLASS*(klass: pointer): PUtilClass = 
+  result = cast[PUtilClass](G_TYPE_CHECK_CLASS_CAST(klass, TYPE_UTIL()))
+
+proc IS_UTIL_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_UTIL())
+
+proc UTIL_GET_CLASS*(obj: pointer): PUtilClass = 
+  result = cast[PUtilClass](G_TYPE_INSTANCE_GET_CLASS(obj, TYPE_UTIL()))
+
+proc TYPE_VALUE*(): GType = 
+  result = value_get_type()
+
+proc IS_VALUE*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_VALUE())
+
+proc VALUE*(obj: pointer): PValue = 
+  result = cast[PValue](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_VALUE()))
+
+proc VALUE_GET_IFACE*(obj: pointer): PValueIface = 
+  result = cast[PValueIface](G_TYPE_INSTANCE_GET_INTERFACE(obj, TYPE_VALUE()))
diff --git a/lib/wrappers/gtk/gdkglext.nim b/lib/wrappers/gtk/gdkglext.nim
new file mode 100755
index 000000000..b5844395b
--- /dev/null
+++ b/lib/wrappers/gtk/gdkglext.nim
@@ -0,0 +1,551 @@
+{.deadCodeElim: on.}
+import 
+  Glib2, gdk2
+
+when defined(WIN32): 
+  const 
+    GLExtLib = "libgdkglext-win32-1.0-0.dll"
+else: 
+  const 
+    GLExtLib = "libgdkglext-x11-1.0.so"
+type 
+  TGLConfigAttrib* = int32
+  TGLConfigCaveat* = int32
+  TGLVisualType* = int32
+  TGLTransparentType* = int32
+  TGLDrawableTypeMask* = int32
+  TGLRenderTypeMask* = int32
+  TGLBufferMask* = int32
+  TGLConfigError* = int32
+  TGLRenderType* = int32
+  TGLDrawableAttrib* = int32
+  TGLPbufferAttrib* = int32
+  TGLEventMask* = int32
+  TGLEventType* = int32
+  TGLDrawableType* = int32
+  TGLProc* = Pointer
+  PGLConfig* = ptr TGLConfig
+  PGLContext* = ptr TGLContext
+  PGLDrawable* = ptr TGLDrawable
+  PGLPixmap* = ptr TGLPixmap
+  PGLWindow* = ptr TGLWindow
+  TGLConfig* = object of TGObject
+    layer_plane*: gint
+    n_aux_buffers*: gint
+    n_sample_buffers*: gint
+    flag0*: int16
+
+  PGLConfigClass* = ptr TGLConfigClass
+  TGLConfigClass* = object of TGObjectClass
+  TGLContext* = object of TGObject
+  PGLContextClass* = ptr TGLContextClass
+  TGLContextClass* = object of TGObjectClass
+  TGLDrawable* = object of TGObject
+  PGLDrawableClass* = ptr TGLDrawableClass
+  TGLDrawableClass* = object of TGTypeInterface
+    create_new_context*: proc (gldrawable: PGLDrawable, share_list: PGLContext, 
+                               direct: gboolean, render_type: int32): PGLContext{.
+        cdecl.}
+    make_context_current*: proc (draw: PGLDrawable, a_read: PGLDrawable, 
+                                 glcontext: PGLContext): gboolean{.cdecl.}
+    is_double_buffered*: proc (gldrawable: PGLDrawable): gboolean{.cdecl.}
+    swap_buffers*: proc (gldrawable: PGLDrawable){.cdecl.}
+    wait_gl*: proc (gldrawable: PGLDrawable){.cdecl.}
+    wait_gdk*: proc (gldrawable: PGLDrawable){.cdecl.}
+    gl_begin*: proc (draw: PGLDrawable, a_read: PGLDrawable, 
+                     glcontext: PGLContext): gboolean{.cdecl.}
+    gl_end*: proc (gldrawable: PGLDrawable){.cdecl.}
+    get_gl_config*: proc (gldrawable: PGLDrawable): PGLConfig{.cdecl.}
+    get_size*: proc (gldrawable: PGLDrawable, width, height: PGInt){.cdecl.}
+
+  TGLPixmap* = object of TGObject
+    drawable*: PDrawable
+
+  PGLPixmapClass* = ptr TGLPixmapClass
+  TGLPixmapClass* = object of TGObjectClass
+  TGLWindow* = object of TGObject
+    drawable*: PDrawable
+
+  PGLWindowClass* = ptr TGLWindowClass
+  TGLWindowClass* = object of TGObjectClass
+
+const 
+  HEADER_GDKGLEXT_MAJOR_VERSION* = 1
+  HEADER_GDKGLEXT_MINOR_VERSION* = 0
+  HEADER_GDKGLEXT_MICRO_VERSION* = 6
+  HEADER_GDKGLEXT_INTERFACE_AGE* = 4
+  HEADER_GDKGLEXT_BINARY_AGE* = 6
+
+proc HEADER_GDKGLEXT_CHECK_VERSION*(major, minor, micro: guint): bool
+var 
+  glext_major_version*{.importc, dynlib: GLExtLib.}: guint
+  glext_minor_version*{.importc, dynlib: GLExtLib.}: guint
+  glext_micro_version*{.importc, dynlib: GLExtLib.}: guint
+  glext_interface_age*{.importc, dynlib: GLExtLib.}: guint
+  glext_binary_age*{.importc, dynlib: GLExtLib.}: guint
+
+const 
+  GL_SUCCESS* = 0
+  GL_ATTRIB_LIST_NONE* = 0
+  GL_USE_GL* = 1
+  GL_BUFFER_SIZE* = 2
+  GL_LEVEL* = 3
+  GL_RGBA* = 4
+  GL_DOUBLEBUFFER* = 5
+  GL_STEREO* = 6
+  GL_AUX_BUFFERS* = 7
+  GL_RED_SIZE* = 8
+  GL_GREEN_SIZE* = 9
+  GL_BLUE_SIZE* = 10
+  GL_ALPHA_SIZE* = 11
+  GL_DEPTH_SIZE* = 12
+  GL_STENCIL_SIZE* = 13
+  GL_ACCUM_RED_SIZE* = 14
+  GL_ACCUM_GREEN_SIZE* = 15
+  GL_ACCUM_BLUE_SIZE* = 16
+  GL_ACCUM_ALPHA_SIZE* = 17
+  GL_CONFIG_CAVEAT* = 0x00000020
+  GL_X_VISUAL_TYPE* = 0x00000022
+  GL_TRANSPARENT_TYPE* = 0x00000023
+  GL_TRANSPARENT_INDEX_VALUE* = 0x00000024
+  GL_TRANSPARENT_RED_VALUE* = 0x00000025
+  GL_TRANSPARENT_GREEN_VALUE* = 0x00000026
+  GL_TRANSPARENT_BLUE_VALUE* = 0x00000027
+  GL_TRANSPARENT_ALPHA_VALUE* = 0x00000028
+  GL_DRAWABLE_TYPE* = 0x00008010
+  GL_RENDER_TYPE* = 0x00008011
+  GL_X_RENDERABLE* = 0x00008012
+  GL_FBCONFIG_ID* = 0x00008013
+  GL_MAX_PBUFFER_WIDTH* = 0x00008016
+  GL_MAX_PBUFFER_HEIGHT* = 0x00008017
+  GL_MAX_PBUFFER_PIXELS* = 0x00008018
+  GL_VISUAL_ID* = 0x0000800B
+  GL_SCREEN* = 0x0000800C
+  GL_SAMPLE_BUFFERS* = 100000
+  GL_SAMPLES* = 100001
+  GL_DONT_CARE* = 0xFFFFFFFF
+  GL_NONE* = 0x00008000
+  GL_CONFIG_CAVEAT_DONT_CARE* = 0xFFFFFFFF
+  GL_CONFIG_CAVEAT_NONE* = 0x00008000
+  GL_SLOW_CONFIG* = 0x00008001
+  GL_NON_CONFORMANT_CONFIG* = 0x0000800D
+  GL_VISUAL_TYPE_DONT_CARE* = 0xFFFFFFFF
+  GL_TRUE_COLOR* = 0x00008002
+  GL_DIRECT_COLOR* = 0x00008003
+  GL_PSEUDO_COLOR* = 0x00008004
+  GL_STATIC_COLOR* = 0x00008005
+  GL_GRAY_SCALE* = 0x00008006
+  GL_STATIC_GRAY* = 0x00008007
+  GL_TRANSPARENT_NONE* = 0x00008000
+  GL_TRANSPARENT_RGB* = 0x00008008
+  GL_TRANSPARENT_INDEX* = 0x00008009
+  GL_WINDOW_BIT* = 1 shl 0
+  GL_PIXMAP_BIT* = 1 shl 1
+  GL_PBUFFER_BIT* = 1 shl 2
+  GL_RGBA_BIT* = 1 shl 0
+  GL_COLOR_INDEX_BIT* = 1 shl 1
+  GL_FRONT_LEFT_BUFFER_BIT* = 1 shl 0
+  GL_FRONT_RIGHT_BUFFER_BIT* = 1 shl 1
+  GL_BACK_LEFT_BUFFER_BIT* = 1 shl 2
+  GL_BACK_RIGHT_BUFFER_BIT* = 1 shl 3
+  GL_AUX_BUFFERS_BIT* = 1 shl 4
+  GL_DEPTH_BUFFER_BIT* = 1 shl 5
+  GL_STENCIL_BUFFER_BIT* = 1 shl 6
+  GL_ACCUM_BUFFER_BIT* = 1 shl 7
+  GL_BAD_SCREEN* = 1
+  GL_BAD_ATTRIBUTE* = 2
+  GL_NO_EXTENSION* = 3
+  GL_BAD_VISUAL* = 4
+  GL_BAD_CONTEXT* = 5
+  GL_BAD_VALUE* = 6
+  GL_BAD_ENUM* = 7
+  GL_RGBA_TYPE* = 0x00008014
+  GL_COLOR_INDEX_TYPE* = 0x00008015
+  GL_PRESERVED_CONTENTS* = 0x0000801B
+  GL_LARGEST_PBUFFER* = 0x0000801C
+  GL_WIDTH* = 0x0000801D
+  GL_HEIGHT* = 0x0000801E
+  GL_EVENT_MASK* = 0x0000801F
+  GL_PBUFFER_PRESERVED_CONTENTS* = 0x0000801B
+  GL_PBUFFER_LARGEST_PBUFFER* = 0x0000801C
+  GL_PBUFFER_HEIGHT* = 0x00008040
+  GL_PBUFFER_WIDTH* = 0x00008041
+  GL_PBUFFER_CLOBBER_MASK* = 1 shl 27
+  GL_DAMAGED* = 0x00008020
+  GL_SAVED* = 0x00008021
+  GL_WINDOW_VALUE* = 0x00008022
+  GL_PBUFFER* = 0x00008023
+
+proc gl_config_attrib_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_config_attrib_get_type".}
+proc TYPE_GL_CONFIG_ATTRIB*(): GType{.cdecl, dynlib: GLExtLib, 
+                                      importc: "gdk_gl_config_attrib_get_type".}
+proc gl_config_caveat_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_config_caveat_get_type".}
+proc TYPE_GL_CONFIG_CAVEAT*(): GType{.cdecl, dynlib: GLExtLib, 
+                                      importc: "gdk_gl_config_caveat_get_type".}
+proc gl_visual_type_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                        importc: "gdk_gl_visual_type_get_type".}
+proc TYPE_GL_VISUAL_TYPE*(): GType{.cdecl, dynlib: GLExtLib, 
+                                    importc: "gdk_gl_visual_type_get_type".}
+proc gl_transparent_type_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_transparent_type_get_type".}
+proc TYPE_GL_TRANSPARENT_TYPE*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_transparent_type_get_type".}
+proc gl_drawable_type_mask_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_drawable_type_mask_get_type".}
+proc TYPE_GL_DRAWABLE_TYPE_MASK*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_drawable_type_mask_get_type".}
+proc gl_render_type_mask_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_render_type_mask_get_type".}
+proc TYPE_GL_RENDER_TYPE_MASK*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_render_type_mask_get_type".}
+proc gl_buffer_mask_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                        importc: "gdk_gl_buffer_mask_get_type".}
+proc TYPE_GL_BUFFER_MASK*(): GType{.cdecl, dynlib: GLExtLib, 
+                                    importc: "gdk_gl_buffer_mask_get_type".}
+proc gl_config_error_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_config_error_get_type".}
+proc TYPE_GL_CONFIG_ERROR*(): GType{.cdecl, dynlib: GLExtLib, 
+                                     importc: "gdk_gl_config_error_get_type".}
+proc gl_render_type_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                        importc: "gdk_gl_render_type_get_type".}
+proc TYPE_GL_RENDER_TYPE*(): GType{.cdecl, dynlib: GLExtLib, 
+                                    importc: "gdk_gl_render_type_get_type".}
+proc gl_drawable_attrib_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_drawable_attrib_get_type".}
+proc TYPE_GL_DRAWABLE_ATTRIB*(): GType{.cdecl, dynlib: GLExtLib, importc: "gdk_gl_drawable_attrib_get_type".}
+proc gl_pbuffer_attrib_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_pbuffer_attrib_get_type".}
+proc TYPE_GL_PBUFFER_ATTRIB*(): GType{.cdecl, dynlib: GLExtLib, importc: "gdk_gl_pbuffer_attrib_get_type".}
+proc gl_event_mask_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                       importc: "gdk_gl_event_mask_get_type".}
+proc TYPE_GL_EVENT_MASK*(): GType{.cdecl, dynlib: GLExtLib, 
+                                   importc: "gdk_gl_event_mask_get_type".}
+proc gl_event_type_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                       importc: "gdk_gl_event_type_get_type".}
+proc TYPE_GL_EVENT_TYPE*(): GType{.cdecl, dynlib: GLExtLib, 
+                                   importc: "gdk_gl_event_type_get_type".}
+proc gl_drawable_type_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_drawable_type_get_type".}
+proc TYPE_GL_DRAWABLE_TYPE*(): GType{.cdecl, dynlib: GLExtLib, 
+                                      importc: "gdk_gl_drawable_type_get_type".}
+proc gl_config_mode_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                        importc: "gdk_gl_config_mode_get_type".}
+proc TYPE_GL_CONFIG_MODE*(): GType{.cdecl, dynlib: GLExtLib, 
+                                    importc: "gdk_gl_config_mode_get_type".}
+proc gl_parse_args*(argc: var int32, argv: ptr cstringArray): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_parse_args".}
+proc gl_init_check*(argc: var int32, argv: ptr cstringArray): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_init_check".}
+proc gl_init*(argc: var int32, argv: ptr cstringArray){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_init".}
+proc gl_query_gl_extension*(extension: cstring): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_query_gl_extension".}
+proc gl_get_proc_address*(proc_name: cstring): TGLProc{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_get_proc_address".}
+const 
+  bm_TGdkGLConfig_is_rgba* = 1 shl 0
+  bp_TGdkGLConfig_is_rgba* = 0
+  bm_TGdkGLConfig_is_double_buffered* = 1 shl 1
+  bp_TGdkGLConfig_is_double_buffered* = 1
+  bm_TGdkGLConfig_as_single_mode* = 1 shl 2
+  bp_TGdkGLConfig_as_single_mode* = 2
+  bm_TGdkGLConfig_is_stereo* = 1 shl 3
+  bp_TGdkGLConfig_is_stereo* = 3
+  bm_TGdkGLConfig_has_alpha* = 1 shl 4
+  bp_TGdkGLConfig_has_alpha* = 4
+  bm_TGdkGLConfig_has_depth_buffer* = 1 shl 5
+  bp_TGdkGLConfig_has_depth_buffer* = 5
+  bm_TGdkGLConfig_has_stencil_buffer* = 1 shl 6
+  bp_TGdkGLConfig_has_stencil_buffer* = 6
+  bm_TGdkGLConfig_has_accum_buffer* = 1 shl 7
+  bp_TGdkGLConfig_has_accum_buffer* = 7
+
+const 
+  GL_MODE_RGB* = 0
+  GL_MODE_RGBA* = 0
+  GL_MODE_INDEX* = 1 shl 0
+  GL_MODE_SINGLE* = 0
+  GL_MODE_DOUBLE* = 1 shl 1
+  GL_MODE_STEREO* = 1 shl 2
+  GL_MODE_ALPHA* = 1 shl 3
+  GL_MODE_DEPTH* = 1 shl 4
+  GL_MODE_STENCIL* = 1 shl 5
+  GL_MODE_ACCUM* = 1 shl 6
+  GL_MODE_MULTISAMPLE* = 1 shl 7
+
+type 
+  TGLConfigMode* = int32
+  PGLConfigMode* = ptr TGLConfigMode
+
+proc TYPE_GL_CONFIG*(): GType
+proc GL_CONFIG*(anObject: Pointer): PGLConfig
+proc GL_CONFIG_CLASS*(klass: Pointer): PGLConfigClass
+proc IS_GL_CONFIG*(anObject: Pointer): bool
+proc IS_GL_CONFIG_CLASS*(klass: Pointer): bool
+proc GL_CONFIG_GET_CLASS*(obj: Pointer): PGLConfigClass
+proc gl_config_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                   importc: "gdk_gl_config_get_type".}
+proc get_screen*(glconfig: PGLConfig): PScreen{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_get_screen".}
+proc get_attrib*(glconfig: PGLConfig, attribute: int, value: var cint): gboolean{.
+    cdecl, dynlib: GLExtLib, importc: "gdk_gl_config_get_attrib".}
+proc get_colormap*(glconfig: PGLConfig): PColormap{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_get_colormap".}
+proc get_visual*(glconfig: PGLConfig): PVisual{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_get_visual".}
+proc get_depth*(glconfig: PGLConfig): gint{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_config_get_depth".}
+proc get_layer_plane*(glconfig: PGLConfig): gint{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_get_layer_plane".}
+proc get_n_aux_buffers*(glconfig: PGLConfig): gint{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_get_n_aux_buffers".}
+proc get_n_sample_buffers*(glconfig: PGLConfig): gint{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_get_n_sample_buffers".}
+proc is_rgba*(glconfig: PGLConfig): gboolean{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_config_is_rgba".}
+proc is_double_buffered*(glconfig: PGLConfig): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_is_double_buffered".}
+proc is_stereo*(glconfig: PGLConfig): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_is_stereo".}
+proc has_alpha*(glconfig: PGLConfig): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_has_alpha".}
+proc has_depth_buffer*(glconfig: PGLConfig): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_has_depth_buffer".}
+proc has_stencil_buffer*(glconfig: PGLConfig): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_has_stencil_buffer".}
+proc has_accum_buffer*(glconfig: PGLConfig): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_config_has_accum_buffer".}
+proc TYPE_GL_CONTEXT*(): GType
+proc GL_CONTEXT*(anObject: Pointer): PGLContext
+proc GL_CONTEXT_CLASS*(klass: Pointer): PGLContextClass
+proc IS_GL_CONTEXT*(anObject: Pointer): bool
+proc IS_GL_CONTEXT_CLASS*(klass: Pointer): bool
+proc GL_CONTEXT_GET_CLASS*(obj: Pointer): PGLContextClass
+proc gl_context_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                    importc: "gdk_gl_context_get_type".}
+proc context_new*(gldrawable: PGLDrawable, share_list: PGLContext, 
+                     direct: gboolean, render_type: int32): PGLContext{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_context_new".}
+proc destroy*(glcontext: PGLContext){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_context_destroy".}
+proc copy*(glcontext: PGLContext, src: PGLContext, mask: int32): gboolean{.
+    cdecl, dynlib: GLExtLib, importc: "gdk_gl_context_copy".}
+proc get_gl_drawable*(glcontext: PGLContext): PGLDrawable{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_context_get_gl_drawable".}
+proc get_gl_config*(glcontext: PGLContext): PGLConfig{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_context_get_gl_config".}
+proc get_share_list*(glcontext: PGLContext): PGLContext{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_context_get_share_list".}
+proc is_direct*(glcontext: PGLContext): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_context_is_direct".}
+proc get_render_type*(glcontext: PGLContext): int32{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_context_get_render_type".}
+proc gl_context_get_current*(): PGLContext{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_context_get_current".}
+proc TYPE_GL_DRAWABLE*(): GType
+proc GL_DRAWABLE*(inst: Pointer): PGLDrawable
+proc GL_DRAWABLE_CLASS*(vtable: Pointer): PGLDrawableClass
+proc IS_GL_DRAWABLE*(inst: Pointer): bool
+proc IS_GL_DRAWABLE_CLASS*(vtable: Pointer): bool
+proc GL_DRAWABLE_GET_CLASS*(inst: Pointer): PGLDrawableClass
+proc gl_drawable_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                     importc: "gdk_gl_drawable_get_type".}
+proc make_current*(gldrawable: PGLDrawable, glcontext: PGLContext): gboolean{.
+    cdecl, dynlib: GLExtLib, importc: "gdk_gl_drawable_make_current".}
+proc is_double_buffered*(gldrawable: PGLDrawable): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_drawable_is_double_buffered".}
+proc swap_buffers*(gldrawable: PGLDrawable){.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_drawable_swap_buffers".}
+proc wait_gl*(gldrawable: PGLDrawable){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_drawable_wait_gl".}
+proc wait_gdk*(gldrawable: PGLDrawable){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_drawable_wait_gdk".}
+proc gl_begin*(gldrawable: PGLDrawable, glcontext: PGLContext): gboolean{.
+    cdecl, dynlib: GLExtLib, importc: "gdk_gl_drawable_gl_begin".}
+proc gl_end*(gldrawable: PGLDrawable){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_drawable_gl_end".}
+proc get_gl_config*(gldrawable: PGLDrawable): PGLConfig{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_drawable_get_gl_config".}
+proc get_size*(gldrawable: PGLDrawable, width, height: PGInt){.
+    cdecl, dynlib: GLExtLib, importc: "gdk_gl_drawable_get_size".}
+proc gl_drawable_get_current*(): PGLDrawable{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_drawable_get_current".}
+proc TYPE_GL_PIXMAP*(): GType
+proc GL_PIXMAP*(anObject: Pointer): PGLPixmap
+proc GL_PIXMAP_CLASS*(klass: Pointer): PGLPixmapClass
+proc IS_GL_PIXMAP*(anObject: Pointer): bool
+proc IS_GL_PIXMAP_CLASS*(klass: Pointer): bool
+proc GL_PIXMAP_GET_CLASS*(obj: Pointer): PGLPixmapClass
+proc gl_pixmap_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                   importc: "gdk_gl_pixmap_get_type".}
+proc pixmap_new*(glconfig: PGLConfig, pixmap: PPixmap, attrib_list: ptr int32): PGLPixmap{.
+    cdecl, dynlib: GLExtLib, importc: "gdk_gl_pixmap_new".}
+proc destroy*(glpixmap: PGLPixmap){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_pixmap_destroy".}
+proc get_pixmap*(glpixmap: PGLPixmap): PPixmap{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_pixmap_get_pixmap".}
+proc set_gl_capability*(pixmap: PPixmap, glconfig: PGLConfig, 
+                               attrib_list: ptr int32): PGLPixmap{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_pixmap_set_gl_capability".}
+proc unset_gl_capability*(pixmap: PPixmap){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_pixmap_unset_gl_capability".}
+proc is_gl_capable*(pixmap: PPixmap): gboolean{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_pixmap_is_gl_capable".}
+proc get_gl_pixmap*(pixmap: PPixmap): PGLPixmap{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_pixmap_get_gl_pixmap".}
+proc get_gl_drawable*(pixmap: PPixmap): PGLDrawable
+proc TYPE_GL_WINDOW*(): GType
+proc GL_WINDOW*(anObject: Pointer): PGLWindow
+proc GL_WINDOW_CLASS*(klass: Pointer): PGLWindowClass
+proc IS_GL_WINDOW*(anObject: Pointer): bool
+proc IS_GL_WINDOW_CLASS*(klass: Pointer): bool
+proc GL_WINDOW_GET_CLASS*(obj: Pointer): PGLWindowClass
+proc gl_window_get_type*(): GType{.cdecl, dynlib: GLExtLib, 
+                                   importc: "gdk_gl_window_get_type".}
+proc window_new*(glconfig: PGLConfig, window: PWindow, attrib_list: ptr int32): PGLWindow{.
+    cdecl, dynlib: GLExtLib, importc: "gdk_gl_window_new".}
+proc destroy*(glwindow: PGLWindow){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_window_destroy".}
+proc get_window*(glwindow: PGLWindow): PWindow{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_window_get_window".}
+proc set_gl_capability*(window: PWindow, glconfig: PGLConfig, 
+                               attrib_list: ptr int32): PGLWindow{.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_window_set_gl_capability".}
+proc unset_gl_capability*(window: PWindow){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_window_unset_gl_capability".}
+proc is_gl_capable*(window: PWindow): gboolean{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_window_is_gl_capable".}
+proc get_gl_window*(window: PWindow): PGLWindow{.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_window_get_gl_window".}
+proc get_gl_drawable*(window: PWindow): PGLDrawable
+proc gl_draw_cube*(solid: gboolean, size: float64){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_draw_cube".}
+proc gl_draw_sphere*(solid: gboolean, radius: float64, slices: int32, 
+                     stacks: int32){.cdecl, dynlib: GLExtLib, 
+                                     importc: "gdk_gl_draw_sphere".}
+proc gl_draw_cone*(solid: gboolean, base: float64, height: float64, 
+                   slices: int32, stacks: int32){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_draw_cone".}
+proc gl_draw_torus*(solid: gboolean, inner_radius: float64, 
+                    outer_radius: float64, nsides: int32, rings: int32){.cdecl, 
+    dynlib: GLExtLib, importc: "gdk_gl_draw_torus".}
+proc gl_draw_tetrahedron*(solid: gboolean){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_draw_tetrahedron".}
+proc gl_draw_octahedron*(solid: gboolean){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_draw_octahedron".}
+proc gl_draw_dodecahedron*(solid: gboolean){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_draw_dodecahedron".}
+proc gl_draw_icosahedron*(solid: gboolean){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_draw_icosahedron".}
+proc gl_draw_teapot*(solid: gboolean, scale: float64){.cdecl, dynlib: GLExtLib, 
+    importc: "gdk_gl_draw_teapot".}
+proc HEADER_GDKGLEXT_CHECK_VERSION*(major, minor, micro: guint): bool = 
+  result = (HEADER_GDKGLEXT_MAJOR_VERSION > major) or
+      ((HEADER_GDKGLEXT_MAJOR_VERSION == major) and
+      (HEADER_GDKGLEXT_MINOR_VERSION > minor)) or
+      ((HEADER_GDKGLEXT_MAJOR_VERSION == major) and
+      (HEADER_GDKGLEXT_MINOR_VERSION == minor) and
+      (HEADER_GDKGLEXT_MICRO_VERSION >= micro))
+
+proc TYPE_GL_CONFIG*(): GType = 
+  result = gl_config_get_type()
+
+proc GL_CONFIG*(anObject: Pointer): PGLConfig = 
+  result = cast[PGLConfig](G_TYPE_CHECK_INSTANCE_CAST(anObject, TYPE_GL_CONFIG()))
+
+proc GL_CONFIG_CLASS*(klass: Pointer): PGLConfigClass = 
+  result = cast[PGLConfigClass](G_TYPE_CHECK_CLASS_CAST(klass, TYPE_GL_CONFIG()))
+
+proc IS_GL_CONFIG*(anObject: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, TYPE_GL_CONFIG())
+
+proc IS_GL_CONFIG_CLASS*(klass: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_GL_CONFIG())
+
+proc GL_CONFIG_GET_CLASS*(obj: Pointer): PGLConfigClass = 
+  result = cast[PGLConfigClass](G_TYPE_INSTANCE_GET_CLASS(obj, TYPE_GL_CONFIG()))
+
+proc TYPE_GL_CONTEXT*(): GType = 
+  result = gl_context_get_type()
+
+proc GL_CONTEXT*(anObject: Pointer): PGLContext = 
+  result = cast[PGLContext](G_TYPE_CHECK_INSTANCE_CAST(anObject, 
+      TYPE_GL_CONTEXT()))
+
+proc GL_CONTEXT_CLASS*(klass: Pointer): PGLContextClass = 
+  result = cast[PGLContextClass](G_TYPE_CHECK_CLASS_CAST(klass, 
+      TYPE_GL_CONTEXT()))
+
+proc IS_GL_CONTEXT*(anObject: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, TYPE_GL_CONTEXT())
+
+proc IS_GL_CONTEXT_CLASS*(klass: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_GL_CONTEXT())
+
+proc GL_CONTEXT_GET_CLASS*(obj: Pointer): PGLContextClass = 
+  result = cast[PGLContextClass](G_TYPE_INSTANCE_GET_CLASS(obj, 
+      TYPE_GL_CONTEXT()))
+
+proc TYPE_GL_DRAWABLE*(): GType = 
+  result = gl_drawable_get_type()
+
+proc GL_DRAWABLE*(inst: Pointer): PGLDrawable = 
+  result = cast[PGLDrawable](G_TYPE_CHECK_INSTANCE_CAST(inst, TYPE_GL_DRAWABLE()))
+
+proc GL_DRAWABLE_CLASS*(vtable: Pointer): PGLDrawableClass = 
+  result = cast[PGLDrawableClass](G_TYPE_CHECK_CLASS_CAST(vtable, 
+      TYPE_GL_DRAWABLE()))
+
+proc IS_GL_DRAWABLE*(inst: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(inst, TYPE_GL_DRAWABLE())
+
+proc IS_GL_DRAWABLE_CLASS*(vtable: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(vtable, TYPE_GL_DRAWABLE())
+
+proc GL_DRAWABLE_GET_CLASS*(inst: Pointer): PGLDrawableClass = 
+  result = cast[PGLDrawableClass](G_TYPE_INSTANCE_GET_INTERFACE(inst, 
+      TYPE_GL_DRAWABLE()))
+
+proc TYPE_GL_PIXMAP*(): GType = 
+  result = gl_pixmap_get_type()
+
+proc GL_PIXMAP*(anObject: Pointer): PGLPixmap = 
+  result = cast[PGLPixmap](G_TYPE_CHECK_INSTANCE_CAST(anObject, TYPE_GL_PIXMAP()))
+
+proc GL_PIXMAP_CLASS*(klass: Pointer): PGLPixmapClass = 
+  result = cast[PGLPixmapClass](G_TYPE_CHECK_CLASS_CAST(klass, TYPE_GL_PIXMAP()))
+
+proc IS_GL_PIXMAP*(anObject: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, TYPE_GL_PIXMAP())
+
+proc IS_GL_PIXMAP_CLASS*(klass: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_GL_PIXMAP())
+
+proc GL_PIXMAP_GET_CLASS*(obj: Pointer): PGLPixmapClass = 
+  result = cast[PGLPixmapClass](G_TYPE_INSTANCE_GET_CLASS(obj, TYPE_GL_PIXMAP()))
+
+proc get_gl_drawable*(pixmap: PPixmap): PGLDrawable = 
+  result = GL_DRAWABLE(get_gl_pixmap(pixmap))
+
+proc TYPE_GL_WINDOW*(): GType = 
+  result = gl_window_get_type()
+
+proc GL_WINDOW*(anObject: Pointer): PGLWindow = 
+  result = cast[PGLWindow](G_TYPE_CHECK_INSTANCE_CAST(anObject, TYPE_GL_WINDOW()))
+
+proc GL_WINDOW_CLASS*(klass: Pointer): PGLWindowClass = 
+  result = cast[PGLWindowClass](G_TYPE_CHECK_CLASS_CAST(klass, TYPE_GL_WINDOW()))
+
+proc IS_GL_WINDOW*(anObject: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, TYPE_GL_WINDOW())
+
+proc IS_GL_WINDOW_CLASS*(klass: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, TYPE_GL_WINDOW())
+
+proc GL_WINDOW_GET_CLASS*(obj: Pointer): PGLWindowClass = 
+  result = cast[PGLWindowClass](G_TYPE_INSTANCE_GET_CLASS(obj, TYPE_GL_WINDOW()))
+
+proc get_gl_drawable*(window: PWindow): PGLDrawable = 
+  result = GL_DRAWABLE(get_gl_window(window))
diff --git a/lib/wrappers/gtk/gtkglext.nim b/lib/wrappers/gtk/gtkglext.nim
new file mode 100755
index 000000000..b6c832a65
--- /dev/null
+++ b/lib/wrappers/gtk/gtkglext.nim
@@ -0,0 +1,46 @@
+{.deadCodeElim: on.}
+import 
+  Glib2, Gdk2, gtk2, GdkGLExt
+
+const 
+  GLExtLib* = if defined(WIN32): "libgtkglext-win32-1.0-0.dll" else: "libgtkglext-x11-1.0.so"
+
+const 
+  HEADER_GTKGLEXT_MAJOR_VERSION* = 1
+  HEADER_GTKGLEXT_MINOR_VERSION* = 0
+  HEADER_GTKGLEXT_MICRO_VERSION* = 6
+  HEADER_GTKGLEXT_INTERFACE_AGE* = 4
+  HEADER_GTKGLEXT_BINARY_AGE* = 6
+
+proc gl_parse_args*(argc: ptr int32, argv: PPPChar): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gtk_gl_parse_args".}
+proc gl_init_check*(argc: ptr int32, argv: PPPChar): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gtk_gl_init_check".}
+proc gl_init*(argc: ptr int32, argv: PPPChar){.cdecl, dynlib: GLExtLib, 
+    importc: "gtk_gl_init".}
+proc set_gl_capability*(widget: PWidget, glconfig: PGLConfig, 
+                               share_list: PGLContext, direct: gboolean, 
+                               render_type: int): gboolean{.cdecl, 
+    dynlib: GLExtLib, importc: "gtk_widget_set_gl_capability".}
+proc is_gl_capable*(widget: PWidget): gboolean{.cdecl, dynlib: GLExtLib, 
+    importc: "gtk_widget_is_gl_capable".}
+proc get_gl_config*(widget: PWidget): PGLConfig{.cdecl, 
+    dynlib: GLExtLib, importc: "gtk_widget_get_gl_config".}
+proc create_gl_context*(widget: PWidget, share_list: PGLContext, 
+                               direct: gboolean, render_type: int): PGLContext{.
+    cdecl, dynlib: GLExtLib, importc: "gtk_widget_create_gl_context".}
+proc get_gl_context*(widget: PWidget): PGLContext{.cdecl, 
+    dynlib: GLExtLib, importc: "gtk_widget_get_gl_context".}
+proc get_gl_window*(widget: PWidget): PGLWindow{.cdecl, 
+    dynlib: GLExtLib, importc: "gtk_widget_get_gl_window".}
+
+proc HEADER_GTKGLEXT_CHECK_VERSION*(major, minor, micro: guint): bool = 
+  result = (HEADER_GTKGLEXT_MAJOR_VERSION > major) or
+      ((HEADER_GTKGLEXT_MAJOR_VERSION == major) and
+      (HEADER_GTKGLEXT_MINOR_VERSION > minor)) or
+      ((HEADER_GTKGLEXT_MAJOR_VERSION == major) and
+      (HEADER_GTKGLEXT_MINOR_VERSION == minor) and
+      (HEADER_GTKGLEXT_MICRO_VERSION >= micro))
+
+proc get_gl_drawable*(widget: PWidget): PGLDrawable = 
+  result = GL_DRAWABLE(get_gl_window(widget))
diff --git a/lib/wrappers/gtk/gtkhtml.nim b/lib/wrappers/gtk/gtkhtml.nim
new file mode 100755
index 000000000..291913b8e
--- /dev/null
+++ b/lib/wrappers/gtk/gtkhtml.nim
@@ -0,0 +1,521 @@
+{.deadCodeElim: on.}
+import 
+  gtk2, glib2, atk, pango, gdk2pixbuf, gdk2
+
+when defined(windows): 
+  {.define: WINDOWING_WIN32.}
+  const 
+    htmllib = "libgtkhtml-win32-2.0-0.dll"
+else: 
+  const 
+    htmllib = "libgtkhtml-2.so"
+const 
+  DOM_UNSPECIFIED_EVENT_TYPE_ERR* = 0
+  DOM_INDEX_SIZE_ERR* = 1
+  DOM_DOMSTRING_SIZE_ERR* = 2
+  DOM_HIERARCHY_REQUEST_ERR* = 3
+  DOM_WRONG_DOCUMENT_ERR* = 4
+  DOM_INVALID_CHARACTER_ERR* = 5
+  DOM_NO_DATA_ALLOWED_ERR* = 6
+  DOM_NO_MODIFICATION_ALLOWED_ERR* = 7
+  DOM_NOT_FOUND_ERR* = 8
+  DOM_NOT_SUPPORTED_ERR* = 9
+  DOM_INUSE_ATTRIBUTE_ERR* = 10
+  DOM_INVALID_STATE_ERR* = 11
+  DOM_SYNTAX_ERR* = 12
+  DOM_INVALID_MODIFICATION_ERR* = 13
+  DOM_NAMESPACE_ERR* = 14
+  DOM_INVALID_ACCESS_ERR* = 15
+  DOM_NO_EXCEPTION* = 255
+  DOM_ELEMENT_NODE* = 1
+  DOM_ATTRIBUTE_NODE* = 2
+  DOM_TEXT_NODE* = 3
+  DOM_CDATA_SECTION_NODE* = 4
+  DOM_ENTITY_REFERENCE_NODE* = 5
+  DOM_ENTITY_NODE* = 6
+  DOM_PROCESSING_INSTRUCTION_NODE* = 7
+  DOM_COMMENT_NODE* = 8
+  DOM_DOCUMENT_NODE* = 9
+  DOM_DOCUMENT_TYPE_NODE* = 10
+  DOM_DOCUMENT_FRAGMENT_NODE* = 11
+  DOM_NOTATION_NODE* = 12
+  bm_HtmlFontSpecification_weight* = 0x0000000F
+  bp_HtmlFontSpecification_weight* = 0
+  bm_HtmlFontSpecification_style* = 0x00000030
+  bp_HtmlFontSpecification_style* = 4
+  bm_HtmlFontSpecification_variant* = 0x000000C0
+  bp_HtmlFontSpecification_variant* = 6
+  bm_HtmlFontSpecification_stretch* = 0x00000F00
+  bp_HtmlFontSpecification_stretch* = 8
+  bm_HtmlFontSpecification_decoration* = 0x00007000
+  bp_HtmlFontSpecification_decoration* = 12
+
+type 
+  TDomString* = gchar
+  PDomString* = cstring
+  TDomBoolean* = gboolean
+  TDomException* = gushort
+  TDomTimeStamp* = guint64
+  PDomNode* = ptr TDomNode
+  TDomNode* = object of TGObject
+    xmlnode*: pointer
+    style*: pointer
+
+  PDomException* = ptr TDomException
+
+  PDomNodeClass* = ptr TDomNodeClass
+  TDomNodeClass* = object of TGObjectClass
+    `get_nodeName`*: proc (node: PDomNode): PDomString{.cdecl.}
+    `get_nodeValue`*: proc (node: PDomNode, exc: PDomException): PDomString{.
+        cdecl.}
+    `set_nodeValue`*: proc (node: PDomNode, value: PDomString, 
+                            exc: PDomException): PDomString{.cdecl.}
+
+  PDomDocument* = ptr TDomDocument
+  TDomDocument*{.final, pure.} = object 
+    parent*: PDomNode
+    iterators*: PGSList
+
+  PDomDocumentClass* = ptr TDomDocumentClass
+  TDomDocumentClass*{.final, pure.} = object 
+    parent_class*: PDomNodeClass
+
+  PHtmlFocusIterator* = ptr THtmlFocusIterator
+  THtmlFocusIterator* = object of TGObject
+    document*: PDomDocument
+    current_node*: PDomNode
+
+  PHtmlFocusIteratorClass* = ptr THtmlFocusIteratorClass
+  THtmlFocusIteratorClass* = object of TGObjectClass
+  THtmlParserType* = enum 
+    HTML_PARSER_TYPE_HTML, HTML_PARSER_TYPE_XML
+  PHtmlParser* = ptr THtmlParser
+  THtmlParser* = object of TGObject
+    parser_type*: THtmlParserType
+    document*: PHtmlDocument
+    stream*: PHtmlStream
+    xmlctxt*: pointer
+    res*: int32
+    chars*: array[0..9, char]
+    blocking*: gboolean
+    blocking_node*: PDomNode
+
+  PHtmlParserClass* = ptr THtmlParserClass
+  THtmlParserClass* = object of gtk2.TObjectClass
+    done_parsing*: proc (parser: PHtmlParser){.cdecl.}
+    new_node*: proc (parser: PHtmlParser, node: PDomNode)
+    parsed_document_node*: proc (parser: PHtmlParser, document: PDomDocument)
+
+  PHtmlStream* = ptr THtmlStream
+  THtmlStreamCloseFunc* = proc (stream: PHtmlStream, user_data: gpointer){.cdecl.}
+  THtmlStreamWriteFunc* = proc (stream: PHtmlStream, buffer: cstring, 
+                                size: guint, user_data: gpointer){.cdecl.}
+  THtmlStreamCancelFunc* = proc (stream: PHtmlStream, user_data: gpointer, 
+                                 cancel_data: gpointer){.cdecl.}
+  THtmlStream* = object of TGObject
+    write_func*: THtmlStreamWriteFunc
+    close_func*: THtmlStreamCloseFunc
+    cancel_func*: THtmlStreamCancelFunc
+    user_data*: gpointer
+    cancel_data*: gpointer
+    written*: gint
+    mime_type*: cstring
+
+  PHtmlStreamClass* = ptr THtmlStreamClass
+  THtmlStreamClass* = object of TGObjectClass
+  THtmlStreamBufferCloseFunc* = proc (str: cstring, len: gint, 
+                                      user_data: gpointer){.cdecl.}
+  PHtmlContext* = ptr THtmlContext
+  THtmlContext* = object of TGObject
+    documents*: PGSList
+    standard_font*: PHtmlFontSpecification
+    fixed_font*: PHtmlFontSpecification
+    debug_painting*: gboolean
+    
+  PHtmlFontSpecification* = ptr THtmlFontSpecification
+  THtmlFontSpecification {.final, pure.} = object
+
+  PHtmlContextClass* = ptr THtmlContextClass
+  THtmlContextClass* = object of TGObjectClass
+  THtmlDocumentState* = enum 
+    HTML_DOCUMENT_STATE_DONE, HTML_DOCUMENT_STATE_PARSING
+  PHtmlDocument* = ptr THtmlDocument
+  THtmlDocument* = object of TGObject
+    stylesheets*: PGSList
+    current_stream*: PHtmlStream
+    state*: THtmlDocumentState
+
+  PHtmlDocumentClass* = ptr THtmlDocumentClass
+  THtmlDocumentClass* = object of TGObjectClass
+    request_url*: proc (document: PHtmlDocument, url: cstring, 
+                        stream: PHtmlStream){.cdecl.}
+    link_clicked*: proc (document: PHtmlDocument, url: cstring){.cdecl.}
+    set_base*: proc (document: PHtmlDocument, url: cstring){.cdecl.}
+    title_changed*: proc (document: PHtmlDocument, new_title: cstring){.cdecl.}
+    submit*: proc (document: PHtmlDocument, `method`: cstring, url: cstring, 
+                   encoding: cstring){.cdecl.}
+
+  PHtmlView* = ptr THtmlView
+  THtmlView* = object of gtk2.TLayout
+    document*: PHtmlDocument
+    node_table*: PGHashTable
+    relayout_idle_id*: guint
+    relayout_timeout_id*: guint
+    mouse_down_x*: gint
+    mouse_down_y*: gint
+    mouse_detail*: gint
+    sel_start_ypos*: gint
+    sel_start_index*: gint
+    sel_end_ypos*: gint
+    sel_end_index*: gint
+    sel_flag*: gboolean
+    sel_backwards*: gboolean
+    sel_start_found*: gboolean
+    sel_list*: PGSList
+    jump_to_anchor*: cstring
+    magnification*: gdouble
+    magnification_modified*: gboolean
+    on_url*: gboolean
+
+  PHtmlViewClass* = ptr THtmlViewClass
+  THtmlViewClass* = object of gtk2.TLayoutClass
+    move_cursor*: proc (html_view: PHtmlView, step: TMovementStep, count: gint, 
+                        extend_selection: gboolean){.cdecl.}
+    on_url*: proc (html_view: PHtmlView, url: cstring)
+    activate*: proc (html_view: PHtmlView)
+    move_focus_out*: proc (html_view: PHtmlView, direction: TDirectionType)
+    
+  PDomNodeList* = ptr TDomNodeList
+  TDomNodeList {.pure, final.} = object
+  
+  PDomNamedNodeMap* = ptr TDomNamedNodeMap
+  TDomNamedNodeMap {.pure, final.} = object
+  
+  PDomDocumentType* = ptr TDomDocumentType
+  TDomDocumentType {.pure, final.} = object
+  
+  PDomElement* = ptr TDomElement
+  TDomElement = object of TDomNode
+  
+  PDomText* = ptr TDomText
+  TDomText = object of TDomNode
+
+  PDomComment* = ptr TDomComment
+  TDomComment = object of TDomNode
+ 
+  THtmlBox {.pure, final.} = object
+  PHtmlBox* = ptr THtmlBox
+
+
+proc DOM_TYPE_NODE*(): GType
+proc DOM_NODE*(theobject: pointer): PDomNode
+proc DOM_NODE_CLASS*(klass: pointer): PDomNodeClass
+proc DOM_IS_NODE*(theobject: pointer): bool
+proc DOM_IS_NODE_CLASS*(klass: pointer): bool
+proc DOM_NODE_GET_CLASS*(obj: pointer): int32
+proc dom_node_get_type*(): GType{.cdecl, dynlib: htmllib, 
+                                  importc: "dom_node_get_type".}
+proc dom_Node_mkref*(node: pointer): PDomNode{.cdecl, dynlib: htmllib, 
+    importc: "dom_Node_mkref".}
+proc get_childNodes*(node: PDomNode): PDomNodeList{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_childNodes".}
+proc removeChild*(node: PDomNode, oldChild: PDomNode, 
+                           exc: PDomException): PDomNode{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node_removeChild".}
+proc get_nodeValue*(node: PDomNode, exc: PDomException): PDomString{.
+    cdecl, dynlib: htmllib, importc: "dom_Node__get_nodeValue".}
+proc get_firstChild*(node: PDomNode): PDomNode{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_firstChild".}
+proc get_nodeName*(node: PDomNode): PDomString{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_nodeName".}
+proc get_attributes*(node: PDomNode): PDomNamedNodeMap{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_attributes".}
+proc get_doctype*(doc: PDomDocument): PDomDocumentType{.cdecl, 
+    dynlib: htmllib, importc: "dom_Document__get_doctype".}
+proc hasChildNodes*(node: PDomNode): bool{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node_hasChildNodes".}
+proc get_parentNode*(node: PDomNode): PDomNode{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_parentNode".}
+proc get_nextSibling*(node: PDomNode): PDomNode{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_nextSibling".}
+proc get_nodeType*(node: PDomNode): gushort{.cdecl, dynlib: htmllib, 
+    importc: "dom_Node__get_nodeType".}
+
+proc cloneNode*(node: PDomNode, deep: bool): PDomNode{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node_cloneNode".}
+proc appendChild*(node: PDomNode, newChild: PDomNode, 
+                           exc: PDomException): PDomNode{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node_appendChild".}
+proc get_localName*(node: PDomNode): PDomString{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_localName".}
+proc get_namespaceURI*(node: PDomNode): PDomString{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_namespaceURI".}
+proc get_previousSibling*(node: PDomNode): PDomNode{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_previousSibling".}
+proc get_lastChild*(node: PDomNode): PDomNode{.cdecl, dynlib: htmllib, 
+    importc: "dom_Node__get_lastChild".}
+proc set_nodeValue*(node: PDomNode, value: PDomString, 
+                              exc: PDomException){.cdecl, dynlib: htmllib, 
+    importc: "dom_Node__set_nodeValue".}
+proc get_ownerDocument*(node: PDomNode): PDomDocument{.cdecl, 
+    dynlib: htmllib, importc: "dom_Node__get_ownerDocument".}
+proc hasAttributes*(node: PDomNode): gboolean{.cdecl, dynlib: htmllib, 
+    importc: "dom_Node_hasAttributes".}
+proc DOM_TYPE_DOCUMENT*(): GType
+proc DOM_DOCUMENT*(theobject: pointer): PDomDocument
+proc DOM_DOCUMENT_CLASS*(klass: pointer): PDomDocumentClass
+proc DOM_IS_DOCUMENT*(theobject: pointer): bool
+proc DOM_IS_DOCUMENT_CLASS*(klass: pointer): bool
+proc DOM_DOCUMENT_GET_CLASS*(obj: pointer): PDomDocumentClass
+proc dom_document_get_type*(): GType
+proc get_documentElement*(doc: PDomDocument): PDomElement
+proc createElement*(doc: PDomDocument, tagName: PDomString): PDomElement
+proc createTextNode*(doc: PDomDocument, data: PDomString): PDomText
+proc createComment*(doc: PDomDocument, data: PDomString): PDomComment
+proc importNode*(doc: PDomDocument, importedNode: PDomNode, 
+                              deep: bool, exc: PDomException): PDomNode
+proc HTML_TYPE_FOCUS_ITERATOR*(): GType
+proc HTML_FOCUS_ITERATOR*(theobject: pointer): PHtmlFocusIterator
+proc HTML_FOCUS_ITERATOR_CLASS*(klass: pointer): PHtmlFocusIteratorClass
+proc HTML_IS_FOCUS_ITERATOR*(theobject: pointer): bool
+proc HTML_IS_FOCUS_ITERATOR_CLASS*(klass: pointer): bool
+proc HTML_FOCUS_ITERATOR_GET_CLASS*(obj: pointer): PHtmlFocusIteratorClass
+proc html_focus_iterator_next_element*(document: PDomDocument, 
+                                       element: PDomElement): PDomElement{.
+    cdecl, dynlib: htmllib, importc: "html_focus_iterator_next_element".}
+proc html_focus_iterator_prev_element*(document: PDomDocument, 
+                                       element: PDomElement): PDomElement{.
+    cdecl, dynlib: htmllib, importc: "html_focus_iterator_prev_element".}
+proc HTML_PARSER_TYPE*(): GType
+proc HTML_PARSER*(obj: pointer): PHtmlParser
+proc HTML_PARSER_CLASS*(klass: pointer): PHtmlParserClass
+proc HTML_IS_PARSER*(obj: pointer): bool
+proc html_parser_get_type*(): GType
+proc parser_new*(document: PHtmlDocument, parser_type: THtmlParserType): PHtmlParser
+proc HTML_TYPE_STREAM*(): GType
+proc HTML_STREAM*(obj: pointer): PHtmlStream
+proc HTML_STREAM_CLASS*(klass: pointer): PHtmlStreamClass
+proc HTML_IS_STREAM*(obj: pointer): bool
+proc HTML_IS_STREAM_CLASS*(klass: pointer): bool
+proc HTML_STREAM_GET_CLASS*(obj: pointer): PHtmlStreamClass
+proc html_stream_get_type*(): GType{.cdecl, dynlib: htmllib, 
+                                     importc: "html_stream_get_type".}
+proc html_stream_new*(write_func: THtmlStreamWriteFunc, 
+                      close_func: THtmlStreamCloseFunc, user_data: gpointer): PHtmlStream{.
+    cdecl, dynlib: htmllib, importc: "html_stream_new".}
+proc write*(stream: PHtmlStream, buffer: cstring, size: guint){.
+    cdecl, dynlib: htmllib, importc: "html_stream_write".}
+proc close*(stream: PHtmlStream){.cdecl, dynlib: htmllib, 
+    importc: "html_stream_close".}
+proc destroy*(stream: PHtmlStream){.cdecl, dynlib: htmllib, 
+    importc: "html_stream_destroy".}
+proc get_written*(stream: PHtmlStream): gint{.cdecl, 
+    dynlib: htmllib, importc: "html_stream_get_written".}
+proc cancel*(stream: PHtmlStream){.cdecl, dynlib: htmllib, 
+    importc: "html_stream_cancel".}
+proc set_cancel_func*(stream: PHtmlStream, 
+                                  abort_func: THtmlStreamCancelFunc, 
+                                  cancel_data: gpointer){.cdecl, 
+    dynlib: htmllib, importc: "html_stream_set_cancel_func".}
+proc get_mime_type*(stream: PHtmlStream): cstring{.cdecl, 
+    dynlib: htmllib, importc: "html_stream_get_mime_type".}
+proc set_mime_type*(stream: PHtmlStream, mime_type: cstring){.cdecl, 
+    dynlib: htmllib, importc: "html_stream_set_mime_type".}
+proc html_stream_buffer_new*(close_func: THtmlStreamBufferCloseFunc, 
+                             user_data: gpointer): PHtmlStream{.cdecl, 
+    dynlib: htmllib, importc: "html_stream_buffer_new".}
+proc event_mouse_move*(view: PHtmlView, event: Gdk2.PEventMotion){.cdecl, 
+    dynlib: htmllib, importc: "html_event_mouse_move".}
+proc event_button_press*(view: PHtmlView, button: Gdk2.PEventButton){.cdecl, 
+    dynlib: htmllib, importc: "html_event_button_press".}
+proc event_button_release*(view: PHtmlView, event: Gdk2.PEventButton){.cdecl, 
+    dynlib: htmllib, importc: "html_event_button_release".}
+proc event_activate*(view: PHtmlView){.cdecl, dynlib: htmllib, 
+    importc: "html_event_activate".}
+proc event_key_press*(view: PHtmlView, event: Gdk2.PEventKey): gboolean{.
+    cdecl, dynlib: htmllib, importc: "html_event_key_press".}
+proc event_find_root_box*(self: PHtmlBox, x: gint, y: gint): PHtmlBox{.
+    cdecl, dynlib: htmllib, importc: "html_event_find_root_box".}
+proc selection_start*(view: PHtmlView, event: Gdk2.PEventButton){.cdecl, 
+    dynlib: htmllib, importc: "html_selection_start".}
+proc selection_end*(view: PHtmlView, event: Gdk2.PEventButton){.cdecl, 
+    dynlib: htmllib, importc: "html_selection_end".}
+proc selection_update*(view: PHtmlView, event: Gdk2.PEventMotion){.cdecl, 
+    dynlib: htmllib, importc: "html_selection_update".}
+proc selection_clear*(view: PHtmlView){.cdecl, dynlib: htmllib, 
+    importc: "html_selection_clear".}
+proc selection_set*(view: PHtmlView, start: PDomNode, offset: int32, 
+                         len: int32){.cdecl, dynlib: htmllib, 
+                                      importc: "html_selection_set".}
+proc HTML_CONTEXT_TYPE*(): GType
+proc HTML_CONTEXT*(obj: pointer): PHtmlContext
+proc HTML_CONTEXT_CLASS*(klass: pointer): PHtmlContextClass
+proc HTML_IS_CONTEXT*(obj: pointer): bool
+proc HTML_IS_CONTEXT_CLASS*(klass: pointer): bool
+proc html_context_get_type*(): GType
+proc html_context_get*(): PHtmlContext
+proc HTML_TYPE_DOCUMENT*(): GType
+proc HTML_DOCUMENT*(obj: pointer): PHtmlDocument
+proc HTML_DOCUMENT_CLASS*(klass: pointer): PHtmlDocumentClass
+proc HTML_IS_DOCUMENT*(obj: pointer): bool
+proc html_document_get_type*(): GType{.cdecl, dynlib: htmllib, 
+                                       importc: "html_document_get_type".}
+proc html_document_new*(): PHtmlDocument{.cdecl, dynlib: htmllib, 
+    importc: "html_document_new".}
+proc open_stream*(document: PHtmlDocument, mime_type: cstring): gboolean{.
+    cdecl, dynlib: htmllib, importc: "html_document_open_stream".}
+proc write_stream*(document: PHtmlDocument, buffer: cstring, 
+                                 len: gint){.cdecl, dynlib: htmllib, 
+    importc: "html_document_write_stream".}
+proc close_stream*(document: PHtmlDocument){.cdecl, 
+    dynlib: htmllib, importc: "html_document_close_stream".}
+proc clear*(document: PHtmlDocument){.cdecl, dynlib: htmllib, 
+    importc: "html_document_clear".}
+proc HTML_TYPE_VIEW*(): GType
+proc HTML_VIEW*(obj: pointer): PHtmlView
+proc HTML_VIEW_CLASS*(klass: pointer): PHtmlViewClass
+proc HTML_IS_VIEW*(obj: pointer): bool
+proc html_view_get_type*(): GType{.cdecl, dynlib: htmllib, 
+                                   importc: "html_view_get_type".}
+proc html_view_new*(): PWidget{.cdecl, dynlib: htmllib, importc: "html_view_new".}
+proc set_document*(view: PHtmlView, document: PHtmlDocument){.cdecl, 
+    dynlib: htmllib, importc: "html_view_set_document".}
+proc jump_to_anchor*(view: PHtmlView, anchor: cstring){.cdecl, 
+    dynlib: htmllib, importc: "html_view_jump_to_anchor".}
+proc get_magnification*(view: PHtmlView): gdouble{.cdecl, 
+    dynlib: htmllib, importc: "html_view_get_magnification".}
+proc set_magnification*(view: PHtmlView, magnification: gdouble){.
+    cdecl, dynlib: htmllib, importc: "html_view_set_magnification".}
+proc zoom_in*(view: PHtmlView){.cdecl, dynlib: htmllib, 
+    importc: "html_view_zoom_in".}
+proc zoom_out*(view: PHtmlView){.cdecl, dynlib: htmllib, 
+    importc: "html_view_zoom_out".}
+proc zoom_reset*(view: PHtmlView){.cdecl, dynlib: htmllib, 
+    importc: "html_view_zoom_reset".}
+
+proc DOM_TYPE_NODE*(): GType = 
+  result = dom_node_get_type()
+
+proc DOM_NODE*(theobject: pointer): PDomNode = 
+  result = G_TYPE_CHECK_INSTANCE_CAST(theobject, DOM_TYPE_NODE())
+
+proc DOM_NODE_CLASS*(klass: pointer): PDomNodeClass = 
+  result = G_TYPE_CHECK_CLASS_CAST(klass, DOM_TYPE_NODE(), TDomNodeClass)
+
+proc DOM_IS_NODE*(theobject: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(theobject, DOM_TYPE_NODE())
+
+proc DOM_IS_NODE_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, DOM_TYPE_NODE())
+
+proc DOM_NODE_GET_CLASS*(obj: pointer): PDomNodeClass = 
+  result = G_TYPE_INSTANCE_GET_CLASS(obj, DOM_TYPE_NODE(), TDomNodeClass)
+
+proc DOM_TYPE_DOCUMENT*(): GType = 
+  result = dom_document_get_type()
+
+proc DOM_DOCUMENT*(theobject: pointer): PDomDocument = 
+  result = G_TYPE_CHECK_INSTANCE_CAST(theobject, DOM_TYPE_DOCUMENT(), 
+                                      TDomDocument)
+
+proc DOM_DOCUMENT_CLASS*(klass: pointer): PDomDocumentClass = 
+  result = G_TYPE_CHECK_CLASS_CAST(klass, DOM_TYPE_DOCUMENT(), TDomDocumentClass)
+
+proc DOM_IS_DOCUMENT*(theobject: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(theobject, DOM_TYPE_DOCUMENT())
+
+proc DOM_IS_DOCUMENT_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, DOM_TYPE_DOCUMENT())
+
+proc DOM_DOCUMENT_GET_CLASS*(obj: pointer): PDomDocumentClass = 
+  result = G_TYPE_INSTANCE_GET_CLASS(obj, DOM_TYPE_DOCUMENT(), TDomDocumentClass)
+
+proc HTML_TYPE_FOCUS_ITERATOR*(): GType = 
+  result = html_focus_iterator_get_type()
+
+proc HTML_FOCUS_ITERATOR*(theobject: pointer): PHtmlFocusIterator = 
+  result = G_TYPE_CHECK_INSTANCE_CAST(theobject, HTML_TYPE_FOCUS_ITERATOR(), 
+                                      HtmlFocusIterator)
+
+proc HTML_FOCUS_ITERATOR_CLASS*(klass: pointer): PHtmlFocusIteratorClass = 
+  result = G_TYPE_CHECK_CLASS_CAST(klass, HTML_TYPE_FOCUS_ITERATOR(), 
+                                   HtmlFocusIteratorClass)
+
+proc HTML_IS_FOCUS_ITERATOR*(theobject: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(theobject, HTML_TYPE_FOCUS_ITERATOR())
+
+proc HTML_IS_FOCUS_ITERATOR_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, HTML_TYPE_FOCUS_ITERATOR())
+
+proc HTML_FOCUS_ITERATOR_GET_CLASS*(obj: pointer): PHtmlFocusIteratorClass = 
+  result = G_TYPE_INSTANCE_GET_CLASS(obj, HTML_TYPE_FOCUS_ITERATOR(), 
+                                     HtmlFocusIteratorClass)
+
+proc HTML_PARSER_TYPE*(): GType = 
+  result = html_parser_get_type()
+
+proc HTML_PARSER*(obj: pointer): PHtmlParser = 
+  result = CHECK_CAST(obj, HTML_PARSER_TYPE(), THtmlParser)
+
+proc HTML_PARSER_CLASS*(klass: pointer): PHtmlParserClass = 
+  result = CHECK_CLASS_CAST(klass, HTML_PARSER_TYPE(), THtmlParserClass)
+
+proc HTML_IS_PARSER*(obj: pointer): bool = 
+  result = CHECK_TYPE(obj, HTML_PARSER_TYPE())
+
+proc HTML_TYPE_STREAM*(): GType = 
+  result = html_stream_get_type()
+
+proc HTML_STREAM*(obj: pointer): PHtmlStream = 
+  result = PHtmlStream(G_TYPE_CHECK_INSTANCE_CAST(obj, HTML_TYPE_STREAM()))
+
+proc HTML_STREAM_CLASS*(klass: pointer): PHtmlStreamClass = 
+  result = G_TYPE_CHECK_CLASS_CAST(klass, HTML_TYPE_STREAM())
+
+proc HTML_IS_STREAM*(obj: pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, HTML_TYPE_STREAM())
+
+proc HTML_IS_STREAM_CLASS*(klass: pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, HTML_TYPE_STREAM())
+
+proc HTML_STREAM_GET_CLASS*(obj: pointer): PHtmlStreamClass = 
+  result = PHtmlStreamClass(G_TYPE_INSTANCE_GET_CLASS(obj, HTML_TYPE_STREAM()))
+
+proc HTML_CONTEXT_TYPE*(): GType = 
+  result = html_context_get_type()
+
+proc HTML_CONTEXT*(obj: pointer): PHtmlContext = 
+  result = CHECK_CAST(obj, HTML_CONTEXT_TYPE(), THtmlContext)
+
+proc HTML_CONTEXT_CLASS*(klass: pointer): PHtmlContextClass = 
+  result = CHECK_CLASS_CAST(klass, HTML_CONTEXT_TYPE(), THtmlContextClass)
+
+proc HTML_IS_CONTEXT*(obj: pointer): bool = 
+  result = CHECK_TYPE(obj, HTML_CONTEXT_TYPE())
+
+proc HTML_IS_CONTEXT_CLASS*(klass: pointer): bool = 
+  result = CHECK_CLASS_TYPE(klass, HTML_CONTEXT_TYPE())
+
+proc HTML_TYPE_DOCUMENT*(): GType = 
+  result = html_document_get_type()
+
+proc HTML_DOCUMENT*(obj: pointer): PHtmlDocument = 
+  result = PHtmlDocument(CHECK_CAST(obj, HTML_TYPE_DOCUMENT()))
+
+proc HTML_DOCUMENT_CLASS*(klass: pointer): PHtmlDocumentClass = 
+  result = CHECK_CLASS_CAST(klass, HTML_TYPE_DOCUMENT())
+
+proc HTML_IS_DOCUMENT*(obj: pointer): bool = 
+  result = CHECK_TYPE(obj, HTML_TYPE_DOCUMENT())
+
+proc HTML_TYPE_VIEW*(): GType = 
+  result = html_view_get_type()
+
+proc HTML_VIEW*(obj: pointer): PHtmlView = 
+  result = PHtmlView(CHECK_CAST(obj, HTML_TYPE_VIEW()))
+
+proc HTML_VIEW_CLASS*(klass: pointer): PHtmlViewClass = 
+  result = PHtmlViewClass(CHECK_CLASS_CAST(klass, HTML_TYPE_VIEW()))
+
+proc HTML_IS_VIEW*(obj: pointer): bool = 
+  result = CHECK_TYPE(obj, HTML_TYPE_VIEW())
diff --git a/lib/wrappers/gtk/pangoutils.nim b/lib/wrappers/gtk/pangoutils.nim
new file mode 100755
index 000000000..240273b11
--- /dev/null
+++ b/lib/wrappers/gtk/pangoutils.nim
@@ -0,0 +1,42 @@
+{.deadCodeElim: on.}
+import 
+  glib2, pango
+
+proc split_file_list*(str: cstring): PPchar{.cdecl, dynlib: lib, 
+    importc: "pango_split_file_list".}
+proc trim_string*(str: cstring): cstring{.cdecl, dynlib: lib, 
+    importc: "pango_trim_string".}
+proc read_line*(stream: TFile, str: PGString): gint{.cdecl, dynlib: lib, 
+    importc: "pango_read_line".}
+proc skip_space*(pos: PPchar): gboolean{.cdecl, dynlib: lib, 
+    importc: "pango_skip_space".}
+proc scan_word*(pos: PPchar, OutStr: PGString): gboolean{.cdecl, dynlib: lib, 
+    importc: "pango_scan_word".}
+proc scan_string*(pos: PPchar, OutStr: PGString): gboolean{.cdecl, dynlib: lib, 
+    importc: "pango_scan_string".}
+proc scan_int*(pos: PPchar, OutInt: ptr int32): gboolean{.cdecl, dynlib: lib, 
+    importc: "pango_scan_int".}
+proc config_key_get*(key: cstring): cstring{.cdecl, dynlib: lib, 
+    importc: "pango_config_key_get".}
+proc lookup_aliases*(fontname: cstring, families: PPPchar, n_families: ptr int32){.
+    cdecl, dynlib: lib, importc: "pango_lookup_aliases".}
+proc parse_style*(str: cstring, style: PStyle, warn: gboolean): gboolean{.cdecl, 
+    dynlib: lib, importc: "pango_parse_style".}
+proc parse_variant*(str: cstring, variant: PVariant, warn: gboolean): gboolean{.
+    cdecl, dynlib: lib, importc: "pango_parse_variant".}
+proc parse_weight*(str: cstring, weight: PWeight, warn: gboolean): gboolean{.
+    cdecl, dynlib: lib, importc: "pango_parse_weight".}
+proc parse_stretch*(str: cstring, stretch: PStretch, warn: gboolean): gboolean{.
+    cdecl, dynlib: lib, importc: "pango_parse_stretch".}
+proc get_sysconf_subdirectory*(): cstring{.cdecl, dynlib: lib, 
+    importc: "pango_get_sysconf_subdirectory".}
+proc get_lib_subdirectory*(): cstring{.cdecl, dynlib: lib, 
+                                      importc: "pango_get_lib_subdirectory".}
+proc log2vis_get_embedding_levels*(str: Pgunichar, len: int32, 
+                                   pbase_dir: PDirection, 
+                                   embedding_level_list: Pguint8): gboolean{.
+    cdecl, dynlib: lib, importc: "pango_log2vis_get_embedding_levels".}
+proc get_mirror_char*(ch: gunichar, mirrored_ch: Pgunichar): gboolean{.cdecl, 
+    dynlib: lib, importc: "pango_get_mirror_char".}
+proc get_sample_string*(language: PLanguage): cstring{.cdecl, 
+    dynlib: lib, importc: "pango_language_get_sample_string".}