added old wrappers

lib/oldwrappers/cairo/cairo.nim

@@ -0,0 +1,698 @@
+
+#* cairo - a vector graphics library with display and print output
+# *
+# * Copyright © 2002 University of Southern California
+# * Copyright © 2005 Red Hat, Inc.
+# *
+# * This library is free software; you can redistribute it and/or
+# * modify it either under the terms of the GNU Lesser General Public
+# * License version 2.1 as published by the Free Software Foundation
+# * (the "LGPL") or, at your option, under the terms of the Mozilla
+# * Public License Version 1.1 (the "MPL"). If you do not alter this
+# * notice, a recipient may use your version of this file under either
+# * the MPL or the LGPL.
+# *
+# * You should have received a copy of the LGPL along with this library
+# * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+# * You should have received a copy of the MPL along with this library
+# * in the file COPYING-MPL-1.1
+# *
+# * The contents of this file are subject to the Mozilla Public License
+# * Version 1.1 (the "License"); you may not use this file except in
+# * compliance with the License. You may obtain a copy of the License at
+# * http://www.mozilla.org/MPL/
+# *
+# * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+# * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+# * the specific language governing rights and limitations.
+# *
+# * The Original Code is the cairo graphics library.
+# *
+# * The Initial Developer of the Original Code is University of Southern
+# * California.
+# *
+# * Contributor(s):
+# *	Carl D. Worth <cworth@cworth.org>
+# #*
+# *  This FreePascal binding generated August 26, 2005
+# *  by Jeffrey Pohlmeyer <yetanothergeek@yahoo.com>
+#
+
+#
+#  - Updated to cairo version 1.4
+#  - Grouped OS specific fuctions in separated units
+#  - Organized the functions by group and ordered exactly as the c header
+#  - Cleared parameter list syntax according to pascal standard
+#
+#  By Luiz Américo Pereira Câmara
+#  October 2007
+#
+
+when defined(windows):
+  const
+    LIB_CAIRO* = "cairo.dll"
+else:
+  const
+    LIB_CAIRO* = "libcairo.so"
+
+type
+  PByte = cstring
+  TCairoStatus* = enum
+    CAIRO_STATUS_SUCCESS = 0, CAIRO_STATUS_NO_MEMORY,
+    CAIRO_STATUS_INVALID_RESTORE, CAIRO_STATUS_INVALID_POP_GROUP,
+    CAIRO_STATUS_NO_CURRENT_POINT, CAIRO_STATUS_INVALID_MATRIX,
+    CAIRO_STATUS_INVALID_STATUS, CAIRO_STATUS_NULL_POINTER,
+    CAIRO_STATUS_INVALID_STRING, CAIRO_STATUS_INVALID_PATH_DATA,
+    CAIRO_STATUS_READ_ERROR, CAIRO_STATUS_WRITE_ERROR,
+    CAIRO_STATUS_SURFACE_FINISHED, CAIRO_STATUS_SURFACE_TYPE_MISMATCH,
+    CAIRO_STATUS_PATTERN_TYPE_MISMATCH, CAIRO_STATUS_INVALID_CONTENT,
+    CAIRO_STATUS_INVALID_FORMAT, CAIRO_STATUS_INVALID_VISUAL,
+    CAIRO_STATUS_FILE_NOT_FOUND, CAIRO_STATUS_INVALID_DASH
+  TCairoOperator* = enum
+    CAIRO_OPERATOR_CLEAR, CAIRO_OPERATOR_SOURCE, CAIRO_OPERATOR_OVER,
+    CAIRO_OPERATOR_IN, CAIRO_OPERATOR_OUT, CAIRO_OPERATOR_ATOP,
+    CAIRO_OPERATOR_DEST, CAIRO_OPERATOR_DEST_OVER, CAIRO_OPERATOR_DEST_IN,
+    CAIRO_OPERATOR_DEST_OUT, CAIRO_OPERATOR_DEST_ATOP, CAIRO_OPERATOR_XOR,
+    CAIRO_OPERATOR_ADD, CAIRO_OPERATOR_SATURATE
+  TCairoAntialias* = enum
+    CAIRO_ANTIALIAS_DEFAULT, CAIRO_ANTIALIAS_NONE, CAIRO_ANTIALIAS_GRAY,
+    CAIRO_ANTIALIAS_SUBPIXEL
+  TCairoFillRule* = enum
+    CAIRO_FILL_RULE_WINDING, CAIRO_FILL_RULE_EVEN_ODD
+  TCairoLineCap* = enum
+    CAIRO_LINE_CAP_BUTT, CAIRO_LINE_CAP_ROUND, CAIRO_LINE_CAP_SQUARE
+  TCairoLineJoin* = enum
+    CAIRO_LINE_JOIN_MITER, CAIRO_LINE_JOIN_ROUND, CAIRO_LINE_JOIN_BEVEL
+  TCairoFontSlant* = enum
+    CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_SLANT_ITALIC, CAIRO_FONT_SLANT_OBLIQUE
+  TCairoFontWeight* = enum
+    CAIRO_FONT_WEIGHT_NORMAL, CAIRO_FONT_WEIGHT_BOLD
+  TCairoSubpixelOrder* = enum
+    CAIRO_SUBPIXEL_ORDER_DEFAULT, CAIRO_SUBPIXEL_ORDER_RGB,
+    CAIRO_SUBPIXEL_ORDER_BGR, CAIRO_SUBPIXEL_ORDER_VRGB,
+    CAIRO_SUBPIXEL_ORDER_VBGR
+  TCairoHintStyle* = enum
+    CAIRO_HINT_STYLE_DEFAULT, CAIRO_HINT_STYLE_NONE, CAIRO_HINT_STYLE_SLIGHT,
+    CAIRO_HINT_STYLE_MEDIUM, CAIRO_HINT_STYLE_FULL
+  TCairoHintMetrics* = enum
+    CAIRO_HINT_METRICS_DEFAULT, CAIRO_HINT_METRICS_OFF, CAIRO_HINT_METRICS_ON
+  TCairoPathDataType* = enum
+    CAIRO_PATH_MOVE_TO, CAIRO_PATH_LINE_TO, CAIRO_PATH_CURVE_TO,
+    CAIRO_PATH_CLOSE_PATH
+  TCairoContent* = enum
+    CAIRO_CONTENT_COLOR = 0x00001000, CAIRO_CONTENT_ALPHA = 0x00002000,
+    CAIRO_CONTENT_COLOR_ALPHA = 0x00003000
+  TCairoFormat* = enum
+    CAIRO_FORMAT_ARGB32, CAIRO_FORMAT_RGB24, CAIRO_FORMAT_A8, CAIRO_FORMAT_A1
+  TCairoExtend* = enum
+    CAIRO_EXTEND_NONE, CAIRO_EXTEND_REPEAT, CAIRO_EXTEND_REFLECT,
+    CAIRO_EXTEND_PAD
+  TCairoFilter* = enum
+    CAIRO_FILTER_FAST, CAIRO_FILTER_GOOD, CAIRO_FILTER_BEST,
+    CAIRO_FILTER_NEAREST, CAIRO_FILTER_BILINEAR, CAIRO_FILTER_GAUSSIAN
+  TCairoFontType* = enum
+    CAIRO_FONT_TYPE_TOY, CAIRO_FONT_TYPE_FT, CAIRO_FONT_TYPE_WIN32,
+    CAIRO_FONT_TYPE_ATSUI
+  TCairoPatternType* = enum
+    CAIRO_PATTERN_TYPE_SOLID, CAIRO_PATTERN_TYPE_SURFACE,
+    CAIRO_PATTERN_TYPE_LINEAR, CAIRO_PATTERN_TYPE_RADIAL
+  TCairoSurfaceType* = enum
+    CAIRO_SURFACE_TYPE_IMAGE, CAIRO_SURFACE_TYPE_PDF, CAIRO_SURFACE_TYPE_PS,
+    CAIRO_SURFACE_TYPE_XLIB, CAIRO_SURFACE_TYPE_XCB, CAIRO_SURFACE_TYPE_GLITZ,
+    CAIRO_SURFACE_TYPE_QUARTZ, CAIRO_SURFACE_TYPE_WIN32,
+    CAIRO_SURFACE_TYPE_BEOS, CAIRO_SURFACE_TYPE_DIRECTFB,
+    CAIRO_SURFACE_TYPE_SVG, CAIRO_SURFACE_TYPE_OS2
+  TCairoSvgVersion* = enum
+    CAIRO_SVG_VERSION_1_1, CAIRO_SVG_VERSION_1_2
+  PCairoSurface* = ptr TCairoSurface
+  PPCairoSurface* = ptr PCairoSurface
+  PCairo* = ptr TCairo
+  PCairoPattern* = ptr TCairoPattern
+  PCairoFontOptions* = ptr TCairoFontOptions
+  PCairoFontFace* = ptr TCairoFontFace
+  PCairoScaledFont* = ptr TCairoScaledFont
+  PCairoBool* = ptr TCairoBool
+  TCairoBool* = int32
+  PCairoMatrix* = ptr TCairoMatrix
+  PCairoUserDataKey* = ptr TCairoUserDataKey
+  PCairoGlyph* = ptr TCairoGlyph
+  PCairoTextExtents* = ptr TCairoTextExtents
+  PCairoFontExtents* = ptr TCairoFontExtents
+  PCairoPathDataType* = ptr TCairoPathDataType
+  PCairoPathData* = ptr TCairoPathData
+  PCairoPath* = ptr TCairoPath
+  PCairoRectangle* = ptr TCairoRectangle
+  PCairoRectangleList* = ptr TCairoRectangleList
+  TCairoDestroyFunc* = proc (data: Pointer){.cdecl.}
+  TCairoWriteFunc* = proc (closure: Pointer, data: PByte, len: int32): TCairoStatus{.
+      cdecl.}
+  TCairoReadFunc* = proc (closure: Pointer, data: PByte, len: int32): TCairoStatus{.
+      cdecl.}
+  TCairo* {.final.} = object           #OPAQUE
+  TCairoSurface* {.final.} = object   #OPAQUE
+  TCairoPattern* {.final.} = object   #OPAQUE
+  TCairoScaledFont* {.final.} = object #OPAQUE
+  TCairoFontFace* {.final.} = object #OPAQUE
+  TCairoFontOptions* {.final.} = object #OPAQUE
+  TCairoMatrix* {.final.} = object
+    xx: float64
+    yx: float64
+    xy: float64
+    yy: float64
+    x0: float64
+    y0: float64
+
+  TCairoUserDataKey* {.final.} = object
+    unused: int32
+
+  TCairoGlyph* {.final.} = object
+    index: int32
+    x: float64
+    y: float64
+
+  TCairoTextExtents* {.final.} = object
+    x_bearing: float64
+    y_bearing: float64
+    width: float64
+    height: float64
+    x_advance: float64
+    y_advance: float64
+
+  TCairoFontExtents* {.final.} = object
+    ascent: float64
+    descent: float64
+    height: float64
+    max_x_advance: float64
+    max_y_advance: float64
+
+  TCairoPathData* {.final.} = object #* _type : TCairoPathDataType;
+                                     #       length : LongInt;
+                                     #    end
+    x: float64
+    y: float64
+
+  TCairoPath* {.final.} = object
+    status: TCairoStatus
+    data: PCairoPathData
+    num_data: int32
+
+  TCairoRectangle* {.final.} = object
+    x, y, width, height: float64
+
+  TCairoRectangleList* {.final.} = object
+    status: TCairoStatus
+    rectangles: PCairoRectangle
+    num_rectangles: int32
+
+
+proc cairo_version*(): int32{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_version_string*(): cstring{.cdecl, importc, dynlib: LIB_CAIRO.}
+  #Helper function to retrieve decoded version
+proc cairo_version*(major, minor, micro: var int32)
+  #* Functions for manipulating state objects
+proc cairo_create*(target: PCairoSurface): PCairo{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_reference*(cr: PCairo): PCairo{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_destroy*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_reference_count*(cr: PCairo): int32{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_user_data*(cr: PCairo, key: PCairoUserDataKey): pointer{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_set_user_data*(cr: PCairo, key: PCairoUserDataKey,
+                          user_data: Pointer, destroy: TCairoDestroyFunc): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_save*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_restore*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_push_group*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_push_group_with_content*(cr: PCairo, content: TCairoContent){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pop_group*(cr: PCairo): PCairoPattern{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pop_group_to_source*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Modify state
+proc cairo_set_operator*(cr: PCairo, op: TCairoOperator){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_source*(cr: PCairo, source: PCairoPattern){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_source_rgb*(cr: PCairo, red, green, blue: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_source_rgba*(cr: PCairo, red, green, blue, alpha: float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_set_source_surface*(cr: PCairo, surface: PCairoSurface,
+                               x, y: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_set_tolerance*(cr: PCairo, tolerance: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_antialias*(cr: PCairo, antialias: TCairoAntialias){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_fill_rule*(cr: PCairo, fill_rule: TCairoFillRule){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_line_width*(cr: PCairo, width: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_line_cap*(cr: PCairo, line_cap: TCairoLineCap){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_line_join*(cr: PCairo, line_join: TCairoLineJoin){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_dash*(cr: PCairo, dashes: openarray[float64],
+                     offset: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_set_miter_limit*(cr: PCairo, limit: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_translate*(cr: PCairo, tx, ty: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scale*(cr: PCairo, sx, sy: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_rotate*(cr: PCairo, angle: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_transform*(cr: PCairo, matrix: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_matrix*(cr: PCairo, matrix: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_identity_matrix*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_user_to_device*(cr: PCairo, x, y: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_user_to_device_distance*(cr: PCairo, dx, dy: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_device_to_user*(cr: PCairo, x, y: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_device_to_user_distance*(cr: PCairo, dx, dy: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+  #* Path creation functions
+proc cairo_new_path*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_move_to*(cr: PCairo, x, y: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_new_sub_path*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_line_to*(cr: PCairo, x, y: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_curve_to*(cr: PCairo, x1, y1, x2, y2, x3, y3: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_arc*(cr: PCairo, xc, yc, radius, angle1, angle2: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_arc_negative*(cr: PCairo, xc, yc, radius, angle1, angle2: float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_rel_move_to*(cr: PCairo, dx, dy: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_rel_line_to*(cr: PCairo, dx, dy: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_rel_curve_to*(cr: PCairo, dx1, dy1, dx2, dy2, dx3, dy3: float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_rectangle*(cr: PCairo, x, y, width, height: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_close_path*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Painting functions
+proc cairo_paint*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_paint_with_alpha*(cr: PCairo, alpha: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_mask*(cr: PCairo, pattern: PCairoPattern){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_mask_surface*(cr: PCairo, surface: PCairoSurface,
+                         surface_x, surface_y: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_stroke*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_stroke_preserve*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_fill*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_fill_preserve*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_copy_page*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_show_page*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Insideness testing
+proc cairo_in_stroke*(cr: PCairo, x, y: float64): TCairoBool{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_in_fill*(cr: PCairo, x, y: float64): TCairoBool{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+  #* Rectangular extents
+proc cairo_stroke_extents*(cr: PCairo, x1, y1, x2, y2: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_fill_extents*(cr: PCairo, x1, y1, x2, y2: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+  #* Clipping
+proc cairo_reset_clip*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_clip*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_clip_preserve*(cr: PCairo){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_clip_extents*(cr: PCairo, x1, y1, x2, y2: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_copy_clip_rectangle_list*(cr: PCairo): PCairoRectangleList{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_rectangle_list_destroy*(rectangle_list: PCairoRectangleList){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Font/Text functions
+proc cairo_font_options_create*(): PCairoFontOptions{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_font_options_copy*(original: PCairoFontOptions): PCairoFontOptions{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_options_destroy*(options: PCairoFontOptions){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_font_options_status*(options: PCairoFontOptions): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_options_merge*(options, other: PCairoFontOptions){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_font_options_equal*(options, other: PCairoFontOptions): TCairoBool{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_options_hash*(options: PCairoFontOptions): int32{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_font_options_set_antialias*(options: PCairoFontOptions,
+                                       antialias: TCairoAntialias){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_font_options_get_antialias*(options: PCairoFontOptions): TCairoAntialias{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_options_set_subpixel_order*(options: PCairoFontOptions,
+    subpixel_order: TCairoSubpixelOrder){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_options_get_subpixel_order*(options: PCairoFontOptions): TCairoSubpixelOrder{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_options_set_hint_style*(options: PCairoFontOptions,
+                                        hint_style: TCairoHintStyle){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_font_options_get_hint_style*(options: PCairoFontOptions): TCairoHintStyle{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_options_set_hint_metrics*(options: PCairoFontOptions,
+    hint_metrics: TCairoHintMetrics){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_options_get_hint_metrics*(options: PCairoFontOptions): TCairoHintMetrics{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+  #* This interface is for dealing with text as text, not caring about the
+  #   font object inside the the TCairo.
+proc cairo_select_font_face*(cr: PCairo, family: cstring,
+                             slant: TCairoFontSlant,
+                             weight: TCairoFontWeight){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_font_size*(cr: PCairo, size: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_set_font_matrix*(cr: PCairo, matrix: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_font_matrix*(cr: PCairo, matrix: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_font_options*(cr: PCairo, options: PCairoFontOptions){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_font_options*(cr: PCairo, options: PCairoFontOptions){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_set_font_face*(cr: PCairo, font_face: PCairoFontFace){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_font_face*(cr: PCairo): PCairoFontFace{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_set_scaled_font*(cr: PCairo, scaled_font: PCairoScaledFont){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_scaled_font*(cr: PCairo): PCairoScaledFont{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_show_text*(cr: PCairo, utf8: cstring){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_show_glyphs*(cr: PCairo, glyphs: PCairoGlyph, num_glyphs: int32){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_text_path*(cr: PCairo, utf8: cstring){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_glyph_path*(cr: PCairo, glyphs: PCairoGlyph, num_glyphs: int32){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_text_extents*(cr: PCairo, utf8: cstring,
+                         extents: PCairoTextExtents){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_glyph_extents*(cr: PCairo, glyphs: PCairoGlyph,
+                          num_glyphs: int32, extents: PCairoTextExtents){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_extents*(cr: PCairo, extents: PCairoFontExtents){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+  #* Generic identifier for a font style
+proc cairo_font_face_reference*(font_face: PCairoFontFace): PCairoFontFace{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_face_destroy*(font_face: PCairoFontFace){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_font_face_get_reference_count*(font_face: PCairoFontFace): int32{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_face_status*(font_face: PCairoFontFace): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_face_get_type*(font_face: PCairoFontFace): TCairoFontType{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_face_get_user_data*(font_face: PCairoFontFace,
+                                    key: PCairoUserDataKey): pointer{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_font_face_set_user_data*(font_face: PCairoFontFace,
+                                    key: PCairoUserDataKey,
+                                    user_data: pointer,
+                                    destroy: TCairoDestroyFunc): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Portable interface to general font features
+proc cairo_scaled_font_create*(font_face: PCairoFontFace,
+                               font_matrix: PCairoMatrix,
+                               ctm: PCairoMatrix,
+                               options: PCairoFontOptions): PCairoScaledFont{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_reference*(scaled_font: PCairoScaledFont): PCairoScaledFont{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_destroy*(scaled_font: PCairoScaledFont){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_get_reference_count*(scaled_font: PCairoScaledFont): int32{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_status*(scaled_font: PCairoScaledFont): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_get_type*(scaled_font: PCairoScaledFont): TCairoFontType{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_get_user_data*(scaled_font: PCairoScaledFont,
+                                      key: PCairoUserDataKey): Pointer{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_set_user_data*(scaled_font: PCairoScaledFont,
+                                      key: PCairoUserDataKey,
+                                      user_data: Pointer,
+                                      destroy: TCairoDestroyFunc): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_extents*(scaled_font: PCairoScaledFont,
+                                extents: PCairoFontExtents){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_text_extents*(scaled_font: PCairoScaledFont,
+                                     utf8: cstring,
+                                     extents: PCairoTextExtents){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_glyph_extents*(scaled_font: PCairoScaledFont,
+                                      glyphs: PCairoGlyph, num_glyphs: int32,
+                                      extents: PCairoTextExtents){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_get_font_face*(scaled_font: PCairoScaledFont): PCairoFontFace{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_get_font_matrix*(scaled_font: PCairoScaledFont,
+                                        font_matrix: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_get_ctm*(scaled_font: PCairoScaledFont,
+                                ctm: PCairoMatrix){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_scaled_font_get_font_options*(scaled_font: PCairoScaledFont,
+    options: PCairoFontOptions){.cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Query functions
+proc cairo_get_operator*(cr: PCairo): TCairoOperator{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_source*(cr: PCairo): PCairoPattern{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_tolerance*(cr: PCairo): float64{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_antialias*(cr: PCairo): TCairoAntialias{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_current_point*(cr: PCairo, x, y: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_fill_rule*(cr: PCairo): TCairoFillRule{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_line_width*(cr: PCairo): float64{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_line_cap*(cr: PCairo): TCairoLineCap{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_line_join*(cr: PCairo): TCairoLineJoin{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_miter_limit*(cr: PCairo): float64{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_dash_count*(cr: PCairo): int32{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_dash*(cr: PCairo, dashes, offset: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_matrix*(cr: PCairo, matrix: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_get_target*(cr: PCairo): PCairoSurface{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_get_group_target*(cr: PCairo): PCairoSurface{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_copy_path*(cr: PCairo): PCairoPath{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_copy_path_flat*(cr: PCairo): PCairoPath{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_append_path*(cr: PCairo, path: PCairoPath){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_path_destroy*(path: PCairoPath){.cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Error status queries
+proc cairo_status*(cr: PCairo): TCairoStatus{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_status_to_string*(status: TCairoStatus): cstring{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+  #* Surface manipulation
+proc cairo_surface_create_similar*(other: PCairoSurface,
+                                   content: TCairoContent,
+                                   width, height: int32): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_reference*(surface: PCairoSurface): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_finish*(surface: PCairoSurface){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_destroy*(surface: PCairoSurface){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_get_reference_count*(surface: PCairoSurface): int32{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_status*(surface: PCairoSurface): TCairoStatus{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_surface_get_type*(surface: PCairoSurface): TCairoSurfaceType{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_get_content*(surface: PCairoSurface): TCairoContent{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_write_to_png*(surface: PCairoSurface, filename: cstring): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_write_to_png_stream*(surface: PCairoSurface,
+                                        write_func: TCairoWriteFunc,
+                                        closure: pointer): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_get_user_data*(surface: PCairoSurface,
+                                  key: PCairoUserDataKey): pointer{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_surface_set_user_data*(surface: PCairoSurface,
+                                  key: PCairoUserDataKey,
+                                  user_data: pointer,
+                                  destroy: TCairoDestroyFunc): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_get_font_options*(surface: PCairoSurface,
+                                     options: PCairoFontOptions){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_surface_flush*(surface: PCairoSurface){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_mark_dirty*(surface: PCairoSurface){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_surface_mark_dirty_rectangle*(surface: PCairoSurface,
+    x, y, width, height: int32){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_surface_set_device_offset*(surface: PCairoSurface,
+                                      x_offset, y_offset: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_surface_get_device_offset*(surface: PCairoSurface,
+                                      x_offset, y_offset: var float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_surface_set_fallback_resolution*(surface: PCairoSurface,
+    x_pixels_per_inch, y_pixels_per_inch: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Image-surface functions
+proc cairo_image_surface_create*(format: TCairoFormat, width, height: int32): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_image_surface_create_for_data*(data: Pbyte, format: TCairoFormat,
+    width, height, stride: int32): PCairoSurface{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_image_surface_get_data*(surface: PCairoSurface): cstring{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_image_surface_get_format*(surface: PCairoSurface): TCairoFormat{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_image_surface_get_width*(surface: PCairoSurface): int32{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_image_surface_get_height*(surface: PCairoSurface): int32{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_image_surface_get_stride*(surface: PCairoSurface): int32{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_image_surface_create_from_png*(filename: cstring): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_image_surface_create_from_png_stream*(read_func: TCairoReadFunc,
+    closure: pointer): PCairoSurface{.cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Pattern creation functions
+proc cairo_pattern_create_rgb*(red, green, blue: float64): PCairoPattern{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_create_rgba*(red, green, blue, alpha: float64): PCairoPattern{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_create_for_surface*(surface: PCairoSurface): PCairoPattern{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_create_linear*(x0, y0, x1, y1: float64): PCairoPattern{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_create_radial*(cx0, cy0, radius0, cx1, cy1, radius1: float64): PCairoPattern{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_reference*(pattern: PCairoPattern): PCairoPattern{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_destroy*(pattern: PCairoPattern){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_reference_count*(pattern: PCairoPattern): int32{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_status*(pattern: PCairoPattern): TCairoStatus{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_user_data*(pattern: PCairoPattern,
+                                  key: PCairoUserDataKey): Pointer{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_pattern_set_user_data*(pattern: PCairoPattern,
+                                  key: PCairoUserDataKey,
+                                  user_data: Pointer,
+                                  destroy: TCairoDestroyFunc): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_type*(pattern: PCairoPattern): TCairoPatternType{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_add_color_stop_rgb*(pattern: PCairoPattern,
+                                       offset, red, green, blue: float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_add_color_stop_rgba*(pattern: PCairoPattern, offset, red,
+    green, blue, alpha: float64){.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_set_matrix*(pattern: PCairoPattern,
+                               matrix: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_matrix*(pattern: PCairoPattern,
+                               matrix: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_pattern_set_extend*(pattern: PCairoPattern, extend: TCairoExtend){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_extend*(pattern: PCairoPattern): TCairoExtend{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_set_filter*(pattern: PCairoPattern, filter: TCairoFilter){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_filter*(pattern: PCairoPattern): TCairoFilter{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_rgba*(pattern: PCairoPattern,
+                             red, green, blue, alpha: var float64): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_surface*(pattern: PCairoPattern,
+                                surface: PPCairoSurface): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_color_stop_rgba*(pattern: PCairoPattern, index: int32,
+    offset, red, green, blue, alpha: var float64): TCairoStatus{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_color_stop_count*(pattern: PCairoPattern,
+    count: var int32): TCairoStatus{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_linear_points*(pattern: PCairoPattern,
+                                      x0, y0, x1, y1: var float64): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pattern_get_radial_circles*(pattern: PCairoPattern,
+                                       x0, y0, r0, x1, y1, r1: var float64): TCairoStatus{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+  #* Matrix functions
+proc cairo_matrix_init*(matrix: PCairoMatrix, xx, yx, xy, yy, x0, y0: float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_matrix_init_identity*(matrix: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_matrix_init_translate*(matrix: PCairoMatrix, tx, ty: float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_matrix_init_scale*(matrix: PCairoMatrix, sx, sy: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_matrix_init_rotate*(matrix: PCairoMatrix, radians: float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_matrix_translate*(matrix: PCairoMatrix, tx, ty: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_matrix_scale*(matrix: PCairoMatrix, sx, sy: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_matrix_rotate*(matrix: PCairoMatrix, radians: float64){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_matrix_invert*(matrix: PCairoMatrix): TCairoStatus{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_matrix_multiply*(result, a, b: PCairoMatrix){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_matrix_transform_distance*(matrix: PCairoMatrix, dx, dy: var float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_matrix_transform_point*(matrix: PCairoMatrix, x, y: var float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+  #* PDF functions
+proc cairo_pdf_surface_create*(filename: cstring,
+                               width_in_points, height_in_points: float64): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pdf_surface_create_for_stream*(write_func: TCairoWriteFunc,
+    closure: Pointer, width_in_points, height_in_points: float64): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_pdf_surface_set_size*(surface: PCairoSurface,
+                                 width_in_points, height_in_points: float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+  #* PS functions
+proc cairo_ps_surface_create*(filename: cstring,
+                              width_in_points, height_in_points: float64): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_ps_surface_create_for_stream*(write_func: TCairoWriteFunc,
+    closure: Pointer, width_in_points, height_in_points: float64): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_ps_surface_set_size*(surface: PCairoSurface,
+                                width_in_points, height_in_points: float64){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_ps_surface_dsc_comment*(surface: PCairoSurface, comment: cstring){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_ps_surface_dsc_begin_setup*(surface: PCairoSurface){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+proc cairo_ps_surface_dsc_begin_page_setup*(surface: PCairoSurface){.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+  #* SVG functions
+proc cairo_svg_surface_create*(filename: cstring,
+                               width_in_points, height_in_points: float64): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_svg_surface_create_for_stream*(write_func: TCairoWriteFunc,
+    closure: Pointer, width_in_points, height_in_points: float64): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_svg_surface_restrict_to_version*(surface: PCairoSurface,
+    version: TCairoSvgVersion){.cdecl, importc, dynlib: LIB_CAIRO.}
+  #todo: see how translate this
+  #procedure cairo_svg_get_versions(TCairoSvgVersion const	**versions,
+  #                        int                      	 *num_versions);
+proc cairo_svg_version_to_string*(version: TCairoSvgVersion): cstring{.cdecl, importc,
+    dynlib: LIB_CAIRO.}
+  #* Functions to be used while debugging (not intended for use in production code)
+proc cairo_debug_reset_static_data*(){.cdecl, importc, dynlib: LIB_CAIRO.}
+# implementation
+
+proc cairo_version(major, minor, micro: var int32) =
+  var version: int32
+  version = cairo_version()
+  major = version div 10000'i32
+  minor = (version mod (major * 10000'i32)) div 100'i32
+  micro = (version mod ((major * 10000'i32) + (minor * 100'i32)))

lib/oldwrappers/cairo/cairoft.nim

@@ -0,0 +1,36 @@
+#
+# 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 cairo_ft_font_face_create_for_pattern*(pattern: PFcPattern): PCairoFontFace{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_ft_font_options_substitute*(options: PCairoFontOptions, 
+                                       pattern: PFcPattern){.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_ft_font_face_create_for_ft_face*(face: TFT_Face, 
+       load_flags: int32): PCairoFontFace {.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_ft_scaled_font_lock_face*(
+  scaled_font: PCairoScaledFont): TFT_Face{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_ft_scaled_font_unlock_face*(
+  scaled_font: PCairoScaledFont){.cdecl, importc, dynlib: LIB_CAIRO.}
+

lib/oldwrappers/cairo/cairowin32.nim

@@ -0,0 +1,36 @@
+
+#
+# Translation of cairo-win32.h version 1.4
+# by Luiz Américo Pereira Câmara 2007
+#
+
+import 
+  Cairo, windows
+
+proc cairo_win32_surface_create*(hdc: HDC): PCairoSurface{.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_win32_surface_create_with_ddb*(hdc: HDC, format: TCairoFormat, 
+    width, height: int32): PCairoSurface{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_win32_surface_create_with_dib*(format: TCairoFormat, 
+    width, height: int32): PCairoSurface{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_win32_surface_get_dc*(surface: PCairoSurface): HDC{.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_win32_surface_get_image*(surface: PCairoSurface): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_win32_font_face_create_for_logfontw*(logfont: pLOGFONTW): PCairoFontFace{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_win32_font_face_create_for_hfont*(font: HFONT): PCairoFontFace{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_win32_scaled_font_select_font*(scaled_font: PCairoScaledFont, 
+    hdc: HDC): TCairoStatus{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_win32_scaled_font_done_font*(scaled_font: PCairoScaledFont){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_win32_scaled_font_get_metrics_factor*(
+    scaled_font: PCairoScaledFont): float64{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_win32_scaled_font_get_logical_to_device*(
+    scaled_font: PCairoScaledFont, logical_to_device: PCairoMatrix){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_win32_scaled_font_get_device_to_logical*(
+    scaled_font: PCairoScaledFont, device_to_logical: PCairoMatrix){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+# implementation

lib/oldwrappers/cairo/cairoxlib.nim

@@ -0,0 +1,40 @@
+
+#
+# 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 cairo_xlib_surface_create*(dpy: PDisplay, drawable: TDrawable, 
+                                visual: PVisual, width, height: int32): PCairoSurface{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_create_for_bitmap*(dpy: PDisplay, bitmap: TPixmap, 
+    screen: PScreen, width, height: int32): PCairoSurface{.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_create_with_xrender_format*(dpy: PDisplay, 
+    drawable: TDrawable, screen: PScreen, format: PXRenderPictFormat, 
+    width, height: int32): PCairoSurface{.cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_get_depth*(surface: PCairoSurface): int32{.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_get_display*(surface: PCairoSurface): PDisplay{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_get_drawable*(surface: PCairoSurface): TDrawable{.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_get_height*(surface: PCairoSurface): int32{.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_get_screen*(surface: PCairoSurface): PScreen{.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_get_visual*(surface: PCairoSurface): PVisual{.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_get_width*(surface: PCairoSurface): int32{.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_set_size*(surface: PCairoSurface, 
+                                  width, height: int32){.cdecl, importc, 
+    dynlib: LIB_CAIRO.}
+proc cairo_xlib_surface_set_drawable*(surface: PCairoSurface, 
+                                      drawable: TDrawable, width, height: int32){.
+    cdecl, importc, dynlib: LIB_CAIRO.}
+# implementation

lib/oldwrappers/gtk/gdk2pixbuf.nim

@@ -0,0 +1,277 @@
+{.deadCodeElim: on.}
+
+import
+  glib2
+
+when defined(win32):
+  const
+    gdkpixbuflib = "libgdk_pixbuf-2.0-0.dll"
+elif defined(darwin):
+  const
+    gdkpixbuflib = "gdk_pixbuf-2.0.0"
+  # linklib gtk-x11-2.0
+  # linklib gdk-x11-2.0
+  # linklib pango-1.0.0
+  # linklib glib-2.0.0
+  # linklib gobject-2.0.0
+  # linklib gdk_pixbuf-2.0.0
+  # linklib atk-1.0.0
+else:
+  const
+    gdkpixbuflib = "libgdk_pixbuf-2.0.so"
+
+type
+  PGdkPixbuf* = pointer
+  PGdkPixbufAnimation* = pointer
+  PGdkPixbufAnimationIter* = pointer
+  PGdkPixbufAlphaMode* = ptr TGdkPixbufAlphaMode
+  TGdkPixbufAlphaMode* = enum
+    GDK_PIXBUF_ALPHA_BILEVEL, GDK_PIXBUF_ALPHA_FULL
+  PGdkColorspace* = ptr TGdkColorspace
+  TGdkColorspace* = enum
+    GDK_COLORSPACE_RGB
+  TGdkPixbufDestroyNotify* = proc (pixels: Pguchar, data: gpointer){.cdecl.}
+  PGdkPixbufError* = ptr TGdkPixbufError
+  TGdkPixbufError* = enum
+    GDK_PIXBUF_ERROR_CORRUPT_IMAGE, GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+    GDK_PIXBUF_ERROR_BAD_OPTION, GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
+    GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION, GDK_PIXBUF_ERROR_FAILED
+  PGdkInterpType* = ptr TGdkInterpType
+  TGdkInterpType* = enum
+    GDK_INTERP_NEAREST, GDK_INTERP_TILES, GDK_INTERP_BILINEAR, GDK_INTERP_HYPER
+
+proc GDK_TYPE_PIXBUF*(): GType
+proc GDK_PIXBUF*(anObject: pointer): PGdkPixbuf
+proc GDK_IS_PIXBUF*(anObject: pointer): bool
+proc GDK_TYPE_PIXBUF_ANIMATION*(): GType
+proc GDK_PIXBUF_ANIMATION*(anObject: pointer): PGdkPixbufAnimation
+proc GDK_IS_PIXBUF_ANIMATION*(anObject: pointer): bool
+proc GDK_TYPE_PIXBUF_ANIMATION_ITER*(): GType
+proc GDK_PIXBUF_ANIMATION_ITER*(anObject: pointer): PGdkPixbufAnimationIter
+proc GDK_IS_PIXBUF_ANIMATION_ITER*(anObject: pointer): bool
+proc GDK_PIXBUF_ERROR*(): TGQuark
+proc gdk_pixbuf_error_quark*(): TGQuark{.cdecl, dynlib: gdkpixbuflib,
+    importc: "gdk_pixbuf_error_quark".}
+proc gdk_pixbuf_get_type*(): GType{.cdecl, dynlib: gdkpixbuflib,
+                                    importc: "gdk_pixbuf_get_type".}
+when not defined(GDK_PIXBUF_DISABLE_DEPRECATED):
+  proc gdk_pixbuf_ref*(pixbuf: PGdkPixbuf): PGdkPixbuf{.cdecl,
+      dynlib: gdkpixbuflib, importc: "gdk_pixbuf_ref".}
+  proc gdk_pixbuf_unref*(pixbuf: PGdkPixbuf){.cdecl, dynlib: gdkpixbuflib,
+      importc: "gdk_pixbuf_unref".}
+proc gdk_pixbuf_get_colorspace*(pixbuf: PGdkPixbuf): TGdkColorspace{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_get_colorspace".}
+proc gdk_pixbuf_get_n_channels*(pixbuf: PGdkPixbuf): int32{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_get_n_channels".}
+proc gdk_pixbuf_get_has_alpha*(pixbuf: PGdkPixbuf): gboolean{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_get_has_alpha".}
+proc gdk_pixbuf_get_bits_per_sample*(pixbuf: PGdkPixbuf): int32{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_get_bits_per_sample".}
+proc gdk_pixbuf_get_pixels*(pixbuf: PGdkPixbuf): Pguchar{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_get_pixels".}
+proc gdk_pixbuf_get_width*(pixbuf: PGdkPixbuf): int32{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_get_width".}
+proc gdk_pixbuf_get_height*(pixbuf: PGdkPixbuf): int32{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_get_height".}
+proc gdk_pixbuf_get_rowstride*(pixbuf: PGdkPixbuf): int32{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_get_rowstride".}
+proc gdk_pixbuf_new*(colorspace: TGdkColorspace, has_alpha: gboolean,
+                     bits_per_sample: int32, width: int32, height: int32): PGdkPixbuf{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_new".}
+proc gdk_pixbuf_copy*(pixbuf: PGdkPixbuf): PGdkPixbuf{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_copy".}
+proc gdk_pixbuf_new_subpixbuf*(src_pixbuf: PGdkPixbuf, src_x: int32,
+                               src_y: int32, width: int32, height: int32): PGdkPixbuf{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_new_subpixbuf".}
+proc gdk_pixbuf_new_from_file*(filename: cstring, error: pointer): PGdkPixbuf{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_new_from_file".}
+proc gdk_pixbuf_new_from_data*(data: Pguchar, colorspace: TGdkColorspace,
+                               has_alpha: gboolean, bits_per_sample: int32,
+                               width: int32, height: int32, rowstride: int32,
+                               destroy_fn: TGdkPixbufDestroyNotify,
+                               destroy_fn_data: gpointer): PGdkPixbuf{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_new_from_data".}
+proc gdk_pixbuf_new_from_xpm_data*(data: PPchar): PGdkPixbuf{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_new_from_xpm_data".}
+proc gdk_pixbuf_new_from_inline*(data_length: gint, a: var guint8,
+                                 copy_pixels: gboolean, error: pointer): PGdkPixbuf{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_new_from_inline".}
+proc gdk_pixbuf_new_from_file_at_size*(filename: cstring, width, height: gint,
+                                       error: pointer): PGdkPixbuf{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_new_from_file_at_size".}
+proc gdk_pixbuf_new_from_file_at_scale*(filename: cstring, width, height: gint,
+    preserve_aspect_ratio: gboolean, error: pointer): PGdkPixbuf{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_new_from_file_at_scale".}
+proc gdk_pixbuf_fill*(pixbuf: PGdkPixbuf, pixel: guint32){.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_fill".}
+proc gdk_pixbuf_save*(pixbuf: PGdkPixbuf, filename: cstring, `type`: cstring,
+                      error: pointer): gboolean{.cdecl, varargs,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_save".}
+proc gdk_pixbuf_savev*(pixbuf: PGdkPixbuf, filename: cstring, `type`: cstring,
+                       option_keys: PPchar, option_values: PPchar,
+                       error: pointer): gboolean{.cdecl, dynlib: gdkpixbuflib,
+    importc: "gdk_pixbuf_savev".}
+proc gdk_pixbuf_add_alpha*(pixbuf: PGdkPixbuf, substitute_color: gboolean,
+                           r: guchar, g: guchar, b: guchar): PGdkPixbuf{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_add_alpha".}
+proc gdk_pixbuf_copy_area*(src_pixbuf: PGdkPixbuf, src_x: int32, src_y: int32,
+                           width: int32, height: int32, dest_pixbuf: PGdkPixbuf,
+                           dest_x: int32, dest_y: int32){.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_copy_area".}
+proc gdk_pixbuf_saturate_and_pixelate*(src: PGdkPixbuf, dest: PGdkPixbuf,
+                                       saturation: gfloat, pixelate: gboolean){.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_saturate_and_pixelate".}
+proc gdk_pixbuf_scale*(src: PGdkPixbuf, dest: PGdkPixbuf, dest_x: int32,
+                       dest_y: int32, dest_width: int32, dest_height: int32,
+                       offset_x: float64, offset_y: float64, scale_x: float64,
+                       scale_y: float64, interp_type: TGdkInterpType){.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_scale".}
+proc gdk_pixbuf_composite*(src: PGdkPixbuf, dest: PGdkPixbuf, dest_x: int32,
+                           dest_y: int32, dest_width: int32, dest_height: int32,
+                           offset_x: float64, offset_y: float64,
+                           scale_x: float64, scale_y: float64,
+                           interp_type: TGdkInterpType, overall_alpha: int32){.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_composite".}
+proc gdk_pixbuf_composite_color*(src: PGdkPixbuf, dest: PGdkPixbuf,
+                                 dest_x: int32, dest_y: int32,
+                                 dest_width: int32, dest_height: int32,
+                                 offset_x: float64, offset_y: float64,
+                                 scale_x: float64, scale_y: float64,
+                                 interp_type: TGdkInterpType,
+                                 overall_alpha: int32, check_x: int32,
+                                 check_y: int32, check_size: int32,
+                                 color1: guint32, color2: guint32){.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_composite_color".}
+proc gdk_pixbuf_scale_simple*(src: PGdkPixbuf, dest_width: int32,
+                              dest_height: int32, interp_type: TGdkInterpType): PGdkPixbuf{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_scale_simple".}
+proc gdk_pixbuf_composite_color_simple*(src: PGdkPixbuf, dest_width: int32,
+                                        dest_height: int32,
+                                        interp_type: TGdkInterpType,
+                                        overall_alpha: int32, check_size: int32,
+                                        color1: guint32, color2: guint32): PGdkPixbuf{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_composite_color_simple".}
+proc gdk_pixbuf_animation_get_type*(): GType{.cdecl, dynlib: gdkpixbuflib,
+    importc: "gdk_pixbuf_animation_get_type".}
+proc gdk_pixbuf_animation_new_from_file*(filename: cstring, error: pointer): PGdkPixbufAnimation{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_animation_new_from_file".}
+when not defined(GDK_PIXBUF_DISABLE_DEPRECATED):
+  proc gdk_pixbuf_animation_ref*(animation: PGdkPixbufAnimation): PGdkPixbufAnimation{.
+      cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_animation_ref".}
+  proc gdk_pixbuf_animation_unref*(animation: PGdkPixbufAnimation){.cdecl,
+      dynlib: gdkpixbuflib, importc: "gdk_pixbuf_animation_unref".}
+proc gdk_pixbuf_animation_get_width*(animation: PGdkPixbufAnimation): int32{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_animation_get_width".}
+proc gdk_pixbuf_animation_get_height*(animation: PGdkPixbufAnimation): int32{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_animation_get_height".}
+proc gdk_pixbuf_animation_is_static_image*(animation: PGdkPixbufAnimation): gboolean{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_animation_is_static_image".}
+proc gdk_pixbuf_animation_get_static_image*(animation: PGdkPixbufAnimation): PGdkPixbuf{.
+    cdecl, dynlib: gdkpixbuflib,
+    importc: "gdk_pixbuf_animation_get_static_image".}
+proc gdk_pixbuf_animation_get_iter*(animation: PGdkPixbufAnimation,
+                                    e: var TGTimeVal): PGdkPixbufAnimationIter{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_animation_get_iter".}
+proc gdk_pixbuf_animation_iter_get_type*(): GType{.cdecl, dynlib: gdkpixbuflib,
+    importc: "gdk_pixbuf_animation_iter_get_type".}
+proc gdk_pixbuf_animation_iter_get_delay_time*(iter: PGdkPixbufAnimationIter): int32{.
+    cdecl, dynlib: gdkpixbuflib,
+    importc: "gdk_pixbuf_animation_iter_get_delay_time".}
+proc gdk_pixbuf_animation_iter_get_pixbuf*(iter: PGdkPixbufAnimationIter): PGdkPixbuf{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_animation_iter_get_pixbuf".}
+proc gdk_pixbuf_animation_iter_on_currently_loading_frame*(
+    iter: PGdkPixbufAnimationIter): gboolean{.cdecl, dynlib: gdkpixbuflib,
+    importc: "gdk_pixbuf_animation_iter_on_currently_loading_frame".}
+proc gdk_pixbuf_animation_iter_advance*(iter: PGdkPixbufAnimationIter,
+                                        e: var TGTimeVal): gboolean{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_animation_iter_advance".}
+proc gdk_pixbuf_get_option*(pixbuf: PGdkPixbuf, key: cstring): cstring{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_get_option".}
+type
+  PGdkPixbufLoader* = ptr TGdkPixbufLoader
+  TGdkPixbufLoader* {.final, pure.} = object
+    parent_instance*: TGObject
+    priv*: gpointer
+
+  PGdkPixbufLoaderClass* = ptr TGdkPixbufLoaderClass
+  TGdkPixbufLoaderClass* {.final, pure.} = object
+    parent_class*: TGObjectClass
+    area_prepared*: proc (loader: PGdkPixbufLoader){.cdecl.}
+    area_updated*: proc (loader: PGdkPixbufLoader, x: int32, y: int32,
+                         width: int32, height: int32){.cdecl.}
+    closed*: proc (loader: PGdkPixbufLoader){.cdecl.}
+
+
+proc GDK_TYPE_PIXBUF_LOADER*(): GType
+proc GDK_PIXBUF_LOADER*(obj: pointer): PGdkPixbufLoader
+proc GDK_PIXBUF_LOADER_CLASS*(klass: pointer): PGdkPixbufLoaderClass
+proc GDK_IS_PIXBUF_LOADER*(obj: pointer): bool
+proc GDK_IS_PIXBUF_LOADER_CLASS*(klass: pointer): bool
+proc GDK_PIXBUF_LOADER_GET_CLASS*(obj: pointer): PGdkPixbufLoaderClass
+proc gdk_pixbuf_loader_get_type*(): GType{.cdecl, dynlib: gdkpixbuflib,
+    importc: "gdk_pixbuf_loader_get_type".}
+proc gdk_pixbuf_loader_new*(): PGdkPixbufLoader{.cdecl, dynlib: gdkpixbuflib,
+    importc: "gdk_pixbuf_loader_new".}
+proc gdk_pixbuf_loader_new_with_type*(image_type: cstring, error: pointer): PGdkPixbufLoader{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_loader_new_with_type".}
+proc gdk_pixbuf_loader_write*(loader: PGdkPixbufLoader, buf: Pguchar,
+                              count: gsize, error: pointer): gboolean{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_loader_write".}
+proc gdk_pixbuf_loader_get_pixbuf*(loader: PGdkPixbufLoader): PGdkPixbuf{.cdecl,
+    dynlib: gdkpixbuflib, importc: "gdk_pixbuf_loader_get_pixbuf".}
+proc gdk_pixbuf_loader_get_animation*(loader: PGdkPixbufLoader): PGdkPixbufAnimation{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_loader_get_animation".}
+proc gdk_pixbuf_loader_close*(loader: PGdkPixbufLoader, error: pointer): gboolean{.
+    cdecl, dynlib: gdkpixbuflib, importc: "gdk_pixbuf_loader_close".}
+proc GDK_TYPE_PIXBUF_LOADER*(): GType =
+  result = gdk_pixbuf_loader_get_type()
+
+proc GDK_PIXBUF_LOADER*(obj: pointer): PGdkPixbufLoader =
+  result = cast[PGdkPixbufLoader](G_TYPE_CHECK_INSTANCE_CAST(obj,
+      GDK_TYPE_PIXBUF_LOADER()))
+
+proc GDK_PIXBUF_LOADER_CLASS*(klass: pointer): PGdkPixbufLoaderClass =
+  result = cast[PGdkPixbufLoaderClass](G_TYPE_CHECK_CLASS_CAST(klass,
+      GDK_TYPE_PIXBUF_LOADER()))
+
+proc GDK_IS_PIXBUF_LOADER*(obj: pointer): bool =
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, GDK_TYPE_PIXBUF_LOADER())
+
+proc GDK_IS_PIXBUF_LOADER_CLASS*(klass: pointer): bool =
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, GDK_TYPE_PIXBUF_LOADER())
+
+proc GDK_PIXBUF_LOADER_GET_CLASS*(obj: pointer): PGdkPixbufLoaderClass =
+  result = cast[PGdkPixbufLoaderClass](G_TYPE_INSTANCE_GET_CLASS(obj,
+      GDK_TYPE_PIXBUF_LOADER()))
+
+proc GDK_TYPE_PIXBUF*(): GType =
+  result = gdk_pixbuf_get_type()
+
+proc GDK_PIXBUF*(anObject: pointer): PGdkPixbuf =
+  result = cast[PGdkPixbuf](G_TYPE_CHECK_INSTANCE_CAST(anObject, GDK_TYPE_PIXBUF()))
+
+proc GDK_IS_PIXBUF*(anObject: pointer): bool =
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, GDK_TYPE_PIXBUF())
+
+proc GDK_TYPE_PIXBUF_ANIMATION*(): GType =
+  result = gdk_pixbuf_animation_get_type()
+
+proc GDK_PIXBUF_ANIMATION*(anObject: pointer): PGdkPixbufAnimation =
+  result = cast[PGdkPixbufAnimation](G_TYPE_CHECK_INSTANCE_CAST(anObject,
+      GDK_TYPE_PIXBUF_ANIMATION()))
+
+proc GDK_IS_PIXBUF_ANIMATION*(anObject: pointer): bool =
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, GDK_TYPE_PIXBUF_ANIMATION())
+
+proc GDK_TYPE_PIXBUF_ANIMATION_ITER*(): GType =
+  result = gdk_pixbuf_animation_iter_get_type()
+
+proc GDK_PIXBUF_ANIMATION_ITER*(anObject: pointer): PGdkPixbufAnimationIter =
+  result = cast[PGdkPixbufAnimationIter](G_TYPE_CHECK_INSTANCE_CAST(anObject,
+    GDK_TYPE_PIXBUF_ANIMATION_ITER()))
+
+proc GDK_IS_PIXBUF_ANIMATION_ITER*(anObject: pointer): bool =
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, GDK_TYPE_PIXBUF_ANIMATION_ITER())
+
+proc GDK_PIXBUF_ERROR*(): TGQuark =
+  result = gdk_pixbuf_error_quark()

lib/oldwrappers/gtk/gdkglext.nim

@@ -0,0 +1,564 @@
+{.deadCodeElim: on.}
+
+import 
+  Glib2, Gdk2
+
+when defined(WIN32): 
+  const 
+    GdkGLExtLib = "libgdkglext-win32-1.0-0.dll"
+else: 
+  const 
+    GdkGLExtLib = "libgdkglext-x11-1.0.so"
+type 
+  TGdkGLConfigAttrib* = int32
+  TGdkGLConfigCaveat* = int32
+  TGdkGLVisualType* = int32
+  TGdkGLTransparentType* = int32
+  TGdkGLDrawableTypeMask* = int32
+  TGdkGLRenderTypeMask* = int32
+  TGdkGLBufferMask* = int32
+  TGdkGLConfigError* = int32
+  TGdkGLRenderType* = int32
+  TGdkGLDrawableAttrib* = int32
+  TGdkGLPbufferAttrib* = int32
+  TGdkGLEventMask* = int32
+  TGdkGLEventType* = int32
+  TGdkGLDrawableType* = int32
+  TGdkGLProc* = Pointer
+  PGdkGLConfig* = ptr TGdkGLConfig
+  PGdkGLContext* = ptr TGdkGLContext
+  PGdkGLDrawable* = ptr TGdkGLDrawable
+  PGdkGLPixmap* = ptr TGdkGLPixmap
+  PGdkGLWindow* = ptr TGdkGLWindow
+  TGdkGLConfig* = object of TGObject
+    layer_plane*: gint
+    n_aux_buffers*: gint
+    n_sample_buffers*: gint
+    flag0*: int16
+
+  PGdkGLConfigClass* = ptr TGdkGLConfigClass
+  TGdkGLConfigClass* = object of TGObjectClass
+
+  TGdkGLContext* = object of TGObject
+
+  PGdkGLContextClass* = ptr TGdkGLContextClass
+  TGdkGLContextClass* = object of TGObjectClass
+
+  TGdkGLDrawable* = object of TGObject
+
+  PGdkGLDrawableClass* = ptr TGdkGLDrawableClass
+  TGdkGLDrawableClass* = object of TGTypeInterface
+    create_new_context*: proc (gldrawable: PGdkGLDrawable, 
+                               share_list: PGdkGLContext, direct: gboolean, 
+                               render_type: int32): PGdkGLContext{.cdecl.}
+    make_context_current*: proc (draw: PGdkGLDrawable, a_read: PGdkGLDrawable, 
+                                 glcontext: PGdkGLContext): gboolean{.cdecl.}
+    is_double_buffered*: proc (gldrawable: PGdkGLDrawable): gboolean{.cdecl.}
+    swap_buffers*: proc (gldrawable: PGdkGLDrawable){.cdecl.}
+    wait_gl*: proc (gldrawable: PGdkGLDrawable){.cdecl.}
+    wait_gdk*: proc (gldrawable: PGdkGLDrawable){.cdecl.}
+    gl_begin*: proc (draw: PGdkGLDrawable, a_read: PGdkGLDrawable, 
+                     glcontext: PGdkGLContext): gboolean{.cdecl.}
+    gl_end*: proc (gldrawable: PGdkGLDrawable){.cdecl.}
+    get_gl_config*: proc (gldrawable: PGdkGLDrawable): PGdkGLConfig{.cdecl.}
+    get_size*: proc (gldrawable: PGdkGLDrawable, width, height: PGInt){.cdecl.}
+
+  TGdkGLPixmap* = object of TGObject
+    drawable*: PGdkDrawable
+
+  PGdkGLPixmapClass* = ptr TGdkGLPixmapClass
+  TGdkGLPixmapClass* = object of TGObjectClass
+
+  TGdkGLWindow* = object of TGObject
+    drawable*: PGdkDrawable
+
+  PGdkGLWindowClass* = ptr TGdkGLWindowClass
+  TGdkGLWindowClass* = 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 
+  gdkglext_major_version*{.importc, dynlib: GdkGLExtLib.}: guint
+  gdkglext_minor_version*{.importc, dynlib: GdkGLExtLib.}: guint
+  gdkglext_micro_version*{.importc, dynlib: GdkGLExtLib.}: guint
+  gdkglext_interface_age*{.importc, dynlib: GdkGLExtLib.}: guint
+  gdkglext_binary_age*{.importc, dynlib: GdkGLExtLib.}: guint
+
+const 
+  GDK_GL_SUCCESS* = 0
+  GDK_GL_ATTRIB_LIST_NONE* = 0
+  GDK_GL_USE_GL* = 1
+  GDK_GL_BUFFER_SIZE* = 2
+  GDK_GL_LEVEL* = 3
+  GDK_GL_RGBA* = 4
+  GDK_GL_DOUBLEBUFFER* = 5
+  GDK_GL_STEREO* = 6
+  GDK_GL_AUX_BUFFERS* = 7
+  GDK_GL_RED_SIZE* = 8
+  GDK_GL_GREEN_SIZE* = 9
+  GDK_GL_BLUE_SIZE* = 10
+  GDK_GL_ALPHA_SIZE* = 11
+  GDK_GL_DEPTH_SIZE* = 12
+  GDK_GL_STENCIL_SIZE* = 13
+  GDK_GL_ACCUM_RED_SIZE* = 14
+  GDK_GL_ACCUM_GREEN_SIZE* = 15
+  GDK_GL_ACCUM_BLUE_SIZE* = 16
+  GDK_GL_ACCUM_ALPHA_SIZE* = 17
+  GDK_GL_CONFIG_CAVEAT* = 0x00000020
+  GDK_GL_X_VISUAL_TYPE* = 0x00000022
+  GDK_GL_TRANSPARENT_TYPE* = 0x00000023
+  GDK_GL_TRANSPARENT_INDEX_VALUE* = 0x00000024
+  GDK_GL_TRANSPARENT_RED_VALUE* = 0x00000025
+  GDK_GL_TRANSPARENT_GREEN_VALUE* = 0x00000026
+  GDK_GL_TRANSPARENT_BLUE_VALUE* = 0x00000027
+  GDK_GL_TRANSPARENT_ALPHA_VALUE* = 0x00000028
+  GDK_GL_DRAWABLE_TYPE* = 0x00008010
+  GDK_GL_RENDER_TYPE* = 0x00008011
+  GDK_GL_X_RENDERABLE* = 0x00008012
+  GDK_GL_FBCONFIG_ID* = 0x00008013
+  GDK_GL_MAX_PBUFFER_WIDTH* = 0x00008016
+  GDK_GL_MAX_PBUFFER_HEIGHT* = 0x00008017
+  GDK_GL_MAX_PBUFFER_PIXELS* = 0x00008018
+  GDK_GL_VISUAL_ID* = 0x0000800B
+  GDK_GL_SCREEN* = 0x0000800C
+  GDK_GL_SAMPLE_BUFFERS* = 100000
+  GDK_GL_SAMPLES* = 100001
+  GDK_GL_DONT_CARE* = 0xFFFFFFFF
+  GDK_GL_NONE* = 0x00008000
+  GDK_GL_CONFIG_CAVEAT_DONT_CARE* = 0xFFFFFFFF
+  GDK_GL_CONFIG_CAVEAT_NONE* = 0x00008000
+  GDK_GL_SLOW_CONFIG* = 0x00008001
+  GDK_GL_NON_CONFORMANT_CONFIG* = 0x0000800D
+  GDK_GL_VISUAL_TYPE_DONT_CARE* = 0xFFFFFFFF
+  GDK_GL_TRUE_COLOR* = 0x00008002
+  GDK_GL_DIRECT_COLOR* = 0x00008003
+  GDK_GL_PSEUDO_COLOR* = 0x00008004
+  GDK_GL_STATIC_COLOR* = 0x00008005
+  GDK_GL_GRAY_SCALE* = 0x00008006
+  GDK_GL_STATIC_GRAY* = 0x00008007
+  GDK_GL_TRANSPARENT_NONE* = 0x00008000
+  GDK_GL_TRANSPARENT_RGB* = 0x00008008
+  GDK_GL_TRANSPARENT_INDEX* = 0x00008009
+  GDK_GL_WINDOW_BIT* = 1 shl 0
+  GDK_GL_PIXMAP_BIT* = 1 shl 1
+  GDK_GL_PBUFFER_BIT* = 1 shl 2
+  GDK_GL_RGBA_BIT* = 1 shl 0
+  GDK_GL_COLOR_INDEX_BIT* = 1 shl 1
+  GDK_GL_FRONT_LEFT_BUFFER_BIT* = 1 shl 0
+  GDK_GL_FRONT_RIGHT_BUFFER_BIT* = 1 shl 1
+  GDK_GL_BACK_LEFT_BUFFER_BIT* = 1 shl 2
+  GDK_GL_BACK_RIGHT_BUFFER_BIT* = 1 shl 3
+  GDK_GL_AUX_BUFFERS_BIT* = 1 shl 4
+  GDK_GL_DEPTH_BUFFER_BIT* = 1 shl 5
+  GDK_GL_STENCIL_BUFFER_BIT* = 1 shl 6
+  GDK_GL_ACCUM_BUFFER_BIT* = 1 shl 7
+  GDK_GL_BAD_SCREEN* = 1
+  GDK_GL_BAD_ATTRIBUTE* = 2
+  GDK_GL_NO_EXTENSION* = 3
+  GDK_GL_BAD_VISUAL* = 4
+  GDK_GL_BAD_CONTEXT* = 5
+  GDK_GL_BAD_VALUE* = 6
+  GDK_GL_BAD_ENUM* = 7
+  GDK_GL_RGBA_TYPE* = 0x00008014
+  GDK_GL_COLOR_INDEX_TYPE* = 0x00008015
+  GDK_GL_PRESERVED_CONTENTS* = 0x0000801B
+  GDK_GL_LARGEST_PBUFFER* = 0x0000801C
+  GDK_GL_WIDTH* = 0x0000801D
+  GDK_GL_HEIGHT* = 0x0000801E
+  GDK_GL_EVENT_MASK* = 0x0000801F
+  GDK_GL_PBUFFER_PRESERVED_CONTENTS* = 0x0000801B
+  GDK_GL_PBUFFER_LARGEST_PBUFFER* = 0x0000801C
+  GDK_GL_PBUFFER_HEIGHT* = 0x00008040
+  GDK_GL_PBUFFER_WIDTH* = 0x00008041
+  GDK_GL_PBUFFER_CLOBBER_MASK* = 1 shl 27
+  GDK_GL_DAMAGED* = 0x00008020
+  GDK_GL_SAVED* = 0x00008021
+  GDK_GL_WINDOW_VALUE* = 0x00008022
+  GDK_GL_PBUFFER* = 0x00008023
+
+proc gdk_gl_config_attrib_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_config_attrib_get_type".}
+proc GDK_TYPE_GL_CONFIG_ATTRIB*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_config_attrib_get_type".}
+proc gdk_gl_config_caveat_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_config_caveat_get_type".}
+proc GDK_TYPE_GL_CONFIG_CAVEAT*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_config_caveat_get_type".}
+proc gdk_gl_visual_type_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_visual_type_get_type".}
+proc GDK_TYPE_GL_VISUAL_TYPE*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                        importc: "gdk_gl_visual_type_get_type".}
+proc gdk_gl_transparent_type_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_transparent_type_get_type".}
+proc GDK_TYPE_GL_TRANSPARENT_TYPE*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_transparent_type_get_type".}
+proc gdk_gl_drawable_type_mask_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_drawable_type_mask_get_type".}
+proc GDK_TYPE_GL_DRAWABLE_TYPE_MASK*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_drawable_type_mask_get_type".}
+proc gdk_gl_render_type_mask_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_render_type_mask_get_type".}
+proc GDK_TYPE_GL_RENDER_TYPE_MASK*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_render_type_mask_get_type".}
+proc gdk_gl_buffer_mask_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_buffer_mask_get_type".}
+proc GDK_TYPE_GL_BUFFER_MASK*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                        importc: "gdk_gl_buffer_mask_get_type".}
+proc gdk_gl_config_error_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_config_error_get_type".}
+proc GDK_TYPE_GL_CONFIG_ERROR*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_config_error_get_type".}
+proc gdk_gl_render_type_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_render_type_get_type".}
+proc GDK_TYPE_GL_RENDER_TYPE*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                        importc: "gdk_gl_render_type_get_type".}
+proc gdk_gl_drawable_attrib_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_drawable_attrib_get_type".}
+proc GDK_TYPE_GL_DRAWABLE_ATTRIB*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_drawable_attrib_get_type".}
+proc gdk_gl_pbuffer_attrib_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_pbuffer_attrib_get_type".}
+proc GDK_TYPE_GL_PBUFFER_ATTRIB*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_pbuffer_attrib_get_type".}
+proc gdk_gl_event_mask_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_event_mask_get_type".}
+proc GDK_TYPE_GL_EVENT_MASK*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                       importc: "gdk_gl_event_mask_get_type".}
+proc gdk_gl_event_type_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_event_type_get_type".}
+proc GDK_TYPE_GL_EVENT_TYPE*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                       importc: "gdk_gl_event_type_get_type".}
+proc gdk_gl_drawable_type_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_drawable_type_get_type".}
+proc GDK_TYPE_GL_DRAWABLE_TYPE*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_drawable_type_get_type".}
+proc gdk_gl_config_mode_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_config_mode_get_type".}
+proc GDK_TYPE_GL_CONFIG_MODE*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                        importc: "gdk_gl_config_mode_get_type".}
+proc gdk_gl_parse_args*(argc: var int32, argv: ptr cstringArray): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_parse_args".}
+proc gdk_gl_init_check*(argc: var int32, argv: ptr cstringArray): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_init_check".}
+proc gdk_gl_init*(argc: var int32, argv: ptr cstringArray){.
+    cdecl, dynlib: GdkGLExtLib, importc: "gdk_gl_init".}
+proc gdk_gl_query_gl_extension*(extension: cstring): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_query_gl_extension".}
+proc gdk_gl_get_proc_address*(proc_name: cstring): TGdkGLProc{.cdecl, 
+    dynlib: GdkGLExtLib, 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 
+  GDK_GL_MODE_RGB* = 0
+  GDK_GL_MODE_RGBA* = 0
+  GDK_GL_MODE_INDEX* = 1 shl 0
+  GDK_GL_MODE_SINGLE* = 0
+  GDK_GL_MODE_DOUBLE* = 1 shl 1
+  GDK_GL_MODE_STEREO* = 1 shl 2
+  GDK_GL_MODE_ALPHA* = 1 shl 3
+  GDK_GL_MODE_DEPTH* = 1 shl 4
+  GDK_GL_MODE_STENCIL* = 1 shl 5
+  GDK_GL_MODE_ACCUM* = 1 shl 6
+  GDK_GL_MODE_MULTISAMPLE* = 1 shl 7
+
+type 
+  TGdkGLConfigMode* = int32
+  PGdkGLConfigMode* = ptr TGdkGLConfigMode
+
+proc GDK_TYPE_GL_CONFIG*(): GType
+proc GDK_GL_CONFIG*(anObject: Pointer): PGdkGLConfig
+proc GDK_GL_CONFIG_CLASS*(klass: Pointer): PGdkGLConfigClass
+proc GDK_IS_GL_CONFIG*(anObject: Pointer): bool
+proc GDK_IS_GL_CONFIG_CLASS*(klass: Pointer): bool
+proc GDK_GL_CONFIG_GET_CLASS*(obj: Pointer): PGdkGLConfigClass
+proc gdk_gl_config_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                       importc: "gdk_gl_config_get_type".}
+proc gdk_gl_config_get_screen*(glconfig: PGdkGLConfig): PGdkScreen{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_get_screen".}
+proc gdk_gl_config_get_attrib*(glconfig: PGdkGLConfig, attribute: int, 
+                               value: var cint): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_get_attrib".}
+proc gdk_gl_config_get_colormap*(glconfig: PGdkGLConfig): PGdkColormap{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_get_colormap".}
+proc gdk_gl_config_get_visual*(glconfig: PGdkGLConfig): PGdkVisual{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_get_visual".}
+proc gdk_gl_config_get_depth*(glconfig: PGdkGLConfig): gint{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_get_depth".}
+proc gdk_gl_config_get_layer_plane*(glconfig: PGdkGLConfig): gint{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_get_layer_plane".}
+proc gdk_gl_config_get_n_aux_buffers*(glconfig: PGdkGLConfig): gint{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_get_n_aux_buffers".}
+proc gdk_gl_config_get_n_sample_buffers*(glconfig: PGdkGLConfig): gint{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_get_n_sample_buffers".}
+proc gdk_gl_config_is_rgba*(glconfig: PGdkGLConfig): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_is_rgba".}
+proc gdk_gl_config_is_double_buffered*(glconfig: PGdkGLConfig): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_is_double_buffered".}
+proc gdk_gl_config_is_stereo*(glconfig: PGdkGLConfig): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_is_stereo".}
+proc gdk_gl_config_has_alpha*(glconfig: PGdkGLConfig): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_has_alpha".}
+proc gdk_gl_config_has_depth_buffer*(glconfig: PGdkGLConfig): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_has_depth_buffer".}
+proc gdk_gl_config_has_stencil_buffer*(glconfig: PGdkGLConfig): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_has_stencil_buffer".}
+proc gdk_gl_config_has_accum_buffer*(glconfig: PGdkGLConfig): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_config_has_accum_buffer".}
+proc GDK_TYPE_GL_CONTEXT*(): GType
+proc GDK_GL_CONTEXT*(anObject: Pointer): PGdkGLContext
+proc GDK_GL_CONTEXT_CLASS*(klass: Pointer): PGdkGLContextClass
+proc GDK_IS_GL_CONTEXT*(anObject: Pointer): bool
+proc GDK_IS_GL_CONTEXT_CLASS*(klass: Pointer): bool
+proc GDK_GL_CONTEXT_GET_CLASS*(obj: Pointer): PGdkGLContextClass
+proc gdk_gl_context_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                        importc: "gdk_gl_context_get_type".}
+proc gdk_gl_context_new*(gldrawable: PGdkGLDrawable, share_list: PGdkGLContext, 
+                         direct: gboolean, render_type: int32): PGdkGLContext{.
+    cdecl, dynlib: GdkGLExtLib, importc: "gdk_gl_context_new".}
+proc gdk_gl_context_destroy*(glcontext: PGdkGLContext){.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_context_destroy".}
+proc gdk_gl_context_copy*(glcontext: PGdkGLContext, src: PGdkGLContext, 
+                          mask: int32): gboolean{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_context_copy".}
+proc gdk_gl_context_get_gl_drawable*(glcontext: PGdkGLContext): PGdkGLDrawable{.
+    cdecl, dynlib: GdkGLExtLib, importc: "gdk_gl_context_get_gl_drawable".}
+proc gdk_gl_context_get_gl_config*(glcontext: PGdkGLContext): PGdkGLConfig{.
+    cdecl, dynlib: GdkGLExtLib, importc: "gdk_gl_context_get_gl_config".}
+proc gdk_gl_context_get_share_list*(glcontext: PGdkGLContext): PGdkGLContext{.
+    cdecl, dynlib: GdkGLExtLib, importc: "gdk_gl_context_get_share_list".}
+proc gdk_gl_context_is_direct*(glcontext: PGdkGLContext): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_context_is_direct".}
+proc gdk_gl_context_get_render_type*(glcontext: PGdkGLContext): int32{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_context_get_render_type".}
+proc gdk_gl_context_get_current*(): PGdkGLContext{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_context_get_current".}
+proc GDK_TYPE_GL_DRAWABLE*(): GType
+proc GDK_GL_DRAWABLE*(inst: Pointer): PGdkGLDrawable
+proc GDK_GL_DRAWABLE_CLASS*(vtable: Pointer): PGdkGLDrawableClass
+proc GDK_IS_GL_DRAWABLE*(inst: Pointer): bool
+proc GDK_IS_GL_DRAWABLE_CLASS*(vtable: Pointer): bool
+proc GDK_GL_DRAWABLE_GET_CLASS*(inst: Pointer): PGdkGLDrawableClass
+proc gdk_gl_drawable_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_drawable_get_type".}
+proc gdk_gl_drawable_make_current*(gldrawable: PGdkGLDrawable, 
+                                   glcontext: PGdkGLContext): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_drawable_make_current".}
+proc gdk_gl_drawable_is_double_buffered*(gldrawable: PGdkGLDrawable): gboolean{.
+    cdecl, dynlib: GdkGLExtLib, importc: "gdk_gl_drawable_is_double_buffered".}
+proc gdk_gl_drawable_swap_buffers*(gldrawable: PGdkGLDrawable){.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_drawable_swap_buffers".}
+proc gdk_gl_drawable_wait_gl*(gldrawable: PGdkGLDrawable){.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_drawable_wait_gl".}
+proc gdk_gl_drawable_wait_gdk*(gldrawable: PGdkGLDrawable){.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_drawable_wait_gdk".}
+proc gdk_gl_drawable_gl_begin*(gldrawable: PGdkGLDrawable, 
+                               glcontext: PGdkGLContext): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_drawable_gl_begin".}
+proc gdk_gl_drawable_gl_end*(gldrawable: PGdkGLDrawable){.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_drawable_gl_end".}
+proc gdk_gl_drawable_get_gl_config*(gldrawable: PGdkGLDrawable): PGdkGLConfig{.
+    cdecl, dynlib: GdkGLExtLib, importc: "gdk_gl_drawable_get_gl_config".}
+proc gdk_gl_drawable_get_size*(gldrawable: PGdkGLDrawable, width, height: PGInt){.
+    cdecl, dynlib: GdkGLExtLib, importc: "gdk_gl_drawable_get_size".}
+proc gdk_gl_drawable_get_current*(): PGdkGLDrawable{.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_drawable_get_current".}
+proc GDK_TYPE_GL_PIXMAP*(): GType
+proc GDK_GL_PIXMAP*(anObject: Pointer): PGdkGLPixmap
+proc GDK_GL_PIXMAP_CLASS*(klass: Pointer): PGdkGLPixmapClass
+proc GDK_IS_GL_PIXMAP*(anObject: Pointer): bool
+proc GDK_IS_GL_PIXMAP_CLASS*(klass: Pointer): bool
+proc GDK_GL_PIXMAP_GET_CLASS*(obj: Pointer): PGdkGLPixmapClass
+proc gdk_gl_pixmap_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                       importc: "gdk_gl_pixmap_get_type".}
+proc gdk_gl_pixmap_new*(glconfig: PGdkGLConfig, pixmap: PGdkPixmap, 
+                        attrib_list: ptr int32): PGdkGLPixmap{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_pixmap_new".}
+proc gdk_gl_pixmap_destroy*(glpixmap: PGdkGLPixmap){.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_pixmap_destroy".}
+proc gdk_gl_pixmap_get_pixmap*(glpixmap: PGdkGLPixmap): PGdkPixmap{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_pixmap_get_pixmap".}
+proc gdk_pixmap_set_gl_capability*(pixmap: PGdkPixmap, glconfig: PGdkGLConfig, 
+                                   attrib_list: ptr int32): PGdkGLPixmap{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_pixmap_set_gl_capability".}
+proc gdk_pixmap_unset_gl_capability*(pixmap: PGdkPixmap){.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_pixmap_unset_gl_capability".}
+proc gdk_pixmap_is_gl_capable*(pixmap: PGdkPixmap): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_pixmap_is_gl_capable".}
+proc gdk_pixmap_get_gl_pixmap*(pixmap: PGdkPixmap): PGdkGLPixmap{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_pixmap_get_gl_pixmap".}
+proc gdk_pixmap_get_gl_drawable*(pixmap: PGdkPixmap): PGdkGLDrawable
+proc GDK_TYPE_GL_WINDOW*(): GType
+proc GDK_GL_WINDOW*(anObject: Pointer): PGdkGLWindow
+proc GDK_GL_WINDOW_CLASS*(klass: Pointer): PGdkGLWindowClass
+proc GDK_IS_GL_WINDOW*(anObject: Pointer): bool
+proc GDK_IS_GL_WINDOW_CLASS*(klass: Pointer): bool
+proc GDK_GL_WINDOW_GET_CLASS*(obj: Pointer): PGdkGLWindowClass
+proc gdk_gl_window_get_type*(): GType{.cdecl, dynlib: GdkGLExtLib, 
+                                       importc: "gdk_gl_window_get_type".}
+proc gdk_gl_window_new*(glconfig: PGdkGLConfig, window: PGdkWindow, 
+                        attrib_list: ptr int32): PGdkGLWindow{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_window_new".}
+proc gdk_gl_window_destroy*(glwindow: PGdkGLWindow){.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_window_destroy".}
+proc gdk_gl_window_get_window*(glwindow: PGdkGLWindow): PGdkWindow{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_window_get_window".}
+proc gdk_window_set_gl_capability*(window: PGdkWindow, glconfig: PGdkGLConfig, 
+                                   attrib_list: ptr int32): PGdkGLWindow{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_window_set_gl_capability".}
+proc gdk_window_unset_gl_capability*(window: PGdkWindow){.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_window_unset_gl_capability".}
+proc gdk_window_is_gl_capable*(window: PGdkWindow): gboolean{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_window_is_gl_capable".}
+proc gdk_window_get_gl_window*(window: PGdkWindow): PGdkGLWindow{.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_window_get_gl_window".}
+proc gdk_window_get_gl_drawable*(window: PGdkWindow): PGdkGLDrawable
+proc gdk_gl_draw_cube*(solid: gboolean, size: float64){.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_draw_cube".}
+proc gdk_gl_draw_sphere*(solid: gboolean, radius: float64, slices: int32, 
+                         stacks: int32){.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_draw_sphere".}
+proc gdk_gl_draw_cone*(solid: gboolean, base: float64, height: float64, 
+                       slices: int32, stacks: int32){.cdecl, 
+    dynlib: GdkGLExtLib, importc: "gdk_gl_draw_cone".}
+proc gdk_gl_draw_torus*(solid: gboolean, inner_radius: float64, 
+                        outer_radius: float64, nsides: int32, rings: int32){.
+    cdecl, dynlib: GdkGLExtLib, importc: "gdk_gl_draw_torus".}
+proc gdk_gl_draw_tetrahedron*(solid: gboolean){.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_draw_tetrahedron".}
+proc gdk_gl_draw_octahedron*(solid: gboolean){.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_draw_octahedron".}
+proc gdk_gl_draw_dodecahedron*(solid: gboolean){.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_draw_dodecahedron".}
+proc gdk_gl_draw_icosahedron*(solid: gboolean){.cdecl, dynlib: GdkGLExtLib, 
+    importc: "gdk_gl_draw_icosahedron".}
+proc gdk_gl_draw_teapot*(solid: gboolean, scale: float64){.cdecl, 
+    dynlib: GdkGLExtLib, 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 GDK_TYPE_GL_CONFIG*(): GType = 
+  result = gdk_gl_config_get_type()
+
+proc GDK_GL_CONFIG*(anObject: Pointer): PGdkGLConfig = 
+  result = cast[PGdkGLConfig](G_TYPE_CHECK_INSTANCE_CAST(anObject, GDK_TYPE_GL_CONFIG()))
+
+proc GDK_GL_CONFIG_CLASS*(klass: Pointer): PGdkGLConfigClass = 
+  result = cast[PGdkGLConfigClass](G_TYPE_CHECK_CLASS_CAST(klass, GDK_TYPE_GL_CONFIG()))
+
+proc GDK_IS_GL_CONFIG*(anObject: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, GDK_TYPE_GL_CONFIG())
+
+proc GDK_IS_GL_CONFIG_CLASS*(klass: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, GDK_TYPE_GL_CONFIG())
+
+proc GDK_GL_CONFIG_GET_CLASS*(obj: Pointer): PGdkGLConfigClass = 
+  result = cast[PGdkGLConfigClass](G_TYPE_INSTANCE_GET_CLASS(obj, GDK_TYPE_GL_CONFIG()))
+
+proc GDK_TYPE_GL_CONTEXT*(): GType = 
+  result = gdk_gl_context_get_type()
+
+proc GDK_GL_CONTEXT*(anObject: Pointer): PGdkGLContext = 
+  result = cast[PGdkGLContext](G_TYPE_CHECK_INSTANCE_CAST(anObject, 
+      GDK_TYPE_GL_CONTEXT()))
+
+proc GDK_GL_CONTEXT_CLASS*(klass: Pointer): PGdkGLContextClass = 
+  result = cast[PGdkGLContextClass](G_TYPE_CHECK_CLASS_CAST(klass, GDK_TYPE_GL_CONTEXT()))
+
+proc GDK_IS_GL_CONTEXT*(anObject: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, GDK_TYPE_GL_CONTEXT())
+
+proc GDK_IS_GL_CONTEXT_CLASS*(klass: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, GDK_TYPE_GL_CONTEXT())
+
+proc GDK_GL_CONTEXT_GET_CLASS*(obj: Pointer): PGdkGLContextClass = 
+  result = cast[PGdkGLContextClass](G_TYPE_INSTANCE_GET_CLASS(obj, GDK_TYPE_GL_CONTEXT()))
+
+proc GDK_TYPE_GL_DRAWABLE*(): GType = 
+  result = gdk_gl_drawable_get_type()
+
+proc GDK_GL_DRAWABLE*(inst: Pointer): PGdkGLDrawable = 
+  result = cast[PGdkGLDrawable](G_TYPE_CHECK_INSTANCE_CAST(inst, GDK_TYPE_GL_DRAWABLE()))
+
+proc GDK_GL_DRAWABLE_CLASS*(vtable: Pointer): PGdkGLDrawableClass = 
+  result = cast[PGdkGLDrawableClass](G_TYPE_CHECK_CLASS_CAST(vtable, 
+      GDK_TYPE_GL_DRAWABLE()))
+
+proc GDK_IS_GL_DRAWABLE*(inst: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(inst, GDK_TYPE_GL_DRAWABLE())
+
+proc GDK_IS_GL_DRAWABLE_CLASS*(vtable: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(vtable, GDK_TYPE_GL_DRAWABLE())
+
+proc GDK_GL_DRAWABLE_GET_CLASS*(inst: Pointer): PGdkGLDrawableClass = 
+  result = cast[PGdkGLDrawableClass](G_TYPE_INSTANCE_GET_INTERFACE(inst, 
+      GDK_TYPE_GL_DRAWABLE()))
+
+proc GDK_TYPE_GL_PIXMAP*(): GType = 
+  result = gdk_gl_pixmap_get_type()
+
+proc GDK_GL_PIXMAP*(anObject: Pointer): PGdkGLPixmap = 
+  result = cast[PGdkGLPixmap](G_TYPE_CHECK_INSTANCE_CAST(anObject, GDK_TYPE_GL_PIXMAP()))
+
+proc GDK_GL_PIXMAP_CLASS*(klass: Pointer): PGdkGLPixmapClass = 
+  result = cast[PGdkGLPixmapClass](G_TYPE_CHECK_CLASS_CAST(klass, GDK_TYPE_GL_PIXMAP()))
+
+proc GDK_IS_GL_PIXMAP*(anObject: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, GDK_TYPE_GL_PIXMAP())
+
+proc GDK_IS_GL_PIXMAP_CLASS*(klass: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, GDK_TYPE_GL_PIXMAP())
+
+proc GDK_GL_PIXMAP_GET_CLASS*(obj: Pointer): PGdkGLPixmapClass = 
+  result = cast[PGdkGLPixmapClass](G_TYPE_INSTANCE_GET_CLASS(obj, GDK_TYPE_GL_PIXMAP()))
+
+proc gdk_pixmap_get_gl_drawable*(pixmap: PGdkPixmap): PGdkGLDrawable = 
+  result = GDK_GL_DRAWABLE(gdk_pixmap_get_gl_pixmap(pixmap))
+
+proc GDK_TYPE_GL_WINDOW*(): GType = 
+  result = gdk_gl_window_get_type()
+
+proc GDK_GL_WINDOW*(anObject: Pointer): PGdkGLWindow = 
+  result = cast[PGdkGLWindow](G_TYPE_CHECK_INSTANCE_CAST(anObject, GDK_TYPE_GL_WINDOW()))
+
+proc GDK_GL_WINDOW_CLASS*(klass: Pointer): PGdkGLWindowClass = 
+  result = cast[PGdkGLWindowClass](G_TYPE_CHECK_CLASS_CAST(klass, GDK_TYPE_GL_WINDOW()))
+
+proc GDK_IS_GL_WINDOW*(anObject: Pointer): bool = 
+  result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, GDK_TYPE_GL_WINDOW())
+
+proc GDK_IS_GL_WINDOW_CLASS*(klass: Pointer): bool = 
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, GDK_TYPE_GL_WINDOW())
+
+proc GDK_GL_WINDOW_GET_CLASS*(obj: Pointer): PGdkGLWindowClass = 
+  result = cast[PGdkGLWindowClass](G_TYPE_INSTANCE_GET_CLASS(obj, GDK_TYPE_GL_WINDOW()))
+
+proc gdk_window_get_gl_drawable*(window: PGdkWindow): PGdkGLDrawable = 
+  result = GDK_GL_DRAWABLE(gdk_window_get_gl_window(window))

lib/oldwrappers/gtk/gtkglext.nim

@@ -0,0 +1,50 @@
+{.deadCodeElim: on.}
+
+import 
+  Glib2, Gdk2, Gtk2, GdkGLExt
+
+const 
+  GtkGLExtLib* = 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 gtk_gl_parse_args*(argc: Plongint, argv: PPPChar): gboolean{.cdecl, 
+    dynlib: GtkGLExtLib, importc: "gtk_gl_parse_args".}
+proc gtk_gl_init_check*(argc: Plongint, argv: PPPChar): gboolean{.cdecl, 
+    dynlib: GtkGLExtLib, importc: "gtk_gl_init_check".}
+proc gtk_gl_init*(argc: Plongint, argv: PPPChar){.cdecl, dynlib: GtkGLExtLib, 
+    importc: "gtk_gl_init".}
+proc gtk_widget_set_gl_capability*(widget: PGtkWidget, glconfig: PGdkGLConfig, 
+                                   share_list: PGdkGLContext, direct: gboolean, 
+                                   render_type: int): gboolean{.cdecl, 
+    dynlib: GtkGLExtLib, importc: "gtk_widget_set_gl_capability".}
+proc gtk_widget_is_gl_capable*(widget: PGtkWidget): gboolean{.cdecl, 
+    dynlib: GtkGLExtLib, importc: "gtk_widget_is_gl_capable".}
+proc gtk_widget_get_gl_config*(widget: PGtkWidget): PGdkGLConfig{.cdecl, 
+    dynlib: GtkGLExtLib, importc: "gtk_widget_get_gl_config".}
+proc gtk_widget_create_gl_context*(widget: PGtkWidget, 
+                                   share_list: PGdkGLContext, direct: gboolean, 
+                                   render_type: int): PGdkGLContext{.cdecl, 
+    dynlib: GtkGLExtLib, importc: "gtk_widget_create_gl_context".}
+proc gtk_widget_get_gl_context*(widget: PGtkWidget): PGdkGLContext{.cdecl, 
+    dynlib: GtkGLExtLib, importc: "gtk_widget_get_gl_context".}
+proc gtk_widget_get_gl_window*(widget: PGtkWidget): PGdkGLWindow{.cdecl, 
+    dynlib: GtkGLExtLib, importc: "gtk_widget_get_gl_window".}
+proc gtk_widget_get_gl_drawable*(widget: PGtkWidget): PGdkGLDrawable = 
+  nil
+
+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 gtk_widget_get_gl_drawable*(widget: PGtkWidget): PGdkGLDrawable = 
+  result = GDK_GL_DRAWABLE(gtk_widget_get_gl_window(widget))

lib/oldwrappers/gtk/gtkhtml.nim

@@ -0,0 +1,499 @@
+{.deadCodeElim: on.}
+
+import 
+  gtk2, glib2, atk, pango, gdk2pixbuf, gdk2
+
+when defined(windows): 
+  {.define: GTK_WINDOWING_WIN32.}
+  const 
+    gtkhtmllib = "libgtkhtml-win32-2.0-0.dll"
+else: 
+  const 
+    gtkhtmllib = "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
+  TDomBoolean* = gboolean
+  TDomException* = gushort
+  TDomTimeStamp* = guint64
+  PDomNode* = ptr TDomNode
+  TDomNode* = object of TGObject
+    xmlnode*: pointer
+    style*: pointer
+
+  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*: xmlParserCtxtPtr
+    res*: int32
+    chars*: array[0..9, char]
+    blocking*: gboolean
+    blocking_node*: PDomNode
+
+  PHtmlParserClass* = ptr THtmlParserClass
+  THtmlParserClass* = object of TGtkObjectClass
+    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: Pgchar, 
+                                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: Pgchar, len: gint, 
+                                      user_data: gpointer){.cdecl.}
+  PGtkHtmlContext* = ptr TGtkHtmlContext
+  TGtkHtmlContext* = object of TGObject
+    documents*: PGSList
+    standard_font*: PHtmlFontSpecification
+    fixed_font*: PHtmlFontSpecification
+    debug_painting*: gboolean
+
+  PGtkHtmlContextClass* = ptr TGtkHtmlContextClass
+  TGtkHtmlContextClass* = 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: Pgchar, 
+                        stream: PHtmlStream){.cdecl.}
+    link_clicked*: proc (document: PHtmlDocument, url: Pgchar){.cdecl.}
+    set_base*: proc (document: PHtmlDocument, url: Pgchar){.cdecl.}
+    title_changed*: proc (document: PHtmlDocument, new_title: Pgchar){.cdecl.}
+    submit*: proc (document: PHtmlDocument, `method`: Pgchar, url: Pgchar, 
+                   encoding: Pgchar){.cdecl.}
+
+  PHtmlView* = ptr THtmlView
+  THtmlView* = object of TGtkLayout
+    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*: pgchar
+    magnification*: gdouble
+    magnification_modified*: gboolean
+    on_url*: gboolean
+
+  PHtmlViewClass* = ptr THtmlViewClass
+  THtmlViewClass* = object of TGtkLayoutClass
+    move_cursor*: proc (html_view: PHtmlView, step: TGtkMovementStep, 
+                        count: gint, extend_selection: gboolean){.cdecl.}
+    on_url*: proc (html_view: PHtmlView, url: Pgchar)
+    activate*: proc (html_view: PHtmlView)
+    move_focus_out*: proc (html_view: PHtmlView, direction: TGtkDirectionType)
+
+
+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: gtkhtmllib, 
+                                  importc: "dom_node_get_type".}
+proc dom_Node_mkref*(node: pointer): PDomNode{.cdecl, dynlib: gtkhtmllib, 
+    importc: "dom_Node_mkref".}
+proc dom_Node_get_childNodes*(node: PDomNode): PDomNodeList{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_childNodes".}
+proc dom_Node_removeChild*(node: PDomNode, oldChild: PDomNode, 
+                           exc: PDomException): PDomNode{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node_removeChild".}
+proc dom_Node_get_nodeValue*(node: PDomNode, exc: PDomException): PDomString{.
+    cdecl, dynlib: gtkhtmllib, importc: "dom_Node__get_nodeValue".}
+proc dom_Node_get_firstChild*(node: PDomNode): PDomNode{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_firstChild".}
+proc dom_Node_get_nodeName*(node: PDomNode): PDomString{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_nodeName".}
+proc dom_Node_get_attributes*(node: PDomNode): PDomNamedNodeMap{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_attributes".}
+proc dom_Document_get_doctype*(doc: PDomDocument): PDomDocumentType{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Document__get_doctype".}
+proc dom_Node_hasChildNodes*(node: PDomNode): DomBoolean{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node_hasChildNodes".}
+proc dom_Node_get_parentNode*(node: PDomNode): PDomNode{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_parentNode".}
+proc dom_Node_get_nextSibling*(node: PDomNode): PDomNode{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_nextSibling".}
+proc dom_Node_get_nodeType*(node: PDomNode): gushort{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_nodeType".}
+proc dom_Node_hasAttributes*(node: PDomNode): DomBoolean{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node_hasAttributes".}
+proc dom_Node_cloneNode*(node: PDomNode, deep: DomBoolean): PDomNode{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node_cloneNode".}
+proc dom_Node_appendChild*(node: PDomNode, newChild: PDomNode, 
+                           exc: PDomException): PDomNode{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node_appendChild".}
+proc dom_Node_get_localName*(node: PDomNode): PDomString{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_localName".}
+proc dom_Node_get_namespaceURI*(node: PDomNode): PDomString{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_namespaceURI".}
+proc dom_Node_get_previousSibling*(node: PDomNode): PDomNode{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_previousSibling".}
+proc dom_Node_get_lastChild*(node: PDomNode): PDomNode{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_lastChild".}
+proc dom_Node_set_nodeValue*(node: PDomNode, value: PDomString, 
+                             exc: PDomException){.cdecl, dynlib: gtkhtmllib, 
+    importc: "dom_Node__set_nodeValue".}
+proc dom_Node_get_ownerDocument*(node: PDomNode): PDomDocument{.cdecl, 
+    dynlib: gtkhtmllib, importc: "dom_Node__get_ownerDocument".}
+proc dom_Node_hasAttributes*(node: PDomNode): gboolean{.cdecl, 
+    dynlib: gtkhtmllib, 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 dom_Document_get_documentElement*(doc: PDomDocument): PDomElement
+proc dom_Document_createElement*(doc: PDomDocument, tagName: PDomString): PDomElement
+proc dom_Document_createTextNode*(doc: PDomDocument, data: PDomString): PDomText
+proc dom_Document_createComment*(doc: PDomDocument, data: PDomString): PDomComment
+proc dom_Document_importNode*(doc: PDomDocument, importedNode: PDomNode, 
+                              deep: DomBoolean, 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: gtkhtmllib, importc: "html_focus_iterator_next_element".}
+proc html_focus_iterator_prev_element*(document: PDomDocument, 
+                                       element: PDomElement): PDomElement{.
+    cdecl, dynlib: gtkhtmllib, 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 html_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: gtkhtmllib, 
+                                     importc: "html_stream_get_type".}
+proc html_stream_new*(write_func: THtmlStreamWriteFunc, 
+                      close_func: THtmlStreamCloseFunc, user_data: gpointer): PHtmlStream{.
+    cdecl, dynlib: gtkhtmllib, importc: "html_stream_new".}
+proc html_stream_write*(stream: PHtmlStream, buffer: Pgchar, size: guint){.
+    cdecl, dynlib: gtkhtmllib, importc: "html_stream_write".}
+proc html_stream_close*(stream: PHtmlStream){.cdecl, dynlib: gtkhtmllib, 
+    importc: "html_stream_close".}
+proc html_stream_destroy*(stream: PHtmlStream){.cdecl, dynlib: gtkhtmllib, 
+    importc: "html_stream_destroy".}
+proc html_stream_get_written*(stream: PHtmlStream): gint{.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_stream_get_written".}
+proc html_stream_cancel*(stream: PHtmlStream){.cdecl, dynlib: gtkhtmllib, 
+    importc: "html_stream_cancel".}
+proc html_stream_set_cancel_func*(stream: PHtmlStream, 
+                                  abort_func: THtmlStreamCancelFunc, 
+                                  cancel_data: gpointer){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_stream_set_cancel_func".}
+proc html_stream_get_mime_type*(stream: PHtmlStream): cstring{.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_stream_get_mime_type".}
+proc html_stream_set_mime_type*(stream: PHtmlStream, mime_type: cstring){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_stream_set_mime_type".}
+proc html_stream_buffer_new*(close_func: THtmlStreamBufferCloseFunc, 
+                             user_data: gpointer): PHtmlStream{.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_stream_buffer_new".}
+proc html_event_mouse_move*(view: PHtmlView, event: PGdkEventMotion){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_event_mouse_move".}
+proc html_event_button_press*(view: PHtmlView, button: PGdkEventButton){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_event_button_press".}
+proc html_event_button_release*(view: PHtmlView, event: PGdkEventButton){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_event_button_release".}
+proc html_event_activate*(view: PHtmlView){.cdecl, dynlib: gtkhtmllib, 
+    importc: "html_event_activate".}
+proc html_event_key_press*(view: PHtmlView, event: PGdkEventKey): gboolean{.
+    cdecl, dynlib: gtkhtmllib, importc: "html_event_key_press".}
+proc html_event_find_root_box*(self: PHtmlBox, x: gint, y: gint): PHtmlBox{.
+    cdecl, dynlib: gtkhtmllib, importc: "html_event_find_root_box".}
+proc html_selection_start*(view: PHtmlView, event: PGdkEventButton){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_selection_start".}
+proc html_selection_end*(view: PHtmlView, event: PGdkEventButton){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_selection_end".}
+proc html_selection_update*(view: PHtmlView, event: PGdkEventMotion){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_selection_update".}
+proc html_selection_clear*(view: PHtmlView){.cdecl, dynlib: gtkhtmllib, 
+    importc: "html_selection_clear".}
+proc html_selection_set*(view: PHtmlView, start: PDomNode, offset: int32, 
+                         len: int32){.cdecl, dynlib: gtkhtmllib, 
+                                      importc: "html_selection_set".}
+proc GTK_HTML_CONTEXT_TYPE*(): GType
+proc GTK_HTML_CONTEXT*(obj: pointer): PGtkHtmlContext
+proc GTK_HTML_CONTEXT_CLASS*(klass: pointer): PGtkHtmlContextClass
+proc GTK_HTML_IS_CONTEXT*(obj: pointer): bool
+proc GTK_HTML_IS_CONTEXT_CLASS*(klass: pointer): bool
+proc gtk_html_context_get_type*(): GType
+proc gtk_html_context_get*(): PGtkHtmlContext
+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: gtkhtmllib, 
+                                       importc: "html_document_get_type".}
+proc html_document_new*(): PHtmlDocument{.cdecl, dynlib: gtkhtmllib, 
+    importc: "html_document_new".}
+proc html_document_open_stream*(document: PHtmlDocument, mime_type: Pgchar): gboolean{.
+    cdecl, dynlib: gtkhtmllib, importc: "html_document_open_stream".}
+proc html_document_write_stream*(document: PHtmlDocument, buffer: Pgchar, 
+                                 len: gint){.cdecl, dynlib: gtkhtmllib, 
+    importc: "html_document_write_stream".}
+proc html_document_close_stream*(document: PHtmlDocument){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_document_close_stream".}
+proc html_document_clear*(document: PHtmlDocument){.cdecl, dynlib: gtkhtmllib, 
+    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: gtkhtmllib, 
+                                   importc: "html_view_get_type".}
+proc html_view_new*(): PGtkWidget{.cdecl, dynlib: gtkhtmllib, 
+                                   importc: "html_view_new".}
+proc html_view_set_document*(view: PHtmlView, document: PHtmlDocument){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_view_set_document".}
+proc html_view_jump_to_anchor*(view: PHtmlView, anchor: Pgchar){.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_view_jump_to_anchor".}
+proc html_view_get_magnification*(view: PHtmlView): gdouble{.cdecl, 
+    dynlib: gtkhtmllib, importc: "html_view_get_magnification".}
+proc html_view_set_magnification*(view: PHtmlView, magnification: gdouble){.
+    cdecl, dynlib: gtkhtmllib, importc: "html_view_set_magnification".}
+proc html_view_zoom_in*(view: PHtmlView){.cdecl, dynlib: gtkhtmllib, 
+    importc: "html_view_zoom_in".}
+proc html_view_zoom_out*(view: PHtmlView){.cdecl, dynlib: gtkhtmllib, 
+    importc: "html_view_zoom_out".}
+proc html_view_zoom_reset*(view: PHtmlView){.cdecl, dynlib: gtkhtmllib, 
+    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(), TDomNode)
+
+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 = GTK_CHECK_CAST(obj, HTML_PARSER_TYPE(), THtmlParser)
+
+proc HTML_PARSER_CLASS*(klass: pointer): PHtmlParserClass = 
+  result = GTK_CHECK_CLASS_CAST(klass, HTML_PARSER_TYPE(), THtmlParserClass)
+
+proc HTML_IS_PARSER*(obj: pointer): bool = 
+  result = GTK_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 GTK_HTML_CONTEXT_TYPE*(): GType = 
+  result = gtk_html_context_get_type()
+
+proc GTK_HTML_CONTEXT*(obj: pointer): PGtkHtmlContext = 
+  result = GTK_CHECK_CAST(obj, GTK_HTML_CONTEXT_TYPE(), TGtkHtmlContext)
+
+proc GTK_HTML_CONTEXT_CLASS*(klass: pointer): PGtkHtmlContextClass = 
+  result = GTK_CHECK_CLASS_CAST(klass, GTK_HTML_CONTEXT_TYPE(), 
+                                TGtkHtmlContextClass)
+
+proc GTK_HTML_IS_CONTEXT*(obj: pointer): bool = 
+  result = GTK_CHECK_TYPE(obj, GTK_HTML_CONTEXT_TYPE())
+
+proc GTK_HTML_IS_CONTEXT_CLASS*(klass: pointer): bool = 
+  result = GTK_CHECK_CLASS_TYPE(klass, GTK_HTML_CONTEXT_TYPE())
+
+proc HTML_TYPE_DOCUMENT*(): GType = 
+  result = html_document_get_type()
+
+proc HTML_DOCUMENT*(obj: pointer): PHtmlDocument = 
+  result = PHtmlDocument(GTK_CHECK_CAST(obj, HTML_TYPE_DOCUMENT()))
+
+proc HTML_DOCUMENT_CLASS*(klass: pointer): PHtmlDocumentClass = 
+  result = GTK_CHECK_CLASS_CAST(klass, HTML_TYPE_DOCUMENT())
+
+proc HTML_IS_DOCUMENT*(obj: pointer): bool = 
+  result = GTK_CHECK_TYPE(obj, HTML_TYPE_DOCUMENT())
+
+proc HTML_TYPE_VIEW*(): GType = 
+  result = html_view_get_type()
+
+proc HTML_VIEW*(obj: pointer): PHtmlView = 
+  result = PHtmlView(GTK_CHECK_CAST(obj, HTML_TYPE_VIEW()))
+
+proc HTML_VIEW_CLASS*(klass: pointer): PHtmlViewClass = 
+  result = PHtmlViewClass(GTK_CHECK_CLASS_CAST(klass, HTML_TYPE_VIEW()))
+
+proc HTML_IS_VIEW*(obj: pointer): bool = 
+  result = GTK_CHECK_TYPE(obj, HTML_TYPE_VIEW())

lib/oldwrappers/gtk/libglade2.nim

@@ -0,0 +1,118 @@
+{.deadCodeElim: on.}
+
+import
+  glib2, gtk2
+
+when defined(win32):
+  const
+    LibGladeLib = "libglade-2.0-0.dll"
+else:
+  const
+    LibGladeLib = "libglade-2.0.so"
+type
+  PLongint* = ptr int32
+  PSmallInt* = ptr int16
+  PByte* = ptr int8
+  PWord* = ptr int16
+  PDWord* = ptr int32
+  PDouble* = ptr float64
+
+proc glade_init*(){.cdecl, dynlib: LibGladeLib, importc: "glade_init".}
+proc glade_require*(TheLibrary: cstring){.cdecl, dynlib: LibGladeLib,
+    importc: "glade_require".}
+proc glade_provide*(TheLibrary: cstring){.cdecl, dynlib: LibGladeLib,
+    importc: "glade_provide".}
+type
+  PGladeXMLPrivate* = pointer
+  PGladeXML* = ptr TGladeXML
+  TGladeXML* = object of TGObject
+    filename*: cstring
+    priv*: PGladeXMLPrivate
+
+  PGladeXMLClass* = ptr TGladeXMLClass
+  TGladeXMLClass* = object of TGObjectClass
+
+  TGladeXMLConnectFunc* = proc (handler_name: cstring, anObject: PGObject,
+                                signal_name: cstring, signal_data: cstring,
+                                connect_object: PGObject, after: gboolean,
+                                user_data: gpointer){.cdecl.}
+
+proc GLADE_TYPE_XML*(): GType
+proc GLADE_XML*(obj: pointer): PGladeXML
+proc GLADE_XML_CLASS*(klass: pointer): PGladeXMLClass
+proc GLADE_IS_XML*(obj: pointer): gboolean
+proc GLADE_IS_XML_CLASS*(klass: pointer): gboolean
+proc GLADE_XML_GET_CLASS*(obj: pointer): PGladeXMLClass
+proc glade_xml_get_type*(): GType{.cdecl, dynlib: LibGladeLib,
+                                   importc: "glade_xml_get_type".}
+proc glade_xml_new*(fname: cstring, root: cstring, domain: cstring): PGladeXML{.
+    cdecl, dynlib: LibGladeLib, importc: "glade_xml_new".}
+proc glade_xml_new_from_buffer*(buffer: cstring, size: int32, root: cstring,
+                                domain: cstring): PGladeXML{.cdecl,
+    dynlib: LibGladeLib, importc: "glade_xml_new_from_buffer".}
+proc glade_xml_construct*(self: PGladeXML, fname: cstring, root: cstring,
+                          domain: cstring): gboolean{.cdecl,
+    dynlib: LibGladeLib, importc: "glade_xml_construct".}
+proc glade_xml_signal_connect*(self: PGladeXML, handlername: cstring,
+                               func: TGCallback){.cdecl, dynlib: LibGladeLib,
+    importc: "glade_xml_signal_connect".}
+proc glade_xml_signal_connect_data*(self: PGladeXML, handlername: cstring,
+                                    func: TGCallback, user_data: gpointer){.
+    cdecl, dynlib: LibGladeLib, importc: "glade_xml_signal_connect_data".}
+proc glade_xml_signal_autoconnect*(self: PGladeXML){.cdecl, dynlib: LibGladeLib,
+    importc: "glade_xml_signal_autoconnect".}
+proc glade_xml_signal_connect_full*(self: PGladeXML, handler_name: cstring,
+                                    func: TGladeXMLConnectFunc,
+                                    user_data: gpointer){.cdecl,
+    dynlib: LibGladeLib, importc: "glade_xml_signal_connect_full".}
+proc glade_xml_signal_autoconnect_full*(self: PGladeXML,
+                                        func: TGladeXMLConnectFunc,
+                                        user_data: gpointer){.cdecl,
+    dynlib: LibGladeLib, importc: "glade_xml_signal_autoconnect_full".}
+proc glade_xml_get_widget*(self: PGladeXML, name: cstring): PGtkWidget{.cdecl,
+    dynlib: LibGladeLib, importc: "glade_xml_get_widget".}
+proc glade_xml_get_widget_prefix*(self: PGladeXML, name: cstring): PGList{.
+    cdecl, dynlib: LibGladeLib, importc: "glade_xml_get_widget_prefix".}
+proc glade_xml_relative_file*(self: PGladeXML, filename: cstring): cstring{.cdecl,
+    dynlib: LibGladeLib, importc: "glade_xml_relative_file".}
+proc glade_get_widget_name*(widget: PGtkWidget): cstring{.cdecl,
+    dynlib: LibGladeLib, importc: "glade_get_widget_name".}
+proc glade_get_widget_tree*(widget: PGtkWidget): PGladeXML{.cdecl,
+    dynlib: LibGladeLib, importc: "glade_get_widget_tree".}
+type
+  PGladeXMLCustomWidgetHandler* = ptr TGladeXMLCustomWidgetHandler
+  TGladeXMLCustomWidgetHandler* = TGtkWidget
+
+proc glade_set_custom_handler*(handler: TGladeXMLCustomWidgetHandler,
+                               user_data: gpointer){.cdecl, dynlib: LibGladeLib,
+    importc: "glade_set_custom_handler".}
+proc glade_gnome_init*() =
+  glade_init()
+
+proc glade_bonobo_init*() =
+  glade_init()
+
+proc glade_xml_new_with_domain*(fname: cstring, root: cstring, domain: cstring): PGladeXML =
+  result = glade_xml_new(fname, root, domain)
+
+proc glade_xml_new_from_memory*(buffer: cstring, size: int32, root: cstring,
+                                domain: cstring): PGladeXML =
+  result = glade_xml_new_from_buffer(buffer, size, root, domain)
+
+proc GLADE_TYPE_XML*(): GType =
+  result = glade_xml_get_type()
+
+proc GLADE_XML*(obj: pointer): PGladeXML =
+  result = cast[PGladeXML](G_TYPE_CHECK_INSTANCE_CAST(obj, GLADE_TYPE_XML()))
+
+proc GLADE_XML_CLASS*(klass: pointer): PGladeXMLClass =
+  result = cast[PGladeXMLClass](G_TYPE_CHECK_CLASS_CAST(klass, GLADE_TYPE_XML()))
+
+proc GLADE_IS_XML*(obj: pointer): gboolean =
+  result = G_TYPE_CHECK_INSTANCE_TYPE(obj, GLADE_TYPE_XML())
+
+proc GLADE_IS_XML_CLASS*(klass: pointer): gboolean =
+  result = G_TYPE_CHECK_CLASS_TYPE(klass, GLADE_TYPE_XML())
+
+proc GLADE_XML_GET_CLASS*(obj: pointer): PGladeXMLClass =
+  result = cast[PGladeXMLClass](G_TYPE_INSTANCE_GET_CLASS(obj, GLADE_TYPE_XML()))

lib/oldwrappers/gtk/pangoutils.nim

@@ -0,0 +1,46 @@
+{.deadCodeElim: on.}
+
+import
+  glib2, pango
+
+type
+  pint32* = ptr int32
+
+proc pango_split_file_list*(str: cstring): PPchar{.cdecl, dynlib: pangolib,
+    importc: "pango_split_file_list".}
+proc pango_trim_string*(str: cstring): cstring{.cdecl, dynlib: pangolib,
+    importc: "pango_trim_string".}
+proc pango_read_line*(stream: TFile, str: PGString): gint{.cdecl,
+    dynlib: pangolib, importc: "pango_read_line".}
+proc pango_skip_space*(pos: PPchar): gboolean{.cdecl, dynlib: pangolib,
+    importc: "pango_skip_space".}
+proc pango_scan_word*(pos: PPchar, OutStr: PGString): gboolean{.cdecl,
+    dynlib: pangolib, importc: "pango_scan_word".}
+proc pango_scan_string*(pos: PPchar, OutStr: PGString): gboolean{.cdecl,
+    dynlib: pangolib, importc: "pango_scan_string".}
+proc pango_scan_int*(pos: PPchar, OutInt: pint32): gboolean{.cdecl,
+    dynlib: pangolib, importc: "pango_scan_int".}
+proc pango_config_key_get(key: cstring): cstring{.cdecl, dynlib: pangolib,
+    importc: "pango_config_key_get".}
+proc pango_lookup_aliases(fontname: cstring, families: PPPchar,
+                          n_families: pint32){.cdecl, dynlib: pangolib,
+    importc: "pango_lookup_aliases".}
+proc pango_parse_style*(str: cstring, style: PPangoStyle, warn: gboolean): gboolean{.
+    cdecl, dynlib: pangolib, importc: "pango_parse_style".}
+proc pango_parse_variant*(str: cstring, variant: PPangoVariant, warn: gboolean): gboolean{.
+    cdecl, dynlib: pangolib, importc: "pango_parse_variant".}
+proc pango_parse_weight*(str: cstring, weight: PPangoWeight, warn: gboolean): gboolean{.
+    cdecl, dynlib: pangolib, importc: "pango_parse_weight".}
+proc pango_parse_stretch*(str: cstring, stretch: PPangoStretch, warn: gboolean): gboolean{.
+    cdecl, dynlib: pangolib, importc: "pango_parse_stretch".}
+proc pango_get_sysconf_subdirectory(): cstring{.cdecl, dynlib: pangolib,
+    importc: "pango_get_sysconf_subdirectory".}
+proc pango_get_lib_subdirectory(): cstring{.cdecl, dynlib: pangolib,
+    importc: "pango_get_lib_subdirectory".}
+proc pango_log2vis_get_embedding_levels*(str: Pgunichar, len: int32,
+    pbase_dir: PPangoDirection, embedding_level_list: Pguint8): gboolean{.cdecl,
+    dynlib: pangolib, importc: "pango_log2vis_get_embedding_levels".}
+proc pango_get_mirror_char*(ch: gunichar, mirrored_ch: Pgunichar): gboolean{.
+    cdecl, dynlib: pangolib, importc: "pango_get_mirror_char".}
+proc pango_language_get_sample_string*(language: PPangoLanguage): cstring{.
+    cdecl, dynlib: pangolib, importc: "pango_language_get_sample_string".}

lib/oldwrappers/iup.nim

@@ -0,0 +1,945 @@
+#
+#    Binding for the IUP GUI toolkit
+#       (c) 2010 Andreas Rumpf 
+#    C header files translated by hand
+#    Licence of IUP follows:
+
+
+# ****************************************************************************
+# Copyright (C) 1994-2009 Tecgraf, PUC-Rio.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# ****************************************************************************
+
+{.deadCodeElim: on.}
+
+when defined(windows): 
+  const dllname = "iup(30|27|26|25|24).dll"
+elif defined(macosx):
+  const dllname = "libiup(3.0|2.7|2.6|2.5|2.4).dylib"
+else: 
+  const dllname = "libiup(3.0|2.7|2.6|2.5|2.4).so.1"
+
+const
+  IUP_NAME* = "IUP - Portable User Interface"
+  IUP_COPYRIGHT* = "Copyright (C) 1994-2009 Tecgraf, PUC-Rio."
+  IUP_DESCRIPTION* = "Portable toolkit for building graphical user interfaces."
+  constIUP_VERSION* = "3.0"
+  constIUP_VERSION_NUMBER* = 300000
+  constIUP_VERSION_DATE* = "2009/07/18"
+
+type
+  Ihandle {.pure.} = object
+  PIhandle* = ptr Ihandle
+
+  Icallback* = proc (arg: PIhandle): cint {.cdecl.}
+
+#                      pre-definided dialogs
+proc FileDlg*: PIhandle {.importc: "IupFileDlg", dynlib: dllname, cdecl.}
+proc MessageDlg*: PIhandle {.importc: "IupMessageDlg", dynlib: dllname, cdecl.}
+proc ColorDlg*: PIhandle {.importc: "IupColorDlg", dynlib: dllname, cdecl.}
+proc FontDlg*: PIhandle {.importc: "IupFontDlg", dynlib: dllname, cdecl.}
+
+proc GetFile*(arq: cstring): cint {.
+  importc: "IupGetFile", dynlib: dllname, cdecl.}
+proc Message*(title, msg: cstring) {.
+  importc: "IupMessage", dynlib: dllname, cdecl.}
+proc Messagef*(title, format: cstring) {.
+  importc: "IupMessagef", dynlib: dllname, cdecl, varargs.}
+proc Alarm*(title, msg, b1, b2, b3: cstring): cint {.
+  importc: "IupAlarm", dynlib: dllname, cdecl.}
+proc Scanf*(format: cstring): cint {.
+  importc: "IupScanf", dynlib: dllname, cdecl, varargs.}
+proc ListDialog*(theType: cint, title: cstring, size: cint, 
+                 list: cstringArray, op, max_col, max_lin: cint, 
+                 marks: ptr cint): cint {.
+                 importc: "IupListDialog", dynlib: dllname, cdecl.}
+proc GetText*(title, text: cstring): cint {.
+  importc: "IupGetText", dynlib: dllname, cdecl.}
+proc GetColor*(x, y: cint, r, g, b: var byte): cint {.
+  importc: "IupGetColor", dynlib: dllname, cdecl.}
+
+type
+  Iparamcb* = proc (dialog: PIhandle, param_index: cint, 
+                    user_data: pointer): cint {.cdecl.}
+
+proc GetParam*(title: cstring, action: Iparamcb, user_data: pointer, 
+               format: cstring): cint {.
+               importc: "IupGetParam", cdecl, varargs, dynlib: dllname.}
+proc GetParamv*(title: cstring, action: Iparamcb, user_data: pointer, 
+                format: cstring, param_count, param_extra: cint, 
+                param_data: pointer): cint {.
+                importc: "IupGetParamv", cdecl, dynlib: dllname.}
+
+
+#                      Functions
+
+proc Open*(argc: ptr cint, argv: ptr cstringArray): cint {.
+  importc: "IupOpen", cdecl, dynlib: dllname.}
+proc Close*() {.importc: "IupClose", cdecl, dynlib: dllname.}
+proc ImageLibOpen*() {.importc: "IupImageLibOpen", cdecl, dynlib: dllname.}
+
+proc MainLoop*(): cint {.importc: "IupMainLoop", cdecl, dynlib: dllname.}
+proc LoopStep*(): cint {.importc: "IupLoopStep", cdecl, dynlib: dllname.}
+proc MainLoopLevel*(): cint {.importc: "IupMainLoopLevel", cdecl, dynlib: dllname.}
+proc Flush*() {.importc: "IupFlush", cdecl, dynlib: dllname.}
+proc ExitLoop*() {.importc: "IupExitLoop", cdecl, dynlib: dllname.}
+
+proc Update*(ih: PIhandle) {.importc: "IupUpdate", cdecl, dynlib: dllname.}
+proc UpdateChildren*(ih: PIhandle) {.importc: "IupUpdateChildren", cdecl, dynlib: dllname.}
+proc Redraw*(ih: PIhandle, children: cint) {.importc: "IupRedraw", cdecl, dynlib: dllname.}
+proc Refresh*(ih: PIhandle) {.importc: "IupRefresh", cdecl, dynlib: dllname.}
+
+proc MapFont*(iupfont: cstring): cstring {.importc: "IupMapFont", cdecl, dynlib: dllname.}
+proc UnMapFont*(driverfont: cstring): cstring {.importc: "IupUnMapFont", cdecl, dynlib: dllname.}
+proc Help*(url: cstring): cint {.importc: "IupHelp", cdecl, dynlib: dllname.}
+proc Load*(filename: cstring): cstring {.importc: "IupLoad", cdecl, dynlib: dllname.}
+
+proc IupVersion*(): cstring {.importc: "IupVersion", cdecl, dynlib: dllname.}
+proc IupVersionDate*(): cstring {.importc: "IupVersionDate", cdecl, dynlib: dllname.}
+proc IupVersionNumber*(): cint {.importc: "IupVersionNumber", cdecl, dynlib: dllname.}
+proc SetLanguage*(lng: cstring) {.importc: "IupSetLanguage", cdecl, dynlib: dllname.}
+proc GetLanguage*(): cstring {.importc: "IupGetLanguage", cdecl, dynlib: dllname.}
+
+proc Destroy*(ih: PIhandle) {.importc: "IupDestroy", cdecl, dynlib: dllname.}
+proc Detach*(child: PIhandle) {.importc: "IupDetach", cdecl, dynlib: dllname.}
+proc Append*(ih, child: PIhandle): PIhandle {.
+  importc: "IupAppend", cdecl, dynlib: dllname.}
+proc Insert*(ih, ref_child, child: PIhandle): PIhandle {.
+  importc: "IupInsert", cdecl, dynlib: dllname.}
+proc GetChild*(ih: PIhandle, pos: cint): PIhandle {.
+  importc: "IupGetChild", cdecl, dynlib: dllname.}
+proc GetChildPos*(ih, child: PIhandle): cint {.
+  importc: "IupGetChildPos", cdecl, dynlib: dllname.}
+proc GetChildCount*(ih: PIhandle): cint {.
+  importc: "IupGetChildCount", cdecl, dynlib: dllname.}
+proc GetNextChild*(ih, child: PIhandle): PIhandle {.
+  importc: "IupGetNextChild", cdecl, dynlib: dllname.}
+proc GetBrother*(ih: PIhandle): PIhandle {.
+  importc: "IupGetBrother", cdecl, dynlib: dllname.}
+proc GetParent*(ih: PIhandle): PIhandle {.
+  importc: "IupGetParent", cdecl, dynlib: dllname.}
+proc GetDialog*(ih: PIhandle): PIhandle {.
+  importc: "IupGetDialog", cdecl, dynlib: dllname.}
+proc GetDialogChild*(ih: PIhandle, name: cstring): PIhandle {.
+  importc: "IupGetDialogChild", cdecl, dynlib: dllname.}
+proc Reparent*(ih, new_parent: PIhandle): cint {.
+  importc: "IupReparent", cdecl, dynlib: dllname.}
+
+proc Popup*(ih: PIhandle, x, y: cint): cint {.
+  importc: "IupPopup", cdecl, dynlib: dllname.}
+proc Show*(ih: PIhandle): cint {.
+  importc: "IupShow", cdecl, dynlib: dllname.}
+proc ShowXY*(ih: PIhandle, x, y: cint): cint {.
+  importc: "IupShowXY", cdecl, dynlib: dllname.}
+proc Hide*(ih: PIhandle): cint {.
+  importc: "IupHide", cdecl, dynlib: dllname.}
+proc Map*(ih: PIhandle): cint {.
+  importc: "IupMap", cdecl, dynlib: dllname.}
+proc Unmap*(ih: PIhandle) {.
+  importc: "IupUnmap", cdecl, dynlib: dllname.}
+
+proc SetAttribute*(ih: PIhandle, name, value: cstring) {.
+  importc: "IupSetAttribute", cdecl, dynlib: dllname.}
+proc StoreAttribute*(ih: PIhandle, name, value: cstring) {.
+  importc: "IupStoreAttribute", cdecl, dynlib: dllname.}
+proc SetAttributes*(ih: PIhandle, str: cstring): PIhandle {.
+  importc: "IupSetAttributes", cdecl, dynlib: dllname.}
+proc GetAttribute*(ih: PIhandle, name: cstring): cstring {.
+  importc: "IupGetAttribute", cdecl, dynlib: dllname.}
+proc GetAttributes*(ih: PIhandle): cstring {.
+  importc: "IupGetAttributes", cdecl, dynlib: dllname.}
+proc GetInt*(ih: PIhandle, name: cstring): cint {.
+  importc: "IupGetInt", cdecl, dynlib: dllname.}
+proc GetInt2*(ih: PIhandle, name: cstring): cint {.
+  importc: "IupGetInt2", cdecl, dynlib: dllname.}
+proc GetIntInt*(ih: PIhandle, name: cstring, i1, i2: var cint): cint {.
+  importc: "IupGetIntInt", cdecl, dynlib: dllname.}
+proc GetFloat*(ih: PIhandle, name: cstring): cfloat {.
+  importc: "IupGetFloat", cdecl, dynlib: dllname.}
+proc SetfAttribute*(ih: PIhandle, name, format: cstring) {.
+  importc: "IupSetfAttribute", cdecl, dynlib: dllname, varargs.}
+proc GetAllAttributes*(ih: PIhandle, names: cstringArray, n: cint): cint {.
+  importc: "IupGetAllAttributes", cdecl, dynlib: dllname.}
+proc SetAtt*(handle_name: cstring, ih: PIhandle, name: cstring): PIhandle {.
+  importc: "IupSetAtt", cdecl, dynlib: dllname, varargs.}
+
+proc SetGlobal*(name, value: cstring) {.
+  importc: "IupSetGlobal", cdecl, dynlib: dllname.}
+proc StoreGlobal*(name, value: cstring) {.
+  importc: "IupStoreGlobal", cdecl, dynlib: dllname.}
+proc GetGlobal*(name: cstring): cstring {.
+  importc: "IupGetGlobal", cdecl, dynlib: dllname.}
+
+proc SetFocus*(ih: PIhandle): PIhandle {.
+  importc: "IupSetFocus", cdecl, dynlib: dllname.}
+proc GetFocus*(): PIhandle {.
+  importc: "IupGetFocus", cdecl, dynlib: dllname.}
+proc PreviousField*(ih: PIhandle): PIhandle {.
+  importc: "IupPreviousField", cdecl, dynlib: dllname.}
+proc NextField*(ih: PIhandle): PIhandle {.
+  importc: "IupNextField", cdecl, dynlib: dllname.}
+
+proc GetCallback*(ih: PIhandle, name: cstring): Icallback {.
+  importc: "IupGetCallback", cdecl, dynlib: dllname.}
+proc SetCallback*(ih: PIhandle, name: cstring, func: Icallback): Icallback {.
+  importc: "IupSetCallback", cdecl, dynlib: dllname.}
+proc SetCallbacks*(ih: PIhandle, name: cstring, func: Icallback): PIhandle {.
+  importc: "IupSetCallbacks", cdecl, dynlib: dllname, varargs.}
+
+proc GetFunction*(name: cstring): Icallback {.
+  importc: "IupGetFunction", cdecl, dynlib: dllname.}
+proc SetFunction*(name: cstring, func: Icallback): Icallback {.
+  importc: "IupSetFunction", cdecl, dynlib: dllname.}
+proc GetActionName*(): cstring {.
+  importc: "IupGetActionName", cdecl, dynlib: dllname.}
+
+proc GetHandle*(name: cstring): PIhandle {.
+  importc: "IupGetHandle", cdecl, dynlib: dllname.}
+proc SetHandle*(name: cstring, ih: PIhandle): PIhandle {.
+  importc: "IupSetHandle", cdecl, dynlib: dllname.}
+proc GetAllNames*(names: cstringArray, n: cint): cint {.
+  importc: "IupGetAllNames", cdecl, dynlib: dllname.}
+proc GetAllDialogs*(names: cstringArray, n: cint): cint {.
+  importc: "IupGetAllDialogs", cdecl, dynlib: dllname.}
+proc GetName*(ih: PIhandle): cstring {.
+  importc: "IupGetName", cdecl, dynlib: dllname.}
+
+proc SetAttributeHandle*(ih: PIhandle, name: cstring, ih_named: PIhandle) {.
+  importc: "IupSetAttributeHandle", cdecl, dynlib: dllname.}
+proc GetAttributeHandle*(ih: PIhandle, name: cstring): PIhandle {.
+  importc: "IupGetAttributeHandle", cdecl, dynlib: dllname.}
+
+proc GetClassName*(ih: PIhandle): cstring {.
+  importc: "IupGetClassName", cdecl, dynlib: dllname.}
+proc GetClassType*(ih: PIhandle): cstring {.
+  importc: "IupGetClassType", cdecl, dynlib: dllname.}
+proc GetClassAttributes*(classname: cstring, names: cstringArray, 
+                         n: cint): cint {.
+  importc: "IupGetClassAttributes", cdecl, dynlib: dllname.}
+proc SaveClassAttributes*(ih: PIhandle) {.
+  importc: "IupSaveClassAttributes", cdecl, dynlib: dllname.}
+proc SetClassDefaultAttribute*(classname, name, value: cstring) {.
+  importc: "IupSetClassDefaultAttribute", cdecl, dynlib: dllname.}
+
+proc Create*(classname: cstring): PIhandle {.
+  importc: "IupCreate", cdecl, dynlib: dllname.}
+proc Createv*(classname: cstring, params: pointer): PIhandle {.
+  importc: "IupCreatev", cdecl, dynlib: dllname.}
+proc Createp*(classname: cstring, first: pointer): PIhandle {.
+  importc: "IupCreatep", cdecl, dynlib: dllname, varargs.}
+
+proc Fill*(): PIhandle {.importc: "IupFill", cdecl, dynlib: dllname.}
+proc Radio*(child: PIhandle): PIhandle {.
+  importc: "IupRadio", cdecl, dynlib: dllname.}
+proc Vbox*(child: PIhandle): PIhandle {.
+  importc: "IupVbox", cdecl, dynlib: dllname, varargs.}
+proc Vboxv*(children: ptr PIhandle): PIhandle {.
+  importc: "IupVboxv", cdecl, dynlib: dllname.}
+proc Zbox*(child: PIhandle): PIhandle {.
+  importc: "IupZbox", cdecl, dynlib: dllname, varargs.}
+proc Zboxv*(children: ptr PIhandle): PIhandle {.
+  importc: "IupZboxv", cdecl, dynlib: dllname.}
+proc Hbox*(child: PIhandle): PIhandle {.
+  importc: "IupHbox", cdecl, dynlib: dllname, varargs.}
+proc Hboxv*(children: ptr PIhandle): PIhandle {.
+  importc: "IupHboxv", cdecl, dynlib: dllname.}
+
+proc Normalizer*(ih_first: PIhandle): PIhandle {.
+  importc: "IupNormalizer", cdecl, dynlib: dllname, varargs.}
+proc Normalizerv*(ih_list: ptr PIhandle): PIhandle {.
+  importc: "IupNormalizerv", cdecl, dynlib: dllname.}
+
+proc Cbox*(child: PIhandle): PIhandle {.
+  importc: "IupCbox", cdecl, dynlib: dllname, varargs.}
+proc Cboxv*(children: ptr PIhandle): PIhandle {.
+  importc: "IupCboxv", cdecl, dynlib: dllname.}
+proc Sbox*(child: PIhandle): PIhandle {.
+  importc: "IupSbox", cdecl, dynlib: dllname.}
+
+proc Frame*(child: PIhandle): PIhandle {.
+  importc: "IupFrame", cdecl, dynlib: dllname.}
+
+proc Image*(width, height: cint, pixmap: pointer): PIhandle {.
+  importc: "IupImage", cdecl, dynlib: dllname.}
+proc ImageRGB*(width, height: cint, pixmap: pointer): PIhandle {.
+  importc: "IupImageRGB", cdecl, dynlib: dllname.}
+proc ImageRGBA*(width, height: cint, pixmap: pointer): PIhandle {.
+  importc: "IupImageRGBA", cdecl, dynlib: dllname.}
+
+proc Item*(title, action: cstring): PIhandle {.
+  importc: "IupItem", cdecl, dynlib: dllname.}
+proc Submenu*(title: cstring, child: PIhandle): PIhandle {.
+  importc: "IupSubmenu", cdecl, dynlib: dllname.}
+proc Separator*(): PIhandle {.
+  importc: "IupSeparator", cdecl, dynlib: dllname.}
+proc Menu*(child: PIhandle): PIhandle {.
+  importc: "IupMenu", cdecl, dynlib: dllname, varargs.}
+proc Menuv*(children: ptr PIhandle): PIhandle {.
+  importc: "IupMenuv", cdecl, dynlib: dllname.}
+
+proc Button*(title, action: cstring): PIhandle {.
+  importc: "IupButton", cdecl, dynlib: dllname.}
+proc Canvas*(action: cstring): PIhandle {.
+  importc: "IupCanvas", cdecl, dynlib: dllname.}
+proc Dialog*(child: PIhandle): PIhandle {.
+  importc: "IupDialog", cdecl, dynlib: dllname.}
+proc User*(): PIhandle {.
+  importc: "IupUser", cdecl, dynlib: dllname.}
+proc Label*(title: cstring): PIhandle {.
+  importc: "IupLabel", cdecl, dynlib: dllname.}
+proc List*(action: cstring): PIhandle {.
+  importc: "IupList", cdecl, dynlib: dllname.}
+proc Text*(action: cstring): PIhandle {.
+  importc: "IupText", cdecl, dynlib: dllname.}
+proc MultiLine*(action: cstring): PIhandle {.
+  importc: "IupMultiLine", cdecl, dynlib: dllname.}
+proc Toggle*(title, action: cstring): PIhandle {.
+  importc: "IupToggle", cdecl, dynlib: dllname.}
+proc Timer*(): PIhandle {.
+  importc: "IupTimer", cdecl, dynlib: dllname.}
+proc ProgressBar*(): PIhandle {.
+  importc: "IupProgressBar", cdecl, dynlib: dllname.}
+proc Val*(theType: cstring): PIhandle {.
+  importc: "IupVal", cdecl, dynlib: dllname.}
+proc Tabs*(child: PIhandle): PIhandle {.
+  importc: "IupTabs", cdecl, dynlib: dllname, varargs.}
+proc Tabsv*(children: ptr PIhandle): PIhandle {.
+  importc: "IupTabsv", cdecl, dynlib: dllname.}
+proc Tree*(): PIhandle {.importc: "IupTree", cdecl, dynlib: dllname.}
+
+proc Spin*(): PIhandle {.importc: "IupSpin", cdecl, dynlib: dllname.}
+proc Spinbox*(child: PIhandle): PIhandle {.
+  importc: "IupSpinbox", cdecl, dynlib: dllname.}
+
+# IupText utilities
+proc TextConvertLinColToPos*(ih: PIhandle, lin, col: cint, pos: var cint) {.
+  importc: "IupTextConvertLinColToPos", cdecl, dynlib: dllname.}
+proc TextConvertPosToLinCol*(ih: PIhandle, pos: cint, lin, col: var cint) {.
+  importc: "IupTextConvertPosToLinCol", cdecl, dynlib: dllname.}
+
+proc ConvertXYToPos*(ih: PIhandle, x, y: cint): cint {.
+  importc: "IupConvertXYToPos", cdecl, dynlib: dllname.}
+
+# IupTree utilities
+proc TreeSetUserId*(ih: PIhandle, id: cint, userid: pointer): cint {.
+  importc: "IupTreeSetUserId", cdecl, dynlib: dllname.}
+proc TreeGetUserId*(ih: PIhandle, id: cint): pointer {.
+  importc: "IupTreeGetUserId", cdecl, dynlib: dllname.}
+proc TreeGetId*(ih: PIhandle, userid: pointer): cint {.
+  importc: "IupTreeGetId", cdecl, dynlib: dllname.}
+
+proc TreeSetAttribute*(ih: PIhandle, name: cstring, id: cint, value: cstring) {.
+  importc: "IupTreeSetAttribute", cdecl, dynlib: dllname.}
+proc TreeStoreAttribute*(ih: PIhandle, name: cstring, id: cint, value: cstring) {.
+  importc: "IupTreeStoreAttribute", cdecl, dynlib: dllname.}
+proc TreeGetAttribute*(ih: PIhandle, name: cstring, id: cint): cstring {.
+  importc: "IupTreeGetAttribute", cdecl, dynlib: dllname.}
+proc TreeGetInt*(ih: PIhandle, name: cstring, id: cint): cint {.
+  importc: "IupTreeGetInt", cdecl, dynlib: dllname.}
+proc TreeGetFloat*(ih: PIhandle, name: cstring, id: cint): cfloat {.
+  importc: "IupTreeGetFloat", cdecl, dynlib: dllname.}
+proc TreeSetfAttribute*(ih: PIhandle, name: cstring, id: cint, format: cstring) {.
+  importc: "IupTreeSetfAttribute", cdecl, dynlib: dllname, varargs.}
+
+
+#                   Common Return Values
+const
+  IUP_ERROR* = cint(1)
+  IUP_NOERROR* = cint(0)
+  IUP_OPENED* = cint(-1)
+  IUP_INVALID* = cint(-1)
+
+  # Callback Return Values
+  IUP_IGNORE* = cint(-1)
+  IUP_DEFAULT* = cint(-2)
+  IUP_CLOSE* = cint(-3)
+  IUP_CONTINUE* = cint(-4)
+
+  # IupPopup and IupShowXY Parameter Values
+  IUP_CENTER* = cint(0xFFFF) 
+  IUP_LEFT* = cint(0xFFFE) 
+  IUP_RIGHT* = cint(0xFFFD) 
+  IUP_MOUSEPOS* = cint(0xFFFC) 
+  IUP_CURRENT* = cint(0xFFFB) 
+  IUP_CENTERPARENT* = cint(0xFFFA) 
+  IUP_TOP* = IUP_LEFT
+  IUP_BOTTOM* = IUP_RIGHT
+
+  # SHOW_CB Callback Values
+  IUP_SHOW* = cint(0)
+  IUP_RESTORE* = cint(1)
+  IUP_MINIMIZE* = cint(2)
+  IUP_MAXIMIZE* = cint(3)
+  IUP_HIDE* = cint(4)
+
+  # SCROLL_CB Callback Values
+  IUP_SBUP* = cint(0)
+  IUP_SBDN* = cint(1)
+  IUP_SBPGUP* = cint(2)   
+  IUP_SBPGDN* = cint(3)
+  IUP_SBPOSV* = cint(4)
+  IUP_SBDRAGV* = cint(5) 
+  IUP_SBLEFT* = cint(6)
+  IUP_SBRIGHT* = cint(7)
+  IUP_SBPGLEFT* = cint(8)
+  IUP_SBPGRIGHT* = cint(9)
+  IUP_SBPOSH* = cint(10)
+  IUP_SBDRAGH* = cint(11)
+
+  # Mouse Button Values and Macros
+  IUP_BUTTON1* = cint(ord('1'))
+  IUP_BUTTON2* = cint(ord('2'))
+  IUP_BUTTON3* = cint(ord('3'))
+  IUP_BUTTON4* = cint(ord('4'))
+  IUP_BUTTON5* = cint(ord('5'))
+
+proc isShift*(s: cstring): bool = return s[0] == 'S'
+proc isControl*(s: cstring): bool = return s[1] == 'C'
+proc isButton1*(s: cstring): bool = return s[2] == '1'
+proc isButton2*(s: cstring): bool = return s[3] == '2'
+proc isbutton3*(s: cstring): bool = return s[4] == '3'
+proc isDouble*(s: cstring): bool = return s[5] == 'D'
+proc isAlt*(s: cstring): bool = return s[6] == 'A'
+proc isSys*(s: cstring): bool = return s[7] == 'Y'
+proc isButton4*(s: cstring): bool = return s[8] == '4'
+proc isButton5*(s: cstring): bool = return s[9] == '5'
+
+# Pre-Defined Masks
+const
+  IUP_MASK_FLOAT* = "[+/-]?(/d+/.?/d*|/./d+)"
+  IUP_MASK_UFLOAT* = "(/d+/.?/d*|/./d+)"
+  IUP_MASK_EFLOAT* = "[+/-]?(/d+/.?/d*|/./d+)([eE][+/-]?/d+)?"
+  IUP_MASK_INT* = "[+/-]?/d+"
+  IUP_MASK_UINT* = "/d+"
+  
+# from 32 to 126, all character sets are equal,
+# the key code i the same as the character code.
+const
+  K_SP* = cint(ord(' '))
+  K_exclam* = cint(ord('!'))   
+  K_quotedbl* = cint(ord('\"'))
+  K_numbersign* = cint(ord('#'))
+  K_dollar* = cint(ord('$'))
+  K_percent* = cint(ord('%'))
+  K_ampersand* = cint(ord('&'))
+  K_apostrophe* = cint(ord('\''))
+  K_parentleft* = cint(ord('('))
+  K_parentright* = cint(ord(')'))
+  K_asterisk* = cint(ord('*'))
+  K_plus* = cint(ord('+'))
+  K_comma* = cint(ord(','))
+  K_minus* = cint(ord('-'))
+  K_period* = cint(ord('.'))
+  K_slash* = cint(ord('/'))
+  K_0* = cint(ord('0'))
+  K_1* = cint(ord('1'))
+  K_2* = cint(ord('2'))
+  K_3* = cint(ord('3'))
+  K_4* = cint(ord('4'))
+  K_5* = cint(ord('5'))
+  K_6* = cint(ord('6'))
+  K_7* = cint(ord('7'))
+  K_8* = cint(ord('8'))
+  K_9* = cint(ord('9'))
+  K_colon* = cint(ord(':'))
+  K_semicolon* = cint(ord(';'))
+  K_less* = cint(ord('<'))
+  K_equal* = cint(ord('='))
+  K_greater* = cint(ord('>'))   
+  K_question* = cint(ord('?'))   
+  K_at* = cint(ord('@'))   
+  K_upperA* = cint(ord('A'))   
+  K_upperB* = cint(ord('B'))   
+  K_upperC* = cint(ord('C'))   
+  K_upperD* = cint(ord('D'))   
+  K_upperE* = cint(ord('E'))   
+  K_upperF* = cint(ord('F'))   
+  K_upperG* = cint(ord('G'))   
+  K_upperH* = cint(ord('H'))   
+  K_upperI* = cint(ord('I'))   
+  K_upperJ* = cint(ord('J'))   
+  K_upperK* = cint(ord('K'))   
+  K_upperL* = cint(ord('L'))   
+  K_upperM* = cint(ord('M'))   
+  K_upperN* = cint(ord('N'))   
+  K_upperO* = cint(ord('O'))   
+  K_upperP* = cint(ord('P'))   
+  K_upperQ* = cint(ord('Q'))  
+  K_upperR* = cint(ord('R'))  
+  K_upperS* = cint(ord('S'))  
+  K_upperT* = cint(ord('T'))  
+  K_upperU* = cint(ord('U'))  
+  K_upperV* = cint(ord('V')) 
+  K_upperW* = cint(ord('W')) 
+  K_upperX* = cint(ord('X'))  
+  K_upperY* = cint(ord('Y'))  
+  K_upperZ* = cint(ord('Z'))  
+  K_bracketleft* = cint(ord('[')) 
+  K_backslash* = cint(ord('\\'))  
+  K_bracketright* = cint(ord(']'))  
+  K_circum* = cint(ord('^'))   
+  K_underscore* = cint(ord('_'))   
+  K_grave* = cint(ord('`'))   
+  K_lowera* = cint(ord('a'))  
+  K_lowerb* = cint(ord('b'))   
+  K_lowerc* = cint(ord('c')) 
+  K_lowerd* = cint(ord('d'))   
+  K_lowere* = cint(ord('e'))   
+  K_lowerf* = cint(ord('f'))  
+  K_lowerg* = cint(ord('g'))
+  K_lowerh* = cint(ord('h')) 
+  K_loweri* = cint(ord('i')) 
+  K_lowerj* = cint(ord('j')) 
+  K_lowerk* = cint(ord('k'))
+  K_lowerl* = cint(ord('l'))
+  K_lowerm* = cint(ord('m'))
+  K_lowern* = cint(ord('n'))
+  K_lowero* = cint(ord('o'))
+  K_lowerp* = cint(ord('p'))
+  K_lowerq* = cint(ord('q'))
+  K_lowerr* = cint(ord('r'))
+  K_lowers* = cint(ord('s'))
+  K_lowert* = cint(ord('t'))
+  K_loweru* = cint(ord('u'))
+  K_lowerv* = cint(ord('v'))
+  K_lowerw* = cint(ord('w'))
+  K_lowerx* = cint(ord('x'))
+  K_lowery* = cint(ord('y'))
+  K_lowerz* = cint(ord('z'))
+  K_braceleft* = cint(ord('{'))
+  K_bar* = cint(ord('|'))
+  K_braceright* = cint(ord('}'))
+  K_tilde* = cint(ord('~'))
+
+proc isPrint*(c: cint): bool = return c > 31 and c < 127
+
+# also define the escape sequences that have keys associated
+const
+  K_BS* = cint(ord('\b'))
+  K_TAB* = cint(ord('\t'))
+  K_LF* = cint(10)
+  K_CR* = cint(13)
+
+# IUP Extended Key Codes, range start at 128
+# Modifiers use 256 interval
+# These key code definitions are specific to IUP
+
+proc isXkey*(c: cint): bool = return c > 128
+proc isShiftXkey*(c: cint): bool = return c > 256 and c < 512
+proc isCtrlXkey*(c: cint): bool = return c > 512 and c < 768
+proc isAltXkey*(c: cint): bool = return c > 768 and c < 1024
+proc isSysXkey*(c: cint): bool = return c > 1024 and c < 1280
+
+proc IUPxCODE*(c: cint): cint = return c + cint(128) # Normal (must be above 128)
+proc IUPsxCODE*(c: cint): cint = 
+  return c + cint(256)
+  # Shift (must have range to include the standard keys and the normal 
+  # extended keys, so must be above 256
+
+proc IUPcxCODE*(c: cint): cint = return c + cint(512) # Ctrl
+proc IUPmxCODE*(c: cint): cint = return c + cint(768) # Alt
+proc IUPyxCODE*(c: cint): cint = return c + cint(1024) # Sys (Win or Apple) 
+
+const
+  IUP_NUMMAXCODES* = 1280 ## 5*256=1280  Normal+Shift+Ctrl+Alt+Sys
+
+  K_HOME* = IUPxCODE(1)                
+  K_UP* = IUPxCODE(2)
+  K_PGUP* = IUPxCODE(3)
+  K_LEFT* = IUPxCODE(4)
+  K_MIDDLE* = IUPxCODE(5)
+  K_RIGHT* = IUPxCODE(6)
+  K_END* = IUPxCODE(7)
+  K_DOWN* = IUPxCODE(8)
+  K_PGDN* = IUPxCODE(9)
+  K_INS* = IUPxCODE(10)    
+  K_DEL* = IUPxCODE(11)    
+  K_PAUSE* = IUPxCODE(12)
+  K_ESC* = IUPxCODE(13)
+  K_ccedilla* = IUPxCODE(14)
+  K_F1* = IUPxCODE(15)
+  K_F2* = IUPxCODE(16)
+  K_F3* = IUPxCODE(17)
+  K_F4* = IUPxCODE(18)
+  K_F5* = IUPxCODE(19)
+  K_F6* = IUPxCODE(20)
+  K_F7* = IUPxCODE(21)
+  K_F8* = IUPxCODE(22)
+  K_F9* = IUPxCODE(23)
+  K_F10* = IUPxCODE(24)
+  K_F11* = IUPxCODE(25)
+  K_F12* = IUPxCODE(26)
+  K_Print* = IUPxCODE(27)
+  K_Menu* = IUPxCODE(28)
+
+  K_acute* = IUPxCODE(29) # no Shift/Ctrl/Alt
+
+  K_sHOME* = IUPsxCODE(K_HOME)
+  K_sUP* = IUPsxCODE(K_UP)
+  K_sPGUP* = IUPsxCODE(K_PGUP)
+  K_sLEFT* = IUPsxCODE(K_LEFT)
+  K_sMIDDLE* = IUPsxCODE(K_MIDDLE)
+  K_sRIGHT* = IUPsxCODE(K_RIGHT)
+  K_sEND* = IUPsxCODE(K_END)
+  K_sDOWN* = IUPsxCODE(K_DOWN)
+  K_sPGDN* = IUPsxCODE(K_PGDN)
+  K_sINS* = IUPsxCODE(K_INS)
+  K_sDEL* = IUPsxCODE(K_DEL)
+  K_sSP* = IUPsxCODE(K_SP)
+  K_sTAB* = IUPsxCODE(K_TAB)
+  K_sCR* = IUPsxCODE(K_CR)
+  K_sBS* = IUPsxCODE(K_BS)
+  K_sPAUSE* = IUPsxCODE(K_PAUSE)
+  K_sESC* = IUPsxCODE(K_ESC)
+  K_sCcedilla* = IUPsxCODE(K_ccedilla)
+  K_sF1* = IUPsxCODE(K_F1)
+  K_sF2* = IUPsxCODE(K_F2)
+  K_sF3* = IUPsxCODE(K_F3)
+  K_sF4* = IUPsxCODE(K_F4)
+  K_sF5* = IUPsxCODE(K_F5)
+  K_sF6* = IUPsxCODE(K_F6)
+  K_sF7* = IUPsxCODE(K_F7)
+  K_sF8* = IUPsxCODE(K_F8)
+  K_sF9* = IUPsxCODE(K_F9)
+  K_sF10* = IUPsxCODE(K_F10)
+  K_sF11* = IUPsxCODE(K_F11)
+  K_sF12* = IUPsxCODE(K_F12)
+  K_sPrint* = IUPsxCODE(K_Print)
+  K_sMenu* = IUPsxCODE(K_Menu)
+
+  K_cHOME* = IUPcxCODE(K_HOME)
+  K_cUP* = IUPcxCODE(K_UP)
+  K_cPGUP* = IUPcxCODE(K_PGUP)
+  K_cLEFT* = IUPcxCODE(K_LEFT)
+  K_cMIDDLE* = IUPcxCODE(K_MIDDLE)
+  K_cRIGHT* = IUPcxCODE(K_RIGHT)
+  K_cEND* = IUPcxCODE(K_END)
+  K_cDOWN* = IUPcxCODE(K_DOWN)
+  K_cPGDN* = IUPcxCODE(K_PGDN)
+  K_cINS* = IUPcxCODE(K_INS)
+  K_cDEL* = IUPcxCODE(K_DEL)
+  K_cSP* = IUPcxCODE(K_SP)
+  K_cTAB* = IUPcxCODE(K_TAB)
+  K_cCR* = IUPcxCODE(K_CR)
+  K_cBS* = IUPcxCODE(K_BS)
+  K_cPAUSE* = IUPcxCODE(K_PAUSE)
+  K_cESC* = IUPcxCODE(K_ESC)
+  K_cCcedilla* = IUPcxCODE(K_ccedilla)
+  K_cF1* = IUPcxCODE(K_F1)
+  K_cF2* = IUPcxCODE(K_F2)
+  K_cF3* = IUPcxCODE(K_F3)
+  K_cF4* = IUPcxCODE(K_F4)
+  K_cF5* = IUPcxCODE(K_F5)
+  K_cF6* = IUPcxCODE(K_F6)
+  K_cF7* = IUPcxCODE(K_F7)
+  K_cF8* = IUPcxCODE(K_F8)
+  K_cF9* = IUPcxCODE(K_F9)
+  K_cF10* = IUPcxCODE(K_F10)
+  K_cF11* = IUPcxCODE(K_F11)
+  K_cF12* = IUPcxCODE(K_F12)
+  K_cPrint* = IUPcxCODE(K_Print)
+  K_cMenu* = IUPcxCODE(K_Menu)
+
+  K_mHOME* = IUPmxCODE(K_HOME)
+  K_mUP* = IUPmxCODE(K_UP)
+  K_mPGUP* = IUPmxCODE(K_PGUP)
+  K_mLEFT* = IUPmxCODE(K_LEFT)
+  K_mMIDDLE* = IUPmxCODE(K_MIDDLE)
+  K_mRIGHT* = IUPmxCODE(K_RIGHT)
+  K_mEND* = IUPmxCODE(K_END)
+  K_mDOWN* = IUPmxCODE(K_DOWN)
+  K_mPGDN* = IUPmxCODE(K_PGDN)
+  K_mINS* = IUPmxCODE(K_INS)
+  K_mDEL* = IUPmxCODE(K_DEL)
+  K_mSP* = IUPmxCODE(K_SP)
+  K_mTAB* = IUPmxCODE(K_TAB)
+  K_mCR* = IUPmxCODE(K_CR)
+  K_mBS* = IUPmxCODE(K_BS)
+  K_mPAUSE* = IUPmxCODE(K_PAUSE)
+  K_mESC* = IUPmxCODE(K_ESC)
+  K_mCcedilla* = IUPmxCODE(K_ccedilla)
+  K_mF1* = IUPmxCODE(K_F1)
+  K_mF2* = IUPmxCODE(K_F2)
+  K_mF3* = IUPmxCODE(K_F3)
+  K_mF4* = IUPmxCODE(K_F4)
+  K_mF5* = IUPmxCODE(K_F5)
+  K_mF6* = IUPmxCODE(K_F6)
+  K_mF7* = IUPmxCODE(K_F7)
+  K_mF8* = IUPmxCODE(K_F8)
+  K_mF9* = IUPmxCODE(K_F9)
+  K_mF10* = IUPmxCODE(K_F10)
+  K_mF11* = IUPmxCODE(K_F11)
+  K_mF12* = IUPmxCODE(K_F12)
+  K_mPrint* = IUPmxCODE(K_Print)
+  K_mMenu* = IUPmxCODE(K_Menu)
+
+  K_yHOME* = IUPyxCODE(K_HOME)
+  K_yUP* = IUPyxCODE(K_UP)
+  K_yPGUP* = IUPyxCODE(K_PGUP)
+  K_yLEFT* = IUPyxCODE(K_LEFT)
+  K_yMIDDLE* = IUPyxCODE(K_MIDDLE)
+  K_yRIGHT* = IUPyxCODE(K_RIGHT)
+  K_yEND* = IUPyxCODE(K_END)
+  K_yDOWN* = IUPyxCODE(K_DOWN)
+  K_yPGDN* = IUPyxCODE(K_PGDN)
+  K_yINS* = IUPyxCODE(K_INS)
+  K_yDEL* = IUPyxCODE(K_DEL)
+  K_ySP* = IUPyxCODE(K_SP)
+  K_yTAB* = IUPyxCODE(K_TAB)
+  K_yCR* = IUPyxCODE(K_CR)
+  K_yBS* = IUPyxCODE(K_BS)
+  K_yPAUSE* = IUPyxCODE(K_PAUSE)
+  K_yESC* = IUPyxCODE(K_ESC)
+  K_yCcedilla* = IUPyxCODE(K_ccedilla)
+  K_yF1* = IUPyxCODE(K_F1)
+  K_yF2* = IUPyxCODE(K_F2)
+  K_yF3* = IUPyxCODE(K_F3)
+  K_yF4* = IUPyxCODE(K_F4)
+  K_yF5* = IUPyxCODE(K_F5)
+  K_yF6* = IUPyxCODE(K_F6)
+  K_yF7* = IUPyxCODE(K_F7)
+  K_yF8* = IUPyxCODE(K_F8)
+  K_yF9* = IUPyxCODE(K_F9)
+  K_yF10* = IUPyxCODE(K_F10)
+  K_yF11* = IUPyxCODE(K_F11)
+  K_yF12* = IUPyxCODE(K_F12)
+  K_yPrint* = IUPyxCODE(K_Print)
+  K_yMenu* = IUPyxCODE(K_Menu)
+
+  K_sPlus* = IUPsxCODE(K_plus)   
+  K_sComma* = IUPsxCODE(K_comma)   
+  K_sMinus* = IUPsxCODE(K_minus)   
+  K_sPeriod* = IUPsxCODE(K_period)   
+  K_sSlash* = IUPsxCODE(K_slash)   
+  K_sAsterisk* = IUPsxCODE(K_asterisk)
+                        
+  K_cupperA* = IUPcxCODE(K_upperA)
+  K_cupperB* = IUPcxCODE(K_upperB)
+  K_cupperC* = IUPcxCODE(K_upperC)
+  K_cupperD* = IUPcxCODE(K_upperD)
+  K_cupperE* = IUPcxCODE(K_upperE)
+  K_cupperF* = IUPcxCODE(K_upperF)
+  K_cupperG* = IUPcxCODE(K_upperG)
+  K_cupperH* = IUPcxCODE(K_upperH)
+  K_cupperI* = IUPcxCODE(K_upperI)
+  K_cupperJ* = IUPcxCODE(K_upperJ)
+  K_cupperK* = IUPcxCODE(K_upperK)
+  K_cupperL* = IUPcxCODE(K_upperL)
+  K_cupperM* = IUPcxCODE(K_upperM)
+  K_cupperN* = IUPcxCODE(K_upperN)
+  K_cupperO* = IUPcxCODE(K_upperO)
+  K_cupperP* = IUPcxCODE(K_upperP)
+  K_cupperQ* = IUPcxCODE(K_upperQ)
+  K_cupperR* = IUPcxCODE(K_upperR)
+  K_cupperS* = IUPcxCODE(K_upperS)
+  K_cupperT* = IUPcxCODE(K_upperT)
+  K_cupperU* = IUPcxCODE(K_upperU)
+  K_cupperV* = IUPcxCODE(K_upperV)
+  K_cupperW* = IUPcxCODE(K_upperW)
+  K_cupperX* = IUPcxCODE(K_upperX)
+  K_cupperY* = IUPcxCODE(K_upperY)
+  K_cupperZ* = IUPcxCODE(K_upperZ)
+  K_c1* = IUPcxCODE(K_1)
+  K_c2* = IUPcxCODE(K_2)
+  K_c3* = IUPcxCODE(K_3)
+  K_c4* = IUPcxCODE(K_4)
+  K_c5* = IUPcxCODE(K_5)
+  K_c6* = IUPcxCODE(K_6)
+  K_c7* = IUPcxCODE(K_7)        
+  K_c8* = IUPcxCODE(K_8)         
+  K_c9* = IUPcxCODE(K_9)
+  K_c0* = IUPcxCODE(K_0)
+  K_cPlus* = IUPcxCODE(K_plus)   
+  K_cComma* = IUPcxCODE(K_comma)   
+  K_cMinus* = IUPcxCODE(K_minus)   
+  K_cPeriod* = IUPcxCODE(K_period)   
+  K_cSlash* = IUPcxCODE(K_slash)   
+  K_cSemicolon* = IUPcxCODE(K_semicolon) 
+  K_cEqual* = IUPcxCODE(K_equal)
+  K_cBracketleft* = IUPcxCODE(K_bracketleft)
+  K_cBracketright* = IUPcxCODE(K_bracketright)
+  K_cBackslash* = IUPcxCODE(K_backslash)
+  K_cAsterisk* = IUPcxCODE(K_asterisk)
+
+  K_mupperA* = IUPmxCODE(K_upperA)
+  K_mupperB* = IUPmxCODE(K_upperB)
+  K_mupperC* = IUPmxCODE(K_upperC)
+  K_mupperD* = IUPmxCODE(K_upperD)
+  K_mupperE* = IUPmxCODE(K_upperE)
+  K_mupperF* = IUPmxCODE(K_upperF)
+  K_mupperG* = IUPmxCODE(K_upperG)
+  K_mupperH* = IUPmxCODE(K_upperH)
+  K_mupperI* = IUPmxCODE(K_upperI)
+  K_mupperJ* = IUPmxCODE(K_upperJ)
+  K_mupperK* = IUPmxCODE(K_upperK)
+  K_mupperL* = IUPmxCODE(K_upperL)
+  K_mupperM* = IUPmxCODE(K_upperM)
+  K_mupperN* = IUPmxCODE(K_upperN)
+  K_mupperO* = IUPmxCODE(K_upperO)
+  K_mupperP* = IUPmxCODE(K_upperP)
+  K_mupperQ* = IUPmxCODE(K_upperQ)
+  K_mupperR* = IUPmxCODE(K_upperR)
+  K_mupperS* = IUPmxCODE(K_upperS)
+  K_mupperT* = IUPmxCODE(K_upperT)
+  K_mupperU* = IUPmxCODE(K_upperU)
+  K_mupperV* = IUPmxCODE(K_upperV)
+  K_mupperW* = IUPmxCODE(K_upperW)
+  K_mupperX* = IUPmxCODE(K_upperX)
+  K_mupperY* = IUPmxCODE(K_upperY)
+  K_mupperZ* = IUPmxCODE(K_upperZ)
+  K_m1* = IUPmxCODE(K_1)
+  K_m2* = IUPmxCODE(K_2)
+  K_m3* = IUPmxCODE(K_3)
+  K_m4* = IUPmxCODE(K_4)
+  K_m5* = IUPmxCODE(K_5)
+  K_m6* = IUPmxCODE(K_6)
+  K_m7* = IUPmxCODE(K_7)        
+  K_m8* = IUPmxCODE(K_8)         
+  K_m9* = IUPmxCODE(K_9)
+  K_m0* = IUPmxCODE(K_0)
+  K_mPlus* = IUPmxCODE(K_plus)   
+  K_mComma* = IUPmxCODE(K_comma)   
+  K_mMinus* = IUPmxCODE(K_minus)   
+  K_mPeriod* = IUPmxCODE(K_period)   
+  K_mSlash* = IUPmxCODE(K_slash)   
+  K_mSemicolon* = IUPmxCODE(K_semicolon) 
+  K_mEqual* = IUPmxCODE(K_equal)
+  K_mBracketleft* = IUPmxCODE(K_bracketleft)
+  K_mBracketright* = IUPmxCODE(K_bracketright)
+  K_mBackslash* = IUPmxCODE(K_backslash)
+  K_mAsterisk* = IUPmxCODE(K_asterisk)
+
+  K_yA* = IUPyxCODE(K_upperA)
+  K_yB* = IUPyxCODE(K_upperB)
+  K_yC* = IUPyxCODE(K_upperC)
+  K_yD* = IUPyxCODE(K_upperD)
+  K_yE* = IUPyxCODE(K_upperE)
+  K_yF* = IUPyxCODE(K_upperF)
+  K_yG* = IUPyxCODE(K_upperG)
+  K_yH* = IUPyxCODE(K_upperH)
+  K_yI* = IUPyxCODE(K_upperI)
+  K_yJ* = IUPyxCODE(K_upperJ)
+  K_yK* = IUPyxCODE(K_upperK)
+  K_yL* = IUPyxCODE(K_upperL)
+  K_yM* = IUPyxCODE(K_upperM)
+  K_yN* = IUPyxCODE(K_upperN)
+  K_yO* = IUPyxCODE(K_upperO)
+  K_yP* = IUPyxCODE(K_upperP)
+  K_yQ* = IUPyxCODE(K_upperQ)
+  K_yR* = IUPyxCODE(K_upperR)
+  K_yS* = IUPyxCODE(K_upperS)
+  K_yT* = IUPyxCODE(K_upperT)
+  K_yU* = IUPyxCODE(K_upperU)
+  K_yV* = IUPyxCODE(K_upperV)
+  K_yW* = IUPyxCODE(K_upperW)
+  K_yX* = IUPyxCODE(K_upperX)
+  K_yY* = IUPyxCODE(K_upperY)
+  K_yZ* = IUPyxCODE(K_upperZ)
+  K_y1* = IUPyxCODE(K_1)
+  K_y2* = IUPyxCODE(K_2)
+  K_y3* = IUPyxCODE(K_3)
+  K_y4* = IUPyxCODE(K_4)
+  K_y5* = IUPyxCODE(K_5)
+  K_y6* = IUPyxCODE(K_6)
+  K_y7* = IUPyxCODE(K_7)        
+  K_y8* = IUPyxCODE(K_8)         
+  K_y9* = IUPyxCODE(K_9)
+  K_y0* = IUPyxCODE(K_0)
+  K_yPlus* = IUPyxCODE(K_plus)
+  K_yComma* = IUPyxCODE(K_comma)
+  K_yMinus* = IUPyxCODE(K_minus)   
+  K_yPeriod* = IUPyxCODE(K_period)   
+  K_ySlash* = IUPyxCODE(K_slash)   
+  K_ySemicolon* = IUPyxCODE(K_semicolon) 
+  K_yEqual* = IUPyxCODE(K_equal)
+  K_yBracketleft* = IUPyxCODE(K_bracketleft)
+  K_yBracketright* = IUPyxCODE(K_bracketright)
+  K_yBackslash* = IUPyxCODE(K_backslash)
+  K_yAsterisk* = IUPyxCODE(K_asterisk)
+
+proc ControlsOpen*(): cint {.cdecl, importc: "IupControlsOpen", dynlib: dllname.}
+proc ControlsClose*() {.cdecl, importc: "IupControlsClose", dynlib: dllname.}
+
+proc OldValOpen*() {.cdecl, importc: "IupOldValOpen", dynlib: dllname.}
+proc OldTabsOpen*() {.cdecl, importc: "IupOldTabsOpen", dynlib: dllname.}
+
+proc Colorbar*(): PIhandle {.cdecl, importc: "IupColorbar", dynlib: dllname.}
+proc Cells*(): PIhandle {.cdecl, importc: "IupCells", dynlib: dllname.}
+proc ColorBrowser*(): PIhandle {.cdecl, importc: "IupColorBrowser", dynlib: dllname.}
+proc Gauge*(): PIhandle {.cdecl, importc: "IupGauge", dynlib: dllname.}
+proc Dial*(theType: cstring): PIhandle {.cdecl, importc: "IupDial", dynlib: dllname.}
+proc Matrix*(action: cstring): PIhandle {.cdecl, importc: "IupMatrix", dynlib: dllname.}
+
+# IupMatrix utilities
+proc MatSetAttribute*(ih: PIhandle, name: cstring, lin, col: cint, 
+                      value: cstring) {.
+                      cdecl, importc: "IupMatSetAttribute", dynlib: dllname.}
+proc MatStoreAttribute*(ih: PIhandle, name: cstring, lin, col: cint, 
+                        value: cstring) {.cdecl, 
+                        importc: "IupMatStoreAttribute", dynlib: dllname.}
+proc MatGetAttribute*(ih: PIhandle, name: cstring, lin, col: cint): cstring {.
+  cdecl, importc: "IupMatGetAttribute", dynlib: dllname.}
+proc MatGetInt*(ih: PIhandle, name: cstring, lin, col: cint): cint {.
+  cdecl, importc: "IupMatGetInt", dynlib: dllname.}
+proc MatGetFloat*(ih: PIhandle, name: cstring, lin, col: cint): cfloat {.
+  cdecl, importc: "IupMatGetFloat", dynlib: dllname.}
+proc MatSetfAttribute*(ih: PIhandle, name: cstring, lin, col: cint, 
+                       format: cstring) {.cdecl, 
+                       importc: "IupMatSetfAttribute", 
+                       dynlib: dllname, varargs.}
+
+# Used by IupColorbar
+const
+  IUP_PRIMARY* = -1
+  IUP_SECONDARY* = -2
+
+# Initialize PPlot widget class
+proc PPlotOpen*() {.cdecl, importc: "IupPPlotOpen", dynlib: dllname.}
+
+# Create an PPlot widget instance
+proc PPlot*: PIhandle {.cdecl, importc: "IupPPlot", dynlib: dllname.}
+
+# Add dataset to plot
+proc PPlotBegin*(ih: PIhandle, strXdata: cint) {.
+  cdecl, importc: "IupPPlotBegin", dynlib: dllname.}
+proc PPlotAdd*(ih: PIhandle, x, y: cfloat) {.
+  cdecl, importc: "IupPPlotAdd", dynlib: dllname.}
+proc PPlotAddStr*(ih: PIhandle, x: cstring, y: cfloat) {.
+  cdecl, importc: "IupPPlotAddStr", dynlib: dllname.}
+proc PPlotEnd*(ih: PIhandle): cint {.
+  cdecl, importc: "IupPPlotEnd", dynlib: dllname.}
+
+proc PPlotInsertStr*(ih: PIhandle, index, sample_index: cint, x: cstring, 
+                     y: cfloat) {.cdecl, importc: "IupPPlotInsertStr", 
+                     dynlib: dllname.}
+proc PPlotInsert*(ih: PIhandle, index, sample_index: cint, 
+                  x, y: cfloat) {.
+                  cdecl, importc: "IupPPlotInsert", dynlib: dllname.}
+
+# convert from plot coordinates to pixels
+proc PPlotTransform*(ih: PIhandle, x, y: cfloat, ix, iy: var cint) {.
+  cdecl, importc: "IupPPlotTransform", dynlib: dllname.}
+
+# Plot on the given device. Uses a "cdCanvas*".
+proc PPlotPaintTo*(ih: PIhandle, cnv: pointer) {.
+  cdecl, importc: "IupPPlotPaintTo", dynlib: dllname.}
+
+

lib/oldwrappers/libcurl.nim

@@ -0,0 +1,644 @@
+#
+#    $Id: header,v 1.1 2000/07/13 06:33:45 michael Exp $
+#    This file is part of the Free Pascal packages
+#    Copyright (c) 1999-2000 by the Free Pascal development team
+#
+#    See the file COPYING.FPC, included in this distribution,
+#    for details about the copyright.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# **********************************************************************
+#
+#   the curl library is governed by its own copyright, see the curl
+#   website for this. 
+# 
+
+{.deadCodeElim: on.}
+
+import times
+
+when defined(windows):
+  const libname = "libcurl.dll"
+elif defined(macosx):
+  const libname = "libcurl-7.19.3.dylib"
+elif defined(unix):
+  const libname = "libcurl.so.4"
+
+type 
+  Pcurl_calloc_callback* = ptr Tcurl_calloc_callback
+  Pcurl_closepolicy* = ptr Tcurl_closepolicy
+  Pcurl_forms* = ptr Tcurl_forms
+  Pcurl_ftpauth* = ptr Tcurl_ftpauth
+  Pcurl_ftpmethod* = ptr Tcurl_ftpmethod
+  Pcurl_ftpssl* = ptr Tcurl_ftpssl
+  PCURL_HTTP_VERSION* = ptr TCURL_HTTP_VERSION
+  Pcurl_httppost* = ptr Tcurl_httppost
+  PPcurl_httppost* = ptr Pcurl_httppost
+  Pcurl_infotype* = ptr Tcurl_infotype
+  Pcurl_lock_access* = ptr Tcurl_lock_access
+  Pcurl_lock_data* = ptr Tcurl_lock_data
+  Pcurl_malloc_callback* = ptr tcurl_malloc_callback
+  PCURL_NETRC_OPTION* = ptr TCURL_NETRC_OPTION
+  Pcurl_proxytype* = ptr Tcurl_proxytype
+  Pcurl_realloc_callback* = ptr tcurl_realloc_callback
+  Pcurl_slist* = ptr Tcurl_slist
+  Pcurl_socket* = ptr Tcurl_socket
+  PCURL_SSL_VERSION* = ptr TCURL_SSL_VERSION
+  Pcurl_strdup_callback* = ptr Tcurl_strdup_callback
+  PCURL_TIMECOND* = ptr TCURL_TIMECOND
+  Pcurl_version_info_data* = ptr Tcurl_version_info_data
+  PCURLcode* = ptr TCURLcode
+  PCURLFORMcode* = ptr TCURLFORMcode
+  PCURLformoption* = ptr TCURLformoption
+  PCURLINFO* = ptr TCURLINFO
+  Pcurliocmd* = ptr Tcurliocmd
+  Pcurlioerr* = ptr Tcurlioerr
+  PCURLM* = ptr TCURLM
+  PCURLMcode* = ptr TCURLMcode
+  PCURLMoption* = ptr TCURLMoption
+  PCURLMSG* = ptr TCURLMSG
+  PCURLoption* = ptr TCURLoption
+  PCURLSH* = ptr TCURLSH
+  PCURLSHcode* = ptr TCURLSHcode
+  PCURLSHoption* = ptr TCURLSHoption
+  PCURLversion* = ptr TCURLversion
+  Pfd_set* = pointer
+  PCURL* = ptr TCurl
+  TCurl* = pointer
+  Tcurl_httppost* {.final, pure.} = object 
+    next*: Pcurl_httppost
+    name*: cstring
+    namelength*: int32
+    contents*: cstring
+    contentslength*: int32
+    buffer*: cstring
+    bufferlength*: int32
+    contenttype*: cstring
+    contentheader*: Pcurl_slist
+    more*: Pcurl_httppost
+    flags*: int32
+    showfilename*: cstring
+
+  Tcurl_progress_callback* = proc (clientp: pointer, dltotal: float64, 
+                                   dlnow: float64, ultotal: float64, 
+                                   ulnow: float64): int32{.cdecl.}
+  Tcurl_write_callback* = proc (buffer: cstring, size: int, nitems: int, 
+                                outstream: pointer): int{.cdecl.}
+  Tcurl_read_callback* = proc (buffer: cstring, size: int, nitems: int, 
+                               instream: pointer): int{.cdecl.}
+  Tcurl_passwd_callback* = proc (clientp: pointer, prompt: cstring, 
+                                 buffer: cstring, buflen: int32): int32{.cdecl.}
+  Tcurlioerr* = enum 
+    CURLIOE_OK, CURLIOE_UNKNOWNCMD, CURLIOE_FAILRESTART, CURLIOE_LAST
+  Tcurliocmd* = enum 
+    CURLIOCMD_NOP, CURLIOCMD_RESTARTREAD, CURLIOCMD_LAST
+  Tcurl_ioctl_callback* = proc (handle: PCURL, cmd: int32, 
+                                clientp: pointer): Tcurlioerr {.cdecl.}
+  Tcurl_malloc_callback* = proc (size: int): pointer {.cdecl.}
+  Tcurl_free_callback* = proc (p: pointer) {.cdecl.}
+  Tcurl_realloc_callback* = proc (p: pointer, size: int): pointer {.cdecl.}
+  Tcurl_strdup_callback* = proc (str: cstring): cstring {.cdecl.}
+  Tcurl_calloc_callback* = proc (nmemb: int, size: int): pointer
+  Tcurl_infotype* = enum 
+    CURLINFO_TEXT = 0, CURLINFO_HEADER_IN, CURLINFO_HEADER_OUT, 
+    CURLINFO_DATA_IN, CURLINFO_DATA_OUT, CURLINFO_SSL_DATA_IN, 
+    CURLINFO_SSL_DATA_OUT, CURLINFO_END
+  Tcurl_debug_callback* = proc (handle: PCURL, theType: Tcurl_infotype, 
+                                data: cstring, size: int, 
+                                userptr: pointer): int32 {.cdecl.}
+  TCURLcode* = enum 
+    CURLE_OK = 0, CURLE_UNSUPPORTED_PROTOCOL, CURLE_FAILED_INIT, 
+    CURLE_URL_MALFORMAT, CURLE_URL_MALFORMAT_USER, CURLE_COULDNT_RESOLVE_PROXY, 
+    CURLE_COULDNT_RESOLVE_HOST, CURLE_COULDNT_CONNECT, 
+    CURLE_FTP_WEIRD_SERVER_REPLY, CURLE_FTP_ACCESS_DENIED, 
+    CURLE_FTP_USER_PASSWORD_INCORRECT, CURLE_FTP_WEIRD_PASS_REPLY, 
+    CURLE_FTP_WEIRD_USER_REPLY, CURLE_FTP_WEIRD_PASV_REPLY, 
+    CURLE_FTP_WEIRD_227_FORMAT, CURLE_FTP_CANT_GET_HOST, 
+    CURLE_FTP_CANT_RECONNECT, CURLE_FTP_COULDNT_SET_BINARY, CURLE_PARTIAL_FILE, 
+    CURLE_FTP_COULDNT_RETR_FILE, CURLE_FTP_WRITE_ERROR, CURLE_FTP_QUOTE_ERROR, 
+    CURLE_HTTP_RETURNED_ERROR, CURLE_WRITE_ERROR, CURLE_MALFORMAT_USER, 
+    CURLE_FTP_COULDNT_STOR_FILE, CURLE_READ_ERROR, CURLE_OUT_OF_MEMORY, 
+    CURLE_OPERATION_TIMEOUTED, CURLE_FTP_COULDNT_SET_ASCII, 
+    CURLE_FTP_PORT_FAILED, CURLE_FTP_COULDNT_USE_REST, 
+    CURLE_FTP_COULDNT_GET_SIZE, CURLE_HTTP_RANGE_ERROR, CURLE_HTTP_POST_ERROR, 
+    CURLE_SSL_CONNECT_ERROR, CURLE_BAD_DOWNLOAD_RESUME, 
+    CURLE_FILE_COULDNT_READ_FILE, CURLE_LDAP_CANNOT_BIND, 
+    CURLE_LDAP_SEARCH_FAILED, CURLE_LIBRARY_NOT_FOUND, CURLE_FUNCTION_NOT_FOUND, 
+    CURLE_ABORTED_BY_CALLBACK, CURLE_BAD_FUNCTION_ARGUMENT, 
+    CURLE_BAD_CALLING_ORDER, CURLE_INTERFACE_FAILED, CURLE_BAD_PASSWORD_ENTERED, 
+    CURLE_TOO_MANY_REDIRECTS, CURLE_UNKNOWN_TELNET_OPTION, 
+    CURLE_TELNET_OPTION_SYNTAX, CURLE_OBSOLETE, CURLE_SSL_PEER_CERTIFICATE, 
+    CURLE_GOT_NOTHING, CURLE_SSL_ENGINE_NOTFOUND, CURLE_SSL_ENGINE_SETFAILED, 
+    CURLE_SEND_ERROR, CURLE_RECV_ERROR, CURLE_SHARE_IN_USE, 
+    CURLE_SSL_CERTPROBLEM, CURLE_SSL_CIPHER, CURLE_SSL_CACERT, 
+    CURLE_BAD_CONTENT_ENCODING, CURLE_LDAP_INVALID_URL, CURLE_FILESIZE_EXCEEDED, 
+    CURLE_FTP_SSL_FAILED, CURLE_SEND_FAIL_REWIND, CURLE_SSL_ENGINE_INITFAILED, 
+    CURLE_LOGIN_DENIED, CURLE_TFTP_NOTFOUND, CURLE_TFTP_PERM, 
+    CURLE_TFTP_DISKFULL, CURLE_TFTP_ILLEGAL, CURLE_TFTP_UNKNOWNID, 
+    CURLE_TFTP_EXISTS, CURLE_TFTP_NOSUCHUSER, CURLE_CONV_FAILED, 
+    CURLE_CONV_REQD, CURL_LAST
+  Tcurl_conv_callback* = proc (buffer: cstring, len: int): TCURLcode {.cdecl.}
+  Tcurl_ssl_ctx_callback* = proc (curl: PCURL, 
+                                 ssl_ctx, userptr: pointer): TCURLcode {.cdecl.}
+  Tcurl_proxytype* = enum 
+    CURLPROXY_HTTP = 0, CURLPROXY_SOCKS4 = 4, CURLPROXY_SOCKS5 = 5
+  Tcurl_ftpssl* = enum 
+    CURLFTPSSL_NONE, CURLFTPSSL_TRY, CURLFTPSSL_CONTROL, CURLFTPSSL_ALL, 
+    CURLFTPSSL_LAST
+  Tcurl_ftpauth* = enum 
+    CURLFTPAUTH_DEFAULT, CURLFTPAUTH_SSL, CURLFTPAUTH_TLS, CURLFTPAUTH_LAST
+  Tcurl_ftpmethod* = enum 
+    CURLFTPMETHOD_DEFAULT, CURLFTPMETHOD_MULTICWD, CURLFTPMETHOD_NOCWD, 
+    CURLFTPMETHOD_SINGLECWD, CURLFTPMETHOD_LAST
+  TCURLoption* = enum 
+    CURLOPT_PORT = 0 + 3,
+    CURLOPT_TIMEOUT = 0 + 13, 
+    CURLOPT_INFILESIZE = 0 + 14, 
+    CURLOPT_LOW_SPEED_LIMIT = 0 + 19, 
+    CURLOPT_LOW_SPEED_TIME = 0 + 20, 
+    CURLOPT_RESUME_FROM = 0 + 21,
+    CURLOPT_CRLF = 0 + 27, 
+    CURLOPT_SSLVERSION = 0 + 32, 
+    CURLOPT_TIMECONDITION = 0 + 33, 
+    CURLOPT_TIMEVALUE = 0 + 34, 
+    CURLOPT_VERBOSE = 0 + 41, 
+    CURLOPT_HEADER = 0 + 42, 
+    CURLOPT_NOPROGRESS = 0 + 43, 
+    CURLOPT_NOBODY = 0 + 44, 
+    CURLOPT_FAILONERROR = 0 + 45, 
+    CURLOPT_UPLOAD = 0 + 46, 
+    CURLOPT_POST = 0 + 47, 
+    CURLOPT_FTPLISTONLY = 0 + 48, 
+    CURLOPT_FTPAPPEND = 0 + 50, 
+    CURLOPT_NETRC = 0 + 51, 
+    CURLOPT_FOLLOWLOCATION = 0 + 52, 
+    CURLOPT_TRANSFERTEXT = 0 + 53, 
+    CURLOPT_PUT = 0 + 54, 
+    CURLOPT_AUTOREFERER = 0 + 58, 
+    CURLOPT_PROXYPORT = 0 + 59, 
+    CURLOPT_POSTFIELDSIZE = 0 + 60, 
+    CURLOPT_HTTPPROXYTUNNEL = 0 + 61, 
+    CURLOPT_SSL_VERIFYPEER = 0 + 64, 
+    CURLOPT_MAXREDIRS = 0 + 68, 
+    CURLOPT_FILETIME = 0 + 69, 
+    CURLOPT_MAXCONNECTS = 0 + 71, 
+    CURLOPT_CLOSEPOLICY = 0 + 72, 
+    CURLOPT_FRESH_CONNECT = 0 + 74, 
+    CURLOPT_FORBID_REUSE = 0 + 75, 
+    CURLOPT_CONNECTTIMEOUT = 0 + 78, 
+    CURLOPT_HTTPGET = 0 + 80, 
+    CURLOPT_SSL_VERIFYHOST = 0 + 81, 
+    CURLOPT_HTTP_VERSION = 0 + 84, 
+    CURLOPT_FTP_USE_EPSV = 0 + 85, 
+    CURLOPT_SSLENGINE_DEFAULT = 0 + 90, 
+    CURLOPT_DNS_USE_GLOBAL_CACHE = 0 + 91, 
+    CURLOPT_DNS_CACHE_TIMEOUT = 0 + 92, 
+    CURLOPT_COOKIESESSION = 0 + 96, 
+    CURLOPT_BUFFERSIZE = 0 + 98, 
+    CURLOPT_NOSIGNAL = 0 + 99, 
+    CURLOPT_PROXYTYPE = 0 + 101, 
+    CURLOPT_UNRESTRICTED_AUTH = 0 + 105, 
+    CURLOPT_FTP_USE_EPRT = 0 + 106, 
+    CURLOPT_HTTPAUTH = 0 + 107, 
+    CURLOPT_FTP_CREATE_MISSING_DIRS = 0 + 110, 
+    CURLOPT_PROXYAUTH = 0 + 111, 
+    CURLOPT_FTP_RESPONSE_TIMEOUT = 0 + 112, 
+    CURLOPT_IPRESOLVE = 0 + 113, 
+    CURLOPT_MAXFILESIZE = 0 + 114, 
+    CURLOPT_FTP_SSL = 0 + 119, 
+    CURLOPT_TCP_NODELAY = 0 + 121, 
+    CURLOPT_FTPSSLAUTH = 0 + 129, 
+    CURLOPT_IGNORE_CONTENT_LENGTH = 0 + 136, 
+    CURLOPT_FTP_SKIP_PASV_IP = 0 + 137, 
+    CURLOPT_FTP_FILEMETHOD = 0 + 138, 
+    CURLOPT_LOCALPORT = 0 + 139, 
+    CURLOPT_LOCALPORTRANGE = 0 + 140, 
+    CURLOPT_CONNECT_ONLY = 0 + 141, 
+
+    CURLOPT_FILE = 10000 + 1, 
+    CURLOPT_URL = 10000 + 2,  
+    CURLOPT_PROXY = 10000 + 4, 
+    CURLOPT_USERPWD = 10000 + 5, 
+    CURLOPT_PROXYUSERPWD = 10000 + 6, 
+    CURLOPT_RANGE = 10000 + 7, 
+    CURLOPT_INFILE = 10000 + 9, 
+    CURLOPT_ERRORBUFFER = 10000 + 10, 
+    CURLOPT_POSTFIELDS = 10000 + 15, 
+    CURLOPT_REFERER = 10000 + 16, 
+    CURLOPT_FTPPORT = 10000 + 17, 
+    CURLOPT_USERAGENT = 10000 + 18, 
+    CURLOPT_COOKIE = 10000 + 22, 
+    CURLOPT_HTTPHEADER = 10000 + 23, 
+    CURLOPT_HTTPPOST = 10000 + 24, 
+    CURLOPT_SSLCERT = 10000 + 25, 
+    CURLOPT_SSLCERTPASSWD = 10000 + 26, 
+    CURLOPT_QUOTE = 10000 + 28, 
+    CURLOPT_WRITEHEADER = 10000 + 29, 
+    CURLOPT_COOKIEFILE = 10000 + 31, 
+    CURLOPT_CUSTOMREQUEST = 10000 + 36, 
+    CURLOPT_STDERR = 10000 + 37, 
+    CURLOPT_POSTQUOTE = 10000 + 39, 
+    CURLOPT_WRITEINFO = 10000 + 40, 
+    CURLOPT_PROGRESSDATA = 10000 + 57, 
+    CURLOPT_INTERFACE = 10000 + 62, 
+    CURLOPT_KRB4LEVEL = 10000 + 63,
+    CURLOPT_CAINFO = 10000 + 65, 
+    CURLOPT_TELNETOPTIONS = 10000 + 70, 
+    CURLOPT_RANDOM_FILE = 10000 + 76, 
+    CURLOPT_EGDSOCKET = 10000 + 77, 
+    CURLOPT_COOKIEJAR = 10000 + 82, 
+    CURLOPT_SSL_CIPHER_LIST = 10000 + 83, 
+    CURLOPT_SSLCERTTYPE = 10000 + 86, 
+    CURLOPT_SSLKEY = 10000 + 87, 
+    CURLOPT_SSLKEYTYPE = 10000 + 88, 
+    CURLOPT_SSLENGINE = 10000 + 89, 
+    CURLOPT_PREQUOTE = 10000 + 93, 
+    CURLOPT_DEBUGDATA = 10000 + 95, 
+    CURLOPT_CAPATH = 10000 + 97, 
+    CURLOPT_SHARE = 10000 + 100, 
+    CURLOPT_ENCODING = 10000 + 102, 
+    CURLOPT_PRIVATE = 10000 + 103, 
+    CURLOPT_HTTP200ALIASES = 10000 + 104, 
+    CURLOPT_SSL_CTX_DATA = 10000 + 109, 
+    CURLOPT_NETRC_FILE = 10000 + 118, 
+    CURLOPT_SOURCE_USERPWD = 10000 + 123, 
+    CURLOPT_SOURCE_PREQUOTE = 10000 + 127, 
+    CURLOPT_SOURCE_POSTQUOTE = 10000 + 128, 
+    CURLOPT_IOCTLDATA = 10000 + 131, 
+    CURLOPT_SOURCE_URL = 10000 + 132, 
+    CURLOPT_SOURCE_QUOTE = 10000 + 133, 
+    CURLOPT_FTP_ACCOUNT = 10000 + 134, 
+    CURLOPT_COOKIELIST = 10000 + 135, 
+    CURLOPT_FTP_ALTERNATIVE_TO_USER = 10000 + 147, 
+    CURLOPT_LASTENTRY = 10000 + 148,
+    
+    CURLOPT_WRITEFUNCTION = 20000 + 11, 
+    CURLOPT_READFUNCTION = 20000 + 12, 
+    CURLOPT_PROGRESSFUNCTION = 20000 + 56, 
+    CURLOPT_HEADERFUNCTION = 20000 + 79, 
+    CURLOPT_DEBUGFUNCTION = 20000 + 94, 
+    CURLOPT_SSL_CTX_FUNCTION = 20000 + 108, 
+    CURLOPT_IOCTLFUNCTION = 20000 + 130, 
+    CURLOPT_CONV_FROM_NETWORK_FUNCTION = 20000 + 142, 
+    CURLOPT_CONV_TO_NETWORK_FUNCTION = 20000 + 143, 
+    CURLOPT_CONV_FROM_UTF8_FUNCTION = 20000 + 144, 
+
+    CURLOPT_INFILESIZE_LARGE = 30000 + 115, 
+    CURLOPT_RESUME_FROM_LARGE = 30000 + 116, 
+    CURLOPT_MAXFILESIZE_LARGE = 30000 + 117, 
+    CURLOPT_POSTFIELDSIZE_LARGE = 30000 + 120, 
+    CURLOPT_MAX_SEND_SPEED_LARGE = 30000 + 145, 
+    CURLOPT_MAX_RECV_SPEED_LARGE = 30000 + 146
+
+    
+  TCURL_HTTP_VERSION* = enum 
+    CURL_HTTP_VERSION_NONE, CURL_HTTP_VERSION_1_0, CURL_HTTP_VERSION_1_1, 
+    CURL_HTTP_VERSION_LAST
+    
+  TCURL_NETRC_OPTION* = enum 
+    CURL_NETRC_IGNORED, CURL_NETRC_OPTIONAL, CURL_NETRC_REQUIRED, 
+    CURL_NETRC_LAST
+    
+  TCURL_SSL_VERSION* = enum 
+    CURL_SSLVERSION_DEFAULT, CURL_SSLVERSION_TLSv1, CURL_SSLVERSION_SSLv2, 
+    CURL_SSLVERSION_SSLv3, CURL_SSLVERSION_LAST
+  
+  TCURL_TIMECOND* = enum 
+    CURL_TIMECOND_NONE, CURL_TIMECOND_IFMODSINCE, CURL_TIMECOND_IFUNMODSINCE, 
+    CURL_TIMECOND_LASTMOD, CURL_TIMECOND_LAST
+  
+  TCURLformoption* = enum 
+    CURLFORM_NOTHING, CURLFORM_COPYNAME, CURLFORM_PTRNAME, CURLFORM_NAMELENGTH, 
+    CURLFORM_COPYCONTENTS, CURLFORM_PTRCONTENTS, CURLFORM_CONTENTSLENGTH, 
+    CURLFORM_FILECONTENT, CURLFORM_ARRAY, CURLFORM_OBSOLETE, CURLFORM_FILE, 
+    CURLFORM_BUFFER, CURLFORM_BUFFERPTR, CURLFORM_BUFFERLENGTH, 
+    CURLFORM_CONTENTTYPE, CURLFORM_CONTENTHEADER, CURLFORM_FILENAME, 
+    CURLFORM_END, CURLFORM_OBSOLETE2, CURLFORM_LASTENTRY
+  
+  Tcurl_forms* {.pure, final.} = object 
+    option*: TCURLformoption
+    value*: cstring
+
+  TCURLFORMcode* = enum 
+    CURL_FORMADD_OK, CURL_FORMADD_MEMORY, CURL_FORMADD_OPTION_TWICE, 
+    CURL_FORMADD_NULL, CURL_FORMADD_UNKNOWN_OPTION, CURL_FORMADD_INCOMPLETE, 
+    CURL_FORMADD_ILLEGAL_ARRAY, CURL_FORMADD_DISABLED, CURL_FORMADD_LAST
+
+  Tcurl_formget_callback* = proc (arg: pointer, buf: cstring, 
+                                 length: int): int {.cdecl.}
+  Tcurl_slist* {.pure, final.} = object 
+    data*: cstring
+    next*: Pcurl_slist
+
+  TCURLINFO* = enum 
+    CURLINFO_NONE = 0, 
+    CURLINFO_LASTONE = 30,
+    CURLINFO_EFFECTIVE_URL = 0x00100000 + 1, 
+    CURLINFO_CONTENT_TYPE = 0x00100000 + 18, 
+    CURLINFO_PRIVATE = 0x00100000 + 21, 
+    CURLINFO_FTP_ENTRY_PATH = 0x00100000 + 30,
+
+    CURLINFO_RESPONSE_CODE = 0x00200000 + 2, 
+    CURLINFO_HEADER_SIZE = 0x00200000 + 11, 
+    CURLINFO_REQUEST_SIZE = 0x00200000 + 12, 
+    CURLINFO_SSL_VERIFYRESULT = 0x00200000 + 13, 
+    CURLINFO_FILETIME = 0x00200000 + 14, 
+    CURLINFO_REDIRECT_COUNT = 0x00200000 + 20, 
+    CURLINFO_HTTP_CONNECTCODE = 0x00200000 + 22, 
+    CURLINFO_HTTPAUTH_AVAIL = 0x00200000 + 23, 
+    CURLINFO_PROXYAUTH_AVAIL = 0x00200000 + 24, 
+    CURLINFO_OS_ERRNO = 0x00200000 + 25, 
+    CURLINFO_NUM_CONNECTS = 0x00200000 + 26, 
+    CURLINFO_LASTSOCKET = 0x00200000 + 29, 
+    
+    CURLINFO_TOTAL_TIME = 0x00300000 + 3, 
+    CURLINFO_NAMELOOKUP_TIME = 0x00300000 + 4, 
+    CURLINFO_CONNECT_TIME = 0x00300000 + 5, 
+    CURLINFO_PRETRANSFER_TIME = 0x00300000 + 6, 
+    CURLINFO_SIZE_UPLOAD = 0x00300000 + 7, 
+    CURLINFO_SIZE_DOWNLOAD = 0x00300000 + 8, 
+    CURLINFO_SPEED_DOWNLOAD = 0x00300000 + 9, 
+    CURLINFO_SPEED_UPLOAD = 0x00300000 + 10, 
+    CURLINFO_CONTENT_LENGTH_DOWNLOAD = 0x00300000 + 15, 
+    CURLINFO_CONTENT_LENGTH_UPLOAD = 0x00300000 + 16, 
+    CURLINFO_STARTTRANSFER_TIME = 0x00300000 + 17, 
+    CURLINFO_REDIRECT_TIME = 0x00300000 + 19, 
+
+    CURLINFO_SSL_ENGINES = 0x00400000 + 27, 
+    CURLINFO_COOKIELIST = 0x00400000 + 28
+
+  Tcurl_closepolicy* = enum 
+    CURLCLOSEPOLICY_NONE, CURLCLOSEPOLICY_OLDEST, 
+    CURLCLOSEPOLICY_LEAST_RECENTLY_USED, CURLCLOSEPOLICY_LEAST_TRAFFIC, 
+    CURLCLOSEPOLICY_SLOWEST, CURLCLOSEPOLICY_CALLBACK, CURLCLOSEPOLICY_LAST
+  Tcurl_lock_data* = enum 
+    CURL_LOCK_DATA_NONE = 0, CURL_LOCK_DATA_SHARE, CURL_LOCK_DATA_COOKIE, 
+    CURL_LOCK_DATA_DNS, CURL_LOCK_DATA_SSL_SESSION, CURL_LOCK_DATA_CONNECT, 
+    CURL_LOCK_DATA_LAST
+  Tcurl_lock_access* = enum 
+    CURL_LOCK_ACCESS_NONE = 0, CURL_LOCK_ACCESS_SHARED = 1, 
+    CURL_LOCK_ACCESS_SINGLE = 2, CURL_LOCK_ACCESS_LAST
+  
+  Tcurl_lock_function* = proc (handle: PCURL, data: Tcurl_lock_data, 
+                              locktype: Tcurl_lock_access, 
+                              userptr: pointer) {.cdecl.}
+  Tcurl_unlock_function* = proc (handle: PCURL, data: Tcurl_lock_data, 
+                                userptr: pointer) {.cdecl.}
+  TCURLSH* = pointer
+  TCURLSHcode* = enum 
+    CURLSHE_OK, CURLSHE_BAD_OPTION, CURLSHE_IN_USE, CURLSHE_INVALID, 
+    CURLSHE_NOMEM, CURLSHE_LAST
+  
+  TCURLSHoption* = enum 
+    CURLSHOPT_NONE, CURLSHOPT_SHARE, CURLSHOPT_UNSHARE, CURLSHOPT_LOCKFUNC, 
+    CURLSHOPT_UNLOCKFUNC, CURLSHOPT_USERDATA, CURLSHOPT_LAST
+  
+  TCURLversion* = enum 
+    CURLVERSION_FIRST, CURLVERSION_SECOND, CURLVERSION_THIRD, CURLVERSION_LAST
+  
+  Tcurl_version_info_data* {.pure, final.} = object 
+    age*: TCURLversion
+    version*: cstring
+    version_num*: int32
+    host*: cstring
+    features*: int32
+    ssl_version*: cstring
+    ssl_version_num*: int32
+    libz_version*: cstring
+    protocols*: cstringArray
+    ares*: cstring
+    ares_num*: int32
+    libidn*: cstring
+    iconv_ver_num*: int32
+
+  TCURLM* = pointer
+  Tcurl_socket* = int32
+  TCURLMcode* = enum 
+    CURLM_CALL_MULTI_PERFORM = -1, 
+    CURLM_OK = 0, 
+    CURLM_BAD_HANDLE, 
+    CURLM_BAD_EASY_HANDLE, 
+    CURLM_OUT_OF_MEMORY, 
+    CURLM_INTERNAL_ERROR, 
+    CURLM_BAD_SOCKET, 
+    CURLM_UNKNOWN_OPTION, 
+    CURLM_LAST
+    
+  TCURLMSGEnum* = enum 
+    CURLMSG_NONE, CURLMSG_DONE, CURLMSG_LAST
+  TCURLMsg* {.pure, final.} = object 
+    msg*: TCURLMSGEnum
+    easy_handle*: PCURL
+    whatever*: Pointer        #data : record
+                              #      case longint of
+                              #        0 : ( whatever : pointer );
+                              #        1 : ( result : CURLcode );
+                              #    end;
+  
+  Tcurl_socket_callback* = proc (easy: PCURL, s: Tcurl_socket, what: int32, 
+                                 userp, socketp: pointer): int32 {.cdecl.}
+  TCURLMoption* = enum 
+    CURLMOPT_SOCKETDATA = 10000 + 2, 
+    CURLMOPT_LASTENTRY = 10000 + 3,
+    CURLMOPT_SOCKETFUNCTION = 20000 + 1
+    
+const 
+  CURLOPT_SSLKEYPASSWD* = CURLOPT_SSLCERTPASSWD
+
+  CURLAUTH_ANY* = not (0)
+  CURLAUTH_BASIC* = 1 shl 0
+  CURLAUTH_ANYSAFE* = not (CURLAUTH_BASIC)
+  CURLAUTH_DIGEST* = 1 shl 1
+  CURLAUTH_GSSNEGOTIATE* = 1 shl 2
+  CURLAUTH_NONE* = 0
+  CURLAUTH_NTLM* = 1 shl 3
+  CURLE_ALREADY_COMPLETE* = 99999
+  CURLE_FTP_BAD_DOWNLOAD_RESUME* = CURLE_BAD_DOWNLOAD_RESUME
+  CURLE_FTP_PARTIAL_FILE* = CURLE_PARTIAL_FILE
+  CURLE_HTTP_NOT_FOUND* = CURLE_HTTP_RETURNED_ERROR
+  CURLE_HTTP_PORT_FAILED* = CURLE_INTERFACE_FAILED
+  CURLE_OPERATION_TIMEDOUT* = CURLE_OPERATION_TIMEOUTED
+  CURL_ERROR_SIZE* = 256
+  CURL_FORMAT_OFF_T* = "%ld"
+  CURL_GLOBAL_NOTHING* = 0
+  CURL_GLOBAL_SSL* = 1 shl 0
+  CURL_GLOBAL_WIN32* = 1 shl 1
+  CURL_GLOBAL_ALL* = CURL_GLOBAL_SSL or CURL_GLOBAL_WIN32
+  CURL_GLOBAL_DEFAULT* = CURL_GLOBAL_ALL
+  CURLINFO_DOUBLE* = 0x00300000
+  CURLINFO_HTTP_CODE* = CURLINFO_RESPONSE_CODE
+  CURLINFO_LONG* = 0x00200000
+  CURLINFO_MASK* = 0x000FFFFF
+  CURLINFO_SLIST* = 0x00400000
+  CURLINFO_STRING* = 0x00100000
+  CURLINFO_TYPEMASK* = 0x00F00000
+  CURL_IPRESOLVE_V4* = 1
+  CURL_IPRESOLVE_V6* = 2
+  CURL_IPRESOLVE_WHATEVER* = 0
+  CURL_MAX_WRITE_SIZE* = 16384
+  CURLM_CALL_MULTI_SOCKET* = CURLM_CALL_MULTI_PERFORM
+  CURLOPT_CLOSEFUNCTION* = - (5)
+  CURLOPT_FTPASCII* = CURLOPT_TRANSFERTEXT
+  CURLOPT_HEADERDATA* = CURLOPT_WRITEHEADER
+  CURLOPT_HTTPREQUEST* = - (1)
+  CURLOPT_MUTE* = - (2)
+  CURLOPT_PASSWDDATA* = - (4)
+  CURLOPT_PASSWDFUNCTION* = - (3)
+  CURLOPT_PASV_HOST* = - (9)
+  CURLOPT_READDATA* = CURLOPT_INFILE
+  CURLOPT_SOURCE_HOST* = - (6)
+  CURLOPT_SOURCE_PATH* = - (7)
+  CURLOPT_SOURCE_PORT* = - (8)
+  CURLOPTTYPE_FUNCTIONPOINT* = 20000
+  CURLOPTTYPE_LONG* = 0
+  CURLOPTTYPE_OBJECTPOINT* = 10000
+  CURLOPTTYPE_OFF_T* = 30000
+  CURLOPT_WRITEDATA* = CURLOPT_FILE
+  CURL_POLL_IN* = 1
+  CURL_POLL_INOUT* = 3
+  CURL_POLL_NONE* = 0
+  CURL_POLL_OUT* = 2
+  CURL_POLL_REMOVE* = 4
+  CURL_READFUNC_ABORT* = 0x10000000
+  CURL_SOCKET_BAD* = - (1)
+  CURL_SOCKET_TIMEOUT* = CURL_SOCKET_BAD
+  CURL_VERSION_ASYNCHDNS* = 1 shl 7
+  CURL_VERSION_CONV* = 1 shl 12
+  CURL_VERSION_DEBUG* = 1 shl 6
+  CURL_VERSION_GSSNEGOTIATE* = 1 shl 5
+  CURL_VERSION_IDN* = 1 shl 10
+  CURL_VERSION_IPV6* = 1 shl 0
+  CURL_VERSION_KERBEROS4* = 1 shl 1
+  CURL_VERSION_LARGEFILE* = 1 shl 9
+  CURL_VERSION_LIBZ* = 1 shl 3
+  CURLVERSION_NOW* = CURLVERSION_THIRD
+  CURL_VERSION_NTLM* = 1 shl 4
+  CURL_VERSION_SPNEGO* = 1 shl 8
+  CURL_VERSION_SSL* = 1 shl 2
+  CURL_VERSION_SSPI* = 1 shl 11
+  FILE_OFFSET_BITS* = 0
+  FILESIZEBITS* = 0
+  FUNCTIONPOINT* = CURLOPTTYPE_FUNCTIONPOINT
+  HTTPPOST_BUFFER* = 1 shl 4
+  HTTPPOST_FILENAME* = 1 shl 0
+  HTTPPOST_PTRBUFFER* = 1 shl 5
+  HTTPPOST_PTRCONTENTS* = 1 shl 3
+  HTTPPOST_PTRNAME* = 1 shl 2
+  HTTPPOST_READFILE* = 1 shl 1
+  LIBCURL_VERSION* = "7.15.5"
+  LIBCURL_VERSION_MAJOR* = 7
+  LIBCURL_VERSION_MINOR* = 15
+  LIBCURL_VERSION_NUM* = 0x00070F05
+  LIBCURL_VERSION_PATCH* = 5
+
+proc curl_strequal*(s1, s2: cstring): int32{.cdecl, 
+    dynlib: libname, importc: "curl_strequal".}
+proc curl_strnequal*(s1, s2: cstring, n: int): int32 {.cdecl, 
+    dynlib: libname, importc: "curl_strnequal".}
+proc curl_formadd*(httppost, last_post: PPcurl_httppost): TCURLFORMcode {.
+    cdecl, varargs, dynlib: libname, importc: "curl_formadd".}
+
+proc curl_formget*(form: Pcurl_httppost, arg: pointer, 
+                   append: Tcurl_formget_callback): int32 {.cdecl, 
+    dynlib: libname, importc: "curl_formget".}
+proc curl_formfree*(form: Pcurl_httppost){.cdecl, dynlib: libname, 
+    importc: "curl_formfree".}
+proc curl_getenv*(variable: cstring): cstring{.cdecl, dynlib: libname, 
+    importc: "curl_getenv".}
+proc curl_version*(): cstring{.cdecl, dynlib: libname, importc: "curl_version".}
+proc curl_easy_escape*(handle: PCURL, str: cstring, len: int32): cstring{.cdecl, 
+    dynlib: libname, importc: "curl_easy_escape".}
+proc curl_escape*(str: cstring, len: int32): cstring{.cdecl, 
+    dynlib: libname, importc: "curl_escape".}
+proc curl_easy_unescape*(handle: PCURL, str: cstring, len: int32, 
+                         outlength: var int32): cstring{.cdecl, 
+    dynlib: libname, importc: "curl_easy_unescape".}
+proc curl_unescape*(str: cstring, len: int32): cstring{.cdecl, 
+    dynlib: libname, importc: "curl_unescape".}
+proc curl_free*(p: pointer){.cdecl, dynlib: libname, 
+                             importc: "curl_free".}
+proc curl_global_init*(flags: int32): TCURLcode {.cdecl, dynlib: libname, 
+    importc: "curl_global_init".}
+proc curl_global_init_mem*(flags: int32, m: Tcurl_malloc_callback, 
+                           f: Tcurl_free_callback, r: Tcurl_realloc_callback, 
+                           s: Tcurl_strdup_callback, 
+                           c: Tcurl_calloc_callback): TCURLcode {.
+    cdecl, dynlib: libname, importc: "curl_global_init_mem".}
+proc curl_global_cleanup*() {.cdecl, dynlib: libname, 
+                              importc: "curl_global_cleanup".}
+proc curl_slist_append*(curl_slist: Pcurl_slist, P: cstring): Pcurl_slist {.
+    cdecl, dynlib: libname, importc: "curl_slist_append".}
+proc curl_slist_free_all*(para1: Pcurl_slist) {.cdecl, dynlib: libname, 
+    importc: "curl_slist_free_all".}
+proc curl_getdate*(p: cstring, unused: ptr TTime): TTime {.cdecl, 
+    dynlib: libname, importc: "curl_getdate".}
+proc curl_share_init*(): PCURLSH{.cdecl, dynlib: libname, 
+                                  importc: "curl_share_init".}
+proc curl_share_setopt*(para1: PCURLSH, option: TCURLSHoption): TCURLSHcode {.
+    cdecl, varargs, dynlib: libname, importc: "curl_share_setopt".}
+
+proc curl_share_cleanup*(para1: PCURLSH): TCURLSHcode {.cdecl, 
+    dynlib: libname, importc: "curl_share_cleanup".}
+proc curl_version_info*(para1: TCURLversion): Pcurl_version_info_data{.cdecl, 
+    dynlib: libname, importc: "curl_version_info".}
+proc curl_easy_strerror*(para1: TCURLcode): cstring {.cdecl, 
+    dynlib: libname, importc: "curl_easy_strerror".}
+proc curl_share_strerror*(para1: TCURLSHcode): cstring {.cdecl, 
+    dynlib: libname, importc: "curl_share_strerror".}
+proc curl_easy_init*(): PCURL {.cdecl, dynlib: libname, 
+                               importc: "curl_easy_init".}
+proc curl_easy_setopt*(curl: PCURL, option: TCURLoption): TCURLcode {.cdecl, 
+    varargs, dynlib: libname, importc: "curl_easy_setopt".}
+
+proc curl_easy_perform*(curl: PCURL): TCURLcode {.cdecl, dynlib: libname, 
+    importc: "curl_easy_perform".}
+proc curl_easy_cleanup*(curl: PCURL) {.cdecl, dynlib: libname, 
+                                       importc: "curl_easy_cleanup".}
+proc curl_easy_getinfo*(curl: PCURL, info: TCURLINFO): TCURLcode {.
+    cdecl, varargs, dynlib: libname, importc: "curl_easy_getinfo".}
+
+proc curl_easy_duphandle*(curl: PCURL): PCURL {.cdecl, dynlib: libname, 
+    importc: "curl_easy_duphandle".}
+proc curl_easy_reset*(curl: PCURL) {.cdecl, dynlib: libname, 
+                                     importc: "curl_easy_reset".}
+proc curl_multi_init*(): PCURLM {.cdecl, dynlib: libname, 
+                                  importc: "curl_multi_init".}
+proc curl_multi_add_handle*(multi_handle: PCURLM, 
+                            curl_handle: PCURL): TCURLMcode {.
+    cdecl, dynlib: libname, importc: "curl_multi_add_handle".}
+proc curl_multi_remove_handle*(multi_handle: PCURLM, 
+                               curl_handle: PCURL): TCURLMcode {.
+    cdecl, dynlib: libname, importc: "curl_multi_remove_handle".}
+proc curl_multi_fdset*(multi_handle: PCURLM, read_fd_set: Pfd_set, 
+                       write_fd_set: Pfd_set, exc_fd_set: Pfd_set, 
+                       max_fd: var int32): TCURLMcode {.cdecl, 
+    dynlib: libname, importc: "curl_multi_fdset".}
+proc curl_multi_perform*(multi_handle: PCURLM, 
+                         running_handles: var int32): TCURLMcode {.
+    cdecl, dynlib: libname, importc: "curl_multi_perform".}
+proc curl_multi_cleanup*(multi_handle: PCURLM): TCURLMcode {.cdecl, 
+    dynlib: libname, importc: "curl_multi_cleanup".}
+proc curl_multi_info_read*(multi_handle: PCURLM, 
+                           msgs_in_queue: var int32): PCURLMsg {.
+    cdecl, dynlib: libname, importc: "curl_multi_info_read".}
+proc curl_multi_strerror*(para1: TCURLMcode): cstring {.cdecl, 
+    dynlib: libname, importc: "curl_multi_strerror".}
+proc curl_multi_socket*(multi_handle: PCURLM, s: Tcurl_socket, 
+                        running_handles: var int32): TCURLMcode {.cdecl, 
+    dynlib: libname, importc: "curl_multi_socket".}
+proc curl_multi_socket_all*(multi_handle: PCURLM, 
+                            running_handles: var int32): TCURLMcode {.
+    cdecl, dynlib: libname, importc: "curl_multi_socket_all".}
+proc curl_multi_timeout*(multi_handle: PCURLM, milliseconds: var int32): TCURLMcode{.
+    cdecl, dynlib: libname, importc: "curl_multi_timeout".}
+proc curl_multi_setopt*(multi_handle: PCURLM, option: TCURLMoption): TCURLMcode{.
+    cdecl, varargs, dynlib: libname, importc: "curl_multi_setopt".}
+
+proc curl_multi_assign*(multi_handle: PCURLM, sockfd: Tcurl_socket, 
+                        sockp: pointer): TCURLMcode {.cdecl, 
+    dynlib: libname, importc: "curl_multi_assign".}
+
+

lib/oldwrappers/lua/lauxlib.nim

@@ -0,0 +1,224 @@
+#*****************************************************************************
+# *                                                                            *
+# *  File:        lauxlib.pas                                                  *
+# *  Authors:     TeCGraf           (C headers + actual Lua libraries)         *
+# *               Lavergne Thomas   (original translation to Pascal)           *
+# *               Bram Kuijvenhoven (update to Lua 5.1.1 for FreePascal)       *
+# *  Description: Lua auxiliary library                                        *
+# *                                                                            *
+# *****************************************************************************
+#
+#** $Id: lauxlib.h,v 1.59 2003/03/18 12:25:32 roberto Exp $
+#** Auxiliary functions for building Lua libraries
+#** See Copyright Notice in lua.h
+#
+#
+#** Translated to pascal by Lavergne Thomas
+#** Notes :
+#**    - Pointers type was prefixed with 'P'
+#** Bug reports :
+#**    - thomas.lavergne@laposte.net
+#**   In french or in english
+#
+
+import lua
+
+proc lua_pushstring*(L: Plua_State, s: string)
+  # compatibilty macros
+proc luaL_getn*(L: Plua_State, n: int): int
+  # calls lua_objlen
+proc luaL_setn*(L: Plua_State, t, n: int)
+  # does nothing!
+type 
+  TLuaL_reg*{.final.} = object 
+    name*: cstring
+    func*: lua_CFunction
+
+  PluaL_reg* = ptr TLuaL_reg
+
+proc luaL_openlib*(L: Plua_State, libname: cstring, lr: PluaL_reg, nup: int){.
+    cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_register*(L: Plua_State, libname: cstring, lr: PluaL_reg){.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_getmetafield*(L: Plua_State, obj: int, e: cstring): int{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_callmeta*(L: Plua_State, obj: int, e: cstring): int{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_typerror*(L: Plua_State, narg: int, tname: cstring): int{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_argerror*(L: Plua_State, numarg: int, extramsg: cstring): int{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_checklstring*(L: Plua_State, numArg: int, len: Psize_t): cstring{.
+    cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_optlstring*(L: Plua_State, numArg: int, def: cstring, len: Psize_t): cstring{.
+    cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_checknumber*(L: Plua_State, numArg: int): lua_Number{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_optnumber*(L: Plua_State, nArg: int, def: lua_Number): lua_Number{.
+    cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_checkinteger*(L: Plua_State, numArg: int): lua_Integer{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_optinteger*(L: Plua_State, nArg: int, def: lua_Integer): lua_Integer{.
+    cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_checkstack*(L: Plua_State, sz: int, msg: cstring){.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_checktype*(L: Plua_State, narg, t: int){.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaL_checkany*(L: Plua_State, narg: int){.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaL_newmetatable*(L: Plua_State, tname: cstring): int{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_checkudata*(L: Plua_State, ud: int, tname: cstring): Pointer{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_where*(L: Plua_State, lvl: int){.cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_error*(L: Plua_State, fmt: cstring): int{.cdecl, varargs, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_checkoption*(L: Plua_State, narg: int, def: cstring, lst: cstringArray): int{.
+    cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_ref*(L: Plua_State, t: int): int{.cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_unref*(L: Plua_State, t, theref: int){.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaL_loadfile*(L: Plua_State, filename: cstring): int{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_loadbuffer*(L: Plua_State, buff: cstring, size: size_t, name: cstring): int{.
+    cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_loadstring*(L: Plua_State, s: cstring): int{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_newstate*(): Plua_State{.cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc lua_open*(): Plua_State
+  # compatibility; moved from unit lua to lauxlib because it needs luaL_newstate
+  #
+  #** ===============================================================
+  #** some useful macros
+  #** ===============================================================
+  #
+proc luaL_argcheck*(L: Plua_State, cond: bool, numarg: int, extramsg: cstring)
+proc luaL_checkstring*(L: Plua_State, n: int): cstring
+proc luaL_optstring*(L: Plua_State, n: int, d: cstring): cstring
+proc luaL_checkint*(L: Plua_State, n: int): int
+proc luaL_checklong*(L: Plua_State, n: int): int32
+proc luaL_optint*(L: Plua_State, n: int, d: float64): int
+proc luaL_optlong*(L: Plua_State, n: int, d: float64): int32
+proc luaL_typename*(L: Plua_State, i: int): cstring
+proc lua_dofile*(L: Plua_State, filename: cstring): int
+proc lua_dostring*(L: Plua_State, str: cstring): int
+proc lua_Lgetmetatable*(L: Plua_State, tname: cstring)
+  # not translated:
+  # #define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+  #
+  #** =======================================================
+  #** Generic Buffer manipulation
+  #** =======================================================
+  #
+const                         # note: this is just arbitrary, as it related to the BUFSIZ defined in stdio.h ...
+  LUAL_BUFFERSIZE* = 4096
+
+type 
+  luaL_Buffer*{.final.} = object 
+    p*: cstring               # current position in buffer 
+    lvl*: int                 # number of strings in the stack (level) 
+    L*: Plua_State
+    buffer*: array[0..LUAL_BUFFERSIZE - 1, Char] # warning: see note above about LUAL_BUFFERSIZE
+  
+  PluaL_Buffer* = ptr luaL_Buffer
+
+proc luaL_addchar*(B: PluaL_Buffer, c: Char)
+  # warning: see note above about LUAL_BUFFERSIZE
+  # compatibility only (alias for luaL_addchar) 
+proc luaL_putchar*(B: PluaL_Buffer, c: Char)
+  # warning: see note above about LUAL_BUFFERSIZE
+proc luaL_addsize*(B: PluaL_Buffer, n: int)
+proc luaL_buffinit*(L: Plua_State, B: PluaL_Buffer){.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_prepbuffer*(B: PluaL_Buffer): cstring{.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaL_addlstring*(B: PluaL_Buffer, s: cstring, L: size_t){.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_addstring*(B: PluaL_Buffer, s: cstring){.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaL_addvalue*(B: PluaL_Buffer){.cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_pushresult*(B: PluaL_Buffer){.cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaL_gsub*(L: Plua_State, s, p, r: cstring): cstring{.cdecl, 
+    dynlib: LUA_LIB_NAME, importc.}
+proc luaL_findtable*(L: Plua_State, idx: int, fname: cstring, szhint: int): cstring{.
+    cdecl, dynlib: LUA_LIB_NAME, importc.}
+  # compatibility with ref system 
+  # pre-defined references 
+const 
+  LUA_NOREF* = - 2
+  LUA_REFNIL* = - 1
+
+proc lua_unref*(L: Plua_State, theref: int)
+proc lua_getref*(L: Plua_State, theref: int)
+  #
+  #** Compatibility macros and functions
+  #
+
+# implementation
+
+proc lua_pushstring(L: Plua_State, s: string) = 
+  lua_pushlstring(L, cstring(s), len(s))
+
+proc luaL_getn(L: Plua_State, n: int): int = 
+  Result = lua_objlen(L, n)
+
+proc luaL_setn(L: Plua_State, t, n: int) = 
+  # does nothing as this operation is deprecated
+  nil
+  
+proc lua_open(): Plua_State = 
+  Result = luaL_newstate()
+
+proc luaL_typename(L: Plua_State, i: int): cstring = 
+  Result = lua_typename(L, lua_type(L, i))
+
+proc lua_dofile(L: Plua_State, filename: cstring): int = 
+  Result = luaL_loadfile(L, filename)
+  if Result == 0: Result = lua_pcall(L, 0, LUA_MULTRET, 0)
+  
+proc lua_dostring(L: Plua_State, str: cstring): int = 
+  Result = luaL_loadstring(L, str)
+  if Result == 0: Result = lua_pcall(L, 0, LUA_MULTRET, 0)
+  
+proc lua_Lgetmetatable(L: Plua_State, tname: cstring) = 
+  lua_getfield(L, LUA_REGISTRYINDEX, tname)
+
+proc luaL_argcheck(L: Plua_State, cond: bool, numarg: int, extramsg: cstring) = 
+  if not cond:
+    discard luaL_argerror(L, numarg, extramsg)
+  
+proc luaL_checkstring(L: Plua_State, n: int): cstring = 
+  Result = luaL_checklstring(L, n, nil)
+
+proc luaL_optstring(L: Plua_State, n: int, d: cstring): cstring = 
+  Result = luaL_optlstring(L, n, d, nil)
+
+proc luaL_checkint(L: Plua_State, n: int): int = 
+  Result = toInt(luaL_checknumber(L, n))
+
+proc luaL_checklong(L: Plua_State, n: int): int32 = 
+  Result = int32(ToInt(luaL_checknumber(L, n)))
+
+proc luaL_optint(L: Plua_State, n: int, d: float64): int = 
+  Result = int(ToInt(luaL_optnumber(L, n, d)))
+
+proc luaL_optlong(L: Plua_State, n: int, d: float64): int32 = 
+  Result = int32(ToInt(luaL_optnumber(L, n, d)))
+
+proc luaL_addchar(B: PluaL_Buffer, c: Char) = 
+  if cast[int](addr((B.p))) < (cast[int](addr((B.buffer[0]))) + LUAL_BUFFERSIZE): 
+    discard luaL_prepbuffer(B)
+  B.p[1] = c
+  B.p = cast[cstring](cast[int](B.p) + 1)
+
+proc luaL_putchar(B: PluaL_Buffer, c: Char) = 
+  luaL_addchar(B, c)
+
+proc luaL_addsize(B: PluaL_Buffer, n: int) = 
+  B.p = cast[cstring](cast[int](B.p) + n)
+
+proc lua_unref(L: Plua_State, theref: int) = 
+  luaL_unref(L, LUA_REGISTRYINDEX, theref)
+
+proc lua_getref(L: Plua_State, theref: int) = 
+  lua_rawgeti(L, LUA_REGISTRYINDEX, theref)

lib/oldwrappers/lua/lua.nim

@@ -0,0 +1,391 @@
+#*****************************************************************************
+# *                                                                            *
+# *  File:        lua.pas                                                      *
+# *  Authors:     TeCGraf           (C headers + actual Lua libraries)         *
+# *               Lavergne Thomas   (original translation to Pascal)           *
+# *               Bram Kuijvenhoven (update to Lua 5.1.1 for FreePascal)       *
+# *  Description: Basic Lua library                                            *
+# *                                                                            *
+# *****************************************************************************
+#
+#** $Id: lua.h,v 1.175 2003/03/18 12:31:39 roberto Exp $
+#** Lua - An Extensible Extension Language
+#** TeCGraf: Computer Graphics Technology Group, PUC-Rio, Brazil
+#** http://www.lua.org   mailto:info@lua.org
+#** See Copyright Notice at the end of this file
+#
+#
+#** Updated to Lua 5.1.1 by Bram Kuijvenhoven (bram at kuijvenhoven dot net),
+#**   Hexis BV (http://www.hexis.nl), the Netherlands
+#** Notes:
+#**    - Only tested with FPC (FreePascal Compiler)
+#**    - Using LuaBinaries styled DLL/SO names, which include version names
+#**    - LUA_YIELD was suffixed by '_' for avoiding name collision
+#
+#
+#** Translated to pascal by Lavergne Thomas
+#** Notes :
+#**    - Pointers type was prefixed with 'P'
+#**    - lua_upvalueindex constant was transformed to function
+#**    - Some compatibility function was isolated because with it you must have
+#**      lualib.
+#**    - LUA_VERSION was suffixed by '_' for avoiding name collision.
+#** Bug reports :
+#**    - thomas.lavergne@laposte.net
+#**   In french or in english
+#
+
+when defined(MACOSX): 
+  const 
+    LUA_NAME* = "liblua(|5.2|5.1|5.0).dylib"
+    LUA_LIB_NAME* = "liblua(|5.2|5.1|5.0).dylib"
+elif defined(UNIX): 
+  const 
+    LUA_NAME* = "liblua(|5.2|5.1|5.0).so(|.0)"
+    LUA_LIB_NAME* = "liblua(|5.2|5.1|5.0).so(|.0)"
+else: 
+  const 
+    LUA_NAME* = "lua(|5.2|5.1|5.0).dll"
+    LUA_LIB_NAME* = "lua(|5.2|5.1|5.0).dll"
+type 
+  size_t* = int
+  Psize_t* = ptr size_t
+
+const 
+  LUA_VERSION* = "Lua 5.1"
+  LUA_RELEASE* = "Lua 5.1.1"
+  LUA_VERSION_NUM* = 501
+  LUA_COPYRIGHT* = "Copyright (C) 1994-2006 Lua.org, PUC-Rio"
+  LUA_AUTHORS* = "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
+  # option for multiple returns in `lua_pcall' and `lua_call' 
+  LUA_MULTRET* = - 1          #
+                              #** pseudo-indices
+                              #
+  LUA_REGISTRYINDEX* = - 10000
+  LUA_ENVIRONINDEX* = - 10001
+  LUA_GLOBALSINDEX* = - 10002
+
+proc lua_upvalueindex*(I: int): int
+const                         # thread status; 0 is OK 
+  constLUA_YIELD* = 1
+  LUA_ERRRUN* = 2
+  LUA_ERRSYNTAX* = 3
+  LUA_ERRMEM* = 4
+  LUA_ERRERR* = 5
+
+type 
+  Plua_State* = Pointer
+  lua_CFunction* = proc (L: Plua_State): int{.cdecl.}
+  
+#
+#** functions that read/write blocks when loading/dumping Lua chunks
+#
+type 
+  lua_Reader* = proc (L: Plua_State, ud: Pointer, sz: Psize_t): cstring{.cdecl.}
+  lua_Writer* = proc (L: Plua_State, p: Pointer, sz: size_t, ud: Pointer): int{.
+      cdecl.}
+  lua_Alloc* = proc (ud, theptr: Pointer, osize, nsize: size_t){.cdecl.}
+
+const
+  LUA_TNONE* = - 1
+  LUA_TNIL* = 0
+  LUA_TBOOLEAN* = 1
+  LUA_TLIGHTUSERDATA* = 2
+  LUA_TNUMBER* = 3
+  LUA_TSTRING* = 4
+  LUA_TTABLE* = 5
+  LUA_TFUNCTION* = 6
+  LUA_TUSERDATA* = 7
+  LUA_TTHREAD* = 8            # minimum Lua stack available to a C function 
+  LUA_MINSTACK* = 20
+
+type                          # Type of Numbers in Lua 
+  lua_Number* = float
+  lua_Integer* = int
+
+proc lua_newstate*(f: lua_Alloc, ud: Pointer): Plua_State{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_close*(L: Plua_State){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_newthread*(L: Plua_State): Plua_State{.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_atpanic*(L: Plua_State, panicf: lua_CFunction): lua_CFunction{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_gettop*(L: Plua_State): int{.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_settop*(L: Plua_State, idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_pushvalue*(L: Plua_State, Idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_remove*(L: Plua_State, idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_insert*(L: Plua_State, idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_replace*(L: Plua_State, idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_checkstack*(L: Plua_State, sz: int): cint{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_xmove*(`from`, `to`: Plua_State, n: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_isnumber*(L: Plua_State, idx: int): cint{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_isstring*(L: Plua_State, idx: int): cint{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_iscfunction*(L: Plua_State, idx: int): cint{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_isuserdata*(L: Plua_State, idx: int): cint{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_type*(L: Plua_State, idx: int): int{.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_typename*(L: Plua_State, tp: int): cstring{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_equal*(L: Plua_State, idx1, idx2: int): cint{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_rawequal*(L: Plua_State, idx1, idx2: int): cint{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_lessthan*(L: Plua_State, idx1, idx2: int): cint{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_tonumber*(L: Plua_State, idx: int): lua_Number{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_tointeger*(L: Plua_State, idx: int): lua_Integer{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_toboolean*(L: Plua_State, idx: int): cint{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_tolstring*(L: Plua_State, idx: int, length: Psize_t): cstring{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_objlen*(L: Plua_State, idx: int): size_t{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_tocfunction*(L: Plua_State, idx: int): lua_CFunction{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_touserdata*(L: Plua_State, idx: int): Pointer{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_tothread*(L: Plua_State, idx: int): Plua_State{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_topointer*(L: Plua_State, idx: int): Pointer{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_pushnil*(L: Plua_State){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_pushnumber*(L: Plua_State, n: lua_Number){.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_pushinteger*(L: Plua_State, n: lua_Integer){.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_pushlstring*(L: Plua_State, s: cstring, len: size_t){.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_pushstring*(L: Plua_State, s: cstring){.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_pushvfstring*(L: Plua_State, fmt: cstring, argp: Pointer): cstring{.
+    cdecl, dynlib: LUA_NAME, importc.}
+proc lua_pushfstring*(L: Plua_State, fmt: cstring): cstring{.cdecl, varargs, 
+    dynlib: LUA_NAME, importc.}
+proc lua_pushcclosure*(L: Plua_State, fn: lua_CFunction, n: int){.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_pushboolean*(L: Plua_State, b: cint){.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_pushlightuserdata*(L: Plua_State, p: Pointer){.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_pushthread*(L: Plua_State){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_gettable*(L: Plua_State, idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_getfield*(L: Plua_state, idx: int, k: cstring){.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_rawget*(L: Plua_State, idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_rawgeti*(L: Plua_State, idx, n: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_createtable*(L: Plua_State, narr, nrec: int){.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_newuserdata*(L: Plua_State, sz: size_t): Pointer{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_getmetatable*(L: Plua_State, objindex: int): int{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_getfenv*(L: Plua_State, idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_settable*(L: Plua_State, idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_setfield*(L: Plua_State, idx: int, k: cstring){.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_rawset*(L: Plua_State, idx: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_rawseti*(L: Plua_State, idx, n: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_setmetatable*(L: Plua_State, objindex: int): int{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_setfenv*(L: Plua_State, idx: int): int{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_call*(L: Plua_State, nargs, nresults: int){.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_pcall*(L: Plua_State, nargs, nresults, errf: int): int{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_cpcall*(L: Plua_State, func: lua_CFunction, ud: Pointer): int{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_load*(L: Plua_State, reader: lua_Reader, dt: Pointer, 
+               chunkname: cstring): int{.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_dump*(L: Plua_State, writer: lua_Writer, data: Pointer): int{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_yield*(L: Plua_State, nresults: int): int{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_resume*(L: Plua_State, narg: int): int{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_status*(L: Plua_State): int{.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_gc*(L: Plua_State, what, data: int): int{.cdecl, dynlib: LUA_NAME, 
+    importc.}
+proc lua_error*(L: Plua_State): int{.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_next*(L: Plua_State, idx: int): int{.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_concat*(L: Plua_State, n: int){.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_getallocf*(L: Plua_State, ud: ptr Pointer): lua_Alloc{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_setallocf*(L: Plua_State, f: lua_Alloc, ud: Pointer){.cdecl, 
+    dynlib: LUA_NAME, importc.}
+
+#
+#** Garbage-collection functions and options
+#
+const 
+  LUA_GCSTOP* = 0
+  LUA_GCRESTART* = 1
+  LUA_GCCOLLECT* = 2
+  LUA_GCCOUNT* = 3
+  LUA_GCCOUNTB* = 4
+  LUA_GCSTEP* = 5
+  LUA_GCSETPAUSE* = 6
+  LUA_GCSETSTEPMUL* = 7
+
+#
+#** ===============================================================
+#** some useful macros
+#** ===============================================================
+#
+
+proc lua_pop*(L: Plua_State, n: int)
+proc lua_newtable*(L: Plua_state)
+proc lua_register*(L: Plua_State, n: cstring, f: lua_CFunction)
+proc lua_pushcfunction*(L: Plua_State, f: lua_CFunction)
+proc lua_strlen*(L: Plua_state, i: int): size_t
+proc lua_isfunction*(L: Plua_State, n: int): bool
+proc lua_istable*(L: Plua_State, n: int): bool
+proc lua_islightuserdata*(L: Plua_State, n: int): bool
+proc lua_isnil*(L: Plua_State, n: int): bool
+proc lua_isboolean*(L: Plua_State, n: int): bool
+proc lua_isthread*(L: Plua_State, n: int): bool
+proc lua_isnone*(L: Plua_State, n: int): bool
+proc lua_isnoneornil*(L: Plua_State, n: int): bool
+proc lua_pushliteral*(L: Plua_State, s: cstring)
+proc lua_setglobal*(L: Plua_State, s: cstring)
+proc lua_getglobal*(L: Plua_State, s: cstring)
+proc lua_tostring*(L: Plua_State, i: int): cstring
+#
+#** compatibility macros and functions
+#
+proc lua_getregistry*(L: Plua_State)
+proc lua_getgccount*(L: Plua_State): int
+type 
+  lua_Chunkreader* = lua_Reader
+  lua_Chunkwriter* = lua_Writer
+  
+#
+#** ======================================================================
+#** Debug API
+#** ======================================================================
+#
+
+const 
+  LUA_HOOKCALL* = 0
+  LUA_HOOKRET* = 1
+  LUA_HOOKLINE* = 2
+  LUA_HOOKCOUNT* = 3
+  LUA_HOOKTAILRET* = 4
+
+const 
+  LUA_MASKCALL* = 1 shl Ord(LUA_HOOKCALL)
+  LUA_MASKRET* = 1 shl Ord(LUA_HOOKRET)
+  LUA_MASKLINE* = 1 shl Ord(LUA_HOOKLINE)
+  LUA_MASKCOUNT* = 1 shl Ord(LUA_HOOKCOUNT)
+
+const 
+  LUA_IDSIZE* = 60
+
+type 
+  lua_Debug*{.final.} = object  # activation record 
+    event*: int
+    name*: cstring            # (n) 
+    namewhat*: cstring        # (n) `global', `local', `field', `method' 
+    what*: cstring            # (S) `Lua', `C', `main', `tail'
+    source*: cstring          # (S) 
+    currentline*: int         # (l) 
+    nups*: int                # (u) number of upvalues 
+    linedefined*: int         # (S) 
+    lastlinedefined*: int     # (S) 
+    short_src*: array[0..LUA_IDSIZE - 1, Char] # (S) 
+                                               # private part 
+    i_ci*: int                # active function 
+  
+  Plua_Debug* = ptr lua_Debug
+  lua_Hook* = proc (L: Plua_State, ar: Plua_Debug){.cdecl.}
+  
+#
+#** ======================================================================
+#** Debug API
+#** ======================================================================
+#
+
+proc lua_getstack*(L: Plua_State, level: int, ar: Plua_Debug): int{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_getinfo*(L: Plua_State, what: cstring, ar: Plua_Debug): int{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_getlocal*(L: Plua_State, ar: Plua_Debug, n: int): cstring{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_setlocal*(L: Plua_State, ar: Plua_Debug, n: int): cstring{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_getupvalue*(L: Plua_State, funcindex: int, n: int): cstring{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_setupvalue*(L: Plua_State, funcindex: int, n: int): cstring{.cdecl, 
+    dynlib: LUA_NAME, importc.}
+proc lua_sethook*(L: Plua_State, func: lua_Hook, mask: int, count: int): int{.
+    cdecl, dynlib: LUA_NAME, importc.}
+proc lua_gethook*(L: Plua_State): lua_Hook{.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_gethookmask*(L: Plua_State): int{.cdecl, dynlib: LUA_NAME, importc.}
+proc lua_gethookcount*(L: Plua_State): int{.cdecl, dynlib: LUA_NAME, importc.}
+# implementation
+
+proc lua_upvalueindex(I: int): int = 
+  Result = LUA_GLOBALSINDEX - i
+
+proc lua_pop(L: Plua_State, n: int) = 
+  lua_settop(L, - n - 1)
+
+proc lua_newtable(L: Plua_State) = 
+  lua_createtable(L, 0, 0)
+
+proc lua_register(L: Plua_State, n: cstring, f: lua_CFunction) = 
+  lua_pushcfunction(L, f)
+  lua_setglobal(L, n)
+
+proc lua_pushcfunction(L: Plua_State, f: lua_CFunction) = 
+  lua_pushcclosure(L, f, 0)
+
+proc lua_strlen(L: Plua_State, i: int): size_t = 
+  Result = lua_objlen(L, i)
+
+proc lua_isfunction(L: Plua_State, n: int): bool = 
+  Result = lua_type(L, n) == LUA_TFUNCTION
+
+proc lua_istable(L: Plua_State, n: int): bool = 
+  Result = lua_type(L, n) == LUA_TTABLE
+
+proc lua_islightuserdata(L: Plua_State, n: int): bool = 
+  Result = lua_type(L, n) == LUA_TLIGHTUSERDATA
+
+proc lua_isnil(L: Plua_State, n: int): bool = 
+  Result = lua_type(L, n) == LUA_TNIL
+
+proc lua_isboolean(L: Plua_State, n: int): bool = 
+  Result = lua_type(L, n) == LUA_TBOOLEAN
+
+proc lua_isthread(L: Plua_State, n: int): bool = 
+  Result = lua_type(L, n) == LUA_TTHREAD
+
+proc lua_isnone(L: Plua_State, n: int): bool = 
+  Result = lua_type(L, n) == LUA_TNONE
+
+proc lua_isnoneornil(L: Plua_State, n: int): bool = 
+  Result = lua_type(L, n) <= 0
+
+proc lua_pushliteral(L: Plua_State, s: cstring) = 
+  lua_pushlstring(L, s, len(s))
+
+proc lua_setglobal(L: Plua_State, s: cstring) = 
+  lua_setfield(L, LUA_GLOBALSINDEX, s)
+
+proc lua_getglobal(L: Plua_State, s: cstring) = 
+  lua_getfield(L, LUA_GLOBALSINDEX, s)
+
+proc lua_tostring(L: Plua_State, i: int): cstring = 
+  Result = lua_tolstring(L, i, nil)
+
+proc lua_getregistry(L: Plua_State) = 
+  lua_pushvalue(L, LUA_REGISTRYINDEX)
+
+proc lua_getgccount(L: Plua_State): int = 
+  Result = lua_gc(L, LUA_GCCOUNT, 0)

lib/oldwrappers/lua/lualib.nim

@@ -0,0 +1,73 @@
+#*****************************************************************************
+# *                                                                            *
+# *  File:        lualib.pas                                                   *
+# *  Authors:     TeCGraf           (C headers + actual Lua libraries)         *
+# *               Lavergne Thomas   (original translation to Pascal)           *
+# *               Bram Kuijvenhoven (update to Lua 5.1.1 for FreePascal)       *
+# *  Description: Standard Lua libraries                                       *
+# *                                                                            *
+# *****************************************************************************
+#
+#** $Id: lualib.h,v 1.28 2003/03/18 12:24:26 roberto Exp $
+#** Lua standard libraries
+#** See Copyright Notice in lua.h
+#
+#
+#** Translated to pascal by Lavergne Thomas
+#** Bug reports :
+#**    - thomas.lavergne@laposte.net
+#**   In french or in english
+#
+
+import lua
+
+const 
+  LUA_COLIBNAME* = "coroutine"
+  LUA_TABLIBNAME* = "table"
+  LUA_IOLIBNAME* = "io"
+  LUA_OSLIBNAME* = "os"
+  LUA_STRLINAME* = "string"
+  LUA_MATHLIBNAME* = "math"
+  LUA_DBLIBNAME* = "debug"
+  LUA_LOADLIBNAME* = "package"
+
+proc luaopen_base*(L: Plua_State): cint{.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaopen_table*(L: Plua_State): cint{.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaopen_io*(L: Plua_State): cint{.cdecl, dynlib: LUA_LIB_NAME, importc.}
+proc luaopen_string*(L: Plua_State): cint{.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaopen_math*(L: Plua_State): cint{.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaopen_debug*(L: Plua_State): cint{.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaopen_package*(L: Plua_State): cint{.cdecl, dynlib: LUA_LIB_NAME, 
+    importc.}
+proc luaL_openlibs*(L: Plua_State){.cdecl, dynlib: LUA_LIB_NAME, importc.}
+  # compatibility code 
+proc lua_baselibopen*(L: Plua_State): Bool
+proc lua_tablibopen*(L: Plua_State): Bool
+proc lua_iolibopen*(L: Plua_State): Bool
+proc lua_strlibopen*(L: Plua_State): Bool
+proc lua_mathlibopen*(L: Plua_State): Bool
+proc lua_dblibopen*(L: Plua_State): Bool
+# implementation
+
+proc lua_baselibopen(L: Plua_State): Bool = 
+  Result = luaopen_base(L) != 0'i32
+
+proc lua_tablibopen(L: Plua_State): Bool = 
+  Result = luaopen_table(L) != 0'i32
+
+proc lua_iolibopen(L: Plua_State): Bool = 
+  Result = luaopen_io(L) != 0'i32
+
+proc lua_strlibopen(L: Plua_State): Bool = 
+  Result = luaopen_string(L) != 0'i32
+
+proc lua_mathlibopen(L: Plua_State): Bool = 
+  Result = luaopen_math(L) != 0'i32
+
+proc lua_dblibopen(L: Plua_State): Bool = 
+  Result = luaopen_debug(L) != 0'i32

lib/oldwrappers/odbcsql.nim

@@ -0,0 +1,788 @@
+
+{.deadCodeElim: on.}
+
+when not defined(ODBCVER):
+  const
+    ODBCVER = 0x0351 ## define ODBC version 3.51 by default
+
+when defined(windows):
+  {.push callconv: stdcall.}
+  const odbclib = "odbc32.dll"
+else:
+  {.push callconv: cdecl.}
+  const odbclib = "libodbc.so"
+
+# DATA TYPES CORRESPONDENCE
+#   BDE fields  ODBC types
+#   ----------  ------------------
+#   ftBlob      SQL_BINARY
+#   ftBoolean   SQL_BIT
+#   ftDate      SQL_TYPE_DATE
+#   ftTime      SQL_TYPE_TIME
+#   ftDateTime  SQL_TYPE_TIMESTAMP
+#   ftInteger   SQL_INTEGER
+#   ftSmallint  SQL_SMALLINT
+#   ftFloat     SQL_DOUBLE
+#   ftString    SQL_CHAR
+#   ftMemo      SQL_BINARY // SQL_VARCHAR
+#
+
+type 
+  TSqlChar* = char
+  TSqlSmallInt* = int16
+  TSqlUSmallInt* = int16
+  TSqlHandle* = pointer
+  TSqlHEnv* = TSqlHandle
+  TSqlHDBC* = TSqlHandle
+  TSqlHStmt* = TSqlHandle
+  TSqlHDesc* = TSqlHandle
+  TSqlInteger* = int
+  TSqlUInteger* = int
+  TSqlPointer* = pointer
+  TSqlReal* = cfloat
+  TSqlDouble* = cdouble
+  TSqlFloat* = cdouble
+  TSqlHWND* = pointer
+  PSQLCHAR* = cstring
+  PSQLINTEGER* = ptr TSqlInteger
+  PSQLUINTEGER* = ptr TSqlUInteger
+  PSQLSMALLINT* = ptr TSqlSmallInt
+  PSQLUSMALLINT* = ptr TSqlUSmallInt
+  PSQLREAL* = ptr TSqlReal
+  PSQLDOUBLE* = ptr TSqlDouble
+  PSQLFLOAT* = ptr TSqlFloat
+  PSQLHANDLE* = ptr TSqlHandle
+
+const                         # SQL data type codes 
+  SQL_UNKNOWN_TYPE* = 0
+  SQL_LONGVARCHAR* = (- 1)
+  SQL_BINARY* = (- 2)
+  SQL_VARBINARY* = (- 3)
+  SQL_LONGVARBINARY* = (- 4)
+  SQL_BIGINT* = (- 5)
+  SQL_TINYINT* = (- 6)
+  SQL_BIT* = (- 7)
+  SQL_WCHAR* = (- 8)
+  SQL_WVARCHAR* = (- 9)
+  SQL_WLONGVARCHAR* = (- 10)
+  SQL_CHAR* = 1
+  SQL_NUMERIC* = 2
+  SQL_DECIMAL* = 3
+  SQL_INTEGER* = 4
+  SQL_SMALLINT* = 5
+  SQL_FLOAT* = 6
+  SQL_REAL* = 7
+  SQL_DOUBLE* = 8
+  SQL_DATETIME* = 9
+  SQL_VARCHAR* = 12
+  SQL_TYPE_DATE* = 91
+  SQL_TYPE_TIME* = 92
+  SQL_TYPE_TIMESTAMP* = 93
+  SQL_DATE* = 9
+  SQL_TIME* = 10
+  SQL_TIMESTAMP* = 11
+  SQL_INTERVAL* = 10
+  SQL_GUID* = - 11            # interval codes
+
+when ODBCVER >= 0x0300: 
+  const 
+    SQL_CODE_YEAR* = 1
+    SQL_CODE_MONTH* = 2
+    SQL_CODE_DAY* = 3
+    SQL_CODE_HOUR* = 4
+    SQL_CODE_MINUTE* = 5
+    SQL_CODE_SECOND* = 6
+    SQL_CODE_YEAR_TO_MONTH* = 7
+    SQL_CODE_DAY_TO_HOUR* = 8
+    SQL_CODE_DAY_TO_MINUTE* = 9
+    SQL_CODE_DAY_TO_SECOND* = 10
+    SQL_CODE_HOUR_TO_MINUTE* = 11
+    SQL_CODE_HOUR_TO_SECOND* = 12
+    SQL_CODE_MINUTE_TO_SECOND* = 13
+    SQL_INTERVAL_YEAR* = 100 + SQL_CODE_YEAR
+    SQL_INTERVAL_MONTH* = 100 + SQL_CODE_MONTH
+    SQL_INTERVAL_DAY* = 100 + SQL_CODE_DAY
+    SQL_INTERVAL_HOUR* = 100 + SQL_CODE_HOUR
+    SQL_INTERVAL_MINUTE* = 100 + SQL_CODE_MINUTE
+    SQL_INTERVAL_SECOND* = 100 + SQL_CODE_SECOND
+    SQL_INTERVAL_YEAR_TO_MONTH* = 100 + SQL_CODE_YEAR_TO_MONTH
+    SQL_INTERVAL_DAY_TO_HOUR* = 100 + SQL_CODE_DAY_TO_HOUR
+    SQL_INTERVAL_DAY_TO_MINUTE* = 100 + SQL_CODE_DAY_TO_MINUTE
+    SQL_INTERVAL_DAY_TO_SECOND* = 100 + SQL_CODE_DAY_TO_SECOND
+    SQL_INTERVAL_HOUR_TO_MINUTE* = 100 + SQL_CODE_HOUR_TO_MINUTE
+    SQL_INTERVAL_HOUR_TO_SECOND* = 100 + SQL_CODE_HOUR_TO_SECOND
+    SQL_INTERVAL_MINUTE_TO_SECOND* = 100 + SQL_CODE_MINUTE_TO_SECOND
+else: 
+  const 
+    SQL_INTERVAL_YEAR* = - 80
+    SQL_INTERVAL_MONTH* = - 81
+    SQL_INTERVAL_YEAR_TO_MONTH* = - 82
+    SQL_INTERVAL_DAY* = - 83
+    SQL_INTERVAL_HOUR* = - 84
+    SQL_INTERVAL_MINUTE* = - 85
+    SQL_INTERVAL_SECOND* = - 86
+    SQL_INTERVAL_DAY_TO_HOUR* = - 87
+    SQL_INTERVAL_DAY_TO_MINUTE* = - 88
+    SQL_INTERVAL_DAY_TO_SECOND* = - 89
+    SQL_INTERVAL_HOUR_TO_MINUTE* = - 90
+    SQL_INTERVAL_HOUR_TO_SECOND* = - 91
+    SQL_INTERVAL_MINUTE_TO_SECOND* = - 92
+
+
+when ODBCVER < 0x0300: 
+  const 
+    SQL_UNICODE* = - 95
+    SQL_UNICODE_VARCHAR* = - 96
+    SQL_UNICODE_LONGVARCHAR* = - 97
+    SQL_UNICODE_CHAR* = SQL_UNICODE
+else: 
+  # The previous definitions for SQL_UNICODE_ are historical and obsolete 
+  const 
+    SQL_UNICODE* = SQL_WCHAR
+    SQL_UNICODE_VARCHAR* = SQL_WVARCHAR
+    SQL_UNICODE_LONGVARCHAR* = SQL_WLONGVARCHAR
+    SQL_UNICODE_CHAR* = SQL_WCHAR
+const                         # C datatype to SQL datatype mapping 
+  SQL_C_CHAR* = SQL_CHAR
+  SQL_C_LONG* = SQL_INTEGER
+  SQL_C_SHORT* = SQL_SMALLINT
+  SQL_C_FLOAT* = SQL_REAL
+  SQL_C_DOUBLE* = SQL_DOUBLE
+  SQL_C_NUMERIC* = SQL_NUMERIC
+  SQL_C_DEFAULT* = 99
+  SQL_SIGNED_OFFSET* = - 20
+  SQL_UNSIGNED_OFFSET* = - 22
+  SQL_C_DATE* = SQL_DATE
+  SQL_C_TIME* = SQL_TIME
+  SQL_C_TIMESTAMP* = SQL_TIMESTAMP
+  SQL_C_TYPE_DATE* = SQL_TYPE_DATE
+  SQL_C_TYPE_TIME* = SQL_TYPE_TIME
+  SQL_C_TYPE_TIMESTAMP* = SQL_TYPE_TIMESTAMP
+  SQL_C_INTERVAL_YEAR* = SQL_INTERVAL_YEAR
+  SQL_C_INTERVAL_MONTH* = SQL_INTERVAL_MONTH
+  SQL_C_INTERVAL_DAY* = SQL_INTERVAL_DAY
+  SQL_C_INTERVAL_HOUR* = SQL_INTERVAL_HOUR
+  SQL_C_INTERVAL_MINUTE* = SQL_INTERVAL_MINUTE
+  SQL_C_INTERVAL_SECOND* = SQL_INTERVAL_SECOND
+  SQL_C_INTERVAL_YEAR_TO_MONTH* = SQL_INTERVAL_YEAR_TO_MONTH
+  SQL_C_INTERVAL_DAY_TO_HOUR* = SQL_INTERVAL_DAY_TO_HOUR
+  SQL_C_INTERVAL_DAY_TO_MINUTE* = SQL_INTERVAL_DAY_TO_MINUTE
+  SQL_C_INTERVAL_DAY_TO_SECOND* = SQL_INTERVAL_DAY_TO_SECOND
+  SQL_C_INTERVAL_HOUR_TO_MINUTE* = SQL_INTERVAL_HOUR_TO_MINUTE
+  SQL_C_INTERVAL_HOUR_TO_SECOND* = SQL_INTERVAL_HOUR_TO_SECOND
+  SQL_C_INTERVAL_MINUTE_TO_SECOND* = SQL_INTERVAL_MINUTE_TO_SECOND
+  SQL_C_BINARY* = SQL_BINARY
+  SQL_C_BIT* = SQL_BIT
+  SQL_C_SBIGINT* = SQL_BIGINT + SQL_SIGNED_OFFSET # SIGNED BIGINT
+  SQL_C_UBIGINT* = SQL_BIGINT + SQL_UNSIGNED_OFFSET # UNSIGNED BIGINT
+  SQL_C_TINYINT* = SQL_TINYINT
+  SQL_C_SLONG* = SQL_C_LONG + SQL_SIGNED_OFFSET # SIGNED INTEGER
+  SQL_C_SSHORT* = SQL_C_SHORT + SQL_SIGNED_OFFSET # SIGNED SMALLINT
+  SQL_C_STINYINT* = SQL_TINYINT + SQL_SIGNED_OFFSET # SIGNED TINYINT
+  SQL_C_ULONG* = SQL_C_LONG + SQL_UNSIGNED_OFFSET # UNSIGNED INTEGER
+  SQL_C_USHORT* = SQL_C_SHORT + SQL_UNSIGNED_OFFSET # UNSIGNED SMALLINT
+  SQL_C_UTINYINT* = SQL_TINYINT + SQL_UNSIGNED_OFFSET # UNSIGNED TINYINT
+  SQL_C_BOOKMARK* = SQL_C_ULONG # BOOKMARK
+  SQL_C_GUID* = SQL_GUID
+  SQL_TYPE_NULL* = 0
+
+when ODBCVER < 0x0300: 
+  const 
+    SQL_TYPE_MIN* = SQL_BIT
+    SQL_TYPE_MAX* = SQL_VARCHAR
+
+const 
+  SQL_C_VARBOOKMARK* = SQL_C_BINARY
+  SQL_API_SQLDESCRIBEPARAM* = 58
+  SQL_NO_TOTAL* = - 4
+
+type 
+  SQL_DATE_STRUCT* {.final, pure.} = object 
+    Year*: TSqlSmallInt
+    Month*: TSqlUSmallInt
+    Day*: TSqlUSmallInt
+
+  PSQL_DATE_STRUCT* = ptr SQL_DATE_STRUCT
+  SQL_TIME_STRUCT* {.final, pure.} = object 
+    Hour*: TSqlUSmallInt
+    Minute*: TSqlUSmallInt
+    Second*: TSqlUSmallInt
+
+  PSQL_TIME_STRUCT* = ptr SQL_TIME_STRUCT
+  SQL_TIMESTAMP_STRUCT* {.final, pure.} = object 
+    Year*: TSqlUSmallInt
+    Month*: TSqlUSmallInt
+    Day*: TSqlUSmallInt
+    Hour*: TSqlUSmallInt
+    Minute*: TSqlUSmallInt
+    Second*: TSqlUSmallInt
+    Fraction*: TSqlUInteger
+
+  PSQL_TIMESTAMP_STRUCT* = ptr SQL_TIMESTAMP_STRUCT
+
+const 
+  SQL_NAME_LEN* = 128
+  SQL_OV_ODBC3* = 3
+  SQL_OV_ODBC2* = 2
+  SQL_ATTR_ODBC_VERSION* = 200 # Options for SQLDriverConnect 
+  SQL_DRIVER_NOPROMPT* = 0
+  SQL_DRIVER_COMPLETE* = 1
+  SQL_DRIVER_PROMPT* = 2
+  SQL_DRIVER_COMPLETE_REQUIRED* = 3 
+  SQL_IS_POINTER* = (- 4)  # whether an attribute is a pointer or not 
+  SQL_IS_UINTEGER* = (- 5)
+  SQL_IS_INTEGER* = (- 6)
+  SQL_IS_USMALLINT* = (- 7)
+  SQL_IS_SMALLINT* = (- 8)    # SQLExtendedFetch "fFetchType" values 
+  SQL_FETCH_BOOKMARK* = 8
+  SQL_SCROLL_OPTIONS* = 44    # SQL_USE_BOOKMARKS options 
+  SQL_UB_OFF* = 0
+  SQL_UB_ON* = 1
+  SQL_UB_DEFAULT* = SQL_UB_OFF
+  SQL_UB_FIXED* = SQL_UB_ON
+  SQL_UB_VARIABLE* = 2        # SQL_SCROLL_OPTIONS masks 
+  SQL_SO_FORWARD_ONLY* = 0x00000001
+  SQL_SO_KEYSET_DRIVEN* = 0x00000002
+  SQL_SO_DYNAMIC* = 0x00000004
+  SQL_SO_MIXED* = 0x00000008
+  SQL_SO_STATIC* = 0x00000010
+  SQL_BOOKMARK_PERSISTENCE* = 82
+  SQL_STATIC_SENSITIVITY* = 83 # SQL_BOOKMARK_PERSISTENCE values 
+  SQL_BP_CLOSE* = 0x00000001
+  SQL_BP_DELETE* = 0x00000002
+  SQL_BP_DROP* = 0x00000004
+  SQL_BP_TRANSACTION* = 0x00000008
+  SQL_BP_UPDATE* = 0x00000010
+  SQL_BP_OTHER_HSTMT* = 0x00000020
+  SQL_BP_SCROLL* = 0x00000040
+  SQL_DYNAMIC_CURSOR_ATTRIBUTES1* = 144
+  SQL_DYNAMIC_CURSOR_ATTRIBUTES2* = 145
+  SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1* = 146
+  SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2* = 147
+  SQL_INDEX_KEYWORDS* = 148
+  SQL_INFO_SCHEMA_VIEWS* = 149
+  SQL_KEYSET_CURSOR_ATTRIBUTES1* = 150
+  SQL_KEYSET_CURSOR_ATTRIBUTES2* = 151
+  SQL_STATIC_CURSOR_ATTRIBUTES1* = 167
+  SQL_STATIC_CURSOR_ATTRIBUTES2* = 168 # supported SQLFetchScroll FetchOrientation's 
+  SQL_CA1_NEXT* = 1
+  SQL_CA1_ABSOLUTE* = 2
+  SQL_CA1_RELATIVE* = 4
+  SQL_CA1_BOOKMARK* = 8       # supported SQLSetPos LockType's 
+  SQL_CA1_LOCK_NO_CHANGE* = 0x00000040
+  SQL_CA1_LOCK_EXCLUSIVE* = 0x00000080
+  SQL_CA1_LOCK_UNLOCK* = 0x00000100 # supported SQLSetPos Operations 
+  SQL_CA1_POS_POSITION* = 0x00000200
+  SQL_CA1_POS_UPDATE* = 0x00000400
+  SQL_CA1_POS_DELETE* = 0x00000800
+  SQL_CA1_POS_REFRESH* = 0x00001000 # positioned updates and deletes 
+  SQL_CA1_POSITIONED_UPDATE* = 0x00002000
+  SQL_CA1_POSITIONED_DELETE* = 0x00004000
+  SQL_CA1_SELECT_FOR_UPDATE* = 0x00008000 # supported SQLBulkOperations operations 
+  SQL_CA1_BULK_ADD* = 0x00010000
+  SQL_CA1_BULK_UPDATE_BY_BOOKMARK* = 0x00020000
+  SQL_CA1_BULK_DELETE_BY_BOOKMARK* = 0x00040000
+  SQL_CA1_BULK_FETCH_BY_BOOKMARK* = 0x00080000 # supported values for SQL_ATTR_SCROLL_CONCURRENCY 
+  SQL_CA2_READ_ONLY_CONCURRENCY* = 1
+  SQL_CA2_LOCK_CONCURRENCY* = 2
+  SQL_CA2_OPT_ROWVER_CONCURRENCY* = 4
+  SQL_CA2_OPT_VALUES_CONCURRENCY* = 8 # sensitivity of the cursor to its own inserts, deletes, and updates 
+  SQL_CA2_SENSITIVITY_ADDITIONS* = 0x00000010
+  SQL_CA2_SENSITIVITY_DELETIONS* = 0x00000020
+  SQL_CA2_SENSITIVITY_UPDATES* = 0x00000040 #  semantics of SQL_ATTR_MAX_ROWS 
+  SQL_CA2_MAX_ROWS_SELECT* = 0x00000080
+  SQL_CA2_MAX_ROWS_INSERT* = 0x00000100
+  SQL_CA2_MAX_ROWS_DELETE* = 0x00000200
+  SQL_CA2_MAX_ROWS_UPDATE* = 0x00000400
+  SQL_CA2_MAX_ROWS_CATALOG* = 0x00000800
+  SQL_CA2_MAX_ROWS_AFFECTS_ALL* = (SQL_CA2_MAX_ROWS_SELECT or
+      SQL_CA2_MAX_ROWS_INSERT or SQL_CA2_MAX_ROWS_DELETE or
+      SQL_CA2_MAX_ROWS_UPDATE or SQL_CA2_MAX_ROWS_CATALOG) # semantics of 
+                                                           # SQL_DIAG_CURSOR_ROW_COUNT 
+  SQL_CA2_CRC_EXACT* = 0x00001000
+  SQL_CA2_CRC_APPROXIMATE* = 0x00002000 #  the kinds of positioned statements that can be simulated 
+  SQL_CA2_SIMULATE_NON_UNIQUE* = 0x00004000
+  SQL_CA2_SIMULATE_TRY_UNIQUE* = 0x00008000
+  SQL_CA2_SIMULATE_UNIQUE* = 0x00010000 #  Operations in SQLBulkOperations 
+  SQL_ADD* = 4
+  SQL_SETPOS_MAX_OPTION_VALUE* = SQL_ADD
+  SQL_UPDATE_BY_BOOKMARK* = 5
+  SQL_DELETE_BY_BOOKMARK* = 6
+  SQL_FETCH_BY_BOOKMARK* = 7  # Operations in SQLSetPos 
+  SQL_POSITION* = 0
+  SQL_REFRESH* = 1
+  SQL_UPDATE* = 2
+  SQL_DELETE* = 3             # Lock options in SQLSetPos 
+  SQL_LOCK_NO_CHANGE* = 0
+  SQL_LOCK_EXCLUSIVE* = 1
+  SQL_LOCK_UNLOCK* = 2        # SQLExtendedFetch "rgfRowStatus" element values 
+  SQL_ROW_SUCCESS* = 0
+  SQL_ROW_DELETED* = 1
+  SQL_ROW_UPDATED* = 2
+  SQL_ROW_NOROW* = 3
+  SQL_ROW_ADDED* = 4
+  SQL_ROW_ERROR* = 5
+  SQL_ROW_SUCCESS_WITH_INFO* = 6
+  SQL_ROW_PROCEED* = 0
+  SQL_ROW_IGNORE* = 1
+  SQL_MAX_DSN_LENGTH* = 32    # maximum data source name size 
+  SQL_MAX_OPTION_STRING_LENGTH* = 256
+  SQL_ODBC_CURSORS* = 110
+  SQL_ATTR_ODBC_CURSORS* = SQL_ODBC_CURSORS # SQL_ODBC_CURSORS options 
+  SQL_CUR_USE_IF_NEEDED* = 0
+  SQL_CUR_USE_ODBC* = 1
+  SQL_CUR_USE_DRIVER* = 2
+  SQL_CUR_DEFAULT* = SQL_CUR_USE_DRIVER
+  SQL_PARAM_TYPE_UNKNOWN* = 0
+  SQL_PARAM_INPUT* = 1
+  SQL_PARAM_INPUT_OUTPUT* = 2
+  SQL_RESULT_COL* = 3
+  SQL_PARAM_OUTPUT* = 4
+  SQL_RETURN_VALUE* = 5       # special length/indicator values 
+  SQL_NULL_DATA* = (- 1)
+  SQL_DATA_AT_EXEC* = (- 2)
+  SQL_SUCCESS* = 0
+  SQL_SUCCESS_WITH_INFO* = 1
+  SQL_NO_DATA* = 100
+  SQL_ERROR* = (- 1)
+  SQL_INVALID_HANDLE* = (- 2)
+  SQL_STILL_EXECUTING* = 2
+  SQL_NEED_DATA* = 99         # flags for null-terminated string 
+  SQL_NTS* = (- 3)            # maximum message length 
+  SQL_MAX_MESSAGE_LENGTH* = 512 # date/time length constants 
+  SQL_DATE_LEN* = 10
+  SQL_TIME_LEN* = 8           # add P+1 if precision is nonzero 
+  SQL_TIMESTAMP_LEN* = 19     # add P+1 if precision is nonzero 
+                              # handle type identifiers 
+  SQL_HANDLE_ENV* = 1
+  SQL_HANDLE_DBC* = 2
+  SQL_HANDLE_STMT* = 3
+  SQL_HANDLE_DESC* = 4        # environment attribute 
+  SQL_ATTR_OUTPUT_NTS* = 10001 # connection attributes 
+  SQL_ATTR_AUTO_IPD* = 10001
+  SQL_ATTR_METADATA_ID* = 10014 # statement attributes 
+  SQL_ATTR_APP_ROW_DESC* = 10010
+  SQL_ATTR_APP_PARAM_DESC* = 10011
+  SQL_ATTR_IMP_ROW_DESC* = 10012
+  SQL_ATTR_IMP_PARAM_DESC* = 10013
+  SQL_ATTR_CURSOR_SCROLLABLE* = (- 1)
+  SQL_ATTR_CURSOR_SENSITIVITY* = (- 2)
+  SQL_QUERY_TIMEOUT* = 0
+  SQL_MAX_ROWS* = 1
+  SQL_NOSCAN* = 2
+  SQL_MAX_LENGTH* = 3
+  SQL_ASYNC_ENABLE* = 4       # same as SQL_ATTR_ASYNC_ENABLE */
+  SQL_BIND_TYPE* = 5
+  SQL_CURSOR_TYPE* = 6
+  SQL_CONCURRENCY* = 7
+  SQL_KEYSET_SIZE* = 8
+  SQL_ROWSET_SIZE* = 9
+  SQL_SIMULATE_CURSOR* = 10
+  SQL_RETRIEVE_DATA* = 11
+  SQL_USE_BOOKMARKS* = 12
+  SQL_GET_BOOKMARK* = 13      #      GetStmtOption Only */
+  SQL_ROW_NUMBER* = 14        #      GetStmtOption Only */
+  SQL_ATTR_CURSOR_TYPE* = SQL_CURSOR_TYPE
+  SQL_ATTR_CONCURRENCY* = SQL_CONCURRENCY
+  SQL_ATTR_FETCH_BOOKMARK_PTR* = 16
+  SQL_ATTR_ROW_STATUS_PTR* = 25
+  SQL_ATTR_ROWS_FETCHED_PTR* = 26
+  SQL_AUTOCOMMIT* = 102
+  SQL_ATTR_AUTOCOMMIT* = SQL_AUTOCOMMIT
+  SQL_ATTR_ROW_NUMBER* = SQL_ROW_NUMBER
+  SQL_TXN_ISOLATION* = 108
+  SQL_ATTR_TXN_ISOLATION* = SQL_TXN_ISOLATION
+  SQL_ATTR_MAX_ROWS* = SQL_MAX_ROWS
+  SQL_ATTR_USE_BOOKMARKS* = SQL_USE_BOOKMARKS #* connection attributes */
+  SQL_ACCESS_MODE* = 101      #  SQL_AUTOCOMMIT              =102;
+  SQL_LOGIN_TIMEOUT* = 103
+  SQL_OPT_TRACE* = 104
+  SQL_OPT_TRACEFILE* = 105
+  SQL_TRANSLATE_DLL* = 106
+  SQL_TRANSLATE_OPTION* = 107 #  SQL_TXN_ISOLATION           =108;
+  SQL_CURRENT_QUALIFIER* = 109 #  SQL_ODBC_CURSORS            =110;
+  SQL_QUIET_MODE* = 111
+  SQL_PACKET_SIZE* = 112      #* connection attributes with new names */
+  SQL_ATTR_ACCESS_MODE* = SQL_ACCESS_MODE #  SQL_ATTR_AUTOCOMMIT                       =SQL_AUTOCOMMIT;
+  SQL_ATTR_CONNECTION_DEAD* = 1209 #* GetConnectAttr only */
+  SQL_ATTR_CONNECTION_TIMEOUT* = 113
+  SQL_ATTR_CURRENT_CATALOG* = SQL_CURRENT_QUALIFIER
+  SQL_ATTR_DISCONNECT_BEHAVIOR* = 114
+  SQL_ATTR_ENLIST_IN_DTC* = 1207
+  SQL_ATTR_ENLIST_IN_XA* = 1208
+  SQL_ATTR_LOGIN_TIMEOUT* = SQL_LOGIN_TIMEOUT #  SQL_ATTR_ODBC_CURSORS             =SQL_ODBC_CURSORS;
+  SQL_ATTR_PACKET_SIZE* = SQL_PACKET_SIZE
+  SQL_ATTR_QUIET_MODE* = SQL_QUIET_MODE
+  SQL_ATTR_TRACE* = SQL_OPT_TRACE
+  SQL_ATTR_TRACEFILE* = SQL_OPT_TRACEFILE
+  SQL_ATTR_TRANSLATE_LIB* = SQL_TRANSLATE_DLL
+  SQL_ATTR_TRANSLATE_OPTION* = SQL_TRANSLATE_OPTION #  SQL_ATTR_TXN_ISOLATION                  =SQL_TXN_ISOLATION;
+                                                    #* SQL_ACCESS_MODE options */
+  SQL_MODE_READ_WRITE* = 0
+  SQL_MODE_READ_ONLY* = 1
+  SQL_MODE_DEFAULT* = SQL_MODE_READ_WRITE #* SQL_AUTOCOMMIT options */
+  SQL_AUTOCOMMIT_OFF* = 0
+  SQL_AUTOCOMMIT_ON* = 1
+  SQL_AUTOCOMMIT_DEFAULT* = SQL_AUTOCOMMIT_ON # SQL_ATTR_CURSOR_SCROLLABLE values 
+  SQL_NONSCROLLABLE* = 0
+  SQL_SCROLLABLE* = 1         # SQL_CURSOR_TYPE options 
+  SQL_CURSOR_FORWARD_ONLY* = 0
+  SQL_CURSOR_KEYSET_DRIVEN* = 1
+  SQL_CURSOR_DYNAMIC* = 2
+  SQL_CURSOR_STATIC* = 3
+  SQL_CURSOR_TYPE_DEFAULT* = SQL_CURSOR_FORWARD_ONLY # Default value 
+                                                     # SQL_CONCURRENCY options 
+  SQL_CONCUR_READ_ONLY* = 1
+  SQL_CONCUR_LOCK* = 2
+  SQL_CONCUR_ROWVER* = 3
+  SQL_CONCUR_VALUES* = 4
+  SQL_CONCUR_DEFAULT* = SQL_CONCUR_READ_ONLY # Default value 
+                                             # identifiers of fields in the SQL descriptor 
+  SQL_DESC_COUNT* = 1001
+  SQL_DESC_TYPE* = 1002
+  SQL_DESC_LENGTH* = 1003
+  SQL_DESC_OCTET_LENGTH_PTR* = 1004
+  SQL_DESC_PRECISION* = 1005
+  SQL_DESC_SCALE* = 1006
+  SQL_DESC_DATETIME_INTERVAL_CODE* = 1007
+  SQL_DESC_NULLABLE* = 1008
+  SQL_DESC_INDICATOR_PTR* = 1009
+  SQL_DESC_DATA_PTR* = 1010
+  SQL_DESC_NAME* = 1011
+  SQL_DESC_UNNAMED* = 1012
+  SQL_DESC_OCTET_LENGTH* = 1013
+  SQL_DESC_ALLOC_TYPE* = 1099 # identifiers of fields in the diagnostics area 
+  SQL_DIAG_RETURNCODE* = 1
+  SQL_DIAG_NUMBER* = 2
+  SQL_DIAG_ROW_COUNT* = 3
+  SQL_DIAG_SQLSTATE* = 4
+  SQL_DIAG_NATIVE* = 5
+  SQL_DIAG_MESSAGE_TEXT* = 6
+  SQL_DIAG_DYNAMIC_FUNCTION* = 7
+  SQL_DIAG_CLASS_ORIGIN* = 8
+  SQL_DIAG_SUBCLASS_ORIGIN* = 9
+  SQL_DIAG_CONNECTION_NAME* = 10
+  SQL_DIAG_SERVER_NAME* = 11
+  SQL_DIAG_DYNAMIC_FUNCTION_CODE* = 12 # dynamic function codes 
+  SQL_DIAG_ALTER_TABLE* = 4
+  SQL_DIAG_CREATE_INDEX* = (- 1)
+  SQL_DIAG_CREATE_TABLE* = 77
+  SQL_DIAG_CREATE_VIEW* = 84
+  SQL_DIAG_DELETE_WHERE* = 19
+  SQL_DIAG_DROP_INDEX* = (- 2)
+  SQL_DIAG_DROP_TABLE* = 32
+  SQL_DIAG_DROP_VIEW* = 36
+  SQL_DIAG_DYNAMIC_DELETE_CURSOR* = 38
+  SQL_DIAG_DYNAMIC_UPDATE_CURSOR* = 81
+  SQL_DIAG_GRANT* = 48
+  SQL_DIAG_INSERT* = 50
+  SQL_DIAG_REVOKE* = 59
+  SQL_DIAG_SELECT_CURSOR* = 85
+  SQL_DIAG_UNKNOWN_STATEMENT* = 0
+  SQL_DIAG_UPDATE_WHERE* = 82 # Statement attribute values for cursor sensitivity 
+  SQL_UNSPECIFIED* = 0
+  SQL_INSENSITIVE* = 1
+  SQL_SENSITIVE* = 2          # GetTypeInfo() request for all data types 
+  SQL_ALL_TYPES* = 0          # Default conversion code for SQLBindCol(), SQLBindParam() and SQLGetData() 
+  SQL_DEFAULT* = 99 # SQLGetData() code indicating that the application row descriptor
+                    #    specifies the data type 
+  SQL_ARD_TYPE* = (- 99)      # SQL date/time type subcodes 
+  SQL_CODE_DATE* = 1
+  SQL_CODE_TIME* = 2
+  SQL_CODE_TIMESTAMP* = 3     # CLI option values 
+  SQL_FALSE* = 0
+  SQL_TRUE* = 1               # values of NULLABLE field in descriptor 
+  SQL_NO_NULLS* = 0
+  SQL_NULLABLE* = 1 # Value returned by SQLGetTypeInfo() to denote that it is
+                    # not known whether or not a data type supports null values. 
+  SQL_NULLABLE_UNKNOWN* = 2 
+  SQL_CLOSE* = 0
+  SQL_DROP* = 1
+  SQL_UNBIND* = 2
+  SQL_RESET_PARAMS* = 3 # Codes used for FetchOrientation in SQLFetchScroll(),
+                        #   and in SQLDataSources() 
+  SQL_FETCH_NEXT* = 1
+  SQL_FETCH_FIRST* = 2
+  SQL_FETCH_FIRST_USER* = 31
+  SQL_FETCH_FIRST_SYSTEM* = 32 # Other codes used for FetchOrientation in SQLFetchScroll() 
+  SQL_FETCH_LAST* = 3
+  SQL_FETCH_PRIOR* = 4
+  SQL_FETCH_ABSOLUTE* = 5
+  SQL_FETCH_RELATIVE* = 6   
+  SQL_NULL_HENV* = TSqlHEnv(nil)
+  SQL_NULL_HDBC* = TSqlHDBC(nil)
+  SQL_NULL_HSTMT* = TSqlHStmt(nil)
+  SQL_NULL_HDESC* = TSqlHDesc(nil) #* null handle used in place of parent handle when allocating HENV */
+  SQL_NULL_HANDLE* = TSqlHandle(nil) #* Values that may appear in the result set of SQLSpecialColumns() */
+  SQL_SCOPE_CURROW* = 0
+  SQL_SCOPE_TRANSACTION* = 1
+  SQL_SCOPE_SESSION* = 2      #* Column types and scopes in SQLSpecialColumns.  */
+  SQL_BEST_ROWID* = 1
+  SQL_ROWVER* = 2             
+  SQL_ROW_IDENTIFIER* = 1     #* Reserved values for UNIQUE argument of SQLStatistics() */
+  SQL_INDEX_UNIQUE* = 0
+  SQL_INDEX_ALL* = 1          #* Reserved values for RESERVED argument of SQLStatistics() */
+  SQL_QUICK* = 0
+  SQL_ENSURE* = 1             #* Values that may appear in the result set of SQLStatistics() */
+  SQL_TABLE_STAT* = 0
+  SQL_INDEX_CLUSTERED* = 1
+  SQL_INDEX_HASHED* = 2
+  SQL_INDEX_OTHER* = 3 
+  SQL_SCROLL_CONCURRENCY* = 43
+  SQL_TXN_CAPABLE* = 46
+  SQL_TRANSACTION_CAPABLE* = SQL_TXN_CAPABLE
+  SQL_USER_NAME* = 47
+  SQL_TXN_ISOLATION_OPTION* = 72
+  SQL_TRANSACTION_ISOLATION_OPTION* = SQL_TXN_ISOLATION_OPTION 
+  SQL_OJ_CAPABILITIES* = 115
+  SQL_OUTER_JOIN_CAPABILITIES* = SQL_OJ_CAPABILITIES
+  SQL_XOPEN_CLI_YEAR* = 10000
+  SQL_CURSOR_SENSITIVITY* = 10001
+  SQL_DESCRIBE_PARAMETER* = 10002
+  SQL_CATALOG_NAME* = 10003
+  SQL_COLLATION_SEQ* = 10004
+  SQL_MAX_IDENTIFIER_LEN* = 10005
+  SQL_MAXIMUM_IDENTIFIER_LENGTH* = SQL_MAX_IDENTIFIER_LEN
+  SQL_SCCO_READ_ONLY* = 1
+  SQL_SCCO_LOCK* = 2
+  SQL_SCCO_OPT_ROWVER* = 4
+  SQL_SCCO_OPT_VALUES* = 8    #* SQL_TXN_CAPABLE values */
+  SQL_TC_NONE* = 0
+  SQL_TC_DML* = 1
+  SQL_TC_ALL* = 2
+  SQL_TC_DDL_COMMIT* = 3
+  SQL_TC_DDL_IGNORE* = 4      #* SQL_TXN_ISOLATION_OPTION bitmasks */
+  SQL_TXN_READ_UNCOMMITTED* = 1
+  SQL_TRANSACTION_READ_UNCOMMITTED* = SQL_TXN_READ_UNCOMMITTED
+  SQL_TXN_READ_COMMITTED* = 2
+  SQL_TRANSACTION_READ_COMMITTED* = SQL_TXN_READ_COMMITTED
+  SQL_TXN_REPEATABLE_READ* = 4
+  SQL_TRANSACTION_REPEATABLE_READ* = SQL_TXN_REPEATABLE_READ
+  SQL_TXN_SERIALIZABLE* = 8
+  SQL_TRANSACTION_SERIALIZABLE* = SQL_TXN_SERIALIZABLE 
+  SQL_SS_ADDITIONS* = 1
+  SQL_SS_DELETIONS* = 2
+  SQL_SS_UPDATES* = 4         # SQLColAttributes defines 
+  SQL_COLUMN_COUNT* = 0
+  SQL_COLUMN_NAME* = 1
+  SQL_COLUMN_TYPE* = 2
+  SQL_COLUMN_LENGTH* = 3
+  SQL_COLUMN_PRECISION* = 4
+  SQL_COLUMN_SCALE* = 5
+  SQL_COLUMN_DISPLAY_SIZE* = 6
+  SQL_COLUMN_NULLABLE* = 7
+  SQL_COLUMN_UNSIGNED* = 8
+  SQL_COLUMN_MONEY* = 9
+  SQL_COLUMN_UPDATABLE* = 10
+  SQL_COLUMN_AUTO_INCREMENT* = 11
+  SQL_COLUMN_CASE_SENSITIVE* = 12
+  SQL_COLUMN_SEARCHABLE* = 13
+  SQL_COLUMN_TYPE_NAME* = 14
+  SQL_COLUMN_TABLE_NAME* = 15
+  SQL_COLUMN_OWNER_NAME* = 16
+  SQL_COLUMN_QUALIFIER_NAME* = 17
+  SQL_COLUMN_LABEL* = 18
+  SQL_COLATT_OPT_MAX* = SQL_COLUMN_LABEL
+  SQL_COLUMN_DRIVER_START* = 1000
+  SQL_DESC_ARRAY_SIZE* = 20
+  SQL_DESC_ARRAY_STATUS_PTR* = 21
+  SQL_DESC_AUTO_UNIQUE_VALUE* = SQL_COLUMN_AUTO_INCREMENT
+  SQL_DESC_BASE_COLUMN_NAME* = 22
+  SQL_DESC_BASE_TABLE_NAME* = 23
+  SQL_DESC_BIND_OFFSET_PTR* = 24
+  SQL_DESC_BIND_TYPE* = 25
+  SQL_DESC_CASE_SENSITIVE* = SQL_COLUMN_CASE_SENSITIVE
+  SQL_DESC_CATALOG_NAME* = SQL_COLUMN_QUALIFIER_NAME
+  SQL_DESC_CONCISE_TYPE* = SQL_COLUMN_TYPE
+  SQL_DESC_DATETIME_INTERVAL_PRECISION* = 26
+  SQL_DESC_DISPLAY_SIZE* = SQL_COLUMN_DISPLAY_SIZE
+  SQL_DESC_FIXED_PREC_SCALE* = SQL_COLUMN_MONEY
+  SQL_DESC_LABEL* = SQL_COLUMN_LABEL
+  SQL_DESC_LITERAL_PREFIX* = 27
+  SQL_DESC_LITERAL_SUFFIX* = 28
+  SQL_DESC_LOCAL_TYPE_NAME* = 29
+  SQL_DESC_MAXIMUM_SCALE* = 30
+  SQL_DESC_MINIMUM_SCALE* = 31
+  SQL_DESC_NUM_PREC_RADIX* = 32
+  SQL_DESC_PARAMETER_TYPE* = 33
+  SQL_DESC_ROWS_PROCESSED_PTR* = 34
+  SQL_DESC_SCHEMA_NAME* = SQL_COLUMN_OWNER_NAME
+  SQL_DESC_SEARCHABLE* = SQL_COLUMN_SEARCHABLE
+  SQL_DESC_TYPE_NAME* = SQL_COLUMN_TYPE_NAME
+  SQL_DESC_TABLE_NAME* = SQL_COLUMN_TABLE_NAME
+  SQL_DESC_UNSIGNED* = SQL_COLUMN_UNSIGNED
+  SQL_DESC_UPDATABLE* = SQL_COLUMN_UPDATABLE #* SQLEndTran() options */
+  SQL_COMMIT* = 0
+  SQL_ROLLBACK* = 1
+  SQL_ATTR_ROW_ARRAY_SIZE* = 27 #* SQLConfigDataSource() options */
+  ODBC_ADD_DSN* = 1
+  ODBC_CONFIG_DSN* = 2
+  ODBC_REMOVE_DSN* = 3
+  ODBC_ADD_SYS_DSN* = 4
+  ODBC_CONFIG_SYS_DSN* = 5
+  ODBC_REMOVE_SYS_DSN* = 6
+
+proc SQLAllocHandle*(HandleType: TSqlSmallInt, InputHandle: TSqlHandle, 
+                     OutputHandlePtr: var TSqlHandle): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLSetEnvAttr*(EnvironmentHandle: TSqlHEnv, Attribute: TSqlInteger, 
+                    Value: TSqlPointer, StringLength: TSqlInteger): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLGetEnvAttr*(EnvironmentHandle: TSqlHEnv, Attribute: TSqlInteger, 
+                    Value: TSqlPointer, BufferLength: TSqlInteger, 
+                    StringLength: PSQLINTEGER): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLFreeHandle*(HandleType: TSqlSmallInt, Handle: TSqlHandle): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLGetDiagRec*(HandleType: TSqlSmallInt, Handle: TSqlHandle, 
+                    RecNumber: TSqlSmallInt, Sqlstate: PSQLCHAR, 
+                    NativeError: var TSqlInteger, MessageText: PSQLCHAR, 
+                    BufferLength: TSqlSmallInt, TextLength: var TSqlSmallInt): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLGetDiagField*(HandleType: TSqlSmallInt, Handle: TSqlHandle, 
+                      RecNumber: TSqlSmallInt, DiagIdentifier: TSqlSmallInt, 
+                      DiagInfoPtr: TSqlPointer, BufferLength: TSqlSmallInt, 
+                      StringLengthPtr: var TSqlSmallInt): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLConnect*(ConnectionHandle: TSqlHDBC, ServerName: PSQLCHAR, 
+                 NameLength1: TSqlSmallInt, UserName: PSQLCHAR, 
+                 NameLength2: TSqlSmallInt, Authentication: PSQLCHAR, 
+                 NameLength3: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLDisconnect*(ConnectionHandle: TSqlHDBC): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLDriverConnect*(hdbc: TSqlHDBC, hwnd: TSqlHWND, szCsin: cstring, 
+                       szCLen: TSqlSmallInt, szCsout: cstring, 
+                       cbCSMax: TSqlSmallInt, cbCsOut: var TSqlSmallInt, 
+                       f: TSqlUSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLBrowseConnect*(hdbc: TSqlHDBC, szConnStrIn: PSQLCHAR, 
+                       cbConnStrIn: TSqlSmallInt, szConnStrOut: PSQLCHAR, 
+                       cbConnStrOutMax: TSqlSmallInt, 
+                       cbConnStrOut: var TSqlSmallInt): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLExecDirect*(StatementHandle: TSqlHStmt, StatementText: PSQLCHAR, 
+                    TextLength: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLPrepare*(StatementHandle: TSqlHStmt, StatementText: PSQLCHAR, 
+                 TextLength: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLCloseCursor*(StatementHandle: TSqlHStmt): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLExecute*(StatementHandle: TSqlHStmt): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLFetch*(StatementHandle: TSqlHStmt): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLNumResultCols*(StatementHandle: TSqlHStmt, ColumnCount: var TSqlSmallInt): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLDescribeCol*(StatementHandle: TSqlHStmt, ColumnNumber: TSqlUSmallInt, 
+                     ColumnName: PSQLCHAR, BufferLength: TSqlSmallInt, 
+                     NameLength: var TSqlSmallInt, DataType: var TSqlSmallInt, 
+                     ColumnSize: var TSqlUInteger, 
+                     DecimalDigits: var TSqlSmallInt, Nullable: var TSqlSmallInt): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLFetchScroll*(StatementHandle: TSqlHStmt, FetchOrientation: TSqlSmallInt, 
+                     FetchOffset: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLExtendedFetch*(hstmt: TSqlHStmt, fFetchType: TSqlUSmallInt, 
+                       irow: TSqlInteger, pcrow: PSQLUINTEGER, 
+                       rgfRowStatus: PSQLUSMALLINT): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLGetData*(StatementHandle: TSqlHStmt, ColumnNumber: TSqlUSmallInt, 
+                 TargetType: TSqlSmallInt, TargetValue: TSqlPointer, 
+                 BufferLength: TSqlInteger, StrLen_or_Ind: PSQLINTEGER): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLSetStmtAttr*(StatementHandle: TSqlHStmt, Attribute: TSqlInteger, 
+                     Value: TSqlPointer, StringLength: TSqlInteger): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLGetStmtAttr*(StatementHandle: TSqlHStmt, Attribute: TSqlInteger, 
+                     Value: TSqlPointer, BufferLength: TSqlInteger, 
+                     StringLength: PSQLINTEGER): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLGetInfo*(ConnectionHandle: TSqlHDBC, InfoType: TSqlUSmallInt, 
+                 InfoValue: TSqlPointer, BufferLength: TSqlSmallInt, 
+                 StringLength: PSQLSMALLINT): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLBulkOperations*(StatementHandle: TSqlHStmt, Operation: TSqlSmallInt): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLPutData*(StatementHandle: TSqlHStmt, Data: TSqlPointer, 
+                 StrLen_or_Ind: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLBindCol*(StatementHandle: TSqlHStmt, ColumnNumber: TSqlUSmallInt, 
+                 TargetType: TSqlSmallInt, TargetValue: TSqlPointer, 
+                 BufferLength: TSqlInteger, StrLen_or_Ind: PSQLINTEGER): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLSetPos*(hstmt: TSqlHStmt, irow: TSqlUSmallInt, fOption: TSqlUSmallInt, 
+                fLock: TSqlUSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLDataSources*(EnvironmentHandle: TSqlHEnv, Direction: TSqlUSmallInt, 
+                     ServerName: PSQLCHAR, BufferLength1: TSqlSmallInt, 
+                     NameLength1: PSQLSMALLINT, Description: PSQLCHAR, 
+                     BufferLength2: TSqlSmallInt, NameLength2: PSQLSMALLINT): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLDrivers*(EnvironmentHandle: TSqlHEnv, Direction: TSqlUSmallInt, 
+                 DriverDescription: PSQLCHAR, BufferLength1: TSqlSmallInt, 
+                 DescriptionLength1: PSQLSMALLINT, DriverAttributes: PSQLCHAR, 
+                 BufferLength2: TSqlSmallInt, AttributesLength2: PSQLSMALLINT): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLSetConnectAttr*(ConnectionHandle: TSqlHDBC, Attribute: TSqlInteger, 
+                        Value: TSqlPointer, StringLength: TSqlInteger): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLGetCursorName*(StatementHandle: TSqlHStmt, CursorName: PSQLCHAR, 
+                       BufferLength: TSqlSmallInt, NameLength: PSQLSMALLINT): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLSetCursorName*(StatementHandle: TSqlHStmt, CursorName: PSQLCHAR, 
+                       NameLength: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLRowCount*(StatementHandle: TSqlHStmt, RowCount: var TSqlInteger): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLBindParameter*(hstmt: TSqlHStmt, ipar: TSqlUSmallInt, 
+                       fParamType: TSqlSmallInt, fCType: TSqlSmallInt, 
+                       fSqlType: TSqlSmallInt, cbColDef: TSqlUInteger, 
+                       ibScale: TSqlSmallInt, rgbValue: TSqlPointer, 
+                       cbValueMax: TSqlInteger, pcbValue: PSQLINTEGER): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLFreeStmt*(StatementHandle: TSqlHStmt, Option: TSqlUSmallInt): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLColAttribute*(StatementHandle: TSqlHStmt, ColumnNumber: TSqlUSmallInt, 
+                      FieldIdentifier: TSqlUSmallInt, 
+                      CharacterAttribute: PSQLCHAR, BufferLength: TSqlSmallInt, 
+                      StringLength: PSQLSMALLINT, 
+                      NumericAttribute: TSqlPointer): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLEndTran*(HandleType: TSqlSmallInt, Handle: TSqlHandle, 
+                 CompletionType: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLTables*(hstmt: TSqlHStmt, szTableQualifier: PSQLCHAR, 
+                cbTableQualifier: TSqlSmallInt, szTableOwner: PSQLCHAR, 
+                cbTableOwner: TSqlSmallInt, szTableName: PSQLCHAR, 
+                cbTableName: TSqlSmallInt, szTableType: PSQLCHAR, 
+                cbTableType: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLColumns*(hstmt: TSqlHStmt, szTableQualifier: PSQLCHAR, 
+                 cbTableQualifier: TSqlSmallInt, szTableOwner: PSQLCHAR, 
+                 cbTableOwner: TSqlSmallInt, szTableName: PSQLCHAR, 
+                 cbTableName: TSqlSmallInt, szColumnName: PSQLCHAR, 
+                 cbColumnName: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
+proc SQLSpecialColumns*(StatementHandle: TSqlHStmt, IdentifierType: TSqlUSmallInt, 
+                        CatalogName: PSQLCHAR, NameLength1: TSqlSmallInt, 
+                        SchemaName: PSQLCHAR, NameLength2: TSqlSmallInt, 
+                        TableName: PSQLCHAR, NameLength3: TSqlSmallInt, 
+                        Scope: TSqlUSmallInt, 
+                        Nullable: TSqlUSmallInt): TSqlSmallInt{.
+    dynlib: odbclib, importc.}
+proc SQLProcedures*(hstmt: TSqlHStmt, szTableQualifier: PSQLCHAR, 
+                    cbTableQualifier: TSqlSmallInt, szTableOwner: PSQLCHAR, 
+                    cbTableOwner: TSqlSmallInt, szTableName: PSQLCHAR, 
+                    cbTableName: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLPrimaryKeys*(hstmt: TSqlHStmt, CatalogName: PSQLCHAR, 
+                     NameLength1: TSqlSmallInt, SchemaName: PSQLCHAR, 
+                     NameLength2: TSqlSmallInt, TableName: PSQLCHAR, 
+                     NameLength3: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLProcedureColumns*(hstmt: TSqlHStmt, CatalogName: PSQLCHAR, 
+                          NameLength1: TSqlSmallInt, SchemaName: PSQLCHAR, 
+                          NameLength2: TSqlSmallInt, ProcName: PSQLCHAR, 
+                          NameLength3: TSqlSmallInt, ColumnName: PSQLCHAR, 
+                          NameLength4: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, 
+    importc.}
+proc SQLStatistics*(hstmt: TSqlHStmt, CatalogName: PSQLCHAR, 
+                    NameLength1: TSqlSmallInt, SchemaName: PSQLCHAR, 
+                    NameLength2: TSqlSmallInt, TableName: PSQLCHAR, 
+                    NameLength3: TSqlSmallInt, Unique: TSqlUSmallInt, 
+                    Reserved: TSqlUSmallInt): TSqlSmallInt {.
+                    dynlib: odbclib, importc.}
+
+{.pop.}

lib/oldwrappers/opengl/glu.nim

@@ -0,0 +1,311 @@
+#
+#
+#  Adaption of the delphi3d.net OpenGL units to FreePascal
+#  Sebastian Guenther (sg@freepascal.org) in 2002
+#  These units are free to use
+#******************************************************************************
+# Converted to Delphi by Tom Nuydens (tom@delphi3d.net)                        
+# For the latest updates, visit Delphi3D: http://www.delphi3d.net              
+#******************************************************************************
+
+import 
+  GL
+
+when defined(windows):
+  const dllname = "glu32.dll"
+elif defined(macosx):
+  const dllname = "/System/Library/Frameworks/OpenGL.framework/Libraries/libGLU.dylib"
+else:
+  const dllname = "libGLU.so.1"
+
+type 
+  TViewPortArray* = array[0..3, TGLint]
+  T16dArray* = array[0..15, TGLdouble]
+  TCallBack* = proc ()
+  T3dArray* = array[0..2, TGLdouble]
+  T4pArray* = array[0..3, Pointer]
+  T4fArray* = array[0..3, TGLfloat]
+  PPointer* = ptr Pointer
+
+type 
+  GLUnurbs*{.final.} = object 
+  PGLUnurbs* = ptr GLUnurbs
+  GLUquadric*{.final.} = object 
+  PGLUquadric* = ptr GLUquadric
+  GLUtesselator*{.final.} = object 
+  PGLUtesselator* = ptr GLUtesselator # backwards compatibility:
+  GLUnurbsObj* = GLUnurbs
+  PGLUnurbsObj* = PGLUnurbs
+  GLUquadricObj* = GLUquadric
+  PGLUquadricObj* = PGLUquadric
+  GLUtesselatorObj* = GLUtesselator
+  PGLUtesselatorObj* = PGLUtesselator
+  GLUtriangulatorObj* = GLUtesselator
+  PGLUtriangulatorObj* = PGLUtesselator
+  TGLUnurbs* = GLUnurbs
+  TGLUquadric* = GLUquadric
+  TGLUtesselator* = GLUtesselator
+  TGLUnurbsObj* = GLUnurbsObj
+  TGLUquadricObj* = GLUquadricObj
+  TGLUtesselatorObj* = GLUtesselatorObj
+  TGLUtriangulatorObj* = GLUtriangulatorObj
+
+proc gluErrorString*(errCode: TGLenum): cstring{.dynlib: dllname, importc.}
+proc gluErrorUnicodeStringEXT*(errCode: TGLenum): ptr int16{.dynlib: dllname, 
+    importc.}
+proc gluGetString*(name: TGLenum): cstring{.dynlib: dllname, importc.}
+proc gluOrtho2D*(left, right, bottom, top: TGLdouble){.dynlib: dllname, importc.}
+proc gluPerspective*(fovy, aspect, zNear, zFar: TGLdouble){.dynlib: dllname, 
+    importc.}
+proc gluPickMatrix*(x, y, width, height: TGLdouble, viewport: var TViewPortArray){.
+    dynlib: dllname, importc.}
+proc gluLookAt*(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: TGLdouble){.
+    dynlib: dllname, importc.}
+proc gluProject*(objx, objy, objz: TGLdouble, 
+                 modelMatrix, projMatrix: var T16dArray, 
+                 viewport: var TViewPortArray, winx, winy, winz: PGLdouble): int{.
+    dynlib: dllname, importc.}
+proc gluUnProject*(winx, winy, winz: TGLdouble, 
+                   modelMatrix, projMatrix: var T16dArray, 
+                   viewport: var TViewPortArray, objx, objy, objz: PGLdouble): int{.
+    dynlib: dllname, importc.}
+proc gluScaleImage*(format: TGLenum, widthin, heightin: TGLint, typein: TGLenum, 
+                    datain: Pointer, widthout, heightout: TGLint, 
+                    typeout: TGLenum, dataout: Pointer): int{.dynlib: dllname, 
+    importc.}
+proc gluBuild1DMipmaps*(target: TGLenum, components, width: TGLint, 
+                        format, atype: TGLenum, data: Pointer): int{.
+    dynlib: dllname, importc.}
+proc gluBuild2DMipmaps*(target: TGLenum, components, width, height: TGLint, 
+                        format, atype: TGLenum, data: Pointer): int{.
+    dynlib: dllname, importc.}
+proc gluNewQuadric*(): PGLUquadric{.dynlib: dllname, importc.}
+proc gluDeleteQuadric*(state: PGLUquadric){.dynlib: dllname, importc.}
+proc gluQuadricNormals*(quadObject: PGLUquadric, normals: TGLenum){.
+    dynlib: dllname, importc.}
+proc gluQuadricTexture*(quadObject: PGLUquadric, textureCoords: TGLboolean){.
+    dynlib: dllname, importc.}
+proc gluQuadricOrientation*(quadObject: PGLUquadric, orientation: TGLenum){.
+    dynlib: dllname, importc.}
+proc gluQuadricDrawStyle*(quadObject: PGLUquadric, drawStyle: TGLenum){.
+    dynlib: dllname, importc.}
+proc gluCylinder*(qobj: PGLUquadric, baseRadius, topRadius, height: TGLdouble, 
+                  slices, stacks: TGLint){.dynlib: dllname, importc.}
+proc gluDisk*(qobj: PGLUquadric, innerRadius, outerRadius: TGLdouble, 
+              slices, loops: TGLint){.dynlib: dllname, importc.}
+proc gluPartialDisk*(qobj: PGLUquadric, innerRadius, outerRadius: TGLdouble, 
+                     slices, loops: TGLint, startAngle, sweepAngle: TGLdouble){.
+    dynlib: dllname, importc.}
+proc gluSphere*(qobj: PGLuquadric, radius: TGLdouble, slices, stacks: TGLint){.
+    dynlib: dllname, importc.}
+proc gluQuadricCallback*(qobj: PGLUquadric, which: TGLenum, fn: TCallBack){.
+    dynlib: dllname, importc.}
+proc gluNewTess*(): PGLUtesselator{.dynlib: dllname, importc.}
+proc gluDeleteTess*(tess: PGLUtesselator){.dynlib: dllname, importc.}
+proc gluTessBeginPolygon*(tess: PGLUtesselator, polygon_data: Pointer){.
+    dynlib: dllname, importc.}
+proc gluTessBeginContour*(tess: PGLUtesselator){.dynlib: dllname, importc.}
+proc gluTessVertex*(tess: PGLUtesselator, coords: var T3dArray, data: Pointer){.
+    dynlib: dllname, importc.}
+proc gluTessEndContour*(tess: PGLUtesselator){.dynlib: dllname, importc.}
+proc gluTessEndPolygon*(tess: PGLUtesselator){.dynlib: dllname, importc.}
+proc gluTessProperty*(tess: PGLUtesselator, which: TGLenum, value: TGLdouble){.
+    dynlib: dllname, importc.}
+proc gluTessNormal*(tess: PGLUtesselator, x, y, z: TGLdouble){.dynlib: dllname, 
+    importc.}
+proc gluTessCallback*(tess: PGLUtesselator, which: TGLenum, fn: TCallBack){.
+    dynlib: dllname, importc.}
+proc gluGetTessProperty*(tess: PGLUtesselator, which: TGLenum, value: PGLdouble){.
+    dynlib: dllname, importc.}
+proc gluNewNurbsRenderer*(): PGLUnurbs{.dynlib: dllname, importc.}
+proc gluDeleteNurbsRenderer*(nobj: PGLUnurbs){.dynlib: dllname, importc.}
+proc gluBeginSurface*(nobj: PGLUnurbs){.dynlib: dllname, importc.}
+proc gluBeginCurve*(nobj: PGLUnurbs){.dynlib: dllname, importc.}
+proc gluEndCurve*(nobj: PGLUnurbs){.dynlib: dllname, importc.}
+proc gluEndSurface*(nobj: PGLUnurbs){.dynlib: dllname, importc.}
+proc gluBeginTrim*(nobj: PGLUnurbs){.dynlib: dllname, importc.}
+proc gluEndTrim*(nobj: PGLUnurbs){.dynlib: dllname, importc.}
+proc gluPwlCurve*(nobj: PGLUnurbs, count: TGLint, aarray: PGLfloat, 
+                  stride: TGLint, atype: TGLenum){.dynlib: dllname, importc.}
+proc gluNurbsCurve*(nobj: PGLUnurbs, nknots: TGLint, knot: PGLfloat, 
+                    stride: TGLint, ctlarray: PGLfloat, order: TGLint, 
+                    atype: TGLenum){.dynlib: dllname, importc.}
+proc gluNurbsSurface*(nobj: PGLUnurbs, sknot_count: TGLint, sknot: PGLfloat, 
+                      tknot_count: TGLint, tknot: PGLfloat, 
+                      s_stride, t_stride: TGLint, ctlarray: PGLfloat, 
+                      sorder, torder: TGLint, atype: TGLenum){.dynlib: dllname, 
+    importc.}
+proc gluLoadSamplingMatrices*(nobj: PGLUnurbs, 
+                              modelMatrix, projMatrix: var T16dArray, 
+                              viewport: var TViewPortArray){.dynlib: dllname, 
+    importc.}
+proc gluNurbsProperty*(nobj: PGLUnurbs, aproperty: TGLenum, value: TGLfloat){.
+    dynlib: dllname, importc.}
+proc gluGetNurbsProperty*(nobj: PGLUnurbs, aproperty: TGLenum, value: PGLfloat){.
+    dynlib: dllname, importc.}
+proc gluNurbsCallback*(nobj: PGLUnurbs, which: TGLenum, fn: TCallBack){.
+    dynlib: dllname, importc.}
+  #*** Callback function prototypes ***
+type                          # gluQuadricCallback
+  GLUquadricErrorProc* = proc (p: TGLenum) # gluTessCallback
+  GLUtessBeginProc* = proc (p: TGLenum)
+  GLUtessEdgeFlagProc* = proc (p: TGLboolean)
+  GLUtessVertexProc* = proc (p: Pointer)
+  GLUtessEndProc* = proc ()
+  GLUtessErrorProc* = proc (p: TGLenum)
+  GLUtessCombineProc* = proc (p1: var T3dArray, p2: T4pArray, p3: T4fArray, 
+                              p4: PPointer)
+  GLUtessBeginDataProc* = proc (p1: TGLenum, p2: Pointer)
+  GLUtessEdgeFlagDataProc* = proc (p1: TGLboolean, p2: Pointer)
+  GLUtessVertexDataProc* = proc (p1, p2: Pointer)
+  GLUtessEndDataProc* = proc (p: Pointer)
+  GLUtessErrorDataProc* = proc (p1: TGLenum, p2: Pointer)
+  GLUtessCombineDataProc* = proc (p1: var T3dArray, p2: var T4pArray, 
+                                  p3: var T4fArray, p4: PPointer, p5: Pointer) # 
+                                                                               # gluNurbsCallback
+  GLUnurbsErrorProc* = proc (p: TGLenum) #***           Generic constants               ****/
+
+const                         # Version
+  GLU_VERSION_1_1* = 1
+  GLU_VERSION_1_2* = 1        # Errors: (return value 0 = no error)
+  GLU_INVALID_ENUM* = 100900
+  GLU_INVALID_VALUE* = 100901
+  GLU_OUT_OF_MEMORY* = 100902
+  GLU_INCOMPATIBLE_GL_VERSION* = 100903 # StringName
+  GLU_VERSION* = 100800
+  GLU_EXTENSIONS* = 100801    # Boolean
+  GLU_TRUE* = GL_TRUE
+  GLU_FALSE* = GL_FALSE #***           Quadric constants               ****/
+                        # QuadricNormal
+  GLU_SMOOTH* = 100000
+  GLU_FLAT* = 100001
+  GLU_NONE* = 100002          # QuadricDrawStyle
+  GLU_POINT* = 100010
+  GLU_LINE* = 100011
+  GLU_FILL* = 100012
+  GLU_SILHOUETTE* = 100013    # QuadricOrientation
+  GLU_OUTSIDE* = 100020
+  GLU_INSIDE* = 100021        # Callback types:
+                              #      GLU_ERROR       = 100103;
+                              #***           Tesselation constants           ****/
+  GLU_TESS_MAX_COORD* = 1.00000e+150 # TessProperty
+  GLU_TESS_WINDING_RULE* = 100140
+  GLU_TESS_BOUNDARY_ONLY* = 100141
+  GLU_TESS_TOLERANCE* = 100142 # TessWinding
+  GLU_TESS_WINDING_ODD* = 100130
+  GLU_TESS_WINDING_NONZERO* = 100131
+  GLU_TESS_WINDING_POSITIVE* = 100132
+  GLU_TESS_WINDING_NEGATIVE* = 100133
+  GLU_TESS_WINDING_ABS_GEQ_TWO* = 100134 # TessCallback
+  GLU_TESS_BEGIN* = 100100    # void (CALLBACK*)(TGLenum    type)
+  constGLU_TESS_VERTEX* = 100101   # void (CALLBACK*)(void      *data)
+  GLU_TESS_END* = 100102      # void (CALLBACK*)(void)
+  GLU_TESS_ERROR* = 100103    # void (CALLBACK*)(TGLenum    errno)
+  GLU_TESS_EDGE_FLAG* = 100104 # void (CALLBACK*)(TGLboolean boundaryEdge)
+  GLU_TESS_COMBINE* = 100105 # void (CALLBACK*)(TGLdouble  coords[3],
+                             #                                                            void      *data[4],
+                             #                                                            TGLfloat   weight[4],
+                             #                                                            void      **dataOut) 
+  GLU_TESS_BEGIN_DATA* = 100106 # void (CALLBACK*)(TGLenum    type,
+                                #                                                            void      *polygon_data) 
+  GLU_TESS_VERTEX_DATA* = 100107 # void (CALLBACK*)(void      *data,
+                                 #                                                            void      *polygon_data) 
+  GLU_TESS_END_DATA* = 100108 # void (CALLBACK*)(void      *polygon_data)
+  GLU_TESS_ERROR_DATA* = 100109 # void (CALLBACK*)(TGLenum    errno,
+                                #                                                            void      *polygon_data) 
+  GLU_TESS_EDGE_FLAG_DATA* = 100110 # void (CALLBACK*)(TGLboolean boundaryEdge,
+                                    #                                                            void      *polygon_data) 
+  GLU_TESS_COMBINE_DATA* = 100111 # void (CALLBACK*)(TGLdouble  coords[3],
+                                  #                                                            void      *data[4],
+                                  #                                                            TGLfloat   weight[4],
+                                  #                                                            void      **dataOut,
+                                  #                                                            void      *polygon_data) 
+                                  # TessError
+  GLU_TESS_ERROR1* = 100151
+  GLU_TESS_ERROR2* = 100152
+  GLU_TESS_ERROR3* = 100153
+  GLU_TESS_ERROR4* = 100154
+  GLU_TESS_ERROR5* = 100155
+  GLU_TESS_ERROR6* = 100156
+  GLU_TESS_ERROR7* = 100157
+  GLU_TESS_ERROR8* = 100158
+  GLU_TESS_MISSING_BEGIN_POLYGON* = GLU_TESS_ERROR1
+  GLU_TESS_MISSING_BEGIN_CONTOUR* = GLU_TESS_ERROR2
+  GLU_TESS_MISSING_END_POLYGON* = GLU_TESS_ERROR3
+  GLU_TESS_MISSING_END_CONTOUR* = GLU_TESS_ERROR4
+  GLU_TESS_COORD_TOO_LARGE* = GLU_TESS_ERROR5
+  GLU_TESS_NEED_COMBINE_CALLBACK* = GLU_TESS_ERROR6 #***           NURBS constants                 ****/
+                                                    # NurbsProperty
+  GLU_AUTO_LOAD_MATRIX* = 100200
+  GLU_CULLING* = 100201
+  GLU_SAMPLING_TOLERANCE* = 100203
+  GLU_DISPLAY_MODE* = 100204
+  GLU_PARAMETRIC_TOLERANCE* = 100202
+  GLU_SAMPLING_METHOD* = 100205
+  GLU_U_STEP* = 100206
+  GLU_V_STEP* = 100207        # NurbsSampling
+  GLU_PATH_LENGTH* = 100215
+  GLU_PARAMETRIC_ERROR* = 100216
+  GLU_DOMAIN_DISTANCE* = 100217 # NurbsTrim
+  GLU_MAP1_TRIM_2* = 100210
+  GLU_MAP1_TRIM_3* = 100211   # NurbsDisplay
+                              #      GLU_FILL                = 100012;
+  GLU_OUTLINE_POLYGON* = 100240
+  GLU_OUTLINE_PATCH* = 100241 # NurbsCallback
+                              #      GLU_ERROR               = 100103;
+                              # NurbsErrors
+  GLU_NURBS_ERROR1* = 100251
+  GLU_NURBS_ERROR2* = 100252
+  GLU_NURBS_ERROR3* = 100253
+  GLU_NURBS_ERROR4* = 100254
+  GLU_NURBS_ERROR5* = 100255
+  GLU_NURBS_ERROR6* = 100256
+  GLU_NURBS_ERROR7* = 100257
+  GLU_NURBS_ERROR8* = 100258
+  GLU_NURBS_ERROR9* = 100259
+  GLU_NURBS_ERROR10* = 100260
+  GLU_NURBS_ERROR11* = 100261
+  GLU_NURBS_ERROR12* = 100262
+  GLU_NURBS_ERROR13* = 100263
+  GLU_NURBS_ERROR14* = 100264
+  GLU_NURBS_ERROR15* = 100265
+  GLU_NURBS_ERROR16* = 100266
+  GLU_NURBS_ERROR17* = 100267
+  GLU_NURBS_ERROR18* = 100268
+  GLU_NURBS_ERROR19* = 100269
+  GLU_NURBS_ERROR20* = 100270
+  GLU_NURBS_ERROR21* = 100271
+  GLU_NURBS_ERROR22* = 100272
+  GLU_NURBS_ERROR23* = 100273
+  GLU_NURBS_ERROR24* = 100274
+  GLU_NURBS_ERROR25* = 100275
+  GLU_NURBS_ERROR26* = 100276
+  GLU_NURBS_ERROR27* = 100277
+  GLU_NURBS_ERROR28* = 100278
+  GLU_NURBS_ERROR29* = 100279
+  GLU_NURBS_ERROR30* = 100280
+  GLU_NURBS_ERROR31* = 100281
+  GLU_NURBS_ERROR32* = 100282
+  GLU_NURBS_ERROR33* = 100283
+  GLU_NURBS_ERROR34* = 100284
+  GLU_NURBS_ERROR35* = 100285
+  GLU_NURBS_ERROR36* = 100286
+  GLU_NURBS_ERROR37* = 100287 #***           Backwards compatibility for old tesselator           ****/
+
+proc gluBeginPolygon*(tess: PGLUtesselator){.dynlib: dllname, importc.}
+proc gluNextContour*(tess: PGLUtesselator, atype: TGLenum){.dynlib: dllname, 
+    importc.}
+proc gluEndPolygon*(tess: PGLUtesselator){.dynlib: dllname, importc.}
+const                         # Contours types -- obsolete!
+  GLU_CW* = 100120
+  GLU_CCW* = 100121
+  GLU_INTERIOR* = 100122
+  GLU_EXTERIOR* = 100123
+  GLU_UNKNOWN* = 100124       # Names without "TESS_" prefix
+  GLU_BEGIN* = GLU_TESS_BEGIN
+  GLU_VERTEX* = constGLU_TESS_VERTEX
+  GLU_END* = GLU_TESS_END
+  GLU_ERROR* = GLU_TESS_ERROR
+  GLU_EDGE_FLAG* = GLU_TESS_EDGE_FLAG
+
+# implementation

lib/oldwrappers/opengl/glut.nim

@@ -0,0 +1,378 @@
+#
+#
+#  Adaption of the delphi3d.net OpenGL units to FreePascal
+#  Sebastian Guenther (sg@freepascal.org) in 2002
+#  These units are free to use
+#
+
+# Copyright (c) Mark J. Kilgard, 1994, 1995, 1996.
+# This program is freely distributable without licensing fees  and is
+#   provided without guarantee or warrantee expressed or  implied. This
+#   program is -not- in the public domain.
+#******************************************************************************
+# Converted to Delphi by Tom Nuydens (tom@delphi3d.net)
+#   Contributions by Igor Karpov (glygrik@hotbox.ru)
+#   For the latest updates, visit Delphi3D: http://www.delphi3d.net
+#******************************************************************************
+
+import
+  GL
+
+when defined(windows):
+  const dllname = "glut32.dll"
+elif defined(macosx):
+  const dllname = "/System/Library/Frameworks/GLUT.framework/GLUT"
+else:
+  const dllname = "libglut.so.3"
+
+type
+  PInteger* = ptr int
+  PPChar* = ptr cstring
+  TGlutVoidCallback* = proc (){.cdecl.}
+  TGlut1IntCallback* = proc (value: cint){.cdecl.}
+  TGlut2IntCallback* = proc (v1, v2: cint){.cdecl.}
+  TGlut3IntCallback* = proc (v1, v2, v3: cint){.cdecl.}
+  TGlut4IntCallback* = proc (v1, v2, v3, v4: cint){.cdecl.}
+  TGlut1Char2IntCallback* = proc (c: int8, v1, v2: cint){.cdecl.}
+  TGlut1UInt3IntCallback* = proc (u, v1, v2, v3: cint){.cdecl.}
+
+const
+  GLUT_API_VERSION* = 3
+  GLUT_XLIB_IMPLEMENTATION* = 12 # Display mode bit masks.
+  GLUT_RGB* = 0
+  GLUT_RGBA* = GLUT_RGB
+  GLUT_INDEX* = 1
+  GLUT_SINGLE* = 0
+  GLUT_DOUBLE* = 2
+  GLUT_ACCUM* = 4
+  GLUT_ALPHA* = 8
+  GLUT_DEPTH* = 16
+  GLUT_STENCIL* = 32
+  GLUT_MULTISAMPLE* = 128
+  GLUT_STEREO* = 256
+  GLUT_LUMINANCE* = 512       # Mouse buttons.
+  GLUT_LEFT_BUTTON* = 0
+  GLUT_MIDDLE_BUTTON* = 1
+  GLUT_RIGHT_BUTTON* = 2      # Mouse button state.
+  GLUT_DOWN* = 0
+  GLUT_UP* = 1                # function keys
+  GLUT_KEY_F1* = 1
+  GLUT_KEY_F2* = 2
+  GLUT_KEY_F3* = 3
+  GLUT_KEY_F4* = 4
+  GLUT_KEY_F5* = 5
+  GLUT_KEY_F6* = 6
+  GLUT_KEY_F7* = 7
+  GLUT_KEY_F8* = 8
+  GLUT_KEY_F9* = 9
+  GLUT_KEY_F10* = 10
+  GLUT_KEY_F11* = 11
+  GLUT_KEY_F12* = 12          # directional keys
+  GLUT_KEY_LEFT* = 100
+  GLUT_KEY_UP* = 101
+  GLUT_KEY_RIGHT* = 102
+  GLUT_KEY_DOWN* = 103
+  GLUT_KEY_PAGE_UP* = 104
+  GLUT_KEY_PAGE_DOWN* = 105
+  GLUT_KEY_HOME* = 106
+  GLUT_KEY_END* = 107
+  GLUT_KEY_INSERT* = 108      # Entry/exit  state.
+  GLUT_LEFT* = 0
+  GLUT_ENTERED* = 1           # Menu usage state.
+  GLUT_MENU_NOT_IN_USE* = 0
+  GLUT_MENU_IN_USE* = 1       # Visibility  state.
+  GLUT_NOT_VISIBLE* = 0
+  GLUT_VISIBLE* = 1           # Window status  state.
+  GLUT_HIDDEN* = 0
+  GLUT_FULLY_RETAINED* = 1
+  GLUT_PARTIALLY_RETAINED* = 2
+  GLUT_FULLY_COVERED* = 3     # Color index component selection values.
+  GLUT_RED* = 0
+  GLUT_GREEN* = 1
+  GLUT_BLUE* = 2              # Layers for use.
+  GLUT_NORMAL* = 0
+  GLUT_OVERLAY* = 1
+
+when defined(Windows):
+  const                       # Stroke font constants (use these in GLUT program).
+    GLUT_STROKE_ROMAN* = cast[Pointer](0)
+    GLUT_STROKE_MONO_ROMAN* = cast[Pointer](1) # Bitmap font constants (use these in GLUT program).
+    GLUT_BITMAP_9_BY_15* = cast[Pointer](2)
+    GLUT_BITMAP_8_BY_13* = cast[Pointer](3)
+    GLUT_BITMAP_TIMES_ROMAN_10* = cast[Pointer](4)
+    GLUT_BITMAP_TIMES_ROMAN_24* = cast[Pointer](5)
+    GLUT_BITMAP_HELVETICA_10* = cast[Pointer](6)
+    GLUT_BITMAP_HELVETICA_12* = cast[Pointer](7)
+    GLUT_BITMAP_HELVETICA_18* = cast[Pointer](8)
+else:
+  var                         # Stroke font constants (use these in GLUT program).
+    GLUT_STROKE_ROMAN*: Pointer
+    GLUT_STROKE_MONO_ROMAN*: Pointer # Bitmap font constants (use these in GLUT program).
+    GLUT_BITMAP_9_BY_15*: Pointer
+    GLUT_BITMAP_8_BY_13*: Pointer
+    GLUT_BITMAP_TIMES_ROMAN_10*: Pointer
+    GLUT_BITMAP_TIMES_ROMAN_24*: Pointer
+    GLUT_BITMAP_HELVETICA_10*: Pointer
+    GLUT_BITMAP_HELVETICA_12*: Pointer
+    GLUT_BITMAP_HELVETICA_18*: Pointer
+const                         # glutGet parameters.
+  GLUT_WINDOW_X* = 100
+  GLUT_WINDOW_Y* = 101
+  GLUT_WINDOW_WIDTH* = 102
+  GLUT_WINDOW_HEIGHT* = 103
+  GLUT_WINDOW_BUFFER_SIZE* = 104
+  GLUT_WINDOW_STENCIL_SIZE* = 105
+  GLUT_WINDOW_DEPTH_SIZE* = 106
+  GLUT_WINDOW_RED_SIZE* = 107
+  GLUT_WINDOW_GREEN_SIZE* = 108
+  GLUT_WINDOW_BLUE_SIZE* = 109
+  GLUT_WINDOW_ALPHA_SIZE* = 110
+  GLUT_WINDOW_ACCUM_RED_SIZE* = 111
+  GLUT_WINDOW_ACCUM_GREEN_SIZE* = 112
+  GLUT_WINDOW_ACCUM_BLUE_SIZE* = 113
+  GLUT_WINDOW_ACCUM_ALPHA_SIZE* = 114
+  GLUT_WINDOW_DOUBLEBUFFER* = 115
+  GLUT_WINDOW_RGBA* = 116
+  GLUT_WINDOW_PARENT* = 117
+  GLUT_WINDOW_NUM_CHILDREN* = 118
+  GLUT_WINDOW_COLORMAP_SIZE* = 119
+  GLUT_WINDOW_NUM_SAMPLES* = 120
+  GLUT_WINDOW_STEREO* = 121
+  GLUT_WINDOW_CURSOR* = 122
+  GLUT_SCREEN_WIDTH* = 200
+  GLUT_SCREEN_HEIGHT* = 201
+  GLUT_SCREEN_WIDTH_MM* = 202
+  GLUT_SCREEN_HEIGHT_MM* = 203
+  GLUT_MENU_NUM_ITEMS* = 300
+  GLUT_DISPLAY_MODE_POSSIBLE* = 400
+  GLUT_INIT_WINDOW_X* = 500
+  GLUT_INIT_WINDOW_Y* = 501
+  GLUT_INIT_WINDOW_WIDTH* = 502
+  GLUT_INIT_WINDOW_HEIGHT* = 503
+  constGLUT_INIT_DISPLAY_MODE* = 504
+  GLUT_ELAPSED_TIME* = 700
+  GLUT_WINDOW_FORMAT_ID* = 123 # glutDeviceGet parameters.
+  GLUT_HAS_KEYBOARD* = 600
+  GLUT_HAS_MOUSE* = 601
+  GLUT_HAS_SPACEBALL* = 602
+  GLUT_HAS_DIAL_AND_BUTTON_BOX* = 603
+  GLUT_HAS_TABLET* = 604
+  GLUT_NUM_MOUSE_BUTTONS* = 605
+  GLUT_NUM_SPACEBALL_BUTTONS* = 606
+  GLUT_NUM_BUTTON_BOX_BUTTONS* = 607
+  GLUT_NUM_DIALS* = 608
+  GLUT_NUM_TABLET_BUTTONS* = 609
+  GLUT_DEVICE_IGNORE_KEY_REPEAT* = 610
+  GLUT_DEVICE_KEY_REPEAT* = 611
+  GLUT_HAS_JOYSTICK* = 612
+  GLUT_OWNS_JOYSTICK* = 613
+  GLUT_JOYSTICK_BUTTONS* = 614
+  GLUT_JOYSTICK_AXES* = 615
+  GLUT_JOYSTICK_POLL_RATE* = 616 # glutLayerGet parameters.
+  GLUT_OVERLAY_POSSIBLE* = 800
+  GLUT_LAYER_IN_USE* = 801
+  GLUT_HAS_OVERLAY* = 802
+  GLUT_TRANSPARENT_INDEX* = 803
+  GLUT_NORMAL_DAMAGED* = 804
+  GLUT_OVERLAY_DAMAGED* = 805 # glutVideoResizeGet parameters.
+  GLUT_VIDEO_RESIZE_POSSIBLE* = 900
+  GLUT_VIDEO_RESIZE_IN_USE* = 901
+  GLUT_VIDEO_RESIZE_X_DELTA* = 902
+  GLUT_VIDEO_RESIZE_Y_DELTA* = 903
+  GLUT_VIDEO_RESIZE_WIDTH_DELTA* = 904
+  GLUT_VIDEO_RESIZE_HEIGHT_DELTA* = 905
+  GLUT_VIDEO_RESIZE_X* = 906
+  GLUT_VIDEO_RESIZE_Y* = 907
+  GLUT_VIDEO_RESIZE_WIDTH* = 908
+  GLUT_VIDEO_RESIZE_HEIGHT* = 909 # glutGetModifiers return mask.
+  GLUT_ACTIVE_SHIFT* = 1
+  GLUT_ACTIVE_CTRL* = 2
+  GLUT_ACTIVE_ALT* = 4        # glutSetCursor parameters.
+                              # Basic arrows.
+  GLUT_CURSOR_RIGHT_ARROW* = 0
+  GLUT_CURSOR_LEFT_ARROW* = 1 # Symbolic cursor shapes.
+  GLUT_CURSOR_INFO* = 2
+  GLUT_CURSOR_DESTROY* = 3
+  GLUT_CURSOR_HELP* = 4
+  GLUT_CURSOR_CYCLE* = 5
+  GLUT_CURSOR_SPRAY* = 6
+  GLUT_CURSOR_WAIT* = 7
+  GLUT_CURSOR_TEXT* = 8
+  GLUT_CURSOR_CROSSHAIR* = 9  # Directional cursors.
+  GLUT_CURSOR_UP_DOWN* = 10
+  GLUT_CURSOR_LEFT_RIGHT* = 11 # Sizing cursors.
+  GLUT_CURSOR_TOP_SIDE* = 12
+  GLUT_CURSOR_BOTTOM_SIDE* = 13
+  GLUT_CURSOR_LEFT_SIDE* = 14
+  GLUT_CURSOR_RIGHT_SIDE* = 15
+  GLUT_CURSOR_TOP_LEFT_CORNER* = 16
+  GLUT_CURSOR_TOP_RIGHT_CORNER* = 17
+  GLUT_CURSOR_BOTTOM_RIGHT_CORNER* = 18
+  GLUT_CURSOR_BOTTOM_LEFT_CORNER* = 19 # Inherit from parent window.
+  GLUT_CURSOR_INHERIT* = 100  # Blank cursor.
+  GLUT_CURSOR_NONE* = 101     # Fullscreen crosshair (if available).
+  GLUT_CURSOR_FULL_CROSSHAIR* = 102 # GLUT device control sub-API.
+                                    # glutSetKeyRepeat modes.
+  GLUT_KEY_REPEAT_OFF* = 0
+  GLUT_KEY_REPEAT_ON* = 1
+  GLUT_KEY_REPEAT_DEFAULT* = 2 # Joystick button masks.
+  GLUT_JOYSTICK_BUTTON_A* = 1
+  GLUT_JOYSTICK_BUTTON_B* = 2
+  GLUT_JOYSTICK_BUTTON_C* = 4
+  GLUT_JOYSTICK_BUTTON_D* = 8 # GLUT game mode sub-API.
+                              # glutGameModeGet.
+  GLUT_GAME_MODE_ACTIVE* = 0
+  GLUT_GAME_MODE_POSSIBLE* = 1
+  GLUT_GAME_MODE_WIDTH* = 2
+  GLUT_GAME_MODE_HEIGHT* = 3
+  GLUT_GAME_MODE_PIXEL_DEPTH* = 4
+  GLUT_GAME_MODE_REFRESH_RATE* = 5
+  GLUT_GAME_MODE_DISPLAY_CHANGED* = 6 # GLUT initialization sub-API.
+
+proc glutInit*(argcp: PInteger, argv: PPChar){.dynlib: dllname, importc.}
+proc glutInitDisplayMode*(mode: int16){.dynlib: dllname, importc.}
+proc glutInitDisplayString*(str: cstring){.dynlib: dllname, importc.}
+proc glutInitWindowPosition*(x, y: int){.dynlib: dllname, importc.}
+proc glutInitWindowSize*(width, height: int){.dynlib: dllname, importc.}
+proc glutMainLoop*(){.dynlib: dllname, importc.}
+  # GLUT window sub-API.
+proc glutCreateWindow*(title: cstring): int{.dynlib: dllname, importc.}
+proc glutCreateSubWindow*(win, x, y, width, height: int): int{.dynlib: dllname,
+    importc.}
+proc glutDestroyWindow*(win: int){.dynlib: dllname, importc.}
+proc glutPostRedisplay*(){.dynlib: dllname, importc.}
+proc glutPostWindowRedisplay*(win: int){.dynlib: dllname, importc.}
+proc glutSwapBuffers*(){.dynlib: dllname, importc.}
+proc glutGetWindow*(): int{.dynlib: dllname, importc.}
+proc glutSetWindow*(win: int){.dynlib: dllname, importc.}
+proc glutSetWindowTitle*(title: cstring){.dynlib: dllname, importc.}
+proc glutSetIconTitle*(title: cstring){.dynlib: dllname, importc.}
+proc glutPositionWindow*(x, y: int){.dynlib: dllname, importc.}
+proc glutReshapeWindow*(width, height: int){.dynlib: dllname, importc.}
+proc glutPopWindow*(){.dynlib: dllname, importc.}
+proc glutPushWindow*(){.dynlib: dllname, importc.}
+proc glutIconifyWindow*(){.dynlib: dllname, importc.}
+proc glutShowWindow*(){.dynlib: dllname, importc.}
+proc glutHideWindow*(){.dynlib: dllname, importc.}
+proc glutFullScreen*(){.dynlib: dllname, importc.}
+proc glutSetCursor*(cursor: int){.dynlib: dllname, importc.}
+proc glutWarpPointer*(x, y: int){.dynlib: dllname, importc.}
+  # GLUT overlay sub-API.
+proc glutEstablishOverlay*(){.dynlib: dllname, importc.}
+proc glutRemoveOverlay*(){.dynlib: dllname, importc.}
+proc glutUseLayer*(layer: TGLenum){.dynlib: dllname, importc.}
+proc glutPostOverlayRedisplay*(){.dynlib: dllname, importc.}
+proc glutPostWindowOverlayRedisplay*(win: int){.dynlib: dllname, importc.}
+proc glutShowOverlay*(){.dynlib: dllname, importc.}
+proc glutHideOverlay*(){.dynlib: dllname, importc.}
+  # GLUT menu sub-API.
+proc glutCreateMenu*(callback: TGlut1IntCallback): int{.dynlib: dllname, importc.}
+proc glutDestroyMenu*(menu: int){.dynlib: dllname, importc.}
+proc glutGetMenu*(): int{.dynlib: dllname, importc.}
+proc glutSetMenu*(menu: int){.dynlib: dllname, importc.}
+proc glutAddMenuEntry*(caption: cstring, value: int){.dynlib: dllname, importc.}
+proc glutAddSubMenu*(caption: cstring, submenu: int){.dynlib: dllname, importc.}
+proc glutChangeToMenuEntry*(item: int, caption: cstring, value: int){.
+    dynlib: dllname, importc.}
+proc glutChangeToSubMenu*(item: int, caption: cstring, submenu: int){.
+    dynlib: dllname, importc.}
+proc glutRemoveMenuItem*(item: int){.dynlib: dllname, importc.}
+proc glutAttachMenu*(button: int){.dynlib: dllname, importc.}
+proc glutDetachMenu*(button: int){.dynlib: dllname, importc.}
+  # GLUT window callback sub-API.
+proc glutDisplayFunc*(f: TGlutVoidCallback){.dynlib: dllname, importc.}
+proc glutReshapeFunc*(f: TGlut2IntCallback){.dynlib: dllname, importc.}
+proc glutKeyboardFunc*(f: TGlut1Char2IntCallback){.dynlib: dllname, importc.}
+proc glutMouseFunc*(f: TGlut4IntCallback){.dynlib: dllname, importc.}
+proc glutMotionFunc*(f: TGlut2IntCallback){.dynlib: dllname, importc.}
+proc glutPassiveMotionFunc*(f: TGlut2IntCallback){.dynlib: dllname, importc.}
+proc glutEntryFunc*(f: TGlut1IntCallback){.dynlib: dllname, importc.}
+proc glutVisibilityFunc*(f: TGlut1IntCallback){.dynlib: dllname, importc.}
+proc glutIdleFunc*(f: TGlutVoidCallback){.dynlib: dllname, importc.}
+proc glutTimerFunc*(millis: int16, f: TGlut1IntCallback, value: int){.
+    dynlib: dllname, importc.}
+proc glutMenuStateFunc*(f: TGlut1IntCallback){.dynlib: dllname, importc.}
+proc glutSpecialFunc*(f: TGlut3IntCallback){.dynlib: dllname, importc.}
+proc glutSpaceballMotionFunc*(f: TGlut3IntCallback){.dynlib: dllname, importc.}
+proc glutSpaceballRotateFunc*(f: TGlut3IntCallback){.dynlib: dllname, importc.}
+proc glutSpaceballButtonFunc*(f: TGlut2IntCallback){.dynlib: dllname, importc.}
+proc glutButtonBoxFunc*(f: TGlut2IntCallback){.dynlib: dllname, importc.}
+proc glutDialsFunc*(f: TGlut2IntCallback){.dynlib: dllname, importc.}
+proc glutTabletMotionFunc*(f: TGlut2IntCallback){.dynlib: dllname, importc.}
+proc glutTabletButtonFunc*(f: TGlut4IntCallback){.dynlib: dllname, importc.}
+proc glutMenuStatusFunc*(f: TGlut3IntCallback){.dynlib: dllname, importc.}
+proc glutOverlayDisplayFunc*(f: TGlutVoidCallback){.dynlib: dllname, importc.}
+proc glutWindowStatusFunc*(f: TGlut1IntCallback){.dynlib: dllname, importc.}
+proc glutKeyboardUpFunc*(f: TGlut1Char2IntCallback){.dynlib: dllname, importc.}
+proc glutSpecialUpFunc*(f: TGlut3IntCallback){.dynlib: dllname, importc.}
+proc glutJoystickFunc*(f: TGlut1UInt3IntCallback, pollInterval: int){.
+    dynlib: dllname, importc.}
+  # GLUT color index sub-API.
+proc glutSetColor*(cell: int, red, green, blue: TGLfloat){.dynlib: dllname,
+    importc.}
+proc glutGetColor*(ndx, component: int): TGLfloat{.dynlib: dllname, importc.}
+proc glutCopyColormap*(win: int){.dynlib: dllname, importc.}
+  # GLUT state retrieval sub-API.
+proc glutGet*(t: TGLenum): int{.dynlib: dllname, importc.}
+proc glutDeviceGet*(t: TGLenum): int{.dynlib: dllname, importc.}
+  # GLUT extension support sub-API
+proc glutExtensionSupported*(name: cstring): int{.dynlib: dllname, importc.}
+proc glutGetModifiers*(): int{.dynlib: dllname, importc.}
+proc glutLayerGet*(t: TGLenum): int{.dynlib: dllname, importc.}
+  # GLUT font sub-API
+proc glutBitmapCharacter*(font: pointer, character: int){.dynlib: dllname,
+    importc.}
+proc glutBitmapWidth*(font: pointer, character: int): int{.dynlib: dllname,
+    importc.}
+proc glutStrokeCharacter*(font: pointer, character: int){.dynlib: dllname,
+    importc.}
+proc glutStrokeWidth*(font: pointer, character: int): int{.dynlib: dllname,
+    importc.}
+proc glutBitmapLength*(font: pointer, str: cstring): int{.dynlib: dllname,
+    importc.}
+proc glutStrokeLength*(font: pointer, str: cstring): int{.dynlib: dllname,
+    importc.}
+  # GLUT pre-built models sub-API
+proc glutWireSphere*(radius: TGLdouble, slices, stacks: TGLint){.dynlib: dllname,
+    importc.}
+proc glutSolidSphere*(radius: TGLdouble, slices, stacks: TGLint){.dynlib: dllname,
+    importc.}
+proc glutWireCone*(base, height: TGLdouble, slices, stacks: TGLint){.
+    dynlib: dllname, importc.}
+proc glutSolidCone*(base, height: TGLdouble, slices, stacks: TGLint){.
+    dynlib: dllname, importc.}
+proc glutWireCube*(size: TGLdouble){.dynlib: dllname, importc.}
+proc glutSolidCube*(size: TGLdouble){.dynlib: dllname, importc.}
+proc glutWireTorus*(innerRadius, outerRadius: TGLdouble, sides, rings: TGLint){.
+    dynlib: dllname, importc.}
+proc glutSolidTorus*(innerRadius, outerRadius: TGLdouble, sides, rings: TGLint){.
+    dynlib: dllname, importc.}
+proc glutWireDodecahedron*(){.dynlib: dllname, importc.}
+proc glutSolidDodecahedron*(){.dynlib: dllname, importc.}
+proc glutWireTeapot*(size: TGLdouble){.dynlib: dllname, importc.}
+proc glutSolidTeapot*(size: TGLdouble){.dynlib: dllname, importc.}
+proc glutWireOctahedron*(){.dynlib: dllname, importc.}
+proc glutSolidOctahedron*(){.dynlib: dllname, importc.}
+proc glutWireTetrahedron*(){.dynlib: dllname, importc.}
+proc glutSolidTetrahedron*(){.dynlib: dllname, importc.}
+proc glutWireIcosahedron*(){.dynlib: dllname, importc.}
+proc glutSolidIcosahedron*(){.dynlib: dllname, importc.}
+  # GLUT video resize sub-API.
+proc glutVideoResizeGet*(param: TGLenum): int{.dynlib: dllname, importc.}
+proc glutSetupVideoResizing*(){.dynlib: dllname, importc.}
+proc glutStopVideoResizing*(){.dynlib: dllname, importc.}
+proc glutVideoResize*(x, y, width, height: int){.dynlib: dllname, importc.}
+proc glutVideoPan*(x, y, width, height: int){.dynlib: dllname, importc.}
+  # GLUT debugging sub-API.
+proc glutReportErrors*(){.dynlib: dllname, importc.}
+  # GLUT device control sub-API.
+proc glutIgnoreKeyRepeat*(ignore: int){.dynlib: dllname, importc.}
+proc glutSetKeyRepeat*(repeatMode: int){.dynlib: dllname, importc.}
+proc glutForceJoystickFunc*(){.dynlib: dllname, importc.}
+  # GLUT game mode sub-API.
+  #example glutGameModeString('1280x1024:32@75');
+proc glutGameModeString*(AString: cstring){.dynlib: dllname, importc.}
+proc glutEnterGameMode*(): int{.dynlib: dllname, importc.}
+proc glutLeaveGameMode*(){.dynlib: dllname, importc.}
+proc glutGameModeGet*(mode: TGLenum): int{.dynlib: dllname, importc.}
+# implementation

lib/oldwrappers/opengl/glx.nim

@@ -0,0 +1,148 @@
+#
+#
+#  Translation of the Mesa GLX headers for FreePascal
+#  Copyright (C) 1999 Sebastian Guenther
+#
+#
+#  Mesa 3-D graphics library
+#  Version:  3.0
+#  Copyright (C) 1995-1998  Brian Paul
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Library General Public
+#  License as published by the Free Software Foundation; either
+#  version 2 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Library General Public License for more details.
+#
+#  You should have received a copy of the GNU Library General Public
+#  License along with this library; if not, write to the Free
+#  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+
+import
+  X, XLib, XUtil, gl
+
+when defined(windows):
+  const dllname = "GL.dll"
+elif defined(macosx):
+  const dllname = "/usr/X11R6/lib/libGL.dylib"
+else:
+  const dllname = "libGL.so"
+
+const
+  GLX_USE_GL* = 1
+  GLX_BUFFER_SIZE* = 2
+  GLX_LEVEL* = 3
+  GLX_RGBA* = 4
+  GLX_DOUBLEBUFFER* = 5
+  GLX_STEREO* = 6
+  GLX_AUX_BUFFERS* = 7
+  GLX_RED_SIZE* = 8
+  GLX_GREEN_SIZE* = 9
+  GLX_BLUE_SIZE* = 10
+  GLX_ALPHA_SIZE* = 11
+  GLX_DEPTH_SIZE* = 12
+  GLX_STENCIL_SIZE* = 13
+  GLX_ACCUM_RED_SIZE* = 14
+  GLX_ACCUM_GREEN_SIZE* = 15
+  GLX_ACCUM_BLUE_SIZE* = 16
+  GLX_ACCUM_ALPHA_SIZE* = 17  # GLX_EXT_visual_info extension
+  GLX_X_VISUAL_TYPE_EXT* = 0x00000022
+  GLX_TRANSPARENT_TYPE_EXT* = 0x00000023
+  GLX_TRANSPARENT_INDEX_VALUE_EXT* = 0x00000024
+  GLX_TRANSPARENT_RED_VALUE_EXT* = 0x00000025
+  GLX_TRANSPARENT_GREEN_VALUE_EXT* = 0x00000026
+  GLX_TRANSPARENT_BLUE_VALUE_EXT* = 0x00000027
+  GLX_TRANSPARENT_ALPHA_VALUE_EXT* = 0x00000028 # Error codes returned by glXGetConfig:
+  GLX_BAD_SCREEN* = 1
+  GLX_BAD_ATTRIBUTE* = 2
+  GLX_NO_EXTENSION* = 3
+  GLX_BAD_VISUAL* = 4
+  GLX_BAD_CONTEXT* = 5
+  GLX_BAD_VALUE* = 6
+  GLX_BAD_ENUM* = 7           # GLX 1.1 and later:
+  GLX_VENDOR* = 1
+  GLX_VERSION* = 2
+  GLX_EXTENSIONS* = 3         # GLX_visual_info extension
+  GLX_TRUE_COLOR_EXT* = 0x00008002
+  GLX_DIRECT_COLOR_EXT* = 0x00008003
+  GLX_PSEUDO_COLOR_EXT* = 0x00008004
+  GLX_STATIC_COLOR_EXT* = 0x00008005
+  GLX_GRAY_SCALE_EXT* = 0x00008006
+  GLX_STATIC_GRAY_EXT* = 0x00008007
+  GLX_NONE_EXT* = 0x00008000
+  GLX_TRANSPARENT_RGB_EXT* = 0x00008008
+  GLX_TRANSPARENT_INDEX_EXT* = 0x00008009
+
+type                          # From XLib:
+  XPixmap* = TXID
+  XFont* = TXID
+  XColormap* = TXID
+  GLXContext* = Pointer
+  GLXPixmap* = TXID
+  GLXDrawable* = TXID
+  GLXContextID* = TXID
+  TXPixmap* = XPixmap
+  TXFont* = XFont
+  TXColormap* = XColormap
+  TGLXContext* = GLXContext
+  TGLXPixmap* = GLXPixmap
+  TGLXDrawable* = GLXDrawable
+  TGLXContextID* = GLXContextID
+
+proc glXChooseVisual*(dpy: PDisplay, screen: int, attribList: ptr int32): PXVisualInfo{.
+    cdecl, dynlib: dllname, importc.}
+proc glXCreateContext*(dpy: PDisplay, vis: PXVisualInfo, shareList: GLXContext,
+                       direct: bool): GLXContext{.cdecl, dynlib: dllname,
+    importc.}
+proc glXDestroyContext*(dpy: PDisplay, ctx: GLXContext){.cdecl, dynlib: dllname,
+    importc.}
+proc glXMakeCurrent*(dpy: PDisplay, drawable: GLXDrawable, ctx: GLXContext): bool{.
+    cdecl, dynlib: dllname, importc.}
+proc glXCopyContext*(dpy: PDisplay, src, dst: GLXContext, mask: int32){.cdecl,
+    dynlib: dllname, importc.}
+proc glXSwapBuffers*(dpy: PDisplay, drawable: GLXDrawable){.cdecl,
+    dynlib: dllname, importc.}
+proc glXCreateGLXPixmap*(dpy: PDisplay, visual: PXVisualInfo, pixmap: XPixmap): GLXPixmap{.
+    cdecl, dynlib: dllname, importc.}
+proc glXDestroyGLXPixmap*(dpy: PDisplay, pixmap: GLXPixmap){.cdecl,
+    dynlib: dllname, importc.}
+proc glXQueryExtension*(dpy: PDisplay, errorb, event: var int): bool{.cdecl,
+    dynlib: dllname, importc.}
+proc glXQueryVersion*(dpy: PDisplay, maj, min: var int): bool{.cdecl,
+    dynlib: dllname, importc.}
+proc glXIsDirect*(dpy: PDisplay, ctx: GLXContext): bool{.cdecl, dynlib: dllname,
+    importc.}
+proc glXGetConfig*(dpy: PDisplay, visual: PXVisualInfo, attrib: int,
+                   value: var int): int{.cdecl, dynlib: dllname, importc.}
+proc glXGetCurrentContext*(): GLXContext{.cdecl, dynlib: dllname, importc.}
+proc glXGetCurrentDrawable*(): GLXDrawable{.cdecl, dynlib: dllname, importc.}
+proc glXWaitGL*(){.cdecl, dynlib: dllname, importc.}
+proc glXWaitX*(){.cdecl, dynlib: dllname, importc.}
+proc glXUseXFont*(font: XFont, first, count, list: int){.cdecl, dynlib: dllname,
+    importc.}
+  # GLX 1.1 and later
+proc glXQueryExtensionsString*(dpy: PDisplay, screen: int): cstring{.cdecl,
+    dynlib: dllname, importc.}
+proc glXQueryServerString*(dpy: PDisplay, screen, name: int): cstring{.cdecl,
+    dynlib: dllname, importc.}
+proc glXGetClientString*(dpy: PDisplay, name: int): cstring{.cdecl,
+    dynlib: dllname, importc.}
+  # Mesa GLX Extensions
+proc glXCreateGLXPixmapMESA*(dpy: PDisplay, visual: PXVisualInfo,
+                             pixmap: XPixmap, cmap: XColormap): GLXPixmap{.
+    cdecl, dynlib: dllname, importc.}
+proc glXReleaseBufferMESA*(dpy: PDisplay, d: GLXDrawable): bool{.cdecl,
+    dynlib: dllname, importc.}
+proc glXCopySubBufferMESA*(dpy: PDisplay, drawbale: GLXDrawable,
+                           x, y, width, height: int){.cdecl, dynlib: dllname,
+    importc.}
+proc glXGetVideoSyncSGI*(counter: var int32): int{.cdecl, dynlib: dllname,
+    importc.}
+proc glXWaitVideoSyncSGI*(divisor, remainder: int, count: var int32): int{.
+    cdecl, dynlib: dllname, importc.}
+# implementation

lib/oldwrappers/opengl/wingl.nim

@@ -0,0 +1,348 @@
+
+import 
+  gl, windows
+
+proc wglGetExtensionsStringARB*(hdc: HDC): cstring{.dynlib: dllname, importc.}
+
+const 
+  WGL_FRONT_COLOR_BUFFER_BIT_ARB* = 0x00000001
+  WGL_BACK_COLOR_BUFFER_BIT_ARB* = 0x00000002
+  WGL_DEPTH_BUFFER_BIT_ARB* = 0x00000004
+  WGL_STENCIL_BUFFER_BIT_ARB* = 0x00000008
+
+proc WinChoosePixelFormat*(DC: HDC, p2: PPixelFormatDescriptor): int{.
+    dynlib: "gdi32", importc: "ChoosePixelFormat".}
+proc wglCreateBufferRegionARB*(hDC: HDC, iLayerPlane: TGLint, uType: TGLuint): THandle{.
+    dynlib: dllname, importc.}
+proc wglDeleteBufferRegionARB*(hRegion: THandle){.dynlib: dllname, importc.}
+proc wglSaveBufferRegionARB*(hRegion: THandle, x: TGLint, y: TGLint, 
+                             width: TGLint, height: TGLint): BOOL{.
+    dynlib: dllname, importc.}
+proc wglRestoreBufferRegionARB*(hRegion: THandle, x: TGLint, y: TGLint, 
+                                width: TGLint, height: TGLint, xSrc: TGLint, 
+                                ySrc: TGLint): BOOL{.dynlib: dllname, importc.}
+proc wglAllocateMemoryNV*(size: TGLsizei, readFrequency: TGLfloat, 
+                          writeFrequency: TGLfloat, priority: TGLfloat): PGLvoid{.
+    dynlib: dllname, importc.}
+proc wglFreeMemoryNV*(pointer: PGLvoid){.dynlib: dllname, importc.}
+const 
+  WGL_IMAGE_BUFFER_MIN_ACCESS_I3D* = 0x00000001
+  WGL_IMAGE_BUFFER_LOCK_I3D* = 0x00000002
+
+proc wglCreateImageBufferI3D*(hDC: HDC, dwSize: DWORD, uFlags: UINT): PGLvoid{.
+    dynlib: dllname, importc.}
+proc wglDestroyImageBufferI3D*(hDC: HDC, pAddress: PGLvoid): BOOL{.
+    dynlib: dllname, importc.}
+proc wglAssociateImageBufferEventsI3D*(hdc: HDC, pEvent: PHandle, 
+                                       pAddress: PGLvoid, pSize: PDWORD, 
+                                       count: UINT): BOOL{.dynlib: dllname, 
+    importc.}
+proc wglReleaseImageBufferEventsI3D*(hdc: HDC, pAddress: PGLvoid, count: UINT): BOOL{.
+    dynlib: dllname, importc.}
+proc wglEnableFrameLockI3D*(): BOOL{.dynlib: dllname, importc.}
+proc wglDisableFrameLockI3D*(): BOOL{.dynlib: dllname, importc.}
+proc wglIsEnabledFrameLockI3D*(pFlag: PBOOL): BOOL{.dynlib: dllname, importc.}
+proc wglQueryFrameLockMasterI3D*(pFlag: PBOOL): BOOL{.dynlib: dllname, importc.}
+proc wglGetFrameUsageI3D*(pUsage: PGLfloat): BOOL{.dynlib: dllname, importc.}
+proc wglBeginFrameTrackingI3D*(): BOOL{.dynlib: dllname, importc.}
+proc wglEndFrameTrackingI3D*(): BOOL{.dynlib: dllname, importc.}
+proc wglQueryFrameTrackingI3D*(pFrameCount: PDWORD, pMissedFrames: PDWORD, 
+                               pLastMissedUsage: PGLfloat): BOOL{.
+    dynlib: dllname, importc.}
+const 
+  WGL_NUMBER_PIXEL_FORMATS_ARB* = 0x00002000
+  WGL_DRAW_TO_WINDOW_ARB* = 0x00002001
+  WGL_DRAW_TO_BITMAP_ARB* = 0x00002002
+  WGL_ACCELERATION_ARB* = 0x00002003
+  WGL_NEED_PALETTE_ARB* = 0x00002004
+  WGL_NEED_SYSTEM_PALETTE_ARB* = 0x00002005
+  WGL_SWAP_LAYER_BUFFERS_ARB* = 0x00002006
+  WGL_SWAP_METHOD_ARB* = 0x00002007
+  WGL_NUMBER_OVERLAYS_ARB* = 0x00002008
+  WGL_NUMBER_UNDERLAYS_ARB* = 0x00002009
+  WGL_TRANSPARENT_ARB* = 0x0000200A
+  WGL_TRANSPARENT_RED_VALUE_ARB* = 0x00002037
+  WGL_TRANSPARENT_GREEN_VALUE_ARB* = 0x00002038
+  WGL_TRANSPARENT_BLUE_VALUE_ARB* = 0x00002039
+  WGL_TRANSPARENT_ALPHA_VALUE_ARB* = 0x0000203A
+  WGL_TRANSPARENT_INDEX_VALUE_ARB* = 0x0000203B
+  WGL_SHARE_DEPTH_ARB* = 0x0000200C
+  WGL_SHARE_STENCIL_ARB* = 0x0000200D
+  WGL_SHARE_ACCUM_ARB* = 0x0000200E
+  WGL_SUPPORT_GDI_ARB* = 0x0000200F
+  WGL_SUPPORT_OPENGL_ARB* = 0x00002010
+  WGL_DOUBLE_BUFFER_ARB* = 0x00002011
+  WGL_STEREO_ARB* = 0x00002012
+  WGL_PIXEL_TYPE_ARB* = 0x00002013
+  WGL_COLOR_BITS_ARB* = 0x00002014
+  WGL_RED_BITS_ARB* = 0x00002015
+  WGL_RED_SHIFT_ARB* = 0x00002016
+  WGL_GREEN_BITS_ARB* = 0x00002017
+  WGL_GREEN_SHIFT_ARB* = 0x00002018
+  WGL_BLUE_BITS_ARB* = 0x00002019
+  WGL_BLUE_SHIFT_ARB* = 0x0000201A
+  WGL_ALPHA_BITS_ARB* = 0x0000201B
+  WGL_ALPHA_SHIFT_ARB* = 0x0000201C
+  WGL_ACCUM_BITS_ARB* = 0x0000201D
+  WGL_ACCUM_RED_BITS_ARB* = 0x0000201E
+  WGL_ACCUM_GREEN_BITS_ARB* = 0x0000201F
+  WGL_ACCUM_BLUE_BITS_ARB* = 0x00002020
+  WGL_ACCUM_ALPHA_BITS_ARB* = 0x00002021
+  WGL_DEPTH_BITS_ARB* = 0x00002022
+  WGL_STENCIL_BITS_ARB* = 0x00002023
+  WGL_AUX_BUFFERS_ARB* = 0x00002024
+  WGL_NO_ACCELERATION_ARB* = 0x00002025
+  WGL_GENERIC_ACCELERATION_ARB* = 0x00002026
+  WGL_FULL_ACCELERATION_ARB* = 0x00002027
+  WGL_SWAP_EXCHANGE_ARB* = 0x00002028
+  WGL_SWAP_COPY_ARB* = 0x00002029
+  WGL_SWAP_UNDEFINED_ARB* = 0x0000202A
+  WGL_TYPE_RGBA_ARB* = 0x0000202B
+  WGL_TYPE_COLORINDEX_ARB* = 0x0000202C
+
+proc wglGetPixelFormatAttribivARB*(hdc: HDC, iPixelFormat: TGLint, 
+                                   iLayerPlane: TGLint, nAttributes: TGLuint, 
+                                   piAttributes: PGLint, piValues: PGLint): BOOL{.
+    dynlib: dllname, importc.}
+proc wglGetPixelFormatAttribfvARB*(hdc: HDC, iPixelFormat: TGLint, 
+                                   iLayerPlane: TGLint, nAttributes: TGLuint, 
+                                   piAttributes: PGLint, pfValues: PGLfloat): BOOL{.
+    dynlib: dllname, importc.}
+proc wglChoosePixelFormatARB*(hdc: HDC, piAttribIList: PGLint, 
+                              pfAttribFList: PGLfloat, nMaxFormats: TGLuint, 
+                              piFormats: PGLint, nNumFormats: PGLuint): BOOL{.
+    dynlib: dllname, importc.}
+const 
+  WGL_ERROR_INVALID_PIXEL_TYPE_ARB* = 0x00002043
+  WGL_ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB* = 0x00002054
+
+proc wglMakeContextCurrentARB*(hDrawDC: HDC, hReadDC: HDC, hglrc: HGLRC): BOOL{.
+    dynlib: dllname, importc.}
+proc wglGetCurrentReadDCARB*(): HDC{.dynlib: dllname, importc.}
+const 
+  WGL_DRAW_TO_PBUFFER_ARB* = 0x0000202D # WGL_DRAW_TO_PBUFFER_ARB  { already defined }
+  WGL_MAX_PBUFFER_PIXELS_ARB* = 0x0000202E
+  WGL_MAX_PBUFFER_WIDTH_ARB* = 0x0000202F
+  WGL_MAX_PBUFFER_HEIGHT_ARB* = 0x00002030
+  WGL_PBUFFER_LARGEST_ARB* = 0x00002033
+  WGL_PBUFFER_WIDTH_ARB* = 0x00002034
+  WGL_PBUFFER_HEIGHT_ARB* = 0x00002035
+  WGL_PBUFFER_LOST_ARB* = 0x00002036
+
+proc wglCreatePbufferARB*(hDC: HDC, iPixelFormat: TGLint, iWidth: TGLint, 
+                          iHeight: TGLint, piAttribList: PGLint): THandle{.
+    dynlib: dllname, importc.}
+proc wglGetPbufferDCARB*(hPbuffer: THandle): HDC{.dynlib: dllname, importc.}
+proc wglReleasePbufferDCARB*(hPbuffer: THandle, hDC: HDC): TGLint{.
+    dynlib: dllname, importc.}
+proc wglDestroyPbufferARB*(hPbuffer: THandle): BOOL{.dynlib: dllname, importc.}
+proc wglQueryPbufferARB*(hPbuffer: THandle, iAttribute: TGLint, piValue: PGLint): BOOL{.
+    dynlib: dllname, importc.}
+proc wglSwapIntervalEXT*(interval: TGLint): BOOL{.dynlib: dllname, importc.}
+proc wglGetSwapIntervalEXT*(): TGLint{.dynlib: dllname, importc.}
+const 
+  WGL_BIND_TO_TEXTURE_RGB_ARB* = 0x00002070
+  WGL_BIND_TO_TEXTURE_RGBA_ARB* = 0x00002071
+  WGL_TEXTURE_FORMAT_ARB* = 0x00002072
+  WGL_TEXTURE_TARGET_ARB* = 0x00002073
+  WGL_MIPMAP_TEXTURE_ARB* = 0x00002074
+  WGL_TEXTURE_RGB_ARB* = 0x00002075
+  WGL_TEXTURE_RGBA_ARB* = 0x00002076
+  WGL_NO_TEXTURE_ARB* = 0x00002077
+  WGL_TEXTURE_CUBE_MAP_ARB* = 0x00002078
+  WGL_TEXTURE_1D_ARB* = 0x00002079
+  WGL_TEXTURE_2D_ARB* = 0x0000207A # WGL_NO_TEXTURE_ARB  { already defined }
+  WGL_MIPMAP_LEVEL_ARB* = 0x0000207B
+  WGL_CUBE_MAP_FACE_ARB* = 0x0000207C
+  WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB* = 0x0000207D
+  WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB* = 0x0000207E
+  WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB* = 0x0000207F
+  WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB* = 0x00002080
+  WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB* = 0x00002081
+  WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB* = 0x00002082
+  WGL_FRONT_LEFT_ARB* = 0x00002083
+  WGL_FRONT_RIGHT_ARB* = 0x00002084
+  WGL_BACK_LEFT_ARB* = 0x00002085
+  WGL_BACK_RIGHT_ARB* = 0x00002086
+  WGL_AUX0_ARB* = 0x00002087
+  WGL_AUX1_ARB* = 0x00002088
+  WGL_AUX2_ARB* = 0x00002089
+  WGL_AUX3_ARB* = 0x0000208A
+  WGL_AUX4_ARB* = 0x0000208B
+  WGL_AUX5_ARB* = 0x0000208C
+  WGL_AUX6_ARB* = 0x0000208D
+  WGL_AUX7_ARB* = 0x0000208E
+  WGL_AUX8_ARB* = 0x0000208F
+  WGL_AUX9_ARB* = 0x00002090
+
+proc wglBindTexImageARB*(hPbuffer: THandle, iBuffer: TGLint): BOOL{.
+    dynlib: dllname, importc.}
+proc wglReleaseTexImageARB*(hPbuffer: THandle, iBuffer: TGLint): BOOL{.
+    dynlib: dllname, importc.}
+proc wglSetPbufferAttribARB*(hPbuffer: THandle, piAttribList: PGLint): BOOL{.
+    dynlib: dllname, importc.}
+proc wglGetExtensionsStringEXT*(): cstring{.dynlib: dllname, importc.}
+proc wglMakeContextCurrentEXT*(hDrawDC: HDC, hReadDC: HDC, hglrc: HGLRC): BOOL{.
+    dynlib: dllname, importc.}
+proc wglGetCurrentReadDCEXT*(): HDC{.dynlib: dllname, importc.}
+const 
+  WGL_DRAW_TO_PBUFFER_EXT* = 0x0000202D
+  WGL_MAX_PBUFFER_PIXELS_EXT* = 0x0000202E
+  WGL_MAX_PBUFFER_WIDTH_EXT* = 0x0000202F
+  WGL_MAX_PBUFFER_HEIGHT_EXT* = 0x00002030
+  WGL_OPTIMAL_PBUFFER_WIDTH_EXT* = 0x00002031
+  WGL_OPTIMAL_PBUFFER_HEIGHT_EXT* = 0x00002032
+  WGL_PBUFFER_LARGEST_EXT* = 0x00002033
+  WGL_PBUFFER_WIDTH_EXT* = 0x00002034
+  WGL_PBUFFER_HEIGHT_EXT* = 0x00002035
+
+proc wglCreatePbufferEXT*(hDC: HDC, iPixelFormat: TGLint, iWidth: TGLint, 
+                          iHeight: TGLint, piAttribList: PGLint): THandle{.
+    dynlib: dllname, importc.}
+proc wglGetPbufferDCEXT*(hPbuffer: THandle): HDC{.dynlib: dllname, importc.}
+proc wglReleasePbufferDCEXT*(hPbuffer: THandle, hDC: HDC): TGLint{.
+    dynlib: dllname, importc.}
+proc wglDestroyPbufferEXT*(hPbuffer: THandle): BOOL{.dynlib: dllname, importc.}
+proc wglQueryPbufferEXT*(hPbuffer: THandle, iAttribute: TGLint, piValue: PGLint): BOOL{.
+    dynlib: dllname, importc.}
+const 
+  WGL_NUMBER_PIXEL_FORMATS_EXT* = 0x00002000
+  WGL_DRAW_TO_WINDOW_EXT* = 0x00002001
+  WGL_DRAW_TO_BITMAP_EXT* = 0x00002002
+  WGL_ACCELERATION_EXT* = 0x00002003
+  WGL_NEED_PALETTE_EXT* = 0x00002004
+  WGL_NEED_SYSTEM_PALETTE_EXT* = 0x00002005
+  WGL_SWAP_LAYER_BUFFERS_EXT* = 0x00002006
+  WGL_SWAP_METHOD_EXT* = 0x00002007
+  WGL_NUMBER_OVERLAYS_EXT* = 0x00002008
+  WGL_NUMBER_UNDERLAYS_EXT* = 0x00002009
+  WGL_TRANSPARENT_EXT* = 0x0000200A
+  WGL_TRANSPARENT_VALUE_EXT* = 0x0000200B
+  WGL_SHARE_DEPTH_EXT* = 0x0000200C
+  WGL_SHARE_STENCIL_EXT* = 0x0000200D
+  WGL_SHARE_ACCUM_EXT* = 0x0000200E
+  WGL_SUPPORT_GDI_EXT* = 0x0000200F
+  WGL_SUPPORT_OPENGL_EXT* = 0x00002010
+  WGL_DOUBLE_BUFFER_EXT* = 0x00002011
+  WGL_STEREO_EXT* = 0x00002012
+  WGL_PIXEL_TYPE_EXT* = 0x00002013
+  WGL_COLOR_BITS_EXT* = 0x00002014
+  WGL_RED_BITS_EXT* = 0x00002015
+  WGL_RED_SHIFT_EXT* = 0x00002016
+  WGL_GREEN_BITS_EXT* = 0x00002017
+  WGL_GREEN_SHIFT_EXT* = 0x00002018
+  WGL_BLUE_BITS_EXT* = 0x00002019
+  WGL_BLUE_SHIFT_EXT* = 0x0000201A
+  WGL_ALPHA_BITS_EXT* = 0x0000201B
+  WGL_ALPHA_SHIFT_EXT* = 0x0000201C
+  WGL_ACCUM_BITS_EXT* = 0x0000201D
+  WGL_ACCUM_RED_BITS_EXT* = 0x0000201E
+  WGL_ACCUM_GREEN_BITS_EXT* = 0x0000201F
+  WGL_ACCUM_BLUE_BITS_EXT* = 0x00002020
+  WGL_ACCUM_ALPHA_BITS_EXT* = 0x00002021
+  WGL_DEPTH_BITS_EXT* = 0x00002022
+  WGL_STENCIL_BITS_EXT* = 0x00002023
+  WGL_AUX_BUFFERS_EXT* = 0x00002024
+  WGL_NO_ACCELERATION_EXT* = 0x00002025
+  WGL_GENERIC_ACCELERATION_EXT* = 0x00002026
+  WGL_FULL_ACCELERATION_EXT* = 0x00002027
+  WGL_SWAP_EXCHANGE_EXT* = 0x00002028
+  WGL_SWAP_COPY_EXT* = 0x00002029
+  WGL_SWAP_UNDEFINED_EXT* = 0x0000202A
+  WGL_TYPE_RGBA_EXT* = 0x0000202B
+  WGL_TYPE_COLORINDEX_EXT* = 0x0000202C
+
+proc wglGetPixelFormatAttribivEXT*(hdc: HDC, iPixelFormat: TGLint, 
+                                   iLayerPlane: TGLint, nAttributes: TGLuint, 
+                                   piAttributes: PGLint, piValues: PGLint): BOOL{.
+    dynlib: dllname, importc.}
+proc wglGetPixelFormatAttribfvEXT*(hdc: HDC, iPixelFormat: TGLint, 
+                                   iLayerPlane: TGLint, nAttributes: TGLuint, 
+                                   piAttributes: PGLint, pfValues: PGLfloat): BOOL{.
+    dynlib: dllname, importc.}
+proc wglChoosePixelFormatEXT*(hdc: HDC, piAttribIList: PGLint, 
+                              pfAttribFList: PGLfloat, nMaxFormats: TGLuint, 
+                              piFormats: PGLint, nNumFormats: PGLuint): BOOL{.
+    dynlib: dllname, importc.}
+const 
+  WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D* = 0x00002050
+  WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D* = 0x00002051
+  WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D* = 0x00002052
+  WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D* = 0x00002053
+
+proc wglGetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: TGLint, 
+                                      piValue: PGLint): BOOL{.dynlib: dllname, 
+    importc.}
+proc wglSetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: TGLint, 
+                                      piValue: PGLint): BOOL{.dynlib: dllname, 
+    importc.}
+const 
+  WGL_GAMMA_TABLE_SIZE_I3D* = 0x0000204E
+  WGL_GAMMA_EXCLUDE_DESKTOP_I3D* = 0x0000204F
+
+proc wglGetGammaTableParametersI3D*(hDC: HDC, iAttribute: TGLint, 
+                                    piValue: PGLint): BOOL{.dynlib: dllname, 
+    importc.}
+proc wglSetGammaTableParametersI3D*(hDC: HDC, iAttribute: TGLint, 
+                                    piValue: PGLint): BOOL{.dynlib: dllname, 
+    importc.}
+proc wglGetGammaTableI3D*(hDC: HDC, iEntries: TGLint, puRed: PGLUSHORT, 
+                          puGreen: PGLUSHORT, puBlue: PGLUSHORT): BOOL{.
+    dynlib: dllname, importc.}
+proc wglSetGammaTableI3D*(hDC: HDC, iEntries: TGLint, puRed: PGLUSHORT, 
+                          puGreen: PGLUSHORT, puBlue: PGLUSHORT): BOOL{.
+    dynlib: dllname, importc.}
+const 
+  WGL_GENLOCK_SOURCE_MULTIVIEW_I3D* = 0x00002044
+  WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D* = 0x00002045
+  WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D* = 0x00002046
+  WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D* = 0x00002047
+  WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D* = 0x00002048
+  WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D* = 0x00002049
+  WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D* = 0x0000204A
+  WGL_GENLOCK_SOURCE_EDGE_RISING_I3D* = 0x0000204B
+  WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D* = 0x0000204C
+  WGL_FLOAT_COMPONENTS_NV* = 0x000020B0
+  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV* = 0x000020B1
+  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV* = 0x000020B2
+  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV* = 0x000020B3
+  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV* = 0x000020B4
+  WGL_TEXTURE_FLOAT_R_NV* = 0x000020B5
+  WGL_TEXTURE_FLOAT_RG_NV* = 0x000020B6
+  WGL_TEXTURE_FLOAT_RGB_NV* = 0x000020B7
+  WGL_TEXTURE_FLOAT_RGBA_NV* = 0x000020B8
+
+proc wglEnableGenlockI3D*(hDC: HDC): BOOL{.dynlib: dllname, importc.}
+proc wglDisableGenlockI3D*(hDC: HDC): BOOL{.dynlib: dllname, importc.}
+proc wglIsEnabledGenlockI3D*(hDC: HDC, pFlag: PBOOL): BOOL{.dynlib: dllname, 
+    importc.}
+proc wglGenlockSourceI3D*(hDC: HDC, uSource: TGLuint): BOOL{.dynlib: dllname, 
+    importc.}
+proc wglGetGenlockSourceI3D*(hDC: HDC, uSource: PGLUINT): BOOL{.dynlib: dllname, 
+    importc.}
+proc wglGenlockSourceEdgeI3D*(hDC: HDC, uEdge: TGLuint): BOOL{.dynlib: dllname, 
+    importc.}
+proc wglGetGenlockSourceEdgeI3D*(hDC: HDC, uEdge: PGLUINT): BOOL{.
+    dynlib: dllname, importc.}
+proc wglGenlockSampleRateI3D*(hDC: HDC, uRate: TGLuint): BOOL{.dynlib: dllname, 
+    importc.}
+proc wglGetGenlockSampleRateI3D*(hDC: HDC, uRate: PGLUINT): BOOL{.
+    dynlib: dllname, importc.}
+proc wglGenlockSourceDelayI3D*(hDC: HDC, uDelay: TGLuint): BOOL{.
+    dynlib: dllname, importc.}
+proc wglGetGenlockSourceDelayI3D*(hDC: HDC, uDelay: PGLUINT): BOOL{.
+    dynlib: dllname, importc.}
+proc wglQueryGenlockMaxSourceDelayI3D*(hDC: HDC, uMaxLineDelay: PGLUINT, 
+                                       uMaxPixelDelay: PGLUINT): BOOL{.
+    dynlib: dllname, importc.}
+const 
+  WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV* = 0x000020A0
+  WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV* = 0x000020A1
+  WGL_TEXTURE_RECTANGLE_NV* = 0x000020A2
+
+const 
+  WGL_RGBA_FLOAT_MODE_ATI* = 0x00008820
+  WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI* = 0x00008835
+  WGL_TYPE_RGBA_FLOAT_ATI* = 0x000021A0
+
+# implementation

lib/oldwrappers/pcre/pcre.nim

@@ -0,0 +1,279 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2009 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+{.compile: "pcre_all.c" .}
+
+type
+  Pbyte = ptr byte
+  PPchar = ptr cstring
+  Pint = ptr cint
+  Ppcre* = ptr TPcre
+  Ppcre_callout_block* = ptr tpcre_callout_block
+  Ppcre_extra* = ptr Tpcre_extra
+  TPcre {.final, pure.} = object
+
+  # The structure for passing additional data to pcre_exec(). This is defined
+  # in such as way as to be extensible.
+  # Bits for which fields are set
+  # Opaque data from pcre_study()
+  # Maximum number of calls to match()
+  # Data passed back in callouts
+  # Const before type ignored
+  # Pointer to character tables
+  Tpcre_extra* {.final, pure.} = object
+    flags: cint
+    study_data: pointer
+    match_limit: cint
+    callout_data: pointer
+    tables: ptr byte
+
+  # The structure for passing out data via the pcre_callout_function. We use a
+  # structure so that new fields can be added on the end in future versions,
+  # without changing the API of the function, thereby allowing old clients to
+  # work without modification.
+  # Identifies version of block
+  # ------------------------ Version 0 -------------------------------
+  # Number compiled into pattern
+  # The offset vector
+  # Const before type ignored
+  # The subject being matched
+  # The length of the subject
+  # Offset to start of this match attempt
+  # Where we currently are in the subject
+  # Max current capture
+  # Most recently closed capture
+  # Data passed in with the call
+  # ------------------- Added for Version 1 --------------------------
+  # Offset to next item in the pattern
+  # Length of next item in the pattern
+  # ------------------------------------------------------------------
+  TPcre_callout_block* {.final, pure.} = object
+    version: cint
+    callout_number: cint
+    offset_vector: ptr cint
+    subject: ptr char
+    subject_length: cint
+    start_match: cint
+    current_position: cint
+    capture_top: cint
+    capture_last: cint
+    callout_data: pointer
+    pattern_position: cint
+    next_item_length: cint
+
+
+#************************************************
+#*       Perl-Compatible Regular Expressions    *
+#************************************************
+#
+#   Modified by Andreas Rumpf for h2pas.
+
+# In its original form, this is the .in file that is transformed by
+# "configure" into pcre.h.
+#
+#           Copyright (c) 1997-2005 University of Cambridge
+#
+# -----------------------------------------------------------------------------
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#    * Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#
+#    * Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#
+#    * Neither the name of the University of Cambridge nor the names of its
+#      contributors may be used to endorse or promote products derived from
+#      this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+
+# The file pcre.h is build by "configure". Do not edit it; instead
+# make changes to pcre.in.
+
+const
+  PCRE_MAJOR* = 6
+  PCRE_MINOR* = 3
+  PCRE_DATE* = "2005/11/29"
+  # Options
+  PCRE_CASELESS* = 0x00000001
+  PCRE_MULTILINE* = 0x00000002
+  PCRE_DOTALL* = 0x00000004
+  PCRE_EXTENDED* = 0x00000008
+  PCRE_ANCHORED* = 0x00000010
+  PCRE_DOLLAR_ENDONLY* = 0x00000020
+  PCRE_EXTRA* = 0x00000040
+  PCRE_NOTBOL* = 0x00000080
+  PCRE_NOTEOL* = 0x00000100
+  PCRE_UNGREEDY* = 0x00000200
+  PCRE_NOTEMPTY* = 0x00000400
+  PCRE_UTF8* = 0x00000800
+  PCRE_NO_AUTO_CAPTURE* = 0x00001000
+  PCRE_NO_UTF8_CHECK* = 0x00002000
+  PCRE_AUTO_CALLOUT* = 0x00004000
+  PCRE_PARTIAL* = 0x00008000
+  PCRE_DFA_SHORTEST* = 0x00010000
+  PCRE_DFA_RESTART* = 0x00020000
+  PCRE_FIRSTLINE* = 0x00040000
+  # Exec-time and get/set-time error codes
+  PCRE_ERROR_NOMATCH* = -(1)
+  PCRE_ERROR_NULL* = -(2)
+  PCRE_ERROR_BADOPTION* = -(3)
+  PCRE_ERROR_BADMAGIC* = -(4)
+  PCRE_ERROR_UNKNOWN_NODE* = -(5)
+  PCRE_ERROR_NOMEMORY* = -(6)
+  PCRE_ERROR_NOSUBSTRING* = -(7)
+  PCRE_ERROR_MATCHLIMIT* = -(8)
+  # Never used by PCRE itself
+  PCRE_ERROR_CALLOUT* = -(9)
+  PCRE_ERROR_BADUTF8* = -(10)
+  PCRE_ERROR_BADUTF8_OFFSET* = -(11)
+  PCRE_ERROR_PARTIAL* = -(12)
+  PCRE_ERROR_BADPARTIAL* = -(13)
+  PCRE_ERROR_INTERNAL* = -(14)
+  PCRE_ERROR_BADCOUNT* = -(15)
+  PCRE_ERROR_DFA_UITEM* = -(16)
+  PCRE_ERROR_DFA_UCOND* = -(17)
+  PCRE_ERROR_DFA_UMLIMIT* = -(18)
+  PCRE_ERROR_DFA_WSSIZE* = -(19)
+  PCRE_ERROR_DFA_RECURSE* = -(20)
+  # Request types for pcre_fullinfo()
+  PCRE_INFO_OPTIONS* = 0
+  PCRE_INFO_SIZE* = 1
+  PCRE_INFO_CAPTURECOUNT* = 2
+  PCRE_INFO_BACKREFMAX* = 3
+  PCRE_INFO_FIRSTBYTE* = 4
+  # For backwards compatibility
+  PCRE_INFO_FIRSTCHAR* = 4
+  PCRE_INFO_FIRSTTABLE* = 5
+  PCRE_INFO_LASTLITERAL* = 6
+  PCRE_INFO_NAMEENTRYSIZE* = 7
+  PCRE_INFO_NAMECOUNT* = 8
+  PCRE_INFO_NAMETABLE* = 9
+  PCRE_INFO_STUDYSIZE* = 10
+  PCRE_INFO_DEFAULT_TABLES* = 11
+  # Request types for pcre_config()
+  PCRE_CONFIG_UTF8* = 0
+  PCRE_CONFIG_NEWLINE* = 1
+  PCRE_CONFIG_LINK_SIZE* = 2
+  PCRE_CONFIG_POSIX_MALLOC_THRESHOLD* = 3
+  PCRE_CONFIG_MATCH_LIMIT* = 4
+  PCRE_CONFIG_STACKRECURSE* = 5
+  PCRE_CONFIG_UNICODE_PROPERTIES* = 6
+  # Bit flags for the pcre_extra structure
+  PCRE_EXTRA_STUDY_DATA* = 0x0001
+  PCRE_EXTRA_MATCH_LIMIT* = 0x0002
+  PCRE_EXTRA_CALLOUT_DATA* = 0x0004
+  PCRE_EXTRA_TABLES* = 0x0008
+
+# Exported PCRE functions
+
+proc pcre_compile*(para1: cstring, para2: cint, para3: ptr cstring,
+                  para4: ptr int, para5: Pbyte): Ppcre {.
+                  importc: "pcre_compile", noconv.}
+
+proc pcre_compile2*(para1: cstring, para2: cint, para3: Pint, para4: PPchar,
+                   para5: ptr int, para6: Pbyte): Ppcre {.
+                   importc: "pcre_compile2", noconv.}
+
+proc pcre_config*(para1: cint, para2: pointer): cint {.
+  importc: "pcre_config", noconv.}
+
+proc pcre_copy_named_substring*(para1: Ppcre, para2: cstring, para3: Pint,
+                               para4: cint, para5: cstring, para6: cstring,
+                               para7: cint): cint {.
+                               importc: "pcre_copy_named_substring", noconv.}
+
+proc pcre_copy_substring*(para1: cstring, para2: Pint, para3: cint, para4: cint,
+                         para5: cstring, para6: cint): cint {.
+                         importc: "pcre_copy_substring", noconv.}
+
+proc pcre_dfa_exec*(para1: Ppcre, para2: Ppcre_extra, para3: cstring,
+                   para4: cint, para5: cint, para6: cint, para7: Pint,
+                   para8: cint, para9: Pint, para10: cint): cint {.
+                   importc: "pcre_dfa_exec", noconv.}
+
+proc pcre_exec*(para1: Ppcre, para2: Ppcre_extra, para3: cstring,
+               para4: cint, para5: cint, para6: cint, para7: Pint,
+               para8: cint): cint {.importc: "pcre_exec", noconv.}
+
+proc pcre_free_substring*(para1: cstring) {.
+  importc: "pcre_free_substring", noconv.}
+
+proc pcre_free_substring_list*(para1: PPchar) {.
+  importc: "pcre_free_substring_list", noconv.}
+
+proc pcre_fullinfo*(para1: Ppcre, para2: Ppcre_extra, para3: cint,
+                   para4: pointer): cint {.importc: "pcre_fullinfo", noconv.}
+
+proc pcre_get_named_substring*(para1: Ppcre, para2: cstring, para3: Pint,
+                              para4: cint, para5: cstring, para6: PPchar): cint {.
+                              importc: "pcre_get_named_substring", noconv.}
+
+proc pcre_get_stringnumber*(para1: Ppcre, para2: cstring): cint {.
+  importc: "pcre_get_stringnumber", noconv.}
+
+proc pcre_get_substring*(para1: cstring, para2: Pint, para3: cint,
+                        para4: cint, para5: PPchar): cint {.
+                        importc: "pcre_get_substring", noconv.}
+
+proc pcre_get_substring_list*(para1: cstring, para2: Pint, para3: cint,
+                             para4: ptr PPchar): cint {.
+                             importc: "pcre_get_substring_list", noconv.}
+
+proc pcre_info*(para1: Ppcre, para2: Pint, para3: Pint): cint {.
+  importc: "pcre_info", noconv.}
+
+proc pcre_maketables*: ptr byte {.
+  importc: "pcre_maketables", noconv.}
+
+proc pcre_refcount*(para1: Ppcre, para2: cint): cint {.
+  importc: "pcre_refcount", noconv.}
+
+proc pcre_study*(para1: Ppcre, para2: cint,
+                 para3: ptr CString): Ppcre_extra {.importc, noconv.}
+
+proc pcre_version*: CString {.importc: "pcre_version", noconv.}
+
+# Indirection for store get and free functions. These can be set to
+# alternative malloc/free functions if required. Special ones are used in the
+# non-recursive case for "frames". There is also an optional callout function
+# that is triggered by the (?) regex item.
+#
+
+# we use Nimrod's memory manager (but not GC!) for these functions:
+type
+  TMalloc = proc (para1: int): pointer {.noconv.}
+  TFree = proc (para1: pointer) {.noconv.}
+var
+  pcre_malloc {.importc: "pcre_malloc".}: TMalloc
+  pcre_free {.importc: "pcre_free".}: TFree
+  pcre_stack_malloc {.importc: "pcre_stack_malloc".}: TMalloc
+  pcre_stack_free  {.importc: "pcre_stack_free".}: TFree
+  pcre_callout {.importc: "pcre_callout".}:
+    proc (para1: Ppcre_callout_block): cint {.noconv.}
+
+pcre_malloc = cast[TMalloc](system.alloc)
+pcre_free = cast[TFree](system.dealloc)
+pcre_stack_malloc = cast[TMalloc](system.alloc)
+pcre_stack_free = cast[TFree](system.dealloc)
+pcre_callout = nil

lib/oldwrappers/postgres.nim

@@ -0,0 +1,386 @@
+# This module contains the definitions for structures and externs for
+# functions used by frontend postgres applications. It is based on
+# Postgresql's libpq-fe.h.
+#
+# It is for postgreSQL version 7.4 and higher with support for the v3.0
+# connection-protocol.
+#
+
+{.deadCodeElim: on.}
+
+when defined(windows):
+  const dllName = "pq.dll"
+elif defined(macosx):
+  const dllName = "libpq.dylib"
+else:
+  const dllName = "libpq.so(.5|)"
+  
+type
+  POid* = ptr Oid
+  Oid* = int32
+
+const 
+  ERROR_MSG_LENGTH* = 4096
+  CMDSTATUS_LEN* = 40
+
+type 
+  TSockAddr* = array[1..112, int8]
+  TPGresAttDesc*{.pure, final.} = object 
+    name*: cstring
+    adtid*: Oid
+    adtsize*: int
+
+  PPGresAttDesc* = ptr TPGresAttDesc
+  PPPGresAttDesc* = ptr PPGresAttDesc
+  TPGresAttValue*{.pure, final.} = object 
+    length*: int32
+    value*: cstring
+
+  PPGresAttValue* = ptr TPGresAttValue
+  PPPGresAttValue* = ptr PPGresAttValue
+  PExecStatusType* = ptr TExecStatusType
+  TExecStatusType* = enum 
+    PGRES_EMPTY_QUERY = 0, PGRES_COMMAND_OK, PGRES_TUPLES_OK, PGRES_COPY_OUT, 
+    PGRES_COPY_IN, PGRES_BAD_RESPONSE, PGRES_NONFATAL_ERROR, PGRES_FATAL_ERROR
+  TPGlobjfuncs*{.pure, final.} = object 
+    fn_lo_open*: Oid
+    fn_lo_close*: Oid
+    fn_lo_creat*: Oid
+    fn_lo_unlink*: Oid
+    fn_lo_lseek*: Oid
+    fn_lo_tell*: Oid
+    fn_lo_read*: Oid
+    fn_lo_write*: Oid
+
+  PPGlobjfuncs* = ptr TPGlobjfuncs
+  PConnStatusType* = ptr TConnStatusType
+  TConnStatusType* = enum 
+    CONNECTION_OK, CONNECTION_BAD, CONNECTION_STARTED, CONNECTION_MADE, 
+    CONNECTION_AWAITING_RESPONSE, CONNECTION_AUTH_OK, CONNECTION_SETENV, 
+    CONNECTION_SSL_STARTUP, CONNECTION_NEEDED
+  TPGconn* {.pure, final.} = object 
+    pghost*: cstring
+    pgtty*: cstring
+    pgport*: cstring
+    pgoptions*: cstring
+    dbName*: cstring
+    status*: TConnStatusType
+    errorMessage*: array[0..(ERROR_MSG_LENGTH) - 1, char]
+    Pfin*: TFile
+    Pfout*: TFile
+    Pfdebug*: TFile
+    sock*: int32
+    laddr*: TSockAddr
+    raddr*: TSockAddr
+    salt*: array[0..(2) - 1, char]
+    asyncNotifyWaiting*: int32
+    notifyList*: pointer
+    pguser*: cstring
+    pgpass*: cstring
+    lobjfuncs*: PPGlobjfuncs
+
+  PPGconn* = ptr TPGconn
+  TPGresult* {.pure, final.} = object 
+    ntups*: int32
+    numAttributes*: int32
+    attDescs*: PPGresAttDesc
+    tuples*: PPPGresAttValue
+    tupArrSize*: int32
+    resultStatus*: TExecStatusType
+    cmdStatus*: array[0..(CMDSTATUS_LEN) - 1, char]
+    binary*: int32
+    conn*: PPGconn
+
+  PPGresult* = ptr TPGresult
+  PPostgresPollingStatusType* = ptr PostgresPollingStatusType
+  PostgresPollingStatusType* = enum 
+    PGRES_POLLING_FAILED = 0, PGRES_POLLING_READING, PGRES_POLLING_WRITING, 
+    PGRES_POLLING_OK, PGRES_POLLING_ACTIVE
+  PPGTransactionStatusType* = ptr PGTransactionStatusType
+  PGTransactionStatusType* = enum 
+    PQTRANS_IDLE, PQTRANS_ACTIVE, PQTRANS_INTRANS, PQTRANS_INERROR, 
+    PQTRANS_UNKNOWN
+  PPGVerbosity* = ptr PGVerbosity
+  PGVerbosity* = enum 
+    PQERRORS_TERSE, PQERRORS_DEFAULT, PQERRORS_VERBOSE
+  PpgNotify* = ptr pgNotify
+  pgNotify* {.pure, final.} = object
+    relname*: cstring
+    be_pid*: int32
+    extra*: cstring
+
+  PQnoticeReceiver* = proc (arg: pointer, res: PPGresult){.cdecl.}
+  PQnoticeProcessor* = proc (arg: pointer, message: cstring){.cdecl.} 
+  Ppqbool* = ptr pqbool
+  pqbool* = char
+  P_PQprintOpt* = ptr PQprintOpt
+  PQprintOpt* {.pure, final.} = object
+    header*: pqbool
+    align*: pqbool
+    standard*: pqbool
+    html3*: pqbool
+    expanded*: pqbool
+    pager*: pqbool
+    fieldSep*: cstring
+    tableOpt*: cstring
+    caption*: cstring
+    fieldName*: ptr cstring
+
+  P_PQconninfoOption* = ptr PQconninfoOption
+  PQconninfoOption* {.pure, final.} = object
+    keyword*: cstring
+    envvar*: cstring
+    compiled*: cstring
+    val*: cstring
+    label*: cstring
+    dispchar*: cstring
+    dispsize*: int32
+
+  PPQArgBlock* = ptr PQArgBlock
+  PQArgBlock* {.pure, final.} = object  
+    length*: int32
+    isint*: int32
+    p*: pointer
+
+proc PQconnectStart*(conninfo: cstring): PPGconn{.cdecl, dynlib: dllName, 
+    importc: "PQconnectStart".}
+proc PQconnectPoll*(conn: PPGconn): PostgresPollingStatusType{.cdecl, 
+    dynlib: dllName, importc: "PQconnectPoll".}
+
+proc PQconnectdb*(conninfo: cstring): PPGconn{.cdecl, dynlib: dllName, 
+    importc: "PQconnectdb".}
+proc PQsetdbLogin*(pghost: cstring, pgport: cstring, pgoptions: cstring, 
+                   pgtty: cstring, dbName: cstring, login: cstring, pwd: cstring): PPGconn{.
+    cdecl, dynlib: dllName, importc: "PQsetdbLogin".}
+
+proc PQsetdb*(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME: cstring): ppgconn
+
+proc PQfinish*(conn: PPGconn){.cdecl, dynlib: dllName, importc: "PQfinish".}
+
+proc PQconndefaults*(): PPQconninfoOption{.cdecl, dynlib: dllName, 
+    importc: "PQconndefaults".}
+
+proc PQconninfoFree*(connOptions: PPQconninfoOption){.cdecl, dynlib: dllName, 
+    importc: "PQconninfoFree".}
+
+proc PQresetStart*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+    importc: "PQresetStart".}
+proc PQresetPoll*(conn: PPGconn): PostgresPollingStatusType{.cdecl, 
+    dynlib: dllName, importc: "PQresetPoll".}
+
+proc PQreset*(conn: PPGconn){.cdecl, dynlib: dllName, importc: "PQreset".}
+
+proc PQrequestCancel*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+    importc: "PQrequestCancel".}
+
+proc PQdb*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, importc: "PQdb".}
+proc PQuser*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, importc: "PQuser".}
+proc PQpass*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, importc: "PQpass".}
+proc PQhost*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, importc: "PQhost".}
+proc PQport*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, importc: "PQport".}
+proc PQtty*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, importc: "PQtty".}
+proc PQoptions*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, 
+    importc: "PQoptions".}
+proc PQstatus*(conn: PPGconn): TConnStatusType{.cdecl, dynlib: dllName, 
+    importc: "PQstatus".}
+proc PQtransactionStatus*(conn: PPGconn): PGTransactionStatusType{.cdecl, 
+    dynlib: dllName, importc: "PQtransactionStatus".}
+proc PQparameterStatus*(conn: PPGconn, paramName: cstring): cstring{.cdecl, 
+    dynlib: dllName, importc: "PQparameterStatus".}
+proc PQprotocolVersion*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+    importc: "PQprotocolVersion".}
+proc PQerrorMessage*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, 
+    importc: "PQerrorMessage".}
+proc PQsocket*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+                                      importc: "PQsocket".}
+proc PQbackendPID*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+    importc: "PQbackendPID".}
+proc PQclientEncoding*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+    importc: "PQclientEncoding".}
+proc PQsetClientEncoding*(conn: PPGconn, encoding: cstring): int32{.cdecl, 
+    dynlib: dllName, importc: "PQsetClientEncoding".}
+when defined(USE_SSL): 
+  # Get the SSL structure associated with a connection  
+  proc PQgetssl*(conn: PPGconn): PSSL{.cdecl, dynlib: dllName, 
+                                       importc: "PQgetssl".}
+
+proc PQsetErrorVerbosity*(conn: PPGconn, verbosity: PGVerbosity): PGVerbosity{.
+    cdecl, dynlib: dllName, importc: "PQsetErrorVerbosity".}
+
+proc PQtrace*(conn: PPGconn, debug_port: TFile){.cdecl, dynlib: dllName, 
+    importc: "PQtrace".}
+proc PQuntrace*(conn: PPGconn){.cdecl, dynlib: dllName, importc: "PQuntrace".}
+
+proc PQsetNoticeReceiver*(conn: PPGconn, theProc: PQnoticeReceiver, 
+                          arg: pointer): PQnoticeReceiver {.
+    cdecl, dynlib: dllName, importc: "PQsetNoticeReceiver".}
+proc PQsetNoticeProcessor*(conn: PPGconn, theProc: PQnoticeProcessor, 
+                           arg: pointer): PQnoticeProcessor{.
+    cdecl, dynlib: dllName, importc: "PQsetNoticeProcessor".}
+
+proc PQexec*(conn: PPGconn, query: cstring): PPGresult{.cdecl, dynlib: dllName, 
+    importc: "PQexec".}
+proc PQexecParams*(conn: PPGconn, command: cstring, nParams: int32, 
+                   paramTypes: POid, paramValues: cstringArray, 
+                   paramLengths, paramFormats: ptr int32, 
+                   resultFormat: int32): PPGresult {.cdecl, dynlib: dllName, 
+    importc: "PQexecParams".}
+proc PQexecPrepared*(conn: PPGconn, stmtName: cstring, nParams: int32, 
+                     paramValues: cstringArray, 
+                     paramLengths, paramFormats: ptr int32, 
+                     resultFormat: int32): PPGresult {.
+    cdecl, dynlib: dllName, importc: "PQexecPrepared".}
+
+proc PQsendQuery*(conn: PPGconn, query: cstring): int32{.cdecl, dynlib: dllName, 
+    importc: "PQsendQuery".}
+proc PQsendQueryParams*(conn: PPGconn, command: cstring, nParams: int32, 
+                        paramTypes: POid, paramValues: cstringArray, 
+                        paramLengths, paramFormats: ptr int32, 
+                        resultFormat: int32): int32 {.cdecl, dynlib: dllName, 
+    importc: "PQsendQueryParams".}
+proc PQsendQueryPrepared*(conn: PPGconn, stmtName: cstring, nParams: int32, 
+                          paramValues: cstringArray, 
+                          paramLengths, paramFormats: ptr int32, 
+                          resultFormat: int32): int32{.
+    cdecl, dynlib: dllName, importc: "PQsendQueryPrepared".}
+proc PQgetResult*(conn: PPGconn): PPGresult{.cdecl, dynlib: dllName, 
+    importc: "PQgetResult".}
+proc PQisBusy*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+                                      importc: "PQisBusy".}
+proc PQconsumeInput*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+    importc: "PQconsumeInput".}
+
+proc PQnotifies*(conn: PPGconn): PPGnotify{.cdecl, dynlib: dllName, 
+    importc: "PQnotifies".}
+
+proc PQputCopyData*(conn: PPGconn, buffer: cstring, nbytes: int32): int32{.
+    cdecl, dynlib: dllName, importc: "PQputCopyData".}
+proc PQputCopyEnd*(conn: PPGconn, errormsg: cstring): int32{.cdecl, 
+    dynlib: dllName, importc: "PQputCopyEnd".}
+proc PQgetCopyData*(conn: PPGconn, buffer: cstringArray, async: int32): int32{.cdecl, 
+    dynlib: dllName, importc: "PQgetCopyData".}
+
+proc PQgetline*(conn: PPGconn, str: cstring, len: int32): int32{.cdecl, 
+    dynlib: dllName, importc: "PQgetline".}
+proc PQputline*(conn: PPGconn, str: cstring): int32{.cdecl, dynlib: dllName, 
+    importc: "PQputline".}
+proc PQgetlineAsync*(conn: PPGconn, buffer: cstring, bufsize: int32): int32{.
+    cdecl, dynlib: dllName, importc: "PQgetlineAsync".}
+proc PQputnbytes*(conn: PPGconn, buffer: cstring, nbytes: int32): int32{.cdecl, 
+    dynlib: dllName, importc: "PQputnbytes".}
+proc PQendcopy*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+                                       importc: "PQendcopy".}
+
+proc PQsetnonblocking*(conn: PPGconn, arg: int32): int32{.cdecl, 
+    dynlib: dllName, importc: "PQsetnonblocking".}
+proc PQisnonblocking*(conn: PPGconn): int32{.cdecl, dynlib: dllName, 
+    importc: "PQisnonblocking".}
+
+proc PQflush*(conn: PPGconn): int32{.cdecl, dynlib: dllName, importc: "PQflush".}
+
+proc PQfn*(conn: PPGconn, fnid: int32, result_buf, 
+           result_len: ptr int32, result_is_int: int32, args: PPQArgBlock, 
+           nargs: int32): PPGresult{.cdecl, dynlib: dllName, importc: "PQfn".}
+
+proc PQresultStatus*(res: PPGresult): TExecStatusType{.cdecl, dynlib: dllName, 
+    importc: "PQresultStatus".}
+proc PQresStatus*(status: TExecStatusType): cstring{.cdecl, dynlib: dllName, 
+    importc: "PQresStatus".}
+proc PQresultErrorMessage*(res: PPGresult): cstring{.cdecl, dynlib: dllName, 
+    importc: "PQresultErrorMessage".}
+proc PQresultErrorField*(res: PPGresult, fieldcode: int32): cstring{.cdecl, 
+    dynlib: dllName, importc: "PQresultErrorField".}
+proc PQntuples*(res: PPGresult): int32{.cdecl, dynlib: dllName, 
+                                        importc: "PQntuples".}
+proc PQnfields*(res: PPGresult): int32{.cdecl, dynlib: dllName, 
+                                        importc: "PQnfields".}
+proc PQbinaryTuples*(res: PPGresult): int32{.cdecl, dynlib: dllName, 
+    importc: "PQbinaryTuples".}
+proc PQfname*(res: PPGresult, field_num: int32): cstring{.cdecl, 
+    dynlib: dllName, importc: "PQfname".}
+proc PQfnumber*(res: PPGresult, field_name: cstring): int32{.cdecl, 
+    dynlib: dllName, importc: "PQfnumber".}
+proc PQftable*(res: PPGresult, field_num: int32): Oid{.cdecl, dynlib: dllName, 
+    importc: "PQftable".}
+proc PQftablecol*(res: PPGresult, field_num: int32): int32{.cdecl, 
+    dynlib: dllName, importc: "PQftablecol".}
+proc PQfformat*(res: PPGresult, field_num: int32): int32{.cdecl, 
+    dynlib: dllName, importc: "PQfformat".}
+proc PQftype*(res: PPGresult, field_num: int32): Oid{.cdecl, dynlib: dllName, 
+    importc: "PQftype".}
+proc PQfsize*(res: PPGresult, field_num: int32): int32{.cdecl, dynlib: dllName, 
+    importc: "PQfsize".}
+proc PQfmod*(res: PPGresult, field_num: int32): int32{.cdecl, dynlib: dllName, 
+    importc: "PQfmod".}
+proc PQcmdStatus*(res: PPGresult): cstring{.cdecl, dynlib: dllName, 
+    importc: "PQcmdStatus".}
+proc PQoidStatus*(res: PPGresult): cstring{.cdecl, dynlib: dllName, 
+    importc: "PQoidStatus".}
+
+proc PQoidValue*(res: PPGresult): Oid{.cdecl, dynlib: dllName, 
+                                       importc: "PQoidValue".}
+
+proc PQcmdTuples*(res: PPGresult): cstring{.cdecl, dynlib: dllName, 
+    importc: "PQcmdTuples".}
+proc PQgetvalue*(res: PPGresult, tup_num: int32, field_num: int32): cstring{.
+    cdecl, dynlib: dllName, importc: "PQgetvalue".}
+proc PQgetlength*(res: PPGresult, tup_num: int32, field_num: int32): int32{.
+    cdecl, dynlib: dllName, importc: "PQgetlength".}
+proc PQgetisnull*(res: PPGresult, tup_num: int32, field_num: int32): int32{.
+    cdecl, dynlib: dllName, importc: "PQgetisnull".}
+
+proc PQclear*(res: PPGresult){.cdecl, dynlib: dllName, importc: "PQclear".}
+
+proc PQfreemem*(p: pointer){.cdecl, dynlib: dllName, importc: "PQfreemem".}
+
+proc PQmakeEmptyPGresult*(conn: PPGconn, status: TExecStatusType): PPGresult{.
+    cdecl, dynlib: dllName, importc: "PQmakeEmptyPGresult".}
+
+proc PQescapeString*(till, `from`: cstring, len: int): int{.cdecl, 
+    dynlib: dllName, importc: "PQescapeString".}
+proc PQescapeBytea*(bintext: cstring, binlen: int, 
+                    bytealen: var int): cstring{.
+    cdecl, dynlib: dllName, importc: "PQescapeBytea".}
+proc PQunescapeBytea*(strtext: cstring, retbuflen: var int): cstring{.cdecl, 
+    dynlib: dllName, importc: "PQunescapeBytea".}
+
+proc PQprint*(fout: TFile, res: PPGresult, ps: PPQprintOpt){.cdecl, 
+    dynlib: dllName, importc: "PQprint".}
+
+proc PQdisplayTuples*(res: PPGresult, fp: TFile, fillAlign: int32, 
+                      fieldSep: cstring, printHeader: int32, quiet: int32){.
+    cdecl, dynlib: dllName, importc: "PQdisplayTuples".}
+
+proc PQprintTuples*(res: PPGresult, fout: TFile, printAttName: int32, 
+                    terseOutput: int32, width: int32){.cdecl, dynlib: dllName, 
+    importc: "PQprintTuples".}
+
+proc lo_open*(conn: PPGconn, lobjId: Oid, mode: int32): int32{.cdecl, 
+    dynlib: dllName, importc: "lo_open".}
+proc lo_close*(conn: PPGconn, fd: int32): int32{.cdecl, dynlib: dllName, 
+    importc: "lo_close".}
+proc lo_read*(conn: PPGconn, fd: int32, buf: cstring, length: int): int32{.
+    cdecl, dynlib: dllName, importc: "lo_read".}
+proc lo_write*(conn: PPGconn, fd: int32, buf: cstring, length: int): int32{.
+    cdecl, dynlib: dllName, importc: "lo_write".}
+proc lo_lseek*(conn: PPGconn, fd: int32, offset: int32, whence: int32): int32{.
+    cdecl, dynlib: dllName, importc: "lo_lseek".}
+proc lo_creat*(conn: PPGconn, mode: int32): Oid{.cdecl, dynlib: dllName, 
+    importc: "lo_creat".}
+proc lo_tell*(conn: PPGconn, fd: int32): int32{.cdecl, dynlib: dllName, 
+    importc: "lo_tell".}
+proc lo_unlink*(conn: PPGconn, lobjId: Oid): int32{.cdecl, dynlib: dllName, 
+    importc: "lo_unlink".}
+proc lo_import*(conn: PPGconn, filename: cstring): Oid{.cdecl, dynlib: dllName, 
+    importc: "lo_import".}
+proc lo_export*(conn: PPGconn, lobjId: Oid, filename: cstring): int32{.cdecl, 
+    dynlib: dllName, importc: "lo_export".}
+
+proc PQmblen*(s: cstring, encoding: int32): int32{.cdecl, dynlib: dllName, 
+    importc: "PQmblen".}
+
+proc PQenv2encoding*(): int32{.cdecl, dynlib: dllName, importc: "PQenv2encoding".}
+
+proc PQsetdb(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME: cstring): ppgconn = 
+  result = PQsetdbLogin(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME, "", "")
+

lib/oldwrappers/sdl/sdl_gfx.nim

@@ -0,0 +1,421 @@
+
+#
+#  $Id: sdl_gfx.pas,v 1.3 2007/05/29 21:31:04 savage Exp $
+#
+#
+#
+#  $Log: sdl_gfx.pas,v $
+#  Revision 1.3  2007/05/29 21:31:04  savage
+#  Changes as suggested by Almindor for 64bit compatibility.
+#
+#  Revision 1.2  2007/05/20 20:30:18  savage
+#  Initial Changes to Handle 64 Bits
+#
+#  Revision 1.1  2005/01/03 19:08:32  savage
+#  Header for the SDL_Gfx library.
+#
+#
+#
+#
+
+import
+  sdl
+
+when defined(windows):
+  const SDLgfxLibName = "SDL_gfx.dll"
+elif defined(macosx):
+  const SDLgfxLibName = "libSDL_gfx.dylib"
+else:
+  const SDLgfxLibName = "libSDL_gfx.so"
+
+const                         # Some rates in Hz
+  FPS_UPPER_LIMIT* = 200
+  FPS_LOWER_LIMIT* = 1
+  FPS_DEFAULT* = 30           # ---- Defines
+  SMOOTHING_OFF* = 0
+  SMOOTHING_ON* = 1
+
+type 
+  PFPSmanager* = ptr TFPSmanager
+  TFPSmanager*{.final.} = object  # ---- Structures
+    framecount*: Uint32
+    rateticks*: float32
+    lastticks*: Uint32
+    rate*: Uint32
+
+  PColorRGBA* = ptr TColorRGBA
+  TColorRGBA*{.final.} = object 
+    r*: Uint8
+    g*: Uint8
+    b*: Uint8
+    a*: Uint8
+
+  PColorY* = ptr TColorY
+  TColorY*{.final.} = object  #
+                              #
+                              # SDL_framerate: framerate manager
+                              #
+                              # LGPL (c) A. Schiffler
+                              #
+                              #
+    y*: Uint8
+
+
+proc SDL_initFramerate*(manager: PFPSmanager){.cdecl, importc, dynlib: SDLgfxLibName.}
+proc SDL_setFramerate*(manager: PFPSmanager, rate: int): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+proc SDL_getFramerate*(manager: PFPSmanager): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc SDL_framerateDelay*(manager: PFPSmanager){.cdecl, importc, dynlib: SDLgfxLibName.}
+  #
+  #
+  # SDL_gfxPrimitives: graphics primitives for SDL
+  #
+  # LGPL (c) A. Schiffler
+  #
+  #
+  # Note: all ___Color routines expect the color to be in format 0xRRGGBBAA 
+  # Pixel 
+proc pixelColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, color: Uint32): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+proc pixelRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, r: Uint8, g: Uint8, 
+                b: Uint8, a: Uint8): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  # Horizontal line 
+proc hlineColor*(dst: PSDL_Surface, x1: Sint16, x2: Sint16, y: Sint16, 
+                 color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc hlineRGBA*(dst: PSDL_Surface, x1: Sint16, x2: Sint16, y: Sint16, r: Uint8, 
+                g: Uint8, b: Uint8, a: Uint8): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  # Vertical line 
+proc vlineColor*(dst: PSDL_Surface, x: Sint16, y1: Sint16, y2: Sint16, 
+                 color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc vlineRGBA*(dst: PSDL_Surface, x: Sint16, y1: Sint16, y2: Sint16, r: Uint8, 
+                g: Uint8, b: Uint8, a: Uint8): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  # Rectangle 
+proc rectangleColor*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                     y2: Sint16, color: Uint32): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+proc rectangleRGBA*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                    y2: Sint16, r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  # Filled rectangle (Box) 
+proc boxColor*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+               y2: Sint16, color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc boxRGBA*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, y2: Sint16, 
+              r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # Line 
+proc lineColor*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                y2: Sint16, color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc lineRGBA*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+               y2: Sint16, r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # AA Line 
+proc aalineColor*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                  y2: Sint16, color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc aalineRGBA*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                 y2: Sint16, r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  # Circle 
+proc circleColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, r: Sint16, 
+                  color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc circleRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, rad: Sint16, r: Uint8, 
+                 g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # AA Circle 
+proc aacircleColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, r: Sint16, 
+                    color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc aacircleRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, rad: Sint16, 
+                   r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # Filled Circle 
+proc filledCircleColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, r: Sint16, 
+                        color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc filledCircleRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, rad: Sint16, 
+                       r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # Ellipse 
+proc ellipseColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, rx: Sint16, 
+                   ry: Sint16, color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc ellipseRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, rx: Sint16, 
+                  ry: Sint16, r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  # AA Ellipse 
+proc aaellipseColor*(dst: PSDL_Surface, xc: Sint16, yc: Sint16, rx: Sint16, 
+                     ry: Sint16, color: Uint32): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+proc aaellipseRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, rx: Sint16, 
+                    ry: Sint16, r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  # Filled Ellipse 
+proc filledEllipseColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, rx: Sint16, 
+                         ry: Sint16, color: Uint32): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+proc filledEllipseRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, rx: Sint16, 
+                        ry: Sint16, r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  # Pie
+proc pieColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, rad: Sint16, 
+               start: Sint16, finish: Sint16, color: Uint32): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+proc pieRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, rad: Sint16, 
+              start: Sint16, finish: Sint16, r: Uint8, g: Uint8, b: Uint8, 
+              a: Uint8): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  # Filled Pie
+proc filledPieColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, rad: Sint16, 
+                     start: Sint16, finish: Sint16, color: Uint32): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+proc filledPieRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, rad: Sint16, 
+                    start: Sint16, finish: Sint16, r: Uint8, g: Uint8, b: Uint8, 
+                    a: Uint8): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  # Trigon
+proc trigonColor*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                  y2: Sint16, x3: Sint16, y3: Sint16, color: Uint32): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+proc trigonRGBA*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                 y2: Sint16, x3: Sint16, y3: Sint16, r: Uint8, g: Uint8, 
+                 b: Uint8, a: Uint8): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  # AA-Trigon
+proc aatrigonColor*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                    y2: Sint16, x3: Sint16, y3: Sint16, color: Uint32): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+proc aatrigonRGBA*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                   y2: Sint16, x3: Sint16, y3: Sint16, r: Uint8, g: Uint8, 
+                   b: Uint8, a: Uint8): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  # Filled Trigon
+proc filledTrigonColor*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                        y2: Sint16, x3: Sint16, y3: Sint16, color: Uint32): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+proc filledTrigonRGBA*(dst: PSDL_Surface, x1: Sint16, y1: Sint16, x2: Sint16, 
+                       y2: Sint16, x3: Sint16, y3: Sint16, r: Uint8, g: Uint8, 
+                       b: Uint8, a: Uint8): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  # Polygon
+proc polygonColor*(dst: PSDL_Surface, vx: PSint16, vy: PSint16, n: int, 
+                   color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc polygonRGBA*(dst: PSDL_Surface, vx: PSint16, vy: PSint16, n: int, r: Uint8, 
+                  g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # AA-Polygon
+proc aapolygonColor*(dst: PSDL_Surface, vx: PSint16, vy: PSint16, n: int, 
+                     color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc aapolygonRGBA*(dst: PSDL_Surface, vx: PSint16, vy: PSint16, n: int, 
+                    r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # Filled Polygon
+proc filledPolygonColor*(dst: PSDL_Surface, vx: PSint16, vy: PSint16, n: int, 
+                         color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc filledPolygonRGBA*(dst: PSDL_Surface, vx: PSint16, vy: PSint16, n: int, 
+                        r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # Bezier
+  # s = number of steps
+proc bezierColor*(dst: PSDL_Surface, vx: PSint16, vy: PSint16, n: int, s: int, 
+                  color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc bezierRGBA*(dst: PSDL_Surface, vx: PSint16, vy: PSint16, n: int, s: int, 
+                 r: Uint8, g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # Characters/Strings
+proc characterColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, c: char, 
+                     color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc characterRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, c: char, r: Uint8, 
+                    g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+proc stringColor*(dst: PSDL_Surface, x: Sint16, y: Sint16, c: cstring, 
+                  color: Uint32): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc stringRGBA*(dst: PSDL_Surface, x: Sint16, y: Sint16, c: cstring, r: Uint8, 
+                 g: Uint8, b: Uint8, a: Uint8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+proc gfxPrimitivesSetFont*(fontdata: Pointer, cw: int, ch: int){.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #
+  #
+  # SDL_imageFilter - bytes-image "filter" routines
+  # (uses inline x86 MMX optimizations if available)
+  #
+  # LGPL (c) A. Schiffler
+  #
+  #
+  # Comments:                                                                           
+  #  1.) MMX functions work best if all data blocks are aligned on a 32 bytes boundary. 
+  #  2.) Data that is not within an 8 byte boundary is processed using the C routine.   
+  #  3.) Convolution routines do not have C routines at this time.                      
+  # Detect MMX capability in CPU
+proc SDL_imageFilterMMXdetect*(): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  # Force use of MMX off (or turn possible use back on)
+proc SDL_imageFilterMMXoff*(){.cdecl, importc, dynlib: SDLgfxLibName.}
+proc SDL_imageFilterMMXon*(){.cdecl, importc, dynlib: SDLgfxLibName.}
+  #
+  # All routines return:
+  #   0   OK
+  #  -1   Error (internal error, parameter error)
+  #
+  #  SDL_imageFilterAdd: D = saturation255(S1 + S2)
+proc SDL_imageFilterAdd*(Src1: cstring, Src2: cstring, Dest: cstring, len: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterMean: D = S1/2 + S2/2
+proc SDL_imageFilterMean*(Src1: cstring, Src2: cstring, Dest: cstring, len: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterSub: D = saturation0(S1 - S2)
+proc SDL_imageFilterSub*(Src1: cstring, Src2: cstring, Dest: cstring, len: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterAbsDiff: D = | S1 - S2 |
+proc SDL_imageFilterAbsDiff*(Src1: cstring, Src2: cstring, Dest: cstring, 
+                             len: int): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterMult: D = saturation(S1 * S2)
+proc SDL_imageFilterMult*(Src1: cstring, Src2: cstring, Dest: cstring, len: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterMultNor: D = S1 * S2   (non-MMX)
+proc SDL_imageFilterMultNor*(Src1: cstring, Src2: cstring, Dest: cstring, 
+                             len: int): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterMultDivby2: D = saturation255(S1/2 * S2)
+proc SDL_imageFilterMultDivby2*(Src1: cstring, Src2: cstring, Dest: cstring, 
+                                len: int): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterMultDivby4: D = saturation255(S1/2 * S2/2)
+proc SDL_imageFilterMultDivby4*(Src1: cstring, Src2: cstring, Dest: cstring, 
+                                len: int): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterBitAnd: D = S1 & S2
+proc SDL_imageFilterBitAnd*(Src1: cstring, Src2: cstring, Dest: cstring, 
+                            len: int): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterBitOr: D = S1 | S2
+proc SDL_imageFilterBitOr*(Src1: cstring, Src2: cstring, Dest: cstring, len: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterDiv: D = S1 / S2   (non-MMX)
+proc SDL_imageFilterDiv*(Src1: cstring, Src2: cstring, Dest: cstring, len: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterBitNegation: D = !S
+proc SDL_imageFilterBitNegation*(Src1: cstring, Dest: cstring, len: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterAddByte: D = saturation255(S + C)
+proc SDL_imageFilterAddByte*(Src1: cstring, Dest: cstring, len: int, C: char): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterAddUint: D = saturation255(S + (uint)C)
+proc SDL_imageFilterAddUint*(Src1: cstring, Dest: cstring, len: int, C: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterAddByteToHalf: D = saturation255(S/2 + C)
+proc SDL_imageFilterAddByteToHalf*(Src1: cstring, Dest: cstring, len: int, 
+                                   C: char): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterSubByte: D = saturation0(S - C)
+proc SDL_imageFilterSubByte*(Src1: cstring, Dest: cstring, len: int, C: char): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterSubUint: D = saturation0(S - (uint)C)
+proc SDL_imageFilterSubUint*(Src1: cstring, Dest: cstring, len: int, C: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterShiftRight: D = saturation0(S >> N)
+proc SDL_imageFilterShiftRight*(Src1: cstring, Dest: cstring, len: int, N: char): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterShiftRightUint: D = saturation0((uint)S >> N)
+proc SDL_imageFilterShiftRightUint*(Src1: cstring, Dest: cstring, len: int, 
+                                    N: char): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterMultByByte: D = saturation255(S * C)
+proc SDL_imageFilterMultByByte*(Src1: cstring, Dest: cstring, len: int, C: char): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterShiftRightAndMultByByte: D = saturation255((S >> N) * C)
+proc SDL_imageFilterShiftRightAndMultByByte*(Src1: cstring, Dest: cstring, 
+    len: int, N: char, C: char): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterShiftLeftByte: D = (S << N)
+proc SDL_imageFilterShiftLeftByte*(Src1: cstring, Dest: cstring, len: int, 
+                                   N: char): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterShiftLeftUint: D = ((uint)S << N)
+proc SDL_imageFilterShiftLeftUint*(Src1: cstring, Dest: cstring, len: int, 
+                                   N: char): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterShiftLeft: D = saturation255(S << N)
+proc SDL_imageFilterShiftLeft*(Src1: cstring, Dest: cstring, len: int, N: char): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterBinarizeUsingThreshold: D = S >= T ? 255:0
+proc SDL_imageFilterBinarizeUsingThreshold*(Src1: cstring, Dest: cstring, 
+    len: int, T: char): int{.cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterClipToRange: D = (S >= Tmin) & (S <= Tmax) 255:0
+proc SDL_imageFilterClipToRange*(Src1: cstring, Dest: cstring, len: int, 
+                                 Tmin: int8, Tmax: int8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterNormalizeLinear: D = saturation255((Nmax - Nmin)/(Cmax - Cmin)*(S - Cmin) + Nmin)
+proc SDL_imageFilterNormalizeLinear*(Src1: cstring, Dest: cstring, len: int, 
+                                     Cmin: int, Cmax: int, Nmin: int, Nmax: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  # !!! NO C-ROUTINE FOR THESE FUNCTIONS YET !!! 
+  #  SDL_imageFilterConvolveKernel3x3Divide: Dij = saturation0and255( ... )
+proc SDL_imageFilterConvolveKernel3x3Divide*(Src: cstring, Dest: cstring, 
+    rows: int, columns: int, Kernel: PShortInt, Divisor: int8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterConvolveKernel5x5Divide: Dij = saturation0and255( ... )
+proc SDL_imageFilterConvolveKernel5x5Divide*(Src: cstring, Dest: cstring, 
+    rows: int, columns: int, Kernel: PShortInt, Divisor: int8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterConvolveKernel7x7Divide: Dij = saturation0and255( ... )
+proc SDL_imageFilterConvolveKernel7x7Divide*(Src: cstring, Dest: cstring, 
+    rows: int, columns: int, Kernel: PShortInt, Divisor: int8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterConvolveKernel9x9Divide: Dij = saturation0and255( ... )
+proc SDL_imageFilterConvolveKernel9x9Divide*(Src: cstring, Dest: cstring, 
+    rows: int, columns: int, Kernel: PShortInt, Divisor: int8): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterConvolveKernel3x3ShiftRight: Dij = saturation0and255( ... )
+proc SDL_imageFilterConvolveKernel3x3ShiftRight*(Src: cstring, Dest: cstring, 
+    rows: int, columns: int, Kernel: PShortInt, NRightShift: char): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterConvolveKernel5x5ShiftRight: Dij = saturation0and255( ... )
+proc SDL_imageFilterConvolveKernel5x5ShiftRight*(Src: cstring, Dest: cstring, 
+    rows: int, columns: int, Kernel: PShortInt, NRightShift: char): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterConvolveKernel7x7ShiftRight: Dij = saturation0and255( ... )
+proc SDL_imageFilterConvolveKernel7x7ShiftRight*(Src: cstring, Dest: cstring, 
+    rows: int, columns: int, Kernel: PShortInt, NRightShift: char): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterConvolveKernel9x9ShiftRight: Dij = saturation0and255( ... )
+proc SDL_imageFilterConvolveKernel9x9ShiftRight*(Src: cstring, Dest: cstring, 
+    rows: int, columns: int, Kernel: PShortInt, NRightShift: char): int{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterSobelX: Dij = saturation255( ... )
+proc SDL_imageFilterSobelX*(Src: cstring, Dest: cstring, rows: int, columns: int): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  #  SDL_imageFilterSobelXShiftRight: Dij = saturation255( ... )
+proc SDL_imageFilterSobelXShiftRight*(Src: cstring, Dest: cstring, rows: int, 
+                                      columns: int, NRightShift: char): int{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  # Align/restore stack to 32 byte boundary -- Functionality untested! --
+proc SDL_imageFilterAlignStack*(){.cdecl, importc, dynlib: SDLgfxLibName.}
+proc SDL_imageFilterRestoreStack*(){.cdecl, importc, dynlib: SDLgfxLibName.}
+  #
+  #
+  # SDL_rotozoom - rotozoomer
+  #
+  # LGPL (c) A. Schiffler
+  #
+  #
+  # 
+  # 
+  # rotozoomSurface()
+  #
+  # Rotates and zoomes a 32bit or 8bit 'src' surface to newly created 'dst' surface.
+  # 'angle' is the rotation in degrees. 'zoom' a scaling factor. If 'smooth' is 1
+  # then the destination 32bit surface is anti-aliased. If the surface is not 8bit
+  # or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
+  #
+  #
+proc rotozoomSurface*(src: PSDL_Surface, angle: float64, zoom: float64, 
+                      smooth: int): PSDL_Surface{.cdecl, importc, dynlib: SDLgfxLibName.}
+proc rotozoomSurfaceXY*(src: PSDL_Surface, angle: float64, zoomx: float64, 
+                        zoomy: float64, smooth: int): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+  # Returns the size of the target surface for a rotozoomSurface() call 
+proc rotozoomSurfaceSize*(width: int, height: int, angle: float64, 
+                          zoom: float64, dstwidth: var int, dstheight: var int){.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+proc rotozoomSurfaceSizeXY*(width: int, height: int, angle: float64, 
+                            zoomx: float64, zoomy: float64, dstwidth: var int, 
+                            dstheight: var int){.cdecl, importc, dynlib: SDLgfxLibName.}
+  #
+  #
+  # zoomSurface()
+  #
+  # Zoomes a 32bit or 8bit 'src' surface to newly created 'dst' surface.
+  # 'zoomx' and 'zoomy' are scaling factors for width and height. If 'smooth' is 1
+  # then the destination 32bit surface is anti-aliased. If the surface is not 8bit
+  # or 32bit RGBA/ABGR it will be converted into a 32bit RGBA format on the fly.
+  #
+  #
+proc zoomSurface*(src: PSDL_Surface, zoomx: float64, zoomy: float64, smooth: int): PSDL_Surface{.
+    cdecl, importc, dynlib: SDLgfxLibName.}
+  # Returns the size of the target surface for a zoomSurface() call 
+proc zoomSurfaceSize*(width: int, height: int, zoomx: float64, zoomy: float64, 
+                      dstwidth: var int, dstheight: var int){.cdecl, 
+    importc, dynlib: SDLgfxLibName.}
+# implementation

lib/oldwrappers/sdl/sdl_image.nim

@@ -0,0 +1,227 @@
+
+#
+#  $Id: sdl_image.pas,v 1.14 2007/05/29 21:31:13 savage Exp $
+#  
+#
+#******************************************************************************
+#                                                                              
+#       Borland Delphi SDL_Image - An example image loading library for use    
+#                                  with SDL                                    
+#       Conversion of the Simple DirectMedia Layer Image Headers               
+#                                                                              
+# Portions created by Sam Lantinga <slouken@devolution.com> are                
+# Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga                     
+# 5635-34 Springhouse Dr.                                                      
+# Pleasanton, CA 94588 (USA)                                                   
+#                                                                              
+# All Rights Reserved.                                                         
+#                                                                              
+# The original files are : SDL_image.h                                         
+#                                                                              
+# The initial developer of this Pascal code was :                              
+# Matthias Thoma <ma.thoma@gmx.de>                                             
+#                                                                              
+# Portions created by Matthias Thoma are                                       
+# Copyright (C) 2000 - 2001 Matthias Thoma.                                    
+#                                                                              
+#                                                                              
+# Contributor(s)                                                               
+# --------------                                                               
+# Dominique Louis <Dominique@SavageSoftware.com.au>                            
+#                                                                              
+# Obtained through:                                                            
+# Joint Endeavour of Delphi Innovators ( Project JEDI )                        
+#                                                                              
+# You may retrieve the latest version of this file at the Project              
+# JEDI home page, located at http://delphi-jedi.org                            
+#                                                                              
+# The contents of this file are used with permission, subject to               
+# the Mozilla Public License Version 1.1 (the "License"); you may              
+# not use this file except in compliance with the License. You may             
+# obtain a copy of the License at                                              
+# http://www.mozilla.org/MPL/MPL-1.1.html                                      
+#                                                                              
+# Software distributed under the License is distributed on an                  
+# "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or               
+# implied. See the License for the specific language governing                 
+# rights and limitations under the License.                                    
+#                                                                              
+# Description                                                                  
+# -----------                                                                  
+#   A simple library to load images of various formats as SDL surfaces         
+#                                                                              
+# Requires                                                                     
+# --------                                                                     
+#   SDL.pas in your search path.                                               
+#                                                                              
+# Programming Notes                                                            
+# -----------------                                                            
+#   See the Aliens Demo on how to make use of this libaray                     
+#                                                                              
+# Revision History                                                             
+# ----------------                                                             
+#   April    02 2001 - MT : Initial Translation                                
+#                                                                              
+#   May      08 2001 - DL : Added ExternalSym derectives and copyright header  
+#                                                                              
+#   April   03 2003 - DL : Added jedi-sdl.inc include file to support more     
+#                          Pascal compilers. Initial support is now included   
+#                          for GnuPascal, VirtualPascal, TMT and obviously     
+#                          continue support for Delphi Kylix and FreePascal.   
+#                                                                              
+#   April   08 2003 - MK : Aka Mr Kroket - Added Better FPC support            
+#                                                                              
+#   April   24 2003 - DL : under instruction from Alexey Barkovoy, I have added
+#                          better TMT Pascal support and under instruction     
+#                          from Prof. Abimbola Olowofoyeku (The African Chief),
+#                          I have added better Gnu Pascal support              
+#                                                                              
+#   April   30 2003 - DL : under instruction from David Mears AKA              
+#                          Jason Siletto, I have added FPC Linux support.      
+#                          This was compiled with fpc 1.1, so remember to set  
+#                          include file path. ie. -Fi/usr/share/fpcsrc/rtl/*   
+#                                                                              
+#
+#  $Log: sdl_image.pas,v $
+#  Revision 1.14  2007/05/29 21:31:13  savage
+#  Changes as suggested by Almindor for 64bit compatibility.
+#
+#  Revision 1.13  2007/05/20 20:30:54  savage
+#  Initial Changes to Handle 64 Bits
+#
+#  Revision 1.12  2006/12/02 00:14:40  savage
+#  Updated to latest version
+#
+#  Revision 1.11  2005/04/10 18:22:59  savage
+#  Changes as suggested by Michalis, thanks.
+#
+#  Revision 1.10  2005/04/10 11:48:33  savage
+#  Changes as suggested by Michalis, thanks.
+#
+#  Revision 1.9  2005/01/05 01:47:07  savage
+#  Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively.
+#
+#  Revision 1.8  2005/01/04 23:14:44  savage
+#  Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively.
+#
+#  Revision 1.7  2005/01/01 02:03:12  savage
+#  Updated to v1.2.4
+#
+#  Revision 1.6  2004/08/14 22:54:30  savage
+#  Updated so that Library name defines are correctly defined for MacOS X.
+#
+#  Revision 1.5  2004/05/10 14:10:04  savage
+#  Initial MacOS X support. Fixed defines for MACOS ( Classic ) and DARWIN ( MacOS X ).
+#
+#  Revision 1.4  2004/04/13 09:32:08  savage
+#  Changed Shared object names back to just the .so extension to avoid conflicts on various Linux/Unix distros. Therefore developers will need to create Symbolic links to the actual Share Objects if necessary.
+#
+#  Revision 1.3  2004/04/01 20:53:23  savage
+#  Changed Linux Shared Object names so they reflect the Symbolic Links that are created when installing the RPMs from the SDL site.
+#
+#  Revision 1.2  2004/03/30 20:23:28  savage
+#  Tidied up use of UNIX compiler directive.
+#
+#  Revision 1.1  2004/02/14 23:35:42  savage
+#  version 1 of sdl_image, sdl_mixer and smpeg.
+#
+#
+#
+#******************************************************************************
+
+import
+  sdl
+
+when defined(windows):
+  const SDL_ImageLibName = "SDL_Image.dll"
+elif defined(macosx):
+  const SDL_ImageLibName = "libSDL_image-1.2.0.dylib"
+else:
+  const SDL_ImageLibName = "libSDL_image.so"
+
+const
+  SDL_IMAGE_MAJOR_VERSION* = 1'i8
+  SDL_IMAGE_MINOR_VERSION* = 2'i8
+  SDL_IMAGE_PATCHLEVEL* = 5'i8
+  
+# This macro can be used to fill a version structure with the compile-time
+#  version of the SDL_image library. 
+
+proc SDL_IMAGE_VERSION*(X: var TSDL_Version)
+  # This function gets the version of the dynamically linked SDL_image library.
+  #   it should NOT be used to fill a version structure, instead you should
+  #   use the SDL_IMAGE_VERSION() macro.
+  # 
+proc IMG_Linked_Version*(): PSDL_version{.importc, dynlib: SDL_ImageLibName.}
+  # Load an image from an SDL data source.
+  #   The 'type' may be one of: "BMP", "GIF", "PNG", etc.
+  #
+  #   If the image format supports a transparent pixel, SDL will set the
+  #   colorkey for the surface.  You can enable RLE acceleration on the
+  #   surface afterwards by calling:
+  #        SDL_SetColorKey(image, SDL_RLEACCEL, image.format.colorkey);
+  #
+proc IMG_LoadTyped_RW*(src: PSDL_RWops, freesrc: int, theType: cstring): PSDL_Surface{.
+    cdecl, importc, dynlib: SDL_ImageLibName.}
+  # Convenience functions 
+proc IMG_Load*(theFile: cstring): PSDL_Surface{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_Load_RW*(src: PSDL_RWops, freesrc: int): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+  # Invert the alpha of a surface for use with OpenGL
+  #  This function is now a no-op, and only provided for backwards compatibility. 
+proc IMG_InvertAlpha*(theOn: int): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+  # Functions to detect a file type, given a seekable source 
+proc IMG_isBMP*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isGIF*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isJPG*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isLBM*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isPCX*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isPNG*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isPNM*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isTIF*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isXCF*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isXPM*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+proc IMG_isXV*(src: PSDL_RWops): int{.cdecl, importc, dynlib: SDL_ImageLibName.}
+  # Individual loading functions 
+proc IMG_LoadBMP_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadGIF_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadJPG_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadLBM_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadPCX_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadPNM_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadPNG_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadTGA_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadTIF_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadXCF_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadXPM_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_LoadXV_RW*(src: PSDL_RWops): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+proc IMG_ReadXPMFromArray*(xpm: cstringArray): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDL_ImageLibName.}
+  # Error Macros 
+  # We'll use SDL for reporting errors 
+proc IMG_SetError*(fmt: cstring)
+proc IMG_GetError*(): cstring
+# implementation
+
+proc SDL_IMAGE_VERSION(X: var TSDL_Version) = 
+  X.major = SDL_IMAGE_MAJOR_VERSION
+  X.minor = SDL_IMAGE_MINOR_VERSION
+  X.patch = SDL_IMAGE_PATCHLEVEL
+
+proc IMG_SetError(fmt: cstring) = 
+  SDL_SetError(fmt)
+
+proc IMG_GetError(): cstring = 
+  result = SDL_GetError()

lib/oldwrappers/sdl/sdl_mixer.nim

@@ -0,0 +1,737 @@
+
+#******************************************************************************
+#
+#  $Id: sdl_mixer.pas,v 1.18 2007/05/29 21:31:44 savage Exp $
+#
+#
+#
+#       Borland Delphi SDL_Mixer - Simple DirectMedia Layer Mixer Library
+#       Conversion of the Simple DirectMedia Layer Headers
+#
+# Portions created by Sam Lantinga <slouken@devolution.com> are
+# Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+# 5635-34 Springhouse Dr.
+# Pleasanton, CA 94588 (USA)
+#
+# All Rights Reserved.
+#
+# The original files are : SDL_mixer.h
+#                          music_cmd.h
+#                          wavestream.h
+#                          timidity.h
+#                          playmidi.h
+#                          music_ogg.h
+#                          mikmod.h
+#
+# The initial developer of this Pascal code was :
+# Dominqiue Louis <Dominique@SavageSoftware.com.au>
+#
+# Portions created by Dominqiue Louis are
+# Copyright (C) 2000 - 2001 Dominqiue Louis.
+#
+#
+# Contributor(s)
+# --------------
+# Matthias Thoma <ma.thoma@gmx.de>
+#
+# Obtained through:
+# Joint Endeavour of Delphi Innovators ( Project JEDI )
+#
+# You may retrieve the latest version of this file at the Project
+# JEDI home page, located at http://delphi-jedi.org
+#
+# The contents of this file are used with permission, subject to
+# the Mozilla Public License Version 1.1 (the "License"); you may
+# not use this file except in compliance with the License. You may
+# obtain a copy of the License at
+# http://www.mozilla.org/MPL/MPL-1.1.html
+#
+# Software distributed under the License is distributed on an
+# "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# Description
+# -----------
+#
+#
+#
+#
+#
+#
+#
+# Requires
+# --------
+#   SDL.pas & SMPEG.pas somewhere within your search path.
+#
+# Programming Notes
+# -----------------
+#   See the Aliens Demo to see how this library is used
+#
+# Revision History
+# ----------------
+#   April    02 2001 - DL : Initial Translation
+#
+#  February  02 2002 - DL : Update to version 1.2.1
+#
+#   April   03 2003 - DL : Added jedi-sdl.inc include file to support more
+#                          Pascal compilers. Initial support is now included
+#                          for GnuPascal, VirtualPascal, TMT and obviously
+#                          continue support for Delphi Kylix and FreePascal.
+#
+#   April   24 2003 - DL : under instruction from Alexey Barkovoy, I have added
+#                          better TMT Pascal support and under instruction
+#                          from Prof. Abimbola Olowofoyeku (The African Chief),
+#                          I have added better Gnu Pascal support
+#
+#   April   30 2003 - DL : under instruction from David Mears AKA
+#                          Jason Siletto, I have added FPC Linux support.
+#                          This was compiled with fpc 1.1, so remember to set
+#                          include file path. ie. -Fi/usr/share/fpcsrc/rtl/*
+#
+#
+#  $Log: sdl_mixer.pas,v $
+#  Revision 1.18  2007/05/29 21:31:44  savage
+#  Changes as suggested by Almindor for 64bit compatibility.
+#
+#  Revision 1.17  2007/05/20 20:31:17  savage
+#  Initial Changes to Handle 64 Bits
+#
+#  Revision 1.16  2006/12/02 00:16:17  savage
+#  Updated to latest version
+#
+#  Revision 1.15  2005/04/10 11:48:33  savage
+#  Changes as suggested by Michalis, thanks.
+#
+#  Revision 1.14  2005/02/24 20:20:07  savage
+#  Changed definition of MusicType and added GetMusicType function
+#
+#  Revision 1.13  2005/01/05 01:47:09  savage
+#  Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively.
+#
+#  Revision 1.12  2005/01/04 23:14:56  savage
+#  Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively.
+#
+#  Revision 1.11  2005/01/01 02:05:19  savage
+#  Updated to v1.2.6
+#
+#  Revision 1.10  2004/09/12 21:45:17  savage
+#  Robert Reed spotted that Mix_SetMusicPosition was missing from the conversion, so this has now been added.
+#
+#  Revision 1.9  2004/08/27 21:48:24  savage
+#  IFDEFed out Smpeg support on MacOS X
+#
+#  Revision 1.8  2004/08/14 22:54:30  savage
+#  Updated so that Library name defines are correctly defined for MacOS X.
+#
+#  Revision 1.7  2004/05/10 14:10:04  savage
+#  Initial MacOS X support. Fixed defines for MACOS ( Classic ) and DARWIN ( MacOS X ).
+#
+#  Revision 1.6  2004/04/13 09:32:08  savage
+#  Changed Shared object names back to just the .so extension to avoid conflicts on various Linux/Unix distros. Therefore developers will need to create Symbolic links to the actual Share Objects if necessary.
+#
+#  Revision 1.5  2004/04/01 20:53:23  savage
+#  Changed Linux Shared Object names so they reflect the Symbolic Links that are created when installing the RPMs from the SDL site.
+#
+#  Revision 1.4  2004/03/31 22:20:02  savage
+#  Windows unit not used in this file, so it was removed to keep the code tidy.
+#
+#  Revision 1.3  2004/03/31 10:05:08  savage
+#  Better defines for Endianess under FreePascal and Borland compilers.
+#
+#  Revision 1.2  2004/03/30 20:23:28  savage
+#  Tidied up use of UNIX compiler directive.
+#
+#  Revision 1.1  2004/02/14 23:35:42  savage
+#  version 1 of sdl_image, sdl_mixer and smpeg.
+#
+#
+#
+#******************************************************************************
+
+import
+  sdl, smpeg
+
+when defined(windows):
+  const SDL_MixerLibName = "SDL_mixer.dll"
+elif defined(macosx):
+  const SDL_MixerLibName = "libSDL_mixer-1.2.0.dylib"
+else:
+  const SDL_MixerLibName = "libSDL_mixer.so"
+
+const
+  SDL_MIXER_MAJOR_VERSION* = 1'i8
+  SDL_MIXER_MINOR_VERSION* = 2'i8
+  SDL_MIXER_PATCHLEVEL* = 7'i8   # Backwards compatibility
+  MIX_MAJOR_VERSION* = SDL_MIXER_MAJOR_VERSION
+  MIX_MINOR_VERSION* = SDL_MIXER_MINOR_VERSION
+  MIX_PATCHLEVEL* = SDL_MIXER_PATCHLEVEL # SDL_Mixer.h constants
+                                         # The default mixer has 8 simultaneous mixing channels
+  MIX_CHANNELS* = 8           # Good default values for a PC soundcard
+  MIX_DEFAULT_FREQUENCY* = 22050
+
+when defined(IA32):
+  const
+    MIX_DEFAULT_FORMAT* = AUDIO_S16LSB
+else:
+  const
+    MIX_DEFAULT_FORMAT* = AUDIO_S16MSB
+const
+  MIX_DEFAULT_CHANNELS* = 2
+  MIX_MAX_VOLUME* = 128       # Volume of a chunk
+  PATH_MAX* = 255             # mikmod.h constants
+                              #*
+                              #  * Library version
+                              #  *
+  LIBMIKMOD_VERSION_MAJOR* = 3
+  LIBMIKMOD_VERSION_MINOR* = 1
+  LIBMIKMOD_REVISION* = 8
+  LIBMIKMOD_VERSION* = ((LIBMIKMOD_VERSION_MAJOR shl 16) or
+      (LIBMIKMOD_VERSION_MINOR shl 8) or (LIBMIKMOD_REVISION))
+
+type                          #music_cmd.h types
+  PMusicCMD* = ptr TMusicCMD
+  TMusicCMD*{.final.} = object  #wavestream.h types
+    filename*: array[0..PATH_MAX - 1, char]
+    cmd*: array[0..PATH_MAX - 1, char]
+    pid*: TSYS_ThreadHandle
+
+  PWAVStream* = ptr TWAVStream
+  TWAVStream*{.final.} = object  #playmidi.h types
+    wavefp*: Pointer
+    start*: int32
+    stop*: int32
+    cvt*: TSDL_AudioCVT
+
+  PMidiEvent* = ptr TMidiEvent
+  TMidiEvent*{.final.} = object
+    time*: int32
+    channel*: uint8
+    typ*: uint8
+    a*: uint8
+    b*: uint8
+
+  PMidiSong* = ptr TMidiSong
+  TMidiSong*{.final.} = object  #music_ogg.h types
+    samples*: int32
+    events*: PMidiEvent
+
+  POGG_Music* = ptr TOGG_Music
+  TOGG_Music*{.final.} = object  # mikmod.h types
+                                 #*
+                                 #  * Error codes
+                                 #  *
+    playing*: int
+    volume*: int              #vf: OggVorbis_File;
+    section*: int
+    cvt*: TSDL_AudioCVT
+    len_available*: int
+    snd_available*: PUint8
+
+  TErrorEnum* = enum
+    MMERR_OPENING_FILE, MMERR_OUT_OF_MEMORY, MMERR_DYNAMIC_LINKING,
+    MMERR_SAMPLE_TOO_BIG, MMERR_OUT_OF_HANDLES, MMERR_UNKNOWN_WAVE_TYPE,
+    MMERR_LOADING_PATTERN, MMERR_LOADING_TRACK, MMERR_LOADING_HEADER,
+    MMERR_LOADING_SAMPLEINFO, MMERR_NOT_A_MODULE, MMERR_NOT_A_STREAM,
+    MMERR_MED_SYNTHSAMPLES, MMERR_ITPACK_INVALID_DATA, MMERR_DETECTING_DEVICE,
+    MMERR_INVALID_DEVICE, MMERR_INITIALIZING_MIXER, MMERR_OPENING_AUDIO,
+    MMERR_8BIT_ONLY, MMERR_16BIT_ONLY, MMERR_STEREO_ONLY, MMERR_ULAW,
+    MMERR_NON_BLOCK, MMERR_AF_AUDIO_PORT, MMERR_AIX_CONFIG_INIT,
+    MMERR_AIX_CONFIG_CONTROL, MMERR_AIX_CONFIG_START, MMERR_GUS_SETTINGS,
+    MMERR_GUS_RESET, MMERR_GUS_TIMER, MMERR_HP_SETSAMPLESIZE, MMERR_HP_SETSPEED,
+    MMERR_HP_CHANNELS, MMERR_HP_AUDIO_OUTPUT, MMERR_HP_AUDIO_DESC,
+    MMERR_HP_BUFFERSIZE, MMERR_OSS_SETFRAGMENT, MMERR_OSS_SETSAMPLESIZE,
+    MMERR_OSS_SETSTEREO, MMERR_OSS_SETSPEED, MMERR_SGI_SPEED, MMERR_SGI_16BIT,
+    MMERR_SGI_8BIT, MMERR_SGI_STEREO, MMERR_SGI_MONO, MMERR_SUN_INIT,
+    MMERR_OS2_MIXSETUP, MMERR_OS2_SEMAPHORE, MMERR_OS2_TIMER, MMERR_OS2_THREAD,
+    MMERR_DS_PRIORITY, MMERR_DS_BUFFER, MMERR_DS_FORMAT, MMERR_DS_NOTIFY,
+    MMERR_DS_EVENT, MMERR_DS_THREAD, MMERR_DS_UPDATE, MMERR_WINMM_HANDLE,
+    MMERR_WINMM_ALLOCATED, MMERR_WINMM_DEVICEID, MMERR_WINMM_FORMAT,
+    MMERR_WINMM_UNKNOWN, MMERR_MAC_SPEED, MMERR_MAC_START, MMERR_MAX
+  PMODULE* = ptr TMODULE
+  TMODULE*{.final.} = object
+  PUNIMOD* = ptr TUNIMOD
+  TUNIMOD* = TMODULE          #SDL_mixer.h types
+                              # The internal format for an audio chunk
+  PMix_Chunk* = ptr TMix_Chunk
+  TMix_Chunk*{.final.} = object
+    allocated*: int
+    abuf*: PUint8
+    alen*: Uint32
+    volume*: Uint8            # Per-sample volume, 0-128
+
+  Mix_Chunk* = TMix_Chunk     # The different fading types supported
+  TMix_Fading* = enum
+    MIX_NO_FADING, MIX_FADING_OUT, MIX_FADING_IN
+  Mix_Fading* = TMix_Fading
+  TMix_MusicType* = enum
+    MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG, MUS_MP3
+  Mix_MusicType* = TMix_MusicType #
+                                  #  TMusicUnion = record
+                                  #    case XXX: Byte of
+                                  #      0 : ( cmd : PMusicCMD );
+                                  #      1 : ( wave : PWAVStream );
+                                  #      2 : ( module : PUNIMOD );
+                                  #      3 : ( midi : TMidiSong );
+                                  #      4 : ( ogg : POGG_music );
+                                  #      {$IFNDEF DARWIN}
+                                  #      5 : ( mp3 : PSMPEG );
+                                  #      {$ENDIF}
+                                  #  end;
+  PMix_Music* = ptr TMix_Music
+  TMix_Music*{.final.} = object  # The internal format for a music chunk interpreted via mikmod
+    typ*: TMix_MusicType      # other fields are not aviable
+                              #    data : TMusicUnion;
+                              #    fading : TMix_Fading;
+                              #    fade_volume : integer;
+                              #    fade_step : integer;
+                              #    fade_steps : integer;
+                              #    error : integer;
+
+  TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{.
+      cdecl.} # This macro can be used to fill a version structure with the compile-time
+              #  version of the SDL_mixer library.
+
+proc SDL_MIXER_VERSION*(X: var TSDL_Version)
+  # This function gets the version of the dynamically linked SDL_mixer library.
+  #     It should NOT be used to fill a version structure, instead you should use the
+  #     SDL_MIXER_VERSION() macro.
+proc Mix_Linked_Version*(): PSDL_version{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Open the mixer with a certain audio format
+proc Mix_OpenAudio*(frequency: int, format: Uint16, channels: int,
+                    chunksize: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Dynamically change the number of channels managed by the mixer.
+  #   If decreasing the number of channels, the upper channels are
+  #   stopped.
+  #   This function returns the new number of allocated channels.
+  #
+proc Mix_AllocateChannels*(numchannels: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Find out what the actual audio device parameters are.
+  #   This function returns 1 if the audio has been opened, 0 otherwise.
+  #
+proc Mix_QuerySpec*(frequency: var int, format: var Uint16, channels: var int): int{.
+    cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Load a wave file or a music (.mod .s3m .it .xm) file
+proc Mix_LoadWAV_RW*(src: PSDL_RWops, freesrc: int): PMix_Chunk{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_LoadWAV*(filename: cstring): PMix_Chunk
+proc Mix_LoadMUS*(filename: cstring): PMix_Music{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Load a wave file of the mixer format from a memory buffer
+proc Mix_QuickLoad_WAV*(mem: PUint8): PMix_Chunk{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Free an audio chunk previously loaded
+proc Mix_FreeChunk*(chunk: PMix_Chunk){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_FreeMusic*(music: PMix_Music){.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Find out the music format of a mixer music, or the currently playing
+  #   music, if 'music' is NULL.
+proc Mix_GetMusicType*(music: PMix_Music): TMix_MusicType{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Set a function that is called after all mixing is performed.
+  #   This can be used to provide real-time visual display of the audio stream
+  #   or add a custom mixer filter for the stream data.
+  #
+proc Mix_SetPostMix*(mix_func: TMixFunction, arg: Pointer){.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Add your own music player or additional mixer function.
+  #   If 'mix_func' is NULL, the default music player is re-enabled.
+  #
+proc Mix_HookMusic*(mix_func: TMixFunction, arg: Pointer){.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Add your own callback when the music has finished playing.
+  #
+proc Mix_HookMusicFinished*(music_finished: Pointer){.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Get a pointer to the user data for the current music hook
+proc Mix_GetMusicHookData*(): Pointer{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  #* Add your own callback when a channel has finished playing. NULL
+  # * to disable callback.*
+type
+  TChannel_finished* = proc (channel: int){.cdecl.}
+
+proc Mix_ChannelFinished*(channel_finished: TChannel_finished){.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+const
+  MIX_CHANNEL_POST* = - 2
+    # This is the format of a special effect callback:
+    #      myeffect(int chan, void *stream, int len, void *udata);
+    #
+    #    (chan) is the channel number that your effect is affecting. (stream) is
+    #     the buffer of data to work upon. (len) is the size of (stream), and
+    #     (udata) is a user-defined bit of data, which you pass as the last arg of
+    #     Mix_RegisterEffect(), and is passed back unmolested to your callback.
+    #     Your effect changes the contents of (stream) based on whatever parameters
+    #     are significant, or just leaves it be, if you prefer. You can do whatever
+    #     you like to the buffer, though, and it will continue in its changed state
+    #     down the mixing pipeline, through any other effect functions, then finally
+    #     to be mixed with the rest of the channels and music for the final output
+    #     stream.
+    #
+
+type
+  TMix_EffectFunc* = proc (chan: int, stream: Pointer, length: int,
+                           udata: Pointer): Pointer{.cdecl.}
+    #   * This is a callback that signifies that a channel has finished all its
+    #   *  loops and has completed playback. This gets called if the buffer
+    #   *  plays out normally, or if you call Mix_HaltChannel(), implicitly stop
+    #   *  a channel via Mix_AllocateChannels(), or unregister a callback while
+    #   *  it's still playing.
+  TMix_EffectDone* = proc (chan: int, udata: Pointer): Pointer{.cdecl.}
+    #* Register a special effect function. At mixing time, the channel data is
+    #  *  copied into a buffer and passed through each registered effect function.
+    #  *  After it passes through all the functions, it is mixed into the final
+    #  *  output stream. The copy to buffer is performed once, then each effect
+    #  *  function performs on the output of the previous effect. Understand that
+    #  *  this extra copy to a buffer is not performed if there are no effects
+    #  *  registered for a given chunk, which saves CPU cycles, and any given
+    #  *  effect will be extra cycles, too, so it is crucial that your code run
+    #  *  fast. Also note that the data that your function is given is in the
+    #  *  format of the sound device, and not the format you gave to Mix_OpenAudio(),
+    #  *  although they may in reality be the same. This is an unfortunate but
+    #  *  necessary speed concern. Use Mix_QuerySpec() to determine if you can
+    #  *  handle the data before you register your effect, and take appropriate
+    #  *  actions.
+    #  * You may also specify a callback (Mix_EffectDone_t) that is called when
+    #  *  the channel finishes playing. This gives you a more fine-grained control
+    #  *  than Mix_ChannelFinished(), in case you need to free effect-specific
+    #  *  resources, etc. If you don't need this, you can specify NULL.
+    #  * You may set the callbacks before or after calling Mix_PlayChannel().
+    #  * Things like Mix_SetPanning() are just internal special effect functions,
+    #  *  so if you are using that, you've already incurred the overhead of a copy
+    #  *  to a separate buffer, and that these effects will be in the queue with
+    #  *  any functions you've registered. The list of registered effects for a
+    #  *  channel is reset when a chunk finishes playing, so you need to explicitly
+    #  *  set them with each call to Mix_PlayChannel*().
+    #  * You may also register a special effect function that is to be run after
+    #  *  final mixing occurs. The rules for these callbacks are identical to those
+    #  *  in Mix_RegisterEffect, but they are run after all the channels and the
+    #  *  music have been mixed into a single stream, whereas channel-specific
+    #  *  effects run on a given channel before any other mixing occurs. These
+    #  *  global effect callbacks are call "posteffects". Posteffects only have
+    #  *  their Mix_EffectDone_t function called when they are unregistered (since
+    #  *  the main output stream is never "done" in the same sense as a channel).
+    #  *  You must unregister them manually when you've had enough. Your callback
+    #  *  will be told that the channel being mixed is (MIX_CHANNEL_POST) if the
+    #  *  processing is considered a posteffect.
+    #  *
+    #  * After all these effects have finished processing, the callback registered
+    #  *  through Mix_SetPostMix() runs, and then the stream goes to the audio
+    #  *  device.
+    #  *
+    #  * returns zero if error (no such channel), nonzero if added.
+    #  *  Error messages can be retrieved from Mix_GetError().
+    #  *
+
+proc Mix_RegisterEffect*(chan: int, f: TMix_EffectFunc, d: TMix_EffectDone,
+                         arg: Pointer): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  #* You may not need to call this explicitly, unless you need to stop an
+  # *  effect from processing in the middle of a chunk's playback.
+  # * Posteffects are never implicitly unregistered as they are for channels,
+  # *  but they may be explicitly unregistered through this function by
+  # *  specifying MIX_CHANNEL_POST for a channel.
+  # * returns zero if error (no such channel or effect), nonzero if removed.
+  # *  Error messages can be retrieved from Mix_GetError().
+  # *
+proc Mix_UnregisterEffect*(channel: int, f: TMix_EffectFunc): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  #* You may not need to call this explicitly, unless you need to stop all
+  #  * effects from processing in the middle of a chunk's playback. Note that
+  #  * this will also shut off some internal effect processing, since
+  #  * Mix_SetPanning( ) and others may use this API under the hood.This is
+  #  * called internally when a channel completes playback.
+  #  * Posteffects are never implicitly unregistered as they are for channels,
+  #  * but they may be explicitly unregistered through this function by
+  #  * specifying MIX_CHANNEL_POST for a channel.
+  #  * returns zero if error( no such channel ), nonzero if all effects removed.
+  #  * Error messages can be retrieved from Mix_GetError( ).
+  #  *
+proc Mix_UnregisterAllEffects*(channel: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+const
+  MIX_EFFECTSMAXSPEED* = "MIX_EFFECTSMAXSPEED"
+    #  * These are the internally - defined mixing effects.They use the same API that
+    #  * effects defined in the application use, but are provided here as a
+    #  * convenience.Some effects can reduce their quality or use more memory in
+    #  * the name of speed; to enable this, make sure the environment variable
+    #  * MIX_EFFECTSMAXSPEED( see above ) is defined before you call
+    #  * Mix_OpenAudio( ).
+    #  *
+    #* set the panning of a channel.The left and right channels are specified
+    #  * as integers between 0 and 255, quietest to loudest, respectively.
+    #  *
+    #  * Technically, this is just individual volume control for a sample with
+    #  * two( stereo )channels, so it can be used for more than just panning.
+    #  * if you want real panning, call it like this :
+    #  *
+    #  * Mix_SetPanning( channel, left, 255 - left );
+    #  *
+    #  * ...which isn't so hard.
+    #  *
+    #  * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
+    #  * the panning will be done to the final mixed stream before passing it on
+    #  * to the audio device.
+    #  *
+    #  * This uses the Mix_RegisterEffect( )API internally, and returns without
+    #  * registering the effect function if the audio device is not configured
+    #  * for stereo output.Setting both( left ) and ( right ) to 255 causes this
+    #  * effect to be unregistered, since that is the data's normal state.
+    #  *
+    #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+    #  * nonzero if panning effect enabled.Note that an audio device in mono
+    #  * mode is a no - op, but this call will return successful in that case .
+    #  * Error messages can be retrieved from Mix_GetError( ).
+    #  *
+
+proc Mix_SetPanning*(channel: int, left: Uint8, right: Uint8): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # * set the position ofa channel.( angle ) is an integer from 0 to 360, that
+  #    * specifies the location of the sound in relation to the listener.( angle )
+  #    * will be reduced as neccesary( 540 becomes 180 degrees, -100 becomes 260 ).
+  #    * Angle 0 is due north, and rotates clockwise as the value increases.
+  #    * for efficiency, the precision of this effect may be limited( angles 1
+  #    * through 7 might all produce the same effect, 8 through 15 are equal, etc ).
+  #    * ( distance ) is an integer between 0 and 255 that specifies the space
+  #    * between the sound and the listener.The larger the number, the further
+  #    * away the sound is .Using 255 does not guarantee that the channel will be
+  #    * culled from the mixing process or be completely silent.For efficiency,
+  #    * the precision of this effect may be limited( distance 0 through 5 might
+  #    * all produce the same effect, 6 through 10 are equal, etc ).Setting( angle )
+  #    * and ( distance ) to 0 unregisters this effect, since the data would be
+  #    * unchanged.
+  #    *
+  #    * if you need more precise positional audio, consider using OpenAL for
+  #    * spatialized effects instead of SDL_mixer.This is only meant to be a
+  #    * basic effect for simple "3D" games.
+  #    *
+  #    * if the audio device is configured for mono output, then you won't get
+  #    * any effectiveness from the angle; however, distance attenuation on the
+  #  * channel will still occur.While this effect will function with stereo
+  #  * voices, it makes more sense to use voices with only one channel of sound,
+  #  * so when they are mixed through this effect, the positioning will sound
+  #  * correct.You can convert them to mono through SDL before giving them to
+  #  * the mixer in the first place if you like.
+  #  *
+  #  * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
+  #  * the positioning will be done to the final mixed stream before passing it
+  #  * on to the audio device.
+  #  *
+  #  * This is a convenience wrapper over Mix_SetDistance( ) and Mix_SetPanning( ).
+  #  *
+  #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+  #  * nonzero if position effect is enabled.
+  #  * Error messages can be retrieved from Mix_GetError( ).
+  #  *
+proc Mix_SetPosition*(channel: int, angle: Sint16, distance: Uint8): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  #* set the "distance" of a channel.( distance ) is an integer from 0 to 255
+  #  * that specifies the location of the sound in relation to the listener.
+  #  * Distance 0 is overlapping the listener, and 255 is as far away as possible
+  #  * A distance of 255 does not guarantee silence; in such a case , you might
+  #  * want to try changing the chunk's volume, or just cull the sample from the
+  #  * mixing process with Mix_HaltChannel( ).
+  #    * for efficiency, the precision of this effect may be limited( distances 1
+  #    * through 7 might all produce the same effect, 8 through 15 are equal, etc ).
+  #    * ( distance ) is an integer between 0 and 255 that specifies the space
+  #    * between the sound and the listener.The larger the number, the further
+  #    * away the sound is .
+  #    * Setting( distance ) to 0 unregisters this effect, since the data would be
+  #    * unchanged.
+  #    * if you need more precise positional audio, consider using OpenAL for
+  #    * spatialized effects instead of SDL_mixer.This is only meant to be a
+  #    * basic effect for simple "3D" games.
+  #    *
+  #    * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
+  #    * the distance attenuation will be done to the final mixed stream before
+  #    * passing it on to the audio device.
+  #    *
+  #  * This uses the Mix_RegisterEffect( )API internally.
+  #  *
+  #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+  #  * nonzero if position effect is enabled.
+  #    * Error messages can be retrieved from Mix_GetError( ).
+  #    *
+proc Mix_SetDistance*(channel: int, distance: Uint8): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # *
+  #    * !!! FIXME : Haven't implemented, since the effect goes past the
+  #  * end of the sound buffer.Will have to think about this.
+  #  * - -ryan.
+  #  * /
+  #  { if 0
+  #  { * Causes an echo effect to be mixed into a sound.( echo ) is the amount
+  #  * of echo to mix.0 is no echo, 255 is infinite( and probably not
+  #  * what you want ).
+  #  *
+  #  * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
+  #  * the reverbing will be done to the final mixed stream before passing it on
+  #  * to the audio device.
+  #  *
+  #  * This uses the Mix_RegisterEffect( )API internally.If you specify an echo
+  #  * of zero, the effect is unregistered, as the data is already in that state.
+  #  *
+  #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+  #  * nonzero if reversing effect is enabled.
+  #    * Error messages can be retrieved from Mix_GetError( ).
+  #    *
+  #    extern no_parse_DECLSPEC int Mix_SetReverb( int channel, Uint8 echo );
+  #  #E ndif
+  # * Causes a channel to reverse its stereo.This is handy if the user has his
+  #    * speakers hooked up backwards, or you would like to have a minor bit of
+  #  * psychedelia in your sound code. : )Calling this function with ( flip )
+  #  * set to non - zero reverses the chunks's usual channels. If (flip) is zero,
+  #  * the effect is unregistered.
+  #  *
+  #  * This uses the Mix_RegisterEffect( )API internally, and thus is probably
+  #  * more CPU intensive than having the user just plug in his speakers
+  #  * correctly.Mix_SetReverseStereo( )returns without registering the effect
+  #  * function if the audio device is not configured for stereo output.
+  #  *
+  #  * if you specify MIX_CHANNEL_POST for ( channel ), then this the effect is used
+  #  * on the final mixed stream before sending it on to the audio device( a
+  #  * posteffect ).
+  #  *
+  #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+  #  * nonzero if reversing effect is enabled.Note that an audio device in mono
+  #  * mode is a no - op, but this call will return successful in that case .
+  #  * Error messages can be retrieved from Mix_GetError( ).
+  #  *
+proc Mix_SetReverseStereo*(channel: int, flip: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # end of effects API. - -ryan. *
+  # Reserve the first channels (0 -> n-1) for the application, i.e. don't allocate
+  #   them dynamically to the next sample if requested with a -1 value below.
+  #   Returns the number of reserved channels.
+  #
+proc Mix_ReserveChannels*(num: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Channel grouping functions
+  # Attach a tag to a channel. A tag can be assigned to several mixer
+  #   channels, to form groups of channels.
+  #   If 'tag' is -1, the tag is removed (actually -1 is the tag used to
+  #   represent the group of all the channels).
+  #   Returns true if everything was OK.
+  #
+proc Mix_GroupChannel*(which: int, tag: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Assign several consecutive channels to a group
+proc Mix_GroupChannels*(`from`: int, `to`: int, tag: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Finds the first available channel in a group of channels
+proc Mix_GroupAvailable*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Returns the number of channels in a group. This is also a subtle
+  #   way to get the total number of channels when 'tag' is -1
+  #
+proc Mix_GroupCount*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Finds the "oldest" sample playing in a group of channels
+proc Mix_GroupOldest*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Finds the "most recent" (i.e. last) sample playing in a group of channels
+proc Mix_GroupNewer*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # The same as above, but the sound is played at most 'ticks' milliseconds
+proc Mix_PlayChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int,
+                           ticks: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Play an audio chunk on a specific channel.
+  #   If the specified channel is -1, play on the first free channel.
+  #   If 'loops' is greater than zero, loop the sound that many times.
+  #   If 'loops' is -1, loop inifinitely (~65000 times).
+  #   Returns which channel was used to play the sound.
+  #
+proc Mix_PlayChannel*(channel: int, chunk: PMix_Chunk, loops: int): int
+proc Mix_PlayMusic*(music: PMix_Music, loops: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions
+proc Mix_FadeInMusic*(music: PMix_Music, loops: int, ms: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadeInChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int,
+                             ms: int, ticks: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadeInChannel*(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int
+  # Set the volume in the range of 0-128 of a specific channel or chunk.
+  #   If the specified channel is -1, set volume for all channels.
+  #   Returns the original volume.
+  #   If the specified volume is -1, just return the current volume.
+  #
+proc Mix_Volume*(channel: int, volume: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_VolumeChunk*(chunk: PMix_Chunk, volume: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_VolumeMusic*(volume: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Halt playing of a particular channel
+proc Mix_HaltChannel*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_HaltGroup*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_HaltMusic*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Change the expiration delay for a particular channel.
+  #   The sample will stop playing after the 'ticks' milliseconds have elapsed,
+  #   or remove the expiration if 'ticks' is -1
+  #
+proc Mix_ExpireChannel*(channel: int, ticks: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Halt a channel, fading it out progressively till it's silent
+  #   The ms parameter indicates the number of milliseconds the fading
+  #   will take.
+  #
+proc Mix_FadeOutChannel*(which: int, ms: int): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadeOutGroup*(tag: int, ms: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadeOutMusic*(ms: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Query the fading status of a channel
+proc Mix_FadingMusic*(): TMix_Fading{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadingChannel*(which: int): TMix_Fading{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Pause/Resume a particular channel
+proc Mix_Pause*(channel: int){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_Resume*(channel: int){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_Paused*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Pause/Resume the music stream
+proc Mix_PauseMusic*(){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_ResumeMusic*(){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_RewindMusic*(){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_PausedMusic*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Set the current position in the music stream.
+  #  This returns 0 if successful, or -1 if it failed or isn't implemented.
+  #  This function is only implemented for MOD music formats (set pattern
+  #  order number) and for OGG music (set position in seconds), at the
+  #  moment.
+  #
+proc Mix_SetMusicPosition*(position: float64): int{.cdecl,
+    importc, dynlib: SDL_MixerLibName.}
+  # Check the status of a specific channel.
+  #   If the specified channel is -1, check all channels.
+  #
+proc Mix_Playing*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_PlayingMusic*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Stop music and set external music playback command
+proc Mix_SetMusicCMD*(command: cstring): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Synchro value is set by MikMod from modules while playing
+proc Mix_SetSynchroValue*(value: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_GetSynchroValue*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  #
+  #  Get the Mix_Chunk currently associated with a mixer channel
+  #    Returns nil if it's an invalid channel, or there's no chunk associated.
+  #
+proc Mix_GetChunk*(channel: int): PMix_Chunk{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Close the mixer, halting all playing audio
+proc Mix_CloseAudio*(){.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # We'll use SDL for reporting errors
+proc Mix_SetError*(fmt: cstring)
+proc Mix_GetError*(): cstring
+# implementation
+
+proc SDL_MIXER_VERSION(X: var TSDL_version) =
+  X.major = SDL_MIXER_MAJOR_VERSION
+  X.minor = SDL_MIXER_MINOR_VERSION
+  X.patch = SDL_MIXER_PATCHLEVEL
+
+proc Mix_LoadWAV(filename: cstring): PMix_Chunk =
+  result = Mix_LoadWAV_RW(SDL_RWFromFile(filename, "rb"), 1)
+
+proc Mix_PlayChannel(channel: int, chunk: PMix_Chunk, loops: int): int =
+  result = Mix_PlayChannelTimed(channel, chunk, loops, - 1)
+
+proc Mix_FadeInChannel(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int =
+  result = Mix_FadeInChannelTimed(channel, chunk, loops, ms, - 1)
+
+proc Mix_SetError(fmt: cstring) =
+  SDL_SetError(fmt)
+
+proc Mix_GetError(): cstring =
+  result = SDL_GetError()

lib/oldwrappers/sdl/sdl_mixer_nosmpeg.nim

@@ -0,0 +1,572 @@
+
+#******************************************************************************
+# Copy of SDL_Mixer without smpeg dependency and mp3 support                    
+#******************************************************************************
+
+import
+  sdl
+
+when defined(windows):
+  const SDL_MixerLibName = "SDL_mixer.dll"
+elif defined(macosx):
+  const SDL_MixerLibName = "libSDL_mixer-1.2.0.dylib"
+else:
+  const SDL_MixerLibName = "libSDL_mixer.so"
+
+const                    
+  SDL_MIXER_MAJOR_VERSION* = 1'i8
+  SDL_MIXER_MINOR_VERSION* = 2'i8
+  SDL_MIXER_PATCHLEVEL* = 7'i8   # Backwards compatibility
+  MIX_MAJOR_VERSION* = SDL_MIXER_MAJOR_VERSION
+  MIX_MINOR_VERSION* = SDL_MIXER_MINOR_VERSION
+  MIX_PATCHLEVEL* = SDL_MIXER_PATCHLEVEL # SDL_Mixer.h constants
+                                         # The default mixer has 8 simultaneous mixing channels 
+  MIX_CHANNELS* = 8           # Good default values for a PC soundcard 
+  MIX_DEFAULT_FREQUENCY* = 22050
+
+when defined(IA32): 
+  const 
+    MIX_DEFAULT_FORMAT* = AUDIO_S16LSB
+else: 
+  const 
+    MIX_DEFAULT_FORMAT* = AUDIO_S16MSB
+const 
+  MIX_DEFAULT_CHANNELS* = 2
+  MIX_MAX_VOLUME* = 128       # Volume of a chunk 
+  PATH_MAX* = 255             # mikmod.h constants
+                              #*
+                              #  * Library version
+                              #  *
+  LIBMIKMOD_VERSION_MAJOR* = 3
+  LIBMIKMOD_VERSION_MINOR* = 1
+  LIBMIKMOD_REVISION* = 8
+  LIBMIKMOD_VERSION* = ((LIBMIKMOD_VERSION_MAJOR shl 16) or
+      (LIBMIKMOD_VERSION_MINOR shl 8) or (LIBMIKMOD_REVISION))
+
+type                          #music_cmd.h types
+  PMusicCMD* = ptr TMusicCMD
+  TMusicCMD*{.final.} = object  #wavestream.h types
+    filename*: array[0..PATH_MAX - 1, char]
+    cmd*: array[0..PATH_MAX - 1, char]
+    pid*: TSYS_ThreadHandle
+
+  PWAVStream* = ptr TWAVStream
+  TWAVStream*{.final.} = object  #playmidi.h types
+    wavefp*: Pointer
+    start*: int32
+    stop*: int32
+    cvt*: TSDL_AudioCVT
+
+  PMidiEvent* = ptr TMidiEvent
+  TMidiEvent*{.final.} = object 
+    time*: int32
+    channel*: uint8
+    typ*: uint8
+    a*: uint8
+    b*: uint8
+
+  PMidiSong* = ptr TMidiSong
+  TMidiSong*{.final.} = object  #music_ogg.h types
+    samples*: int32
+    events*: PMidiEvent
+
+  POGG_Music* = ptr TOGG_Music
+  TOGG_Music*{.final.} = object  # mikmod.h types
+                                 #*
+                                 #  * Error codes
+                                 #  *
+    playing*: int
+    volume*: int              #vf: OggVorbis_File;
+    section*: int
+    cvt*: TSDL_AudioCVT
+    len_available*: int
+    snd_available*: PUint8
+
+  TErrorEnum* = enum 
+    MMERR_OPENING_FILE, MMERR_OUT_OF_MEMORY, MMERR_DYNAMIC_LINKING, 
+    MMERR_SAMPLE_TOO_BIG, MMERR_OUT_OF_HANDLES, MMERR_UNKNOWN_WAVE_TYPE, 
+    MMERR_LOADING_PATTERN, MMERR_LOADING_TRACK, MMERR_LOADING_HEADER, 
+    MMERR_LOADING_SAMPLEINFO, MMERR_NOT_A_MODULE, MMERR_NOT_A_STREAM, 
+    MMERR_MED_SYNTHSAMPLES, MMERR_ITPACK_INVALID_DATA, MMERR_DETECTING_DEVICE, 
+    MMERR_INVALID_DEVICE, MMERR_INITIALIZING_MIXER, MMERR_OPENING_AUDIO, 
+    MMERR_8BIT_ONLY, MMERR_16BIT_ONLY, MMERR_STEREO_ONLY, MMERR_ULAW, 
+    MMERR_NON_BLOCK, MMERR_AF_AUDIO_PORT, MMERR_AIX_CONFIG_INIT, 
+    MMERR_AIX_CONFIG_CONTROL, MMERR_AIX_CONFIG_START, MMERR_GUS_SETTINGS, 
+    MMERR_GUS_RESET, MMERR_GUS_TIMER, MMERR_HP_SETSAMPLESIZE, MMERR_HP_SETSPEED, 
+    MMERR_HP_CHANNELS, MMERR_HP_AUDIO_OUTPUT, MMERR_HP_AUDIO_DESC, 
+    MMERR_HP_BUFFERSIZE, MMERR_OSS_SETFRAGMENT, MMERR_OSS_SETSAMPLESIZE, 
+    MMERR_OSS_SETSTEREO, MMERR_OSS_SETSPEED, MMERR_SGI_SPEED, MMERR_SGI_16BIT, 
+    MMERR_SGI_8BIT, MMERR_SGI_STEREO, MMERR_SGI_MONO, MMERR_SUN_INIT, 
+    MMERR_OS2_MIXSETUP, MMERR_OS2_SEMAPHORE, MMERR_OS2_TIMER, MMERR_OS2_THREAD, 
+    MMERR_DS_PRIORITY, MMERR_DS_BUFFER, MMERR_DS_FORMAT, MMERR_DS_NOTIFY, 
+    MMERR_DS_EVENT, MMERR_DS_THREAD, MMERR_DS_UPDATE, MMERR_WINMM_HANDLE, 
+    MMERR_WINMM_ALLOCATED, MMERR_WINMM_DEVICEID, MMERR_WINMM_FORMAT, 
+    MMERR_WINMM_UNKNOWN, MMERR_MAC_SPEED, MMERR_MAC_START, MMERR_MAX
+  PMODULE* = ptr TMODULE
+  TMODULE*{.final.} = object 
+  PUNIMOD* = ptr TUNIMOD
+  TUNIMOD* = TMODULE          #SDL_mixer.h types
+                              # The internal format for an audio chunk 
+  PMix_Chunk* = ptr TMix_Chunk
+  TMix_Chunk*{.final.} = object 
+    allocated*: int
+    abuf*: PUint8
+    alen*: Uint32
+    volume*: Uint8            # Per-sample volume, 0-128 
+  
+  Mix_Chunk* = TMix_Chunk     # The different fading types supported 
+  TMix_Fading* = enum 
+    MIX_NO_FADING, MIX_FADING_OUT, MIX_FADING_IN
+  Mix_Fading* = TMix_Fading
+  TMix_MusicType* = enum 
+    MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG
+  PMix_Music* = ptr TMix_Music
+  TMix_Music*{.final.} = object 
+    typ*: TMix_MusicType
+
+  TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{.
+      cdecl.} # This macro can be used to fill a version structure with the compile-time
+              #  version of the SDL_mixer library. 
+
+proc SDL_MIXER_VERSION*(X: var TSDL_Version)
+  # This function gets the version of the dynamically linked SDL_mixer library.
+  #     It should NOT be used to fill a version structure, instead you should use the
+  #     SDL_MIXER_VERSION() macro. 
+proc Mix_Linked_Version*(): PSDL_version{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Open the mixer with a certain audio format 
+proc Mix_OpenAudio*(frequency: int, format: Uint16, channels: int, 
+                    chunksize: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Dynamically change the number of channels managed by the mixer.
+  #   If decreasing the number of channels, the upper channels are
+  #   stopped.
+  #   This function returns the new number of allocated channels.
+  # 
+proc Mix_AllocateChannels*(numchannels: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Find out what the actual audio device parameters are.
+  #   This function returns 1 if the audio has been opened, 0 otherwise.
+  # 
+proc Mix_QuerySpec*(frequency: var int, format: var Uint16, channels: var int): int{.
+    cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Load a wave file or a music (.mod .s3m .it .xm) file 
+proc Mix_LoadWAV_RW*(src: PSDL_RWops, freesrc: int): PMix_Chunk{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_LoadWAV*(filename: cstring): PMix_Chunk
+proc Mix_LoadMUS*(filename: cstring): PMix_Music{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Load a wave file of the mixer format from a memory buffer 
+proc Mix_QuickLoad_WAV*(mem: PUint8): PMix_Chunk{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Free an audio chunk previously loaded 
+proc Mix_FreeChunk*(chunk: PMix_Chunk){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_FreeMusic*(music: PMix_Music){.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Find out the music format of a mixer music, or the currently playing
+  #   music, if 'music' is NULL.
+proc Mix_GetMusicType*(music: PMix_Music): TMix_MusicType{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Set a function that is called after all mixing is performed.
+  #   This can be used to provide real-time visual display of the audio stream
+  #   or add a custom mixer filter for the stream data.
+  #
+proc Mix_SetPostMix*(mix_func: TMixFunction, arg: Pointer){.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Add your own music player or additional mixer function.
+  #   If 'mix_func' is NULL, the default music player is re-enabled.
+  # 
+proc Mix_HookMusic*(mix_func: TMixFunction, arg: Pointer){.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Add your own callback when the music has finished playing.
+  # 
+proc Mix_HookMusicFinished*(music_finished: Pointer){.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Get a pointer to the user data for the current music hook 
+proc Mix_GetMusicHookData*(): Pointer{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  #* Add your own callback when a channel has finished playing. NULL
+  # * to disable callback.*
+type 
+  TChannel_finished* = proc (channel: int){.cdecl.}
+
+proc Mix_ChannelFinished*(channel_finished: TChannel_finished){.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+const 
+  MIX_CHANNEL_POST* = - 2 #* This is the format of a special effect callback:
+                          #   *
+                          #   *   myeffect(int chan, void *stream, int len, void *udata);
+                          #   *
+                          #   * (chan) is the channel number that your effect is affecting. (stream) is
+                          #   *  the buffer of data to work upon. (len) is the size of (stream), and
+                          #   *  (udata) is a user-defined bit of data, which you pass as the last arg of
+                          #   *  Mix_RegisterEffect(), and is passed back unmolested to your callback.
+                          #   *  Your effect changes the contents of (stream) based on whatever parameters
+                          #   *  are significant, or just leaves it be, if you prefer. You can do whatever
+                          #   *  you like to the buffer, though, and it will continue in its changed state
+                          #   *  down the mixing pipeline, through any other effect functions, then finally
+                          #   *  to be mixed with the rest of the channels and music for the final output
+                          #   *  stream.
+                          #   *
+
+type 
+  TMix_EffectFunc* = proc (chan: int, stream: Pointer, length: int, 
+                           udata: Pointer): Pointer{.cdecl.} 
+    #   * This is a callback that signifies that a channel has finished all its
+    #   *  loops and has completed playback. This gets called if the buffer
+    #   *  plays out normally, or if you call Mix_HaltChannel(), implicitly stop
+    #   *  a channel via Mix_AllocateChannels(), or unregister a callback while
+    #   *  it's still playing.
+  TMix_EffectDone* = proc (chan: int, udata: Pointer): Pointer{.cdecl.}
+    #* Register a special effect function. At mixing time, the channel data is
+    #  *  copied into a buffer and passed through each registered effect function.
+    #  *  After it passes through all the functions, it is mixed into the final
+    #  *  output stream. The copy to buffer is performed once, then each effect
+    #  *  function performs on the output of the previous effect. Understand that
+    #  *  this extra copy to a buffer is not performed if there are no effects
+    #  *  registered for a given chunk, which saves CPU cycles, and any given
+    #  *  effect will be extra cycles, too, so it is crucial that your code run
+    #  *  fast. Also note that the data that your function is given is in the
+    #  *  format of the sound device, and not the format you gave to Mix_OpenAudio(),
+    #  *  although they may in reality be the same. This is an unfortunate but
+    #  *  necessary speed concern. Use Mix_QuerySpec() to determine if you can
+    #  *  handle the data before you register your effect, and take appropriate
+    #  *  actions.
+    #  * You may also specify a callback (Mix_EffectDone_t) that is called when
+    #  *  the channel finishes playing. This gives you a more fine-grained control
+    #  *  than Mix_ChannelFinished(), in case you need to free effect-specific
+    #  *  resources, etc. If you don't need this, you can specify NULL.
+    #  * You may set the callbacks before or after calling Mix_PlayChannel().
+    #  * Things like Mix_SetPanning() are just internal special effect functions,
+    #  *  so if you are using that, you've already incurred the overhead of a copy
+    #  *  to a separate buffer, and that these effects will be in the queue with
+    #  *  any functions you've registered. The list of registered effects for a
+    #  *  channel is reset when a chunk finishes playing, so you need to explicitly
+    #  *  set them with each call to Mix_PlayChannel*().
+    #  * You may also register a special effect function that is to be run after
+    #  *  final mixing occurs. The rules for these callbacks are identical to those
+    #  *  in Mix_RegisterEffect, but they are run after all the channels and the
+    #  *  music have been mixed into a single stream, whereas channel-specific
+    #  *  effects run on a given channel before any other mixing occurs. These
+    #  *  global effect callbacks are call "posteffects". Posteffects only have
+    #  *  their Mix_EffectDone_t function called when they are unregistered (since
+    #  *  the main output stream is never "done" in the same sense as a channel).
+    #  *  You must unregister them manually when you've had enough. Your callback
+    #  *  will be told that the channel being mixed is (MIX_CHANNEL_POST) if the
+    #  *  processing is considered a posteffect.
+    #  *
+    #  * After all these effects have finished processing, the callback registered
+    #  *  through Mix_SetPostMix() runs, and then the stream goes to the audio
+    #  *  device.
+    #  *
+    #  * returns zero if error (no such channel), nonzero if added.
+    #  *  Error messages can be retrieved from Mix_GetError().
+
+proc Mix_RegisterEffect*(chan: int, f: TMix_EffectFunc, d: TMix_EffectDone, 
+                         arg: Pointer): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  #* You may not need to call this explicitly, unless you need to stop an
+  # *  effect from processing in the middle of a chunk's playback.
+  # * Posteffects are never implicitly unregistered as they are for channels,
+  # *  but they may be explicitly unregistered through this function by
+  # *  specifying MIX_CHANNEL_POST for a channel.
+  # * returns zero if error (no such channel or effect), nonzero if removed.
+  # *  Error messages can be retrieved from Mix_GetError().
+  # *
+proc Mix_UnregisterEffect*(channel: int, f: TMix_EffectFunc): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  #* You may not need to call this explicitly, unless you need to stop all
+  #  * effects from processing in the middle of a chunk's playback. Note that
+  #  * this will also shut off some internal effect processing, since
+  #  * Mix_SetPanning( ) and others may use this API under the hood.This is
+  #  * called internally when a channel completes playback.
+  #  * Posteffects are never implicitly unregistered as they are for channels,
+  #  * but they may be explicitly unregistered through this function by
+  #  * specifying MIX_CHANNEL_POST for a channel.
+  #  * returns zero if error( no such channel ), nonzero if all effects removed.
+  #  * Error messages can be retrieved from Mix_GetError( ).
+  #  *
+proc Mix_UnregisterAllEffects*(channel: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+const 
+  MIX_EFFECTSMAXSPEED* = "MIX_EFFECTSMAXSPEED" 
+    #  * These are the internally - defined mixing effects.They use the same API that
+    #  * effects defined in the application use, but are provided here as a
+    #  * convenience.Some effects can reduce their quality or use more memory in
+    #  * the name of speed; to enable this, make sure the environment variable
+    #  * MIX_EFFECTSMAXSPEED( see above ) is defined before you call
+    #  * Mix_OpenAudio( ).
+    #  * 
+    #* set the panning of a channel.The left and right channels are specified
+    #  * as integers between 0 and 255, quietest to loudest, respectively.
+    #  *
+    #  * Technically, this is just individual volume control for a sample with
+    #  * two( stereo )channels, so it can be used for more than just panning.
+    #  * if you want real panning, call it like this :
+    #  *
+    #  * Mix_SetPanning( channel, left, 255 - left );
+    #  *
+    #  * ...which isn't so hard.
+    #  *
+    #  * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
+    #  * the panning will be done to the final mixed stream before passing it on
+    #  * to the audio device.
+    #  *
+    #  * This uses the Mix_RegisterEffect( )API internally, and returns without
+    #  * registering the effect function if the audio device is not configured
+    #  * for stereo output.Setting both( left ) and ( right ) to 255 causes this
+    #  * effect to be unregistered, since that is the data's normal state.
+    #  *
+    #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+    #  * nonzero if panning effect enabled.Note that an audio device in mono
+    #  * mode is a no - op, but this call will return successful in that case .
+    #  * Error messages can be retrieved from Mix_GetError( ).
+                                               
+
+proc Mix_SetPanning*(channel: int, left: Uint8, right: Uint8): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # * set the position ofa channel.( angle ) is an integer from 0 to 360, that
+  #    * specifies the location of the sound in relation to the listener.( angle )
+  #    * will be reduced as neccesary( 540 becomes 180 degrees, -100 becomes 260 ).
+  #    * Angle 0 is due north, and rotates clockwise as the value increases.
+  #    * for efficiency, the precision of this effect may be limited( angles 1
+  #    * through 7 might all produce the same effect, 8 through 15 are equal, etc ).
+  #    * ( distance ) is an integer between 0 and 255 that specifies the space
+  #    * between the sound and the listener.The larger the number, the further
+  #    * away the sound is .Using 255 does not guarantee that the channel will be
+  #    * culled from the mixing process or be completely silent.For efficiency,
+  #    * the precision of this effect may be limited( distance 0 through 5 might
+  #    * all produce the same effect, 6 through 10 are equal, etc ).Setting( angle )
+  #    * and ( distance ) to 0 unregisters this effect, since the data would be
+  #    * unchanged.
+  #    *
+  #    * if you need more precise positional audio, consider using OpenAL for
+  #    * spatialized effects instead of SDL_mixer.This is only meant to be a
+  #    * basic effect for simple "3D" games.
+  #    *
+  #    * if the audio device is configured for mono output, then you won't get
+  #    * any effectiveness from the angle; however, distance attenuation on the
+  #  * channel will still occur.While this effect will function with stereo
+  #  * voices, it makes more sense to use voices with only one channel of sound,
+  #  * so when they are mixed through this effect, the positioning will sound
+  #  * correct.You can convert them to mono through SDL before giving them to
+  #  * the mixer in the first place if you like.
+  #  *
+  #  * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
+  #  * the positioning will be done to the final mixed stream before passing it
+  #  * on to the audio device.
+  #  *
+  #  * This is a convenience wrapper over Mix_SetDistance( ) and Mix_SetPanning( ).
+  #  *
+  #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+  #  * nonzero if position effect is enabled.
+  #  * Error messages can be retrieved from Mix_GetError( ).
+  #  * 
+proc Mix_SetPosition*(channel: int, angle: Sint16, distance: Uint8): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  #* set the "distance" of a channel.( distance ) is an integer from 0 to 255
+  #  * that specifies the location of the sound in relation to the listener.
+  #  * Distance 0 is overlapping the listener, and 255 is as far away as possible
+  #  * A distance of 255 does not guarantee silence; in such a case , you might
+  #  * want to try changing the chunk's volume, or just cull the sample from the
+  #  * mixing process with Mix_HaltChannel( ).
+  #    * for efficiency, the precision of this effect may be limited( distances 1
+  #    * through 7 might all produce the same effect, 8 through 15 are equal, etc ).
+  #    * ( distance ) is an integer between 0 and 255 that specifies the space
+  #    * between the sound and the listener.The larger the number, the further
+  #    * away the sound is .
+  #    * Setting( distance ) to 0 unregisters this effect, since the data would be
+  #    * unchanged.
+  #    * if you need more precise positional audio, consider using OpenAL for
+  #    * spatialized effects instead of SDL_mixer.This is only meant to be a
+  #    * basic effect for simple "3D" games.
+  #    *
+  #    * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
+  #    * the distance attenuation will be done to the final mixed stream before
+  #    * passing it on to the audio device.
+  #    *
+  #  * This uses the Mix_RegisterEffect( )API internally.
+  #  *
+  #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+  #  * nonzero if position effect is enabled.
+  #    * Error messages can be retrieved from Mix_GetError( ).
+  #    * 
+proc Mix_SetDistance*(channel: int, distance: Uint8): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # *
+  #    * !!! FIXME : Haven't implemented, since the effect goes past the
+  #  * end of the sound buffer.Will have to think about this.
+  #  * - -ryan.
+  #  * /
+  #  { if 0
+  #  { * Causes an echo effect to be mixed into a sound.( echo ) is the amount
+  #  * of echo to mix.0 is no echo, 255 is infinite( and probably not
+  #  * what you want ).
+  #  *
+  #  * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
+  #  * the reverbing will be done to the final mixed stream before passing it on
+  #  * to the audio device.
+  #  *
+  #  * This uses the Mix_RegisterEffect( )API internally.If you specify an echo
+  #  * of zero, the effect is unregistered, as the data is already in that state.
+  #  *
+  #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+  #  * nonzero if reversing effect is enabled.
+  #    * Error messages can be retrieved from Mix_GetError( ).
+  #    *
+  #    extern no_parse_DECLSPEC int Mix_SetReverb( int channel, Uint8 echo );
+  #  #E ndif
+  # * Causes a channel to reverse its stereo.This is handy if the user has his
+  #    * speakers hooked up backwards, or you would like to have a minor bit of
+  #  * psychedelia in your sound code. : )Calling this function with ( flip )
+  #  * set to non - zero reverses the chunks's usual channels. If (flip) is zero,
+  #  * the effect is unregistered.
+  #  *
+  #  * This uses the Mix_RegisterEffect( )API internally, and thus is probably
+  #  * more CPU intensive than having the user just plug in his speakers
+  #  * correctly.Mix_SetReverseStereo( )returns without registering the effect
+  #  * function if the audio device is not configured for stereo output.
+  #  *
+  #  * if you specify MIX_CHANNEL_POST for ( channel ), then this the effect is used
+  #  * on the final mixed stream before sending it on to the audio device( a
+  #  * posteffect ).
+  #  *
+  #  * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
+  #  * nonzero if reversing effect is enabled.Note that an audio device in mono
+  #  * mode is a no - op, but this call will return successful in that case .
+  #  * Error messages can be retrieved from Mix_GetError( ).
+  #  * 
+proc Mix_SetReverseStereo*(channel: int, flip: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # end of effects API. - -ryan. *
+  # Reserve the first channels (0 -> n-1) for the application, i.e. don't allocate
+  #   them dynamically to the next sample if requested with a -1 value below.
+  #   Returns the number of reserved channels.
+  # 
+proc Mix_ReserveChannels*(num: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Channel grouping functions 
+  # Attach a tag to a channel. A tag can be assigned to several mixer
+  #   channels, to form groups of channels.
+  #   If 'tag' is -1, the tag is removed (actually -1 is the tag used to
+  #   represent the group of all the channels).
+  #   Returns true if everything was OK.
+  # 
+proc Mix_GroupChannel*(which: int, tag: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Assign several consecutive channels to a group 
+proc Mix_GroupChannels*(`from`: int, `to`: int, tag: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Finds the first available channel in a group of channels 
+proc Mix_GroupAvailable*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Returns the number of channels in a group. This is also a subtle
+  #   way to get the total number of channels when 'tag' is -1
+  # 
+proc Mix_GroupCount*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Finds the "oldest" sample playing in a group of channels 
+proc Mix_GroupOldest*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Finds the "most recent" (i.e. last) sample playing in a group of channels 
+proc Mix_GroupNewer*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # The same as above, but the sound is played at most 'ticks' milliseconds 
+proc Mix_PlayChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int, 
+                           ticks: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Play an audio chunk on a specific channel.
+  #   If the specified channel is -1, play on the first free channel.
+  #   If 'loops' is greater than zero, loop the sound that many times.
+  #   If 'loops' is -1, loop inifinitely (~65000 times).
+  #   Returns which channel was used to play the sound.
+  #
+proc Mix_PlayChannel*(channel: int, chunk: PMix_Chunk, loops: int): int
+proc Mix_PlayMusic*(music: PMix_Music, loops: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions 
+proc Mix_FadeInMusic*(music: PMix_Music, loops: int, ms: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadeInChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int, 
+                             ms: int, ticks: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadeInChannel*(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int
+  # Set the volume in the range of 0-128 of a specific channel or chunk.
+  #   If the specified channel is -1, set volume for all channels.
+  #   Returns the original volume.
+  #   If the specified volume is -1, just return the current volume.
+  #
+proc Mix_Volume*(channel: int, volume: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_VolumeChunk*(chunk: PMix_Chunk, volume: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_VolumeMusic*(volume: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Halt playing of a particular channel 
+proc Mix_HaltChannel*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_HaltGroup*(tag: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_HaltMusic*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Change the expiration delay for a particular channel.
+  #   The sample will stop playing after the 'ticks' milliseconds have elapsed,
+  #   or remove the expiration if 'ticks' is -1
+  #
+proc Mix_ExpireChannel*(channel: int, ticks: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Halt a channel, fading it out progressively till it's silent
+  #   The ms parameter indicates the number of milliseconds the fading
+  #   will take.
+  # 
+proc Mix_FadeOutChannel*(which: int, ms: int): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadeOutGroup*(tag: int, ms: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadeOutMusic*(ms: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Query the fading status of a channel 
+proc Mix_FadingMusic*(): TMix_Fading{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_FadingChannel*(which: int): TMix_Fading{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Pause/Resume a particular channel 
+proc Mix_Pause*(channel: int){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_Resume*(channel: int){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_Paused*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Pause/Resume the music stream 
+proc Mix_PauseMusic*(){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_ResumeMusic*(){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_RewindMusic*(){.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_PausedMusic*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Set the current position in the music stream.
+  #  This returns 0 if successful, or -1 if it failed or isn't implemented.
+  #  This function is only implemented for MOD music formats (set pattern
+  #  order number) and for OGG music (set position in seconds), at the
+  #  moment.
+  #
+proc Mix_SetMusicPosition*(position: float64): int{.cdecl, 
+    importc, dynlib: SDL_MixerLibName.}
+  # Check the status of a specific channel.
+  #   If the specified channel is -1, check all channels.
+  #
+proc Mix_Playing*(channel: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_PlayingMusic*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Stop music and set external music playback command 
+proc Mix_SetMusicCMD*(command: cstring): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Synchro value is set by MikMod from modules while playing 
+proc Mix_SetSynchroValue*(value: int): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+proc Mix_GetSynchroValue*(): int{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  #
+  #  Get the Mix_Chunk currently associated with a mixer channel
+  #    Returns nil if it's an invalid channel, or there's no chunk associated.
+  #
+proc Mix_GetChunk*(channel: int): PMix_Chunk{.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # Close the mixer, halting all playing audio 
+proc Mix_CloseAudio*(){.cdecl, importc, dynlib: SDL_MixerLibName.}
+  # We'll use SDL for reporting errors 
+proc Mix_SetError*(fmt: cstring)
+proc Mix_GetError*(): cstring
+# implementation
+
+proc SDL_MIXER_VERSION(X: var TSDL_version) = 
+  X.major = SDL_MIXER_MAJOR_VERSION
+  X.minor = SDL_MIXER_MINOR_VERSION
+  X.patch = SDL_MIXER_PATCHLEVEL
+
+proc Mix_LoadWAV(filename: cstring): PMix_Chunk = 
+  result = Mix_LoadWAV_RW(SDL_RWFromFile(filename, "rb"), 1)
+
+proc Mix_PlayChannel(channel: int, chunk: PMix_Chunk, loops: int): int = 
+  result = Mix_PlayChannelTimed(channel, chunk, loops, - 1)
+
+proc Mix_FadeInChannel(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int = 
+  result = Mix_FadeInChannelTimed(channel, chunk, loops, ms, - 1)
+
+proc Mix_SetError(fmt: cstring) = 
+  SDL_SetError(fmt)
+
+proc Mix_GetError(): cstring = 
+  result = SDL_GetError()

lib/oldwrappers/sdl/sdl_net.nim

@@ -0,0 +1,431 @@
+
+#******************************************************************************
+#
+#  $Id: sdl_net.pas,v 1.7 2005/01/01 02:14:21 savage Exp $
+#
+#
+#                                                                              
+#       Borland Delphi SDL_Net - A x-platform network library for use with SDL.
+#       Conversion of the Simple DirectMedia Layer Network Headers             
+#                                                                              
+# Portions created by Sam Lantinga <slouken@devolution.com> are                
+# Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga                     
+# 5635-34 Springhouse Dr.                                                      
+# Pleasanton, CA 94588 (USA)                                                   
+#                                                                              
+# All Rights Reserved.                                                         
+#                                                                              
+# The original files are : SDL_net.h                                           
+#                                                                              
+# The initial developer of this Pascal code was :                              
+# Dominqiue Louis <Dominique@SavageSoftware.com.au>                            
+#                                                                              
+# Portions created by Dominqiue Louis are                                      
+# Copyright (C) 2000 - 2001 Dominqiue Louis.                                   
+#                                                                              
+#                                                                              
+# Contributor(s)                                                               
+# --------------                                                               
+# Matthias Thoma <ma.thoma@gmx.de>                                             
+#                                                                              
+# Obtained through:                                                            
+# Joint Endeavour of Delphi Innovators ( Project JEDI )                        
+#                                                                              
+# You may retrieve the latest version of this file at the Project              
+# JEDI home page, located at http://delphi-jedi.org                            
+#                                                                              
+# The contents of this file are used with permission, subject to               
+# the Mozilla Public License Version 1.1 (the "License"); you may              
+# not use this file except in compliance with the License. You may             
+# obtain a copy of the License at                                              
+# http://www.mozilla.org/MPL/MPL-1.1.html                                      
+#                                                                              
+# Software distributed under the License is distributed on an                  
+# "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or               
+# implied. See the License for the specific language governing                 
+# rights and limitations under the License.                                    
+#                                                                              
+# Description                                                                  
+# -----------                                                                  
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+# Requires                                                                     
+# --------                                                                     
+#   SDL.pas somehere in your search path                                       
+#                                                                              
+# Programming Notes                                                            
+# -----------------                                                            
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+# Revision History                                                             
+# ----------------                                                             
+#   April   09 2001 - DL : Initial Translation                                 
+#                                                                              
+#   April   03 2003 - DL : Added jedi-sdl.inc include file to support more     
+#                          Pascal compilers. Initial support is now included   
+#                          for GnuPascal, VirtualPascal, TMT and obviously     
+#                          continue support for Delphi Kylix and FreePascal.   
+#                                                                              
+#   April   24 2003 - DL : under instruction from Alexey Barkovoy, I have added
+#                          better TMT Pascal support and under instruction     
+#                          from Prof. Abimbola Olowofoyeku (The African Chief),
+#                          I have added better Gnu Pascal support              
+#                                                                              
+#   April   30 2003 - DL : under instruction from David Mears AKA              
+#                          Jason Siletto, I have added FPC Linux support.      
+#                          This was compiled with fpc 1.1, so remember to set  
+#                          include file path. ie. -Fi/usr/share/fpcsrc/rtl/*   
+#                                                                              
+#
+#  $Log: sdl_net.pas,v $
+#  Revision 1.7  2005/01/01 02:14:21  savage
+#  Updated to v1.2.5
+#
+#  Revision 1.6  2004/08/14 22:54:30  savage
+#  Updated so that Library name defines are correctly defined for MacOS X.
+#
+#  Revision 1.5  2004/05/10 14:10:04  savage
+#  Initial MacOS X support. Fixed defines for MACOS ( Classic ) and DARWIN ( MacOS X ).
+#
+#  Revision 1.4  2004/04/13 09:32:08  savage
+#  Changed Shared object names back to just the .so extension to avoid conflicts on various Linux/Unix distros. Therefore developers will need to create Symbolic links to the actual Share Objects if necessary.
+#
+#  Revision 1.3  2004/04/01 20:53:23  savage
+#  Changed Linux Shared Object names so they reflect the Symbolic Links that are created when installing the RPMs from the SDL site.
+#
+#  Revision 1.2  2004/03/30 20:23:28  savage
+#  Tidied up use of UNIX compiler directive.
+#
+#  Revision 1.1  2004/02/16 22:16:40  savage
+#  v1.0 changes
+#
+#
+#
+#******************************************************************************
+
+import
+  sdl
+
+when defined(windows):
+  const SDLNetLibName = "SDL_net.dll"
+elif defined(macosx):
+  const SDLNetLibName = "libSDL_net.dylib"
+else:
+  const SDLNetLibName = "libSDL_net.so"
+
+const                         #* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *
+  SDL_NET_MAJOR_VERSION* = 1'i8
+  SDL_NET_MINOR_VERSION* = 2'i8
+  SDL_NET_PATCHLEVEL* = 5'i8  # SDL_Net.h constants
+                              #* Resolve a host name and port to an IP address in network form.
+                              #   If the function succeeds, it will return 0.
+                              #   If the host couldn't be resolved, the host portion of the returned
+                              #   address will be INADDR_NONE, and the function will return -1.
+                              #   If 'host' is NULL, the resolved host will be set to INADDR_ANY.
+                              # *
+  INADDR_ANY* = 0x00000000
+  INADDR_NONE* = 0xFFFFFFFF #***********************************************************************
+                            #* UDP network API                                                     *
+                            #***********************************************************************
+                            #* The maximum channels on a a UDP socket *
+  SDLNET_MAX_UDPCHANNELS* = 32 #* The maximum addresses bound to a single UDP socket channel *
+  SDLNET_MAX_UDPADDRESSES* = 4
+
+type  # SDL_net.h types
+      #***********************************************************************
+      #* IPv4 hostname resolution API                                        *
+      #***********************************************************************
+  PIPAddress* = ptr TIPAddress
+  TIPAddress*{.final.} = object  #* TCP network API                                                     
+    host*: Uint32             # 32-bit IPv4 host address */
+    port*: Uint16             # 16-bit protocol port */
+  
+  PTCPSocket* = ptr TTCPSocket
+  TTCPSocket*{.final.} = object  #***********************************************************************
+                                 #* UDP network API                                                     *
+                                 #***********************************************************************
+    ready*: int
+    channel*: int
+    remoteAddress*: TIPaddress
+    localAddress*: TIPaddress
+    sflag*: int
+
+  PUDP_Channel* = ptr TUDP_Channel
+  TUDP_Channel*{.final.} = object 
+    numbound*: int
+    address*: array[0..SDLNET_MAX_UDPADDRESSES - 1, TIPAddress]
+
+  PUDPSocket* = ptr TUDPSocket
+  TUDPSocket*{.final.} = object 
+    ready*: int
+    channel*: int
+    address*: TIPAddress
+    binding*: array[0..SDLNET_MAX_UDPCHANNELS - 1, TUDP_Channel]
+
+  PUDPpacket* = ptr TUDPpacket
+  PPUDPpacket* = ptr PUDPpacket
+  TUDPpacket*{.final.} = object  #***********************************************************************
+                                 #* Hooks for checking sockets for available data                       *
+                                 #***********************************************************************
+    channel*: int             #* The src/dst channel of the packet *
+    data*: PUint8             #* The packet data *
+    length*: int              #* The length of the packet data *
+    maxlen*: int              #* The size of the data buffer *
+    status*: int              #* packet status after sending *
+    address*: TIPAddress      #* The source/dest address of an incoming/outgoing packet *
+  
+  PSDLNet_Socket* = ptr TSDLNet_Socket
+  TSDLNet_Socket*{.final.} = object 
+    ready*: int
+    channel*: int
+
+  PSDLNet_SocketSet* = ptr TSDLNet_SocketSet
+  TSDLNet_SocketSet*{.final.} = object  #* Any network socket can be safely cast to this socket type *
+    numsockets*: int
+    maxsockets*: int
+    sockets*: PSDLNet_Socket
+
+  PSDLNet_GenericSocket* = ptr TSDLNet_GenericSocket
+  TSDLNet_GenericSocket*{.final.} = object  # This macro can be used to fill a version structure with the compile-time
+                                            #  version of the SDL_net library. 
+    ready*: int
+
+
+proc SDL_NET_VERSION*(X: var TSDL_version)
+  #* Initialize/Cleanup the network API
+  #   SDL must be initialized before calls to functions in this library,
+  #   because this library uses utility functions from the SDL library.
+  #*
+proc SDLNet_Init*(): int{.cdecl, importc, dynlib: SDLNetLibName.}
+proc SDLNet_Quit*(){.cdecl, importc, dynlib: SDLNetLibName.}
+  #* Resolve a host name and port to an IP address in network form.
+  #   If the function succeeds, it will return 0.
+  #   If the host couldn't be resolved, the host portion of the returned
+  #   address will be INADDR_NONE, and the function will return -1.
+  #   If 'host' is NULL, the resolved host will be set to INADDR_ANY.
+  # *
+proc SDLNet_ResolveHost*(address: var TIPaddress, host: cstring, port: Uint16): int{.
+    cdecl, importc, dynlib: SDLNetLibName.}
+  #* Resolve an ip address to a host name in canonical form.
+  #   If the ip couldn't be resolved, this function returns NULL,
+  #   otherwise a pointer to a static buffer containing the hostname
+  #   is returned.  Note that this function is not thread-safe.
+  #*
+proc SDLNet_ResolveIP*(ip: var TIPaddress): cstring{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #***********************************************************************
+  #* TCP network API                                                     *
+  #***********************************************************************
+  #* Open a TCP network socket
+  #   If ip.host is INADDR_NONE, this creates a local server socket on the
+  #   given port, otherwise a TCP connection to the remote host and port is
+  #   attempted.  The address passed in should already be swapped to network
+  #   byte order (addresses returned from SDLNet_ResolveHost() are already
+  #   in the correct form).
+  #   The newly created socket is returned, or NULL if there was an error.
+  #*
+proc SDLNet_TCP_Open*(ip: var TIPaddress): PTCPSocket{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #* Accept an incoming connection on the given server socket.
+  #   The newly created socket is returned, or NULL if there was an error.
+  #*
+proc SDLNet_TCP_Accept*(server: PTCPsocket): PTCPSocket{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #* Get the IP address of the remote system associated with the socket.
+  #   If the socket is a server socket, this function returns NULL.
+  #*
+proc SDLNet_TCP_GetPeerAddress*(sock: PTCPsocket): PIPAddress{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #* Send 'len' bytes of 'data' over the non-server socket 'sock'
+  #   This function returns the actual amount of data sent.  If the return value
+  #   is less than the amount of data sent, then either the remote connection was
+  #   closed, or an unknown socket error occurred.
+  #*
+proc SDLNet_TCP_Send*(sock: PTCPsocket, data: Pointer, length: int): int{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #* Receive up to 'maxlen' bytes of data over the non-server socket 'sock',
+  #   and store them in the buffer pointed to by 'data'.
+  #   This function returns the actual amount of data received.  If the return
+  #   value is less than or equal to zero, then either the remote connection was
+  #   closed, or an unknown socket error occurred.
+  #*
+proc SDLNet_TCP_Recv*(sock: PTCPsocket, data: Pointer, maxlen: int): int{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #* Close a TCP network socket *
+proc SDLNet_TCP_Close*(sock: PTCPsocket){.cdecl, importc, dynlib: SDLNetLibName.}
+  #***********************************************************************
+  #* UDP network API                                                     *
+  #***********************************************************************
+  #* Allocate/resize/free a single UDP packet 'size' bytes long.
+  #   The new packet is returned, or NULL if the function ran out of memory.
+  # *
+proc SDLNet_AllocPacket*(size: int): PUDPpacket{.cdecl, importc, dynlib: SDLNetLibName.}
+proc SDLNet_ResizePacket*(packet: PUDPpacket, newsize: int): int{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+proc SDLNet_FreePacket*(packet: PUDPpacket){.cdecl, importc, dynlib: SDLNetLibName.}
+  #* Allocate/Free a UDP packet vector (array of packets) of 'howmany' packets,
+  #   each 'size' bytes long.
+  #   A pointer to the first packet in the array is returned, or NULL if the
+  #   function ran out of memory.
+  # *
+proc SDLNet_AllocPacketV*(howmany: int, size: int): PUDPpacket{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+proc SDLNet_FreePacketV*(packetV: PUDPpacket){.cdecl, importc, dynlib: SDLNetLibName.}
+  #* Open a UDP network socket
+  #   If 'port' is non-zero, the UDP socket is bound to a local port.
+  #   This allows other systems to send to this socket via a known port.
+  #*
+proc SDLNet_UDP_Open*(port: Uint16): PUDPsocket{.cdecl, importc, dynlib: SDLNetLibName.}
+  #* Bind the address 'address' to the requested channel on the UDP socket.
+  #   If the channel is -1, then the first unbound channel will be bound with
+  #   the given address as it's primary address.
+  #   If the channel is already bound, this new address will be added to the
+  #   list of valid source addresses for packets arriving on the channel.
+  #   If the channel is not already bound, then the address becomes the primary
+  #   address, to which all outbound packets on the channel are sent.
+  #   This function returns the channel which was bound, or -1 on error.
+  #*
+proc SDLNet_UDP_Bind*(sock: PUDPsocket, channel: int, address: var TIPaddress): int{.
+    cdecl, importc, dynlib: SDLNetLibName.}
+  #* Unbind all addresses from the given channel *
+proc SDLNet_UDP_Unbind*(sock: PUDPsocket, channel: int){.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #* Get the primary IP address of the remote system associated with the
+  #   socket and channel.  If the channel is -1, then the primary IP port
+  #   of the UDP socket is returned -- this is only meaningful for sockets
+  #   opened with a specific port.
+  #   If the channel is not bound and not -1, this function returns NULL.
+  # *
+proc SDLNet_UDP_GetPeerAddress*(sock: PUDPsocket, channel: int): PIPAddress{.
+    cdecl, importc, dynlib: SDLNetLibName.}
+  #* Send a vector of packets to the the channels specified within the packet.
+  #   If the channel specified in the packet is -1, the packet will be sent to
+  #   the address in the 'src' member of the packet.
+  #   Each packet will be updated with the status of the packet after it has
+  #   been sent, -1 if the packet send failed.
+  #   This function returns the number of packets sent.
+  #*
+proc SDLNet_UDP_SendV*(sock: PUDPsocket, packets: PPUDPpacket, npackets: int): int{.
+    cdecl, importc, dynlib: SDLNetLibName.}
+  #* Send a single packet to the specified channel.
+  #   If the channel specified in the packet is -1, the packet will be sent to
+  #   the address in the 'src' member of the packet.
+  #   The packet will be updated with the status of the packet after it has
+  #   been sent.
+  #   This function returns 1 if the packet was sent, or 0 on error.
+  #*
+proc SDLNet_UDP_Send*(sock: PUDPsocket, channel: int, packet: PUDPpacket): int{.
+    cdecl, importc, dynlib: SDLNetLibName.}
+  #* Receive a vector of pending packets from the UDP socket.
+  #   The returned packets contain the source address and the channel they arrived
+  #   on.  If they did not arrive on a bound channel, the the channel will be set
+  #   to -1.
+  #   The channels are checked in highest to lowest order, so if an address is
+  #   bound to multiple channels, the highest channel with the source address
+  #   bound will be returned.
+  #   This function returns the number of packets read from the network, or -1
+  #   on error.  This function does not block, so can return 0 packets pending.
+  #*
+proc SDLNet_UDP_RecvV*(sock: PUDPsocket, packets: PPUDPpacket): int{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #* Receive a single packet from the UDP socket.
+  #   The returned packet contains the source address and the channel it arrived
+  #   on.  If it did not arrive on a bound channel, the the channel will be set
+  #   to -1.
+  #   The channels are checked in highest to lowest order, so if an address is
+  #   bound to multiple channels, the highest channel with the source address
+  #   bound will be returned.
+  #   This function returns the number of packets read from the network, or -1
+  #   on error.  This function does not block, so can return 0 packets pending.
+  #*
+proc SDLNet_UDP_Recv*(sock: PUDPsocket, packet: PUDPpacket): int{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #* Close a UDP network socket *
+proc SDLNet_UDP_Close*(sock: PUDPsocket){.cdecl, importc, dynlib: SDLNetLibName.}
+  #***********************************************************************
+  #* Hooks for checking sockets for available data                       *
+  #***********************************************************************
+  #* Allocate a socket set for use with SDLNet_CheckSockets()
+  #   This returns a socket set for up to 'maxsockets' sockets, or NULL if
+  #   the function ran out of memory.
+  # *
+proc SDLNet_AllocSocketSet*(maxsockets: int): PSDLNet_SocketSet{.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #* Add a socket to a set of sockets to be checked for available data *
+proc SDLNet_AddSocket*(theSet: PSDLNet_SocketSet, sock: PSDLNet_GenericSocket): int{.
+    cdecl, importc, dynlib: SDLNetLibName.}
+proc SDLNet_TCP_AddSocket*(theSet: PSDLNet_SocketSet, sock: PTCPSocket): int
+proc SDLNet_UDP_AddSocket*(theSet: PSDLNet_SocketSet, sock: PUDPSocket): int
+  #* Remove a socket from a set of sockets to be checked for available data *
+proc SDLNet_DelSocket*(theSet: PSDLNet_SocketSet, sock: PSDLNet_GenericSocket): int{.
+    cdecl, importc, dynlib: SDLNetLibName.}
+proc SDLNet_TCP_DelSocket*(theSet: PSDLNet_SocketSet, sock: PTCPSocket): int
+  # SDLNet_DelSocket(set, (SDLNet_GenericSocket)sock)
+proc SDLNet_UDP_DelSocket*(theSet: PSDLNet_SocketSet, sock: PUDPSocket): int
+  #SDLNet_DelSocket(set, (SDLNet_GenericSocket)sock)
+  #* This function checks to see if data is available for reading on the
+  #   given set of sockets.  If 'timeout' is 0, it performs a quick poll,
+  #   otherwise the function returns when either data is available for
+  #   reading, or the timeout in milliseconds has elapsed, which ever occurs
+  #   first.  This function returns the number of sockets ready for reading,
+  #   or -1 if there was an error with the select() system call.
+  #*
+proc SDLNet_CheckSockets*(theSet: PSDLNet_SocketSet, timeout: Sint32): int{.
+    cdecl, importc, dynlib: SDLNetLibName.}
+  #* After calling SDLNet_CheckSockets(), you can use this function on a
+  #   socket that was in the socket set, to find out if data is available
+  #   for reading.
+  #*
+proc SDLNet_SocketReady*(sock: PSDLNet_GenericSocket): bool
+  #* Free a set of sockets allocated by SDL_NetAllocSocketSet() *
+proc SDLNet_FreeSocketSet*(theSet: PSDLNet_SocketSet){.cdecl, 
+    importc, dynlib: SDLNetLibName.}
+  #***********************************************************************
+  #* Platform-independent data conversion functions                      *
+  #***********************************************************************
+  #* Write a 16/32 bit value to network packet buffer *
+proc SDLNet_Write16*(value: Uint16, area: Pointer){.cdecl, importc, dynlib: SDLNetLibName.}
+proc SDLNet_Write32*(value: Uint32, area: Pointer){.cdecl, importc, dynlib: SDLNetLibName.}
+  #* Read a 16/32 bit value from network packet buffer *
+proc SDLNet_Read16*(area: Pointer): Uint16{.cdecl, importc, dynlib: SDLNetLibName.}
+proc SDLNet_Read32*(area: Pointer): Uint32{.cdecl, importc, dynlib: SDLNetLibName.}
+  #***********************************************************************
+  #* Error reporting functions                                           *
+  #***********************************************************************
+  #* We'll use SDL's functions for error reporting *
+proc SDLNet_SetError*(fmt: cstring)
+proc SDLNet_GetError*(): cstring
+# implementation
+
+proc SDL_NET_VERSION(X: var TSDL_version) = 
+  X.major = SDL_NET_MAJOR_VERSION
+  X.minor = SDL_NET_MINOR_VERSION
+  X.patch = SDL_NET_PATCHLEVEL
+
+proc SDLNet_TCP_AddSocket(theSet: PSDLNet_SocketSet, sock: PTCPSocket): int = 
+  result = SDLNet_AddSocket(theSet, cast[PSDLNet_GenericSocket](sock))
+
+proc SDLNet_UDP_AddSocket(theSet: PSDLNet_SocketSet, sock: PUDPSocket): int = 
+  result = SDLNet_AddSocket(theSet, cast[PSDLNet_GenericSocket](sock))
+
+proc SDLNet_TCP_DelSocket(theSet: PSDLNet_SocketSet, sock: PTCPSocket): int = 
+  result = SDLNet_DelSocket(theSet, cast[PSDLNet_GenericSocket](sock))
+
+proc SDLNet_UDP_DelSocket(theSet: PSDLNet_SocketSet, sock: PUDPSocket): int = 
+  result = SDLNet_DelSocket(theSet, cast[PSDLNet_GenericSocket](sock))
+
+proc SDLNet_SocketReady(sock: PSDLNet_GenericSocket): bool = 
+  result = ((sock != nil) and (sock.ready == 1))
+
+proc SDLNet_SetError(fmt: cstring) = 
+  SDL_SetError(fmt)
+
+proc SDLNet_GetError(): cstring = 
+  result = SDL_GetError()

lib/oldwrappers/sdl/sdl_ttf.nim

@@ -0,0 +1,346 @@
+
+#
+#  $Id: sdl_ttf.pas,v 1.18 2007/06/01 11:16:33 savage Exp $
+#
+#
+#******************************************************************************
+#                                                                              
+#          JEDI-SDL : Pascal units for SDL - Simple DirectMedia Layer          
+#       Conversion of the Simple DirectMedia Layer Headers                     
+#                                                                              
+# Portions created by Sam Lantinga <slouken@devolution.com> are                
+# Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga                     
+# 5635-34 Springhouse Dr.                                                      
+# Pleasanton, CA 94588 (USA)                                                   
+#                                                                              
+# All Rights Reserved.                                                         
+#                                                                              
+# The original files are : SDL_ttf.h                                           
+#                                                                              
+# The initial developer of this Pascal code was :                              
+# Dominqiue Louis <Dominique@SavageSoftware.com.au>                            
+#                                                                              
+# Portions created by Dominqiue Louis are                                      
+# Copyright (C) 2000 - 2001 Dominqiue Louis.                                   
+#                                                                              
+#                                                                              
+# Contributor(s)                                                               
+# --------------                                                               
+# Tom Jones <tigertomjones@gmx.de>  His Project inspired this conversion       
+#                                                                              
+# Obtained through:                                                            
+# Joint Endeavour of Delphi Innovators ( Project JEDI )                        
+#                                                                              
+# You may retrieve the latest version of this file at the Project              
+# JEDI home page, located at http://delphi-jedi.org                            
+#                                                                              
+# The contents of this file are used with permission, subject to               
+# the Mozilla Public License Version 1.1 (the "License"); you may              
+# not use this file except in compliance with the License. You may             
+# obtain a copy of the License at                                              
+# http://www.mozilla.org/MPL/MPL-1.1.html                                      
+#                                                                              
+# Software distributed under the License is distributed on an                  
+# "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or               
+# implied. See the License for the specific language governing                 
+# rights and limitations under the License.                                    
+#                                                                              
+# Description                                                                  
+# -----------                                                                  
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+# Requires                                                                     
+# --------                                                                     
+#   The SDL Runtime libraris on Win32  : SDL.dll on Linux : libSDL.so          
+#   They are available from...                                                 
+#   http://www.libsdl.org .                                                    
+#                                                                              
+# Programming Notes                                                            
+# -----------------                                                            
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+# Revision History                                                             
+# ----------------                                                             
+#   December 08 2002 - DL : Fixed definition of TTF_RenderUnicode_Solid        
+#                                                                              
+#   April   03 2003 - DL : Added jedi-sdl.inc include file to support more     
+#                          Pascal compilers. Initial support is now included   
+#                          for GnuPascal, VirtualPascal, TMT and obviously     
+#                          continue support for Delphi Kylix and FreePascal.   
+#                                                                              
+#   April   24 2003 - DL : under instruction from Alexey Barkovoy, I have added
+#                          better TMT Pascal support and under instruction     
+#                          from Prof. Abimbola Olowofoyeku (The African Chief),
+#                          I have added better Gnu Pascal support              
+#                                                                              
+#   April   30 2003 - DL : under instruction from David Mears AKA              
+#                          Jason Siletto, I have added FPC Linux support.      
+#                          This was compiled with fpc 1.1, so remember to set  
+#                          include file path. ie. -Fi/usr/share/fpcsrc/rtl/*   
+#                                                                              
+#
+#  $Log: sdl_ttf.pas,v $
+#  Revision 1.18  2007/06/01 11:16:33  savage
+#  Added IFDEF UNIX for Workaround.
+#
+#  Revision 1.17  2007/06/01 08:38:21  savage
+#  Added TTF_RenderText_Solid workaround as suggested by Michalis Kamburelis
+#
+#  Revision 1.16  2007/05/29 21:32:14  savage
+#  Changes as suggested by Almindor for 64bit compatibility.
+#
+#  Revision 1.15  2007/05/20 20:32:45  savage
+#  Initial Changes to Handle 64 Bits
+#
+#  Revision 1.14  2006/12/02 00:19:01  savage
+#  Updated to latest version
+#
+#  Revision 1.13  2005/04/10 11:48:33  savage
+#  Changes as suggested by Michalis, thanks.
+#
+#  Revision 1.12  2005/01/05 01:47:14  savage
+#  Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively.
+#
+#  Revision 1.11  2005/01/04 23:14:57  savage
+#  Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively.
+#
+#  Revision 1.10  2005/01/02 19:07:32  savage
+#  Slight bug fix to use LongInt instead of Long ( Thanks Michalis Kamburelis )
+#
+#  Revision 1.9  2005/01/01 02:15:20  savage
+#  Updated to v2.0.7
+#
+#  Revision 1.8  2004/10/07 21:02:32  savage
+#  Fix for FPC
+#
+#  Revision 1.7  2004/09/30 22:39:50  savage
+#  Added a true type font class which contains a wrap text function.
+#  Changed the sdl_ttf.pas header to reflect the future of jedi-sdl.
+#
+#  Revision 1.6  2004/08/14 22:54:30  savage
+#  Updated so that Library name defines are correctly defined for MacOS X.
+#
+#  Revision 1.5  2004/05/10 14:10:04  savage
+#  Initial MacOS X support. Fixed defines for MACOS ( Classic ) and DARWIN ( MacOS X ).
+#
+#  Revision 1.4  2004/04/13 09:32:08  savage
+#  Changed Shared object names back to just the .so extension to avoid conflicts on various Linux/Unix distros. Therefore developers will need to create Symbolic links to the actual Share Objects if necessary.
+#
+#  Revision 1.3  2004/04/01 20:53:24  savage
+#  Changed Linux Shared Object names so they reflect the Symbolic Links that are created when installing the RPMs from the SDL site.
+#
+#  Revision 1.2  2004/03/30 20:23:28  savage
+#  Tidied up use of UNIX compiler directive.
+#
+#  Revision 1.1  2004/02/16 22:16:40  savage
+#  v1.0 changes
+#
+#  
+#
+#******************************************************************************
+#
+#  Define this to workaround a known bug in some freetype versions.
+#  The error manifests as TTF_RenderGlyph_Solid returning nil (error)
+#  and error message (in SDL_Error) is
+#  "Failed loading DPMSDisable: /usr/lib/libX11.so.6: undefined symbol: DPMSDisable"
+#  See [http://lists.libsdl.org/pipermail/sdl-libsdl.org/2007-March/060459.html]
+#
+
+import sdl
+
+when defined(windows):
+  const SDLttfLibName = "SDL_ttf.dll"
+elif defined(macosx):
+  const SDLttfLibName = "libSDL_ttf-2.0.0.dylib"
+else:
+  const SDLttfLibName = "libSDL_ttf.so"
+
+const
+  SDL_TTF_MAJOR_VERSION* = 2'i8
+  SDL_TTF_MINOR_VERSION* = 0'i8
+  SDL_TTF_PATCHLEVEL* = 8'i8     # Backwards compatibility
+  TTF_MAJOR_VERSION* = SDL_TTF_MAJOR_VERSION
+  TTF_MINOR_VERSION* = SDL_TTF_MINOR_VERSION
+  TTF_PATCHLEVEL* = SDL_TTF_PATCHLEVEL #*
+                                       #   Set and retrieve the font style
+                                       #   This font style is implemented by modifying the font glyphs, and
+                                       #   doesn't reflect any inherent properties of the truetype font file.
+                                       #*
+  TTF_STYLE_NORMAL* = 0x00000000
+  TTF_STYLE_BOLD* = 0x00000001
+  TTF_STYLE_ITALIC* = 0x00000002
+  TTF_STYLE_UNDERLINE* = 0x00000004 # ZERO WIDTH NO-BREAKSPACE (Unicode byte order mark)
+  UNICODE_BOM_NATIVE* = 0x0000FEFF
+  UNICODE_BOM_SWAPPED* = 0x0000FFFE
+
+type 
+  PTTF_Font* = ptr TTTF_font
+  TTTF_Font*{.final.} = object  # This macro can be used to fill a version structure with the compile-time
+                                #  version of the SDL_ttf library. 
+
+proc SDL_TTF_VERSION*(X: var TSDL_version)
+  # This function gets the version of the dynamically linked SDL_ttf library.
+  #     It should NOT be used to fill a version structure, instead you should use the
+  #     SDL_TTF_VERSION() macro. 
+proc TTF_Linked_Version*(): PSDL_version{.cdecl, importc, dynlib: SDLttfLibName.}
+  # This function tells the library whether UNICODE text is generally
+  #   byteswapped.  A UNICODE BOM character in a string will override
+  #   this setting for the remainder of that string.
+  #
+proc TTF_ByteSwappedUNICODE*(swapped: int){.cdecl, importc, dynlib: SDLttfLibName.}
+  #returns 0 on succes, -1 if error occurs
+proc TTF_Init*(): int{.cdecl, importc, dynlib: SDLttfLibName.}
+  #
+  # Open a font file and create a font of the specified point size.
+  # Some .fon fonts will have several sizes embedded in the file, so the
+  # point size becomes the index of choosing which size.  If the value
+  # is too high, the last indexed size will be the default.
+  #
+proc TTF_OpenFont*(filename: cstring, ptsize: int): PTTF_Font{.cdecl, 
+    importc, dynlib: SDLttfLibName.}
+proc TTF_OpenFontIndex*(filename: cstring, ptsize: int, index: int32): PTTF_Font{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+proc TTF_OpenFontRW*(src: PSDL_RWops, freesrc: int, ptsize: int): PTTF_Font{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+proc TTF_OpenFontIndexRW*(src: PSDL_RWops, freesrc: int, ptsize: int, 
+                          index: int32): PTTF_Font{.cdecl, importc, dynlib: SDLttfLibName.}
+proc TTF_GetFontStyle*(font: PTTF_Font): int{.cdecl, importc, dynlib: SDLttfLibName.}
+proc TTF_SetFontStyle*(font: PTTF_Font, style: int){.cdecl, 
+    importc, dynlib: SDLttfLibName.}
+  # Get the total height of the font - usually equal to point size 
+proc TTF_FontHeight*(font: PTTF_Font): int{.cdecl, importc, dynlib: SDLttfLibName.}
+  # Get the offset from the baseline to the top of the font
+  #   This is a positive value, relative to the baseline.
+  #
+proc TTF_FontAscent*(font: PTTF_Font): int{.cdecl, importc, dynlib: SDLttfLibName.}
+  # Get the offset from the baseline to the bottom of the font
+  #   This is a negative value, relative to the baseline.
+  #
+proc TTF_FontDescent*(font: PTTF_Font): int{.cdecl, importc, dynlib: SDLttfLibName.}
+  # Get the recommended spacing between lines of text for this font 
+proc TTF_FontLineSkip*(font: PTTF_Font): int{.cdecl, importc, dynlib: SDLttfLibName.}
+  # Get the number of faces of the font 
+proc TTF_FontFaces*(font: PTTF_Font): int32{.cdecl, importc, dynlib: SDLttfLibName.}
+  # Get the font face attributes, if any 
+proc TTF_FontFaceIsFixedWidth*(font: PTTF_Font): int{.cdecl, 
+    importc, dynlib: SDLttfLibName.}
+proc TTF_FontFaceFamilyName*(font: PTTF_Font): cstring{.cdecl, 
+    importc, dynlib: SDLttfLibName.}
+proc TTF_FontFaceStyleName*(font: PTTF_Font): cstring{.cdecl, 
+    importc, dynlib: SDLttfLibName.}
+  # Get the metrics (dimensions) of a glyph 
+proc TTF_GlyphMetrics*(font: PTTF_Font, ch: Uint16, minx: var int, 
+                       maxx: var int, miny: var int, maxy: var int, 
+                       advance: var int): int{.cdecl, importc, dynlib: SDLttfLibName.}
+  # Get the dimensions of a rendered string of text 
+proc TTF_SizeText*(font: PTTF_Font, text: cstring, w: var int, y: var int): int{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+proc TTF_SizeUTF8*(font: PTTF_Font, text: cstring, w: var int, y: var int): int{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+proc TTF_SizeUNICODE*(font: PTTF_Font, text: PUint16, w: var int, y: var int): int{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+  # Create an 8-bit palettized surface and render the given text at
+  #   fast quality with the given font and color.  The 0 pixel is the
+  #   colorkey, giving a transparent background, and the 1 pixel is set
+  #   to the text color.
+  #   This function returns the new surface, or NULL if there was an error.
+  #
+proc TTF_RenderUTF8_Solid*(font: PTTF_Font, text: cstring, fg: TSDL_Color): PSDL_Surface{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+proc TTF_RenderUNICODE_Solid*(font: PTTF_Font, text: PUint16, fg: TSDL_Color): PSDL_Surface{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+  #
+  #Create an 8-bit palettized surface and render the given glyph at
+  #   fast quality with the given font and color.  The 0 pixel is the
+  #   colorkey, giving a transparent background, and the 1 pixel is set
+  #   to the text color.  The glyph is rendered without any padding or
+  #   centering in the X direction, and aligned normally in the Y direction.
+  #   This function returns the new surface, or NULL if there was an error.
+  #
+proc TTF_RenderGlyph_Solid*(font: PTTF_Font, ch: Uint16, fg: TSDL_Color): PSDL_Surface{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+  # Create an 8-bit palettized surface and render the given text at
+  #   high quality with the given font and colors.  The 0 pixel is background,
+  #   while other pixels have varying degrees of the foreground color.
+  #   This function returns the new surface, or NULL if there was an error.
+  #
+proc TTF_RenderText_Shaded*(font: PTTF_Font, text: cstring, fg: TSDL_Color, 
+                            bg: TSDL_Color): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDLttfLibName.}
+proc TTF_RenderUTF8_Shaded*(font: PTTF_Font, text: cstring, fg: TSDL_Color, 
+                            bg: TSDL_Color): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDLttfLibName.}
+proc TTF_RenderUNICODE_Shaded*(font: PTTF_Font, text: PUint16, fg: TSDL_Color, 
+                               bg: TSDL_Color): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDLttfLibName.}
+  # Create an 8-bit palettized surface and render the given glyph at
+  #   high quality with the given font and colors.  The 0 pixel is background,
+  #   while other pixels have varying degrees of the foreground color.
+  #   The glyph is rendered without any padding or centering in the X
+  #   direction, and aligned normally in the Y direction.
+  #   This function returns the new surface, or NULL if there was an error.
+  #
+proc TTF_RenderGlyph_Shaded*(font: PTTF_Font, ch: Uint16, fg: TSDL_Color, 
+                             bg: TSDL_Color): PSDL_Surface{.cdecl, 
+    importc, dynlib: SDLttfLibName.}
+  # Create a 32-bit ARGB surface and render the given text at high quality,
+  #   using alpha blending to dither the font with the given color.
+  #   This function returns the new surface, or NULL if there was an error.
+  #
+proc TTF_RenderText_Blended*(font: PTTF_Font, text: cstring, fg: TSDL_Color): PSDL_Surface{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+proc TTF_RenderUTF8_Blended*(font: PTTF_Font, text: cstring, fg: TSDL_Color): PSDL_Surface{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+proc TTF_RenderUNICODE_Blended*(font: PTTF_Font, text: PUint16, fg: TSDL_Color): PSDL_Surface{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+  # Create a 32-bit ARGB surface and render the given glyph at high quality,
+  #   using alpha blending to dither the font with the given color.
+  #   The glyph is rendered without any padding or centering in the X
+  #   direction, and aligned normally in the Y direction.
+  #   This function returns the new surface, or NULL if there was an error.
+  #
+proc TTF_RenderGlyph_Blended*(font: PTTF_Font, ch: Uint16, fg: TSDL_Color): PSDL_Surface{.
+    cdecl, importc, dynlib: SDLttfLibName.}
+  # For compatibility with previous versions, here are the old functions 
+  ##define TTF_RenderText(font, text, fg, bg)
+  #	TTF_RenderText_Shaded(font, text, fg, bg)
+  ##define TTF_RenderUTF8(font, text, fg, bg)	
+  #	TTF_RenderUTF8_Shaded(font, text, fg, bg)
+  ##define TTF_RenderUNICODE(font, text, fg, bg)	
+  #	TTF_RenderUNICODE_Shaded(font, text, fg, bg)
+  # Close an opened font file 
+proc TTF_CloseFont*(font: PTTF_Font){.cdecl, importc, dynlib: SDLttfLibName.}
+  #De-initialize TTF engine
+proc TTF_Quit*(){.cdecl, importc, dynlib: SDLttfLibName.}
+  # Check if the TTF engine is initialized
+proc TTF_WasInit*(): int{.cdecl, importc, dynlib: SDLttfLibName.}
+  # We'll use SDL for reporting errors
+proc TTF_SetError*(fmt: cstring)
+proc TTF_GetError*(): cstring
+# implementation
+
+proc SDL_TTF_VERSION(X: var TSDL_version) = 
+  X.major = SDL_TTF_MAJOR_VERSION
+  X.minor = SDL_TTF_MINOR_VERSION
+  X.patch = SDL_TTF_PATCHLEVEL
+
+proc TTF_SetError(fmt: cstring) = 
+  SDL_SetError(fmt)
+
+proc TTF_GetError(): cstring = 
+  result = SDL_GetError()
+
+when not(defined(Workaround_TTF_RenderText_Solid)): 
+  proc TTF_RenderText_Solid*(font: PTTF_Font, text: cstring, fg: TSDL_Color): PSDL_Surface{.
+      cdecl, importc, dynlib: SDLttfLibName.}
+else: 
+  proc TTF_RenderText_Solid(font: PTTF_Font, text: cstring, fg: TSDL_Color): PSDL_Surface = 
+    var Black: TSDL_Color # initialized to zero
+    Result = TTF_RenderText_Shaded(font, text, fg, Black)

lib/oldwrappers/sdl/smpeg.nim

@@ -0,0 +1,319 @@
+
+#******************************************************************************
+#
+#  $Id: smpeg.pas,v 1.7 2004/08/14 22:54:30 savage Exp $
+#  
+#
+#                                                                              
+#       Borland Delphi SMPEG - SDL MPEG Player Library                         
+#       Conversion of the SMPEG - SDL MPEG Player Library                      
+#                                                                              
+# Portions created by Sam Lantinga <slouken@devolution.com> are                
+# Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga                     
+# 5635-34 Springhouse Dr.                                                      
+# Pleasanton, CA 94588 (USA)                                                   
+#                                                                              
+# All Rights Reserved.                                                         
+#                                                                              
+# The original files are : smpeg.h                                             
+#                                                                              
+# The initial developer of this Pascal code was :                              
+# Matthias Thoma <ma.thoma@gmx.de>                                             
+#                                                                              
+# Portions created by Matthias Thoma are                                       
+# Copyright (C) 2000 - 2001 Matthias Thoma.                                    
+#                                                                              
+#                                                                              
+# Contributor(s)                                                               
+# --------------                                                               
+# Tom Jones <tigertomjones@gmx.de>  His Project inspired this conversion       
+# Matthias Thoma <ma.thoma@gmx.de>                                             
+#                                                                              
+# Obtained through:                                                            
+# Joint Endeavour of Delphi Innovators ( Project JEDI )                        
+#                                                                              
+# You may retrieve the latest version of this file at the Project              
+# JEDI home page, located at http://delphi-jedi.org                            
+#                                                                              
+# The contents of this file are used with permission, subject to               
+# the Mozilla Public License Version 1.1 (the "License"); you may              
+# not use this file except in compliance with the License. You may             
+# obtain a copy of the License at                                              
+# http://www.mozilla.org/MPL/MPL-1.1.html                                      
+#                                                                              
+# Software distributed under the License is distributed on an                  
+# "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or               
+# implied. See the License for the specific language governing                 
+# rights and limitations under the License.                                    
+#                                                                              
+# Description                                                                  
+# -----------                                                                  
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+# Requires                                                                     
+# --------                                                                     
+#   The SDL Runtime libraris on Win32  : SDL.dll on Linux : libSDL-1.2.so.0    
+#   They are available from...                                                 
+#   http://www.libsdl.org .                                                    
+#                                                                              
+# Programming Notes                                                            
+# -----------------                                                            
+#                                                                              
+#                                                                              
+#                                                                              
+#                                                                              
+# Revision History                                                             
+# ----------------                                                             
+#   May      08 2001 - MT : Initial conversion                                 
+#                                                                              
+#   October  12 2001 - DA : Various changes as suggested by David Acklam       
+#                                                                              
+#   April   03 2003 - DL : Added jedi-sdl.inc include file to support more     
+#                          Pascal compilers. Initial support is now included   
+#                          for GnuPascal, VirtualPascal, TMT and obviously     
+#                          continue support for Delphi Kylix and FreePascal.   
+#                                                                              
+#   April   08 2003 - MK : Aka Mr Kroket - Added Better FPC support            
+#                          Fixed all invalid calls to DLL.                     
+#                          Changed constant names to:                          
+#                          const                                               
+#                          STATUS_SMPEG_ERROR = -1;                            
+#                          STATUS_SMPEG_STOPPED = 0;                           
+#                          STATUS_SMPEG_PLAYING = 1;                           
+#                          because SMPEG_ERROR is a function (_SMPEG_error     
+#                          isn't correct), and cannot be two elements with the 
+#                          same name                                           
+#                                                                              
+#   April   24 2003 - DL : under instruction from Alexey Barkovoy, I have added
+#                          better TMT Pascal support and under instruction     
+#                          from Prof. Abimbola Olowofoyeku (The African Chief),
+#                          I have added better Gnu Pascal support              
+#                                                                              
+#   April   30 2003 - DL : under instruction from David Mears AKA              
+#                          Jason Siletto, I have added FPC Linux support.      
+#                          This was compiled with fpc 1.1, so remember to set  
+#                          include file path. ie. -Fi/usr/share/fpcsrc/rtl/*   
+#                                                                              
+#
+#  $Log: smpeg.pas,v $
+#  Revision 1.7  2004/08/14 22:54:30  savage
+#  Updated so that Library name defines are correctly defined for MacOS X.
+#
+#  Revision 1.6  2004/05/10 14:10:04  savage
+#  Initial MacOS X support. Fixed defines for MACOS ( Classic ) and DARWIN ( MacOS X ).
+#
+#  Revision 1.5  2004/04/13 09:32:08  savage
+#  Changed Shared object names back to just the .so extension to avoid conflicts on various Linux/Unix distros. Therefore developers will need to create Symbolic links to the actual Share Objects if necessary.
+#
+#  Revision 1.4  2004/04/02 10:40:55  savage
+#  Changed Linux Shared Object name so they reflect the Symbolic Links that are created when installing the RPMs from the SDL site.
+#
+#  Revision 1.3  2004/03/31 22:20:02  savage
+#  Windows unit not used in this file, so it was removed to keep the code tidy.
+#
+#  Revision 1.2  2004/03/30 20:23:28  savage
+#  Tidied up use of UNIX compiler directive.
+#
+#  Revision 1.1  2004/02/14 23:35:42  savage
+#  version 1 of sdl_image, sdl_mixer and smpeg.
+#
+#  
+#
+#******************************************************************************
+
+import
+  sdl
+
+when defined(windows):
+  const SmpegLibName = "smpeg.dll"
+elif defined(macosx):
+  const SmpegLibName = "libsmpeg.dylib"
+else:
+  const SmpegLibName = "libsmpeg.so"
+
+const 
+  SMPEG_FILTER_INFO_MB_ERROR* = 1
+  SMPEG_FILTER_INFO_PIXEL_ERROR* = 2 # Filter info from SMPEG 
+
+type 
+  SMPEG_FilterInfo*{.final.} = object 
+    yuv_mb_square_error*: PUint16
+    yuv_pixel_square_error*: PUint16
+
+  TSMPEG_FilterInfo* = SMPEG_FilterInfo
+  PSMPEG_FilterInfo* = ptr SMPEG_FilterInfo # MPEG filter definition 
+  PSMPEG_Filter* = ptr TSMPEG_Filter # Callback functions for the filter 
+  TSMPEG_FilterCallback* = proc (dest, source: PSDL_Overlay, region: PSDL_Rect, 
+                                 filter_info: PSMPEG_FilterInfo, data: Pointer): Pointer{.
+      cdecl.}
+  TSMPEG_FilterDestroy* = proc (Filter: PSMPEG_Filter): Pointer{.cdecl.} # The filter 
+                                                                         # definition itself 
+  TSMPEG_Filter*{.final.} = object  # The null filter (default). It simply copies the source rectangle to the video overlay. 
+    flags*: Uint32
+    data*: Pointer
+    callback*: TSMPEG_FilterCallback
+    destroy*: TSMPEG_FilterDestroy
+
+
+proc SMPEGfilter_null*(): PSMPEG_Filter{.cdecl, importc, dynlib: SmpegLibName.}
+  # The bilinear filter. A basic low-pass filter that will produce a smoother image. 
+proc SMPEGfilter_bilinear*(): PSMPEG_Filter{.cdecl, importc, dynlib: SmpegLibName.}
+  # The deblocking filter. It filters block borders and non-intra coded blocks to reduce blockiness 
+proc SMPEGfilter_deblocking*(): PSMPEG_Filter{.cdecl, importc, dynlib: SmpegLibName.}
+  #------------------------------------------------------------------------------
+  # SMPEG.h
+  #------------------------------------------------------------------------------
+const 
+  SMPEG_MAJOR_VERSION* = 0'i8
+  SMPEG_MINOR_VERSION* = 4'i8
+  SMPEG_PATCHLEVEL* = 2'i8
+
+type 
+  SMPEG_version*{.final.} = object 
+    major*: UInt8
+    minor*: UInt8
+    patch*: UInt8
+
+  TSMPEG_version* = SMPEG_version
+  PSMPEG_version* = ptr TSMPEG_version # This is the actual SMPEG object
+  TSMPEG*{.final.} = object 
+  PSMPEG* = ptr TSMPEG        # Used to get information about the SMPEG object 
+  TSMPEG_Info*{.final.} = object 
+    has_audio*: int
+    has_video*: int
+    width*: int
+    height*: int
+    current_frame*: int
+    current_fps*: float64
+    audio_string*: array[0..79, char]
+    audio_current_frame*: int
+    current_offset*: UInt32
+    total_size*: UInt32
+    current_time*: float64
+    total_time*: float64
+
+  PSMPEG_Info* = ptr TSMPEG_Info # Possible MPEG status codes 
+
+const 
+  STATUS_SMPEG_ERROR* = - 1
+  STATUS_SMPEG_STOPPED* = 0
+  STATUS_SMPEG_PLAYING* = 1
+
+type 
+  TSMPEGstatus* = int
+  PSMPEGstatus* = ptr int     # Matches the declaration of SDL_UpdateRect() 
+  TSMPEG_DisplayCallback* = proc (dst: PSDL_Surface, x, y: int, w, h: int): Pointer{.
+      cdecl.} # Create a new SMPEG object from an MPEG file.
+              #  On return, if 'info' is not NULL, it will be filled with information
+              #  about the MPEG object.
+              #  This function returns a new SMPEG object.  Use SMPEG_error() to find out
+              #  whether or not there was a problem building the MPEG stream.
+              #  The sdl_audio parameter indicates if SMPEG should initialize the SDL audio
+              #  subsystem. If not, you will have to use the SMPEG_playaudio() function below
+              #  to extract the decoded data. 
+
+proc SMPEG_new*(theFile: cstring, info: PSMPEG_Info, sdl_audio: int): PSMPEG{.
+    cdecl, importc, dynlib: SmpegLibName.}
+  # The same as above for a file descriptor 
+proc SMPEG_new_descr*(theFile: int, info: PSMPEG_Info, sdl_audio: int): PSMPEG{.
+    cdecl, importc, dynlib: SmpegLibName.}
+  #  The same as above but for a raw chunk of data.  SMPEG makes a copy of the
+  #   data, so the application is free to delete after a successful call to this
+  #   function. 
+proc SMPEG_new_data*(data: Pointer, size: int, info: PSMPEG_Info, sdl_audio: int): PSMPEG{.
+    cdecl, importc, dynlib: SmpegLibName.}
+  # Get current information about an SMPEG object 
+proc SMPEG_getinfo*(mpeg: PSMPEG, info: PSMPEG_Info){.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  #procedure SMPEG_getinfo(mpeg: PSMPEG; info: Pointer);
+  #cdecl; external  SmpegLibName;
+  # Enable or disable audio playback in MPEG stream 
+proc SMPEG_enableaudio*(mpeg: PSMPEG, enable: int){.cdecl, importc, dynlib: SmpegLibName.}
+  # Enable or disable video playback in MPEG stream 
+proc SMPEG_enablevideo*(mpeg: PSMPEG, enable: int){.cdecl, importc, dynlib: SmpegLibName.}
+  # Delete an SMPEG object 
+proc SMPEG_delete*(mpeg: PSMPEG){.cdecl, importc, dynlib: SmpegLibName.}
+  # Get the current status of an SMPEG object 
+proc SMPEG_status*(mpeg: PSMPEG): TSMPEGstatus{.cdecl, importc, dynlib: SmpegLibName.}
+  # status
+  # Set the audio volume of an MPEG stream, in the range 0-100 
+proc SMPEG_setvolume*(mpeg: PSMPEG, volume: int){.cdecl, importc, dynlib: SmpegLibName.}
+  # Set the destination surface for MPEG video playback
+  #  'surfLock' is a mutex used to synchronize access to 'dst', and can be NULL.
+  #  'callback' is a function called when an area of 'dst' needs to be updated.
+  #  If 'callback' is NULL, the default function (SDL_UpdateRect) will be used. 
+proc SMPEG_setdisplay*(mpeg: PSMPEG, dst: PSDL_Surface, surfLock: PSDL_mutex, 
+                       callback: TSMPEG_DisplayCallback){.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  # Set or clear looping play on an SMPEG object 
+proc SMPEG_loop*(mpeg: PSMPEG, repeat: int){.cdecl, importc, dynlib: SmpegLibName.}
+  # Scale pixel display on an SMPEG object 
+proc SMPEG_scaleXY*(mpeg: PSMPEG, width, height: int){.cdecl, 
+    importc, dynlib: SmpegLibName.}
+proc SMPEG_scale*(mpeg: PSMPEG, scale: int){.cdecl, importc, dynlib: SmpegLibName.}
+proc SMPEG_Double*(mpeg: PSMPEG, doubleit: bool)
+  # Move the video display area within the destination surface 
+proc SMPEG_move*(mpeg: PSMPEG, x, y: int){.cdecl, importc, dynlib: SmpegLibName.}
+  # Set the region of the video to be shown 
+proc SMPEG_setdisplayregion*(mpeg: PSMPEG, x, y, w, h: int){.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  # Play an SMPEG object 
+proc SMPEG_play*(mpeg: PSMPEG){.cdecl, importc, dynlib: SmpegLibName.}
+  # Pause/Resume playback of an SMPEG object
+proc SMPEG_pause*(mpeg: PSMPEG){.cdecl, importc, dynlib: SmpegLibName.}
+  # Stop playback of an SMPEG object 
+proc SMPEG_stop*(mpeg: PSMPEG){.cdecl, importc, dynlib: SmpegLibName.}
+  # Rewind the play position of an SMPEG object to the beginning of the MPEG 
+proc SMPEG_rewind*(mpeg: PSMPEG){.cdecl, importc, dynlib: SmpegLibName.}
+  # Seek 'bytes' bytes in the MPEG stream 
+proc SMPEG_seek*(mpeg: PSMPEG, bytes: int){.cdecl, importc, dynlib: SmpegLibName.}
+  # Skip 'seconds' seconds in the MPEG stream 
+proc SMPEG_skip*(mpeg: PSMPEG, seconds: float32){.cdecl, importc, dynlib: SmpegLibName.}
+  # Render a particular frame in the MPEG video
+  #   API CHANGE: This function no longer takes a target surface and position.
+  #               Use SMPEG_setdisplay() and SMPEG_move() to set this information. 
+proc SMPEG_renderFrame*(mpeg: PSMPEG, framenum: int){.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  # Render the last frame of an MPEG video 
+proc SMPEG_renderFinal*(mpeg: PSMPEG, dst: PSDL_Surface, x, y: int){.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  # Set video filter 
+proc SMPEG_filter*(mpeg: PSMPEG, filter: PSMPEG_Filter): PSMPEG_Filter{.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  # Return NULL if there is no error in the MPEG stream, or an error message
+  #   if there was a fatal error in the MPEG stream for the SMPEG object. 
+proc SMPEG_error*(mpeg: PSMPEG): cstring{.cdecl, importc, dynlib: SmpegLibName.}
+  # Exported callback function for audio playback.
+  #   The function takes a buffer and the amount of data to fill, and returns
+  #   the amount of data in bytes that was actually written.  This will be the
+  #   amount requested unless the MPEG audio has finished.
+  #
+proc SMPEG_playAudio*(mpeg: PSMPEG, stream: PUInt8, length: int): int{.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  # Wrapper for SMPEG_playAudio() that can be passed to SDL and SDL_mixer 
+proc SMPEG_playAudioSDL*(mpeg: Pointer, stream: PUInt8, length: int){.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  # Get the best SDL audio spec for the audio stream 
+proc SMPEG_wantedSpec*(mpeg: PSMPEG, wanted: PSDL_AudioSpec): int{.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  # Inform SMPEG of the actual SDL audio spec used for sound playback 
+proc SMPEG_actualSpec*(mpeg: PSMPEG, spec: PSDL_AudioSpec){.cdecl, 
+    importc, dynlib: SmpegLibName.}
+  # This macro can be used to fill a version structure with the compile-time
+  #  version of the SDL library. 
+proc SMPEG_GETVERSION*(X: var TSMPEG_version)
+# implementation
+
+proc SMPEG_double(mpeg: PSMPEG, doubleit: bool) = 
+  if doubleit: SMPEG_scale(mpeg, 2)
+  else: SMPEG_scale(mpeg, 1)
+  
+proc SMPEG_GETVERSION(X: var TSMPEG_version) = 
+  X.major = SMPEG_MAJOR_VERSION
+  X.minor = SMPEG_MINOR_VERSION
+  X.patch = SMPEG_PATCHLEVEL

lib/oldwrappers/sqlite3.nim

@@ -0,0 +1,376 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2010 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+{.deadCodeElim: on.}
+
+when defined(windows): 
+  const Sqlite3Lib = "sqlite3.dll"
+elif defined(macosx):
+  const Sqlite3Lib = "sqlite-3.6.13.dylib"
+else: 
+  const Sqlite3Lib = "libsqlite3.so"
+
+const 
+  SQLITE_INTEGER* = 1
+  SQLITE_FLOAT* = 2
+  SQLITE_BLOB* = 4
+  SQLITE_NULL* = 5
+  SQLITE_TEXT* = 3
+  SQLITE3_TEXT* = 3
+  SQLITE_UTF8* = 1
+  SQLITE_UTF16LE* = 2
+  SQLITE_UTF16BE* = 3         # Use native byte order  
+  SQLITE_UTF16* = 4           # sqlite3_create_function only  
+  SQLITE_ANY* = 5             #sqlite_exec return values
+  SQLITE_OK* = 0
+  SQLITE_ERROR* = 1           # SQL error or missing database  
+  SQLITE_INTERNAL* = 2        # An internal logic error in SQLite  
+  SQLITE_PERM* = 3            # Access permission denied  
+  SQLITE_ABORT* = 4           # Callback routine requested an abort  
+  SQLITE_BUSY* = 5            # The database file is locked  
+  SQLITE_LOCKED* = 6          # A table in the database is locked  
+  SQLITE_NOMEM* = 7           # A malloc() failed  
+  SQLITE_READONLY* = 8        # Attempt to write a readonly database  
+  SQLITE_INTERRUPT* = 9       # Operation terminated by sqlite3_interrupt() 
+  SQLITE_IOERR* = 10          # Some kind of disk I/O error occurred  
+  SQLITE_CORRUPT* = 11        # The database disk image is malformed  
+  SQLITE_NOTFOUND* = 12       # (Internal Only) Table or record not found  
+  SQLITE_FULL* = 13           # Insertion failed because database is full  
+  SQLITE_CANTOPEN* = 14       # Unable to open the database file  
+  SQLITE_PROTOCOL* = 15       # Database lock protocol error  
+  SQLITE_EMPTY* = 16          # Database is empty  
+  SQLITE_SCHEMA* = 17         # The database schema changed  
+  SQLITE_TOOBIG* = 18         # Too much data for one row of a table  
+  SQLITE_CONSTRAINT* = 19     # Abort due to contraint violation  
+  SQLITE_MISMATCH* = 20       # Data type mismatch  
+  SQLITE_MISUSE* = 21         # Library used incorrectly  
+  SQLITE_NOLFS* = 22          # Uses OS features not supported on host  
+  SQLITE_AUTH* = 23           # Authorization denied  
+  SQLITE_FORMAT* = 24         # Auxiliary database format error  
+  SQLITE_RANGE* = 25          # 2nd parameter to sqlite3_bind out of range  
+  SQLITE_NOTADB* = 26         # File opened that is not a database file  
+  SQLITE_ROW* = 100           # sqlite3_step() has another row ready  
+  SQLITE_DONE* = 101          # sqlite3_step() has finished executing  
+  SQLITE_COPY* = 0
+  SQLITE_CREATE_INDEX* = 1
+  SQLITE_CREATE_TABLE* = 2
+  SQLITE_CREATE_TEMP_INDEX* = 3
+  SQLITE_CREATE_TEMP_TABLE* = 4
+  SQLITE_CREATE_TEMP_TRIGGER* = 5
+  SQLITE_CREATE_TEMP_VIEW* = 6
+  SQLITE_CREATE_TRIGGER* = 7
+  SQLITE_CREATE_VIEW* = 8
+  SQLITE_DELETE* = 9
+  SQLITE_DROP_INDEX* = 10
+  SQLITE_DROP_TABLE* = 11
+  SQLITE_DROP_TEMP_INDEX* = 12
+  SQLITE_DROP_TEMP_TABLE* = 13
+  SQLITE_DROP_TEMP_TRIGGER* = 14
+  SQLITE_DROP_TEMP_VIEW* = 15
+  SQLITE_DROP_TRIGGER* = 16
+  SQLITE_DROP_VIEW* = 17
+  SQLITE_INSERT* = 18
+  SQLITE_PRAGMA* = 19
+  SQLITE_READ* = 20
+  SQLITE_SELECT* = 21
+  SQLITE_TRANSACTION* = 22
+  SQLITE_UPDATE* = 23
+  SQLITE_ATTACH* = 24
+  SQLITE_DETACH* = 25
+  SQLITE_ALTER_TABLE* = 26
+  SQLITE_REINDEX* = 27
+  SQLITE_DENY* = 1
+  SQLITE_IGNORE* = 2          # Original from sqlite3.h: 
+                              ##define SQLITE_STATIC      ((void(*)(void *))0)
+                              ##define SQLITE_TRANSIENT   ((void(*)(void *))-1)
+
+const 
+  SQLITE_STATIC* = nil
+  SQLITE_TRANSIENT* = cast[pointer](-1)
+
+type 
+  sqlite_int64* = int64
+  PPPChar* = ptr ptr cstring
+  TSqlite3 {.pure, final.} = object
+  Psqlite3* = ptr TSqlite3
+  PPSqlite3* = ptr PSqlite3
+  TSqlLite3Context {.pure, final.} = object
+  Psqlite3_context* = ptr TSqlLite3Context
+  Tsqlite3_stmt {.pure, final.} = object
+  Psqlite3_stmt* = ptr TSqlite3_stmt
+  PPsqlite3_stmt* = ptr Psqlite3_stmt
+  Tsqlite3_value {.pure, final.} = object
+  Psqlite3_value* = ptr Tsqlite3_value
+  PPsqlite3_value* = ptr Psqlite3_value #Callback function types
+                                        #Notice that most functions 
+                                        #were named using as prefix the 
+                                        #function name that uses them,
+                                        #rather than describing their functions  
+  Tsqlite3_callback* = proc (para1: pointer, para2: int32, para3, 
+                             para4: cstringArray): int32{.cdecl.}
+  Tbind_destructor_func* = proc (para1: pointer){.cdecl.}
+  Tcreate_function_step_func* = proc (para1: Psqlite3_context, para2: int32, 
+                                     para3: PPsqlite3_value){.cdecl.}
+  Tcreate_function_func_func* = proc (para1: Psqlite3_context, para2: int32, 
+                                     para3: PPsqlite3_value){.cdecl.}
+  Tcreate_function_final_func* = proc (para1: Psqlite3_context){.cdecl.}
+  Tsqlite3_result_func* = proc (para1: pointer){.cdecl.}
+  Tsqlite3_create_collation_func* = proc (para1: pointer, para2: int32, 
+      para3: pointer, para4: int32, para5: pointer): int32{.cdecl.}
+  Tsqlite3_collation_needed_func* = proc (para1: pointer, para2: Psqlite3, 
+      eTextRep: int32, para4: cstring){.cdecl.}
+
+proc sqlite3_close*(para1: Psqlite3): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_close".}
+proc sqlite3_exec*(para1: Psqlite3, sql: cstring, para3: Tsqlite3_callback, 
+                   para4: pointer, errmsg: var cstring): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_exec".}
+proc sqlite3_last_insert_rowid*(para1: Psqlite3): sqlite_int64{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_last_insert_rowid".}
+proc sqlite3_changes*(para1: Psqlite3): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_changes".}
+proc sqlite3_total_changes*(para1: Psqlite3): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_total_changes".}
+proc sqlite3_interrupt*(para1: Psqlite3){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_interrupt".}
+proc sqlite3_complete*(sql: cstring): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_complete".}
+proc sqlite3_complete16*(sql: pointer): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_complete16".}
+proc sqlite3_busy_handler*(para1: Psqlite3, 
+    para2: proc (para1: pointer, para2: int32): int32 {.cdecl.}, 
+    para3: pointer): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_busy_handler".}
+proc sqlite3_busy_timeout*(para1: Psqlite3, ms: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_busy_timeout".}
+proc sqlite3_get_table*(para1: Psqlite3, sql: cstring, resultp: var cstringArray, 
+                        nrow, ncolumn: var cint, errmsg: ptr cstring): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_get_table".}
+proc sqlite3_free_table*(result: cstringArray){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_free_table".}
+  # Todo: see how translate sqlite3_mprintf, sqlite3_vmprintf, sqlite3_snprintf
+  # function sqlite3_mprintf(_para1:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_mprintf';
+proc sqlite3_mprintf*(para1: cstring): cstring{.cdecl, varargs, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_mprintf".}
+  #function sqlite3_vmprintf(_para1:Pchar; _para2:va_list):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_vmprintf';
+proc sqlite3_free*(z: cstring){.cdecl, dynlib: Sqlite3Lib, 
+                                importc: "sqlite3_free".}
+  #function sqlite3_snprintf(_para1:longint; _para2:Pchar; _para3:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_snprintf';
+proc sqlite3_snprintf*(para1: int32, para2: cstring, para3: cstring): cstring{.
+    cdecl, dynlib: Sqlite3Lib, varargs, importc: "sqlite3_snprintf".}
+proc sqlite3_set_authorizer*(para1: Psqlite3, 
+                             xAuth: proc (para1: pointer, para2: int32, 
+                                      para3: cstring, para4: cstring, 
+                                      para5: cstring, 
+                                      para6: cstring): int32{.cdecl.}, 
+                             pUserData: pointer): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_set_authorizer".}
+proc sqlite3_trace*(para1: Psqlite3, 
+                    xTrace: proc (para1: pointer, para2: cstring){.cdecl.}, 
+                    para3: pointer): pointer{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_trace".}
+proc sqlite3_progress_handler*(para1: Psqlite3, para2: int32, 
+                               para3: proc (para1: pointer): int32 {.cdecl.}, 
+                               para4: pointer){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_progress_handler".}
+proc sqlite3_commit_hook*(para1: Psqlite3, 
+                          para2: proc (para1: pointer): int32{.cdecl.}, 
+                          para3: pointer): pointer{.cdecl, dynlib: Sqlite3Lib,
+    importc: "sqlite3_commit_hook".}
+proc sqlite3_open*(filename: cstring, ppDb: var Psqlite3): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_open".}
+proc sqlite3_open16*(filename: pointer, ppDb: var Psqlite3): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_open16".}
+proc sqlite3_errcode*(db: Psqlite3): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_errcode".}
+proc sqlite3_errmsg*(para1: Psqlite3): cstring{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_errmsg".}
+proc sqlite3_errmsg16*(para1: Psqlite3): pointer{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_errmsg16".}
+proc sqlite3_prepare*(db: Psqlite3, zSql: cstring, nBytes: int32, 
+                      ppStmt: PPsqlite3_stmt, pzTail: ptr cstring): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_prepare".}
+proc sqlite3_prepare16*(db: Psqlite3, zSql: pointer, nBytes: int32, 
+                        ppStmt: PPsqlite3_stmt, pzTail: var pointer): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_prepare16".}
+proc sqlite3_bind_blob*(para1: Psqlite3_stmt, para2: int32, para3: pointer, 
+                        n: int32, para5: Tbind_destructor_func): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_blob".}
+proc sqlite3_bind_double*(para1: Psqlite3_stmt, para2: int32, para3: float64): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_double".}
+proc sqlite3_bind_int*(para1: Psqlite3_stmt, para2: int32, para3: int32): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_int".}
+proc sqlite3_bind_int64*(para1: Psqlite3_stmt, para2: int32, para3: sqlite_int64): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_int64".}
+proc sqlite3_bind_null*(para1: Psqlite3_stmt, para2: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_null".}
+proc sqlite3_bind_text*(para1: Psqlite3_stmt, para2: int32, para3: cstring, 
+                        n: int32, para5: Tbind_destructor_func): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_text".}
+proc sqlite3_bind_text16*(para1: Psqlite3_stmt, para2: int32, para3: pointer, 
+                          para4: int32, para5: Tbind_destructor_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_text16".}
+  #function sqlite3_bind_value(_para1:Psqlite3_stmt; _para2:longint; _para3:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_value';
+  #These overloaded functions were introduced to allow the use of SQLITE_STATIC and SQLITE_TRANSIENT
+  #It's the c world man ;-)
+proc sqlite3_bind_blob*(para1: Psqlite3_stmt, para2: int32, para3: pointer, 
+                        n: int32, para5: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_blob".}
+proc sqlite3_bind_text*(para1: Psqlite3_stmt, para2: int32, para3: cstring, 
+                        n: int32, para5: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_text".}
+proc sqlite3_bind_text16*(para1: Psqlite3_stmt, para2: int32, para3: pointer, 
+                          para4: int32, para5: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_text16".}
+proc sqlite3_bind_parameter_count*(para1: Psqlite3_stmt): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_parameter_count".}
+proc sqlite3_bind_parameter_name*(para1: Psqlite3_stmt, para2: int32): cstring{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_parameter_name".}
+proc sqlite3_bind_parameter_index*(para1: Psqlite3_stmt, zName: cstring): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_parameter_index".}
+  #function sqlite3_clear_bindings(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_clear_bindings';
+proc sqlite3_column_count*(pStmt: Psqlite3_stmt): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_count".}
+proc sqlite3_column_name*(para1: Psqlite3_stmt, para2: int32): cstring{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_name".}
+proc sqlite3_column_name16*(para1: Psqlite3_stmt, para2: int32): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_name16".}
+proc sqlite3_column_decltype*(para1: Psqlite3_stmt, i: int32): cstring{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_decltype".}
+proc sqlite3_column_decltype16*(para1: Psqlite3_stmt, para2: int32): pointer{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_column_decltype16".}
+proc sqlite3_step*(para1: Psqlite3_stmt): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_step".}
+proc sqlite3_data_count*(pStmt: Psqlite3_stmt): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_data_count".}
+proc sqlite3_column_blob*(para1: Psqlite3_stmt, iCol: int32): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_blob".}
+proc sqlite3_column_bytes*(para1: Psqlite3_stmt, iCol: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_bytes".}
+proc sqlite3_column_bytes16*(para1: Psqlite3_stmt, iCol: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_bytes16".}
+proc sqlite3_column_double*(para1: Psqlite3_stmt, iCol: int32): float64{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_double".}
+proc sqlite3_column_int*(para1: Psqlite3_stmt, iCol: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_int".}
+proc sqlite3_column_int64*(para1: Psqlite3_stmt, iCol: int32): sqlite_int64{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_column_int64".}
+proc sqlite3_column_text*(para1: Psqlite3_stmt, iCol: int32): cstring{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_text".}
+proc sqlite3_column_text16*(para1: Psqlite3_stmt, iCol: int32): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_text16".}
+proc sqlite3_column_type*(para1: Psqlite3_stmt, iCol: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_type".}
+proc sqlite3_finalize*(pStmt: Psqlite3_stmt): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_finalize".}
+proc sqlite3_reset*(pStmt: Psqlite3_stmt): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_reset".}
+proc sqlite3_create_function*(para1: Psqlite3, zFunctionName: cstring, 
+                              nArg: int32, eTextRep: int32, para5: pointer, 
+                              xFunc: Tcreate_function_func_func, 
+                              xStep: Tcreate_function_step_func, 
+                              xFinal: Tcreate_function_final_func): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_create_function".}
+proc sqlite3_create_function16*(para1: Psqlite3, zFunctionName: pointer, 
+                                nArg: int32, eTextRep: int32, para5: pointer, 
+                                xFunc: Tcreate_function_func_func, 
+                                xStep: Tcreate_function_step_func, 
+                                xFinal: Tcreate_function_final_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_create_function16".}
+proc sqlite3_aggregate_count*(para1: Psqlite3_context): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_aggregate_count".}
+proc sqlite3_value_blob*(para1: Psqlite3_value): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_blob".}
+proc sqlite3_value_bytes*(para1: Psqlite3_value): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_bytes".}
+proc sqlite3_value_bytes16*(para1: Psqlite3_value): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_bytes16".}
+proc sqlite3_value_double*(para1: Psqlite3_value): float64{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_double".}
+proc sqlite3_value_int*(para1: Psqlite3_value): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_int".}
+proc sqlite3_value_int64*(para1: Psqlite3_value): sqlite_int64{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_int64".}
+proc sqlite3_value_text*(para1: Psqlite3_value): cstring{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_text".}
+proc sqlite3_value_text16*(para1: Psqlite3_value): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_text16".}
+proc sqlite3_value_text16le*(para1: Psqlite3_value): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_text16le".}
+proc sqlite3_value_text16be*(para1: Psqlite3_value): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_text16be".}
+proc sqlite3_value_type*(para1: Psqlite3_value): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_type".}
+proc sqlite3_aggregate_context*(para1: Psqlite3_context, nBytes: int32): pointer{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_aggregate_context".}
+proc sqlite3_user_data*(para1: Psqlite3_context): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_user_data".}
+proc sqlite3_get_auxdata*(para1: Psqlite3_context, para2: int32): pointer{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_get_auxdata".}
+proc sqlite3_set_auxdata*(para1: Psqlite3_context, para2: int32, para3: pointer, 
+                          para4: proc (para1: pointer) {.cdecl.}){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_set_auxdata".}
+proc sqlite3_result_blob*(para1: Psqlite3_context, para2: pointer, para3: int32, 
+                          para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_blob".}
+proc sqlite3_result_double*(para1: Psqlite3_context, para2: float64){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_double".}
+proc sqlite3_result_error*(para1: Psqlite3_context, para2: cstring, para3: int32){.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_result_error".}
+proc sqlite3_result_error16*(para1: Psqlite3_context, para2: pointer, 
+                             para3: int32){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_result_error16".}
+proc sqlite3_result_int*(para1: Psqlite3_context, para2: int32){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_int".}
+proc sqlite3_result_int64*(para1: Psqlite3_context, para2: sqlite_int64){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_int64".}
+proc sqlite3_result_null*(para1: Psqlite3_context){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_result_null".}
+proc sqlite3_result_text*(para1: Psqlite3_context, para2: cstring, para3: int32, 
+                          para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_text".}
+proc sqlite3_result_text16*(para1: Psqlite3_context, para2: pointer, 
+                            para3: int32, para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_text16".}
+proc sqlite3_result_text16le*(para1: Psqlite3_context, para2: pointer, 
+                              para3: int32, para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_text16le".}
+proc sqlite3_result_text16be*(para1: Psqlite3_context, para2: pointer, 
+                              para3: int32, para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_text16be".}
+proc sqlite3_result_value*(para1: Psqlite3_context, para2: Psqlite3_value){.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_result_value".}
+proc sqlite3_create_collation*(para1: Psqlite3, zName: cstring, eTextRep: int32, 
+                               para4: pointer, 
+                               xCompare: Tsqlite3_create_collation_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_create_collation".}
+proc sqlite3_create_collation16*(para1: Psqlite3, zName: cstring, 
+                                 eTextRep: int32, para4: pointer, 
+                                 xCompare: Tsqlite3_create_collation_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_create_collation16".}
+proc sqlite3_collation_needed*(para1: Psqlite3, para2: pointer, 
+                               para3: Tsqlite3_collation_needed_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_collation_needed".}
+proc sqlite3_collation_needed16*(para1: Psqlite3, para2: pointer, 
+                                 para3: Tsqlite3_collation_needed_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_collation_needed16".}
+proc sqlite3_libversion*(): cstring{.cdecl, dynlib: Sqlite3Lib, 
+                                     importc: "sqlite3_libversion".}
+  #Alias for allowing better code portability (win32 is not working with external variables) 
+proc sqlite3_version*(): cstring{.cdecl, dynlib: Sqlite3Lib, 
+                                  importc: "sqlite3_libversion".}
+  # Not published functions
+proc sqlite3_libversion_number*(): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_libversion_number".}
+  #function sqlite3_key(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_key';
+  #function sqlite3_rekey(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_rekey';
+  #function sqlite3_sleep(_para1:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_sleep';
+  #function sqlite3_expired(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_expired';
+  #function sqlite3_global_recover:longint;cdecl; external Sqlite3Lib name 'sqlite3_global_recover';
+# implementation

lib/oldwrappers/tcl.nim

@@ -0,0 +1,857 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2009 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## This module is a wrapper for the TCL programming language.
+
+#
+#  tcl.h --
+# 
+#  This header file describes the externally-visible facilities of the Tcl
+#  interpreter.
+# 
+#  Translated to Pascal Copyright (c) 2002 by Max Artemev
+#  aka Bert Raccoon (bert@furry.ru, bert_raccoon@freemail.ru)
+# 
+# 
+#  Copyright (c) 1998-2000 by Scriptics Corporation.
+#  Copyright (c) 1994-1998 Sun Microsystems, Inc.
+#  Copyright (c) 1993-1996 Lucent Technologies.
+#  Copyright (c) 1987-1994 John Ousterhout, The Regents of the
+#                          University of California, Berkeley.
+# 
+#  ***********************************************************************
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#  ***********************************************************************
+# 
+
+{.deadCodeElim: on.}
+
+when defined(WIN32): 
+  const dllName = "tcl(85|84|83|82|81|80).dll"
+elif defined(macosx): 
+  const dllName = "libtcl(8.5|8.4|8.3|8.2|8.1).dynlib"
+else:
+  const dllName = "libtcl(8.5|8.4|8.3|8.2|8.1).so.(1|0)"
+
+const 
+  TCL_DESTROYED* = 0xDEADDEAD
+  TCL_OK* = 0
+  TCL_ERROR* = 1
+  TCL_RETURN* = 2
+  TCL_BREAK* = 3
+  TCL_CONTINUE* = 4
+  TCL_RESULT_SIZE* = 200
+  MAX_ARGV* = 0x00007FFF
+  TCL_VERSION_MAJOR* = 0
+  TCL_VERSION_MINOR* = 0
+  TCL_NO_EVAL* = 0x00010000
+  TCL_EVAL_GLOBAL* = 0x00020000 # Flag values passed to variable-related procedures. *
+  TCL_GLOBAL_ONLY* = 1
+  TCL_NAMESPACE_ONLY* = 2
+  TCL_APPEND_VALUE* = 4
+  TCL_LIST_ELEMENT* = 8
+  TCL_TRACE_READS* = 0x00000010
+  TCL_TRACE_WRITES* = 0x00000020
+  TCL_TRACE_UNSETS* = 0x00000040
+  TCL_TRACE_DESTROYED* = 0x00000080
+  TCL_INTERP_DESTROYED* = 0x00000100
+  TCL_LEAVE_ERR_MSG* = 0x00000200
+  TCL_PARSE_PART1* = 0x00000400 # Types for linked variables: *
+  TCL_LINK_INT* = 1
+  TCL_LINK_DOUBLE* = 2
+  TCL_LINK_BOOLEAN* = 3
+  TCL_LINK_STRING* = 4
+  TCL_LINK_READ_ONLY* = 0x00000080
+  TCL_SMALL_HASH_TABLE* = 4   # Hash Table *
+  TCL_STRING_KEYS* = 0
+  TCL_ONE_WORD_KEYS* = 1      # Const/enums Tcl_QueuePosition *
+                              # typedef enum {
+  TCL_QUEUE_TAIL* = 0
+  TCL_QUEUE_HEAD* = 1
+  TCL_QUEUE_MARK* = 2         #} Tcl_QueuePosition;
+                              # Event Flags
+  TCL_DONT_WAIT* = 1 shl 1
+  TCL_WINDOW_EVENTS* = 1 shl 2
+  TCL_FILE_EVENTS* = 1 shl 3
+  TCL_TIMER_EVENTS* = 1 shl 4
+  TCL_IDLE_EVENTS* = 1 shl 5  # WAS 0x10 ???? *
+  TCL_ALL_EVENTS* = not TCL_DONT_WAIT 
+
+  TCL_VOLATILE* = 1
+  TCL_STATIC* = 0
+  TCL_DYNAMIC* = 3            # Channel
+  TCL_STDIN* = 1 shl 1
+  TCL_STDOUT* = 1 shl 2
+  TCL_STDERR* = 1 shl 3
+  TCL_ENFORCE_MODE* = 1 shl 4
+  TCL_READABLE* = 1 shl 1
+  TCL_WRITABLE* = 1 shl 2
+  TCL_EXCEPTION* = 1 shl 3    # POSIX *
+  EPERM* = 1 # Operation not permitted; only the owner of the file (or other
+             # resource) or processes with special privileges can perform the
+             # operation.
+             #
+  ENOENT* = 2 # No such file or directory.  This is a "file doesn't exist" error
+              # for ordinary files that are referenced in contexts where they are
+              # expected to already exist.
+              #
+  ESRCH* = 3                  # No process matches the specified process ID. *
+  EINTR* = 4 # Interrupted function call; an asynchronous signal occurred and
+             # prevented completion of the call.  When this happens, you should
+             # try the call again.
+             #
+  EIO* = 5                    # Input/output error; usually used for physical read or write errors. *
+  ENXIO* = 6 # No such device or address.  The system tried to use the device
+             # represented by a file you specified, and it couldn't find the
+             # device.  This can mean that the device file was installed
+             # incorrectly, or that the physical device is missing or not
+             # correctly attached to the computer.
+             #
+  E2BIG* = 7 # Argument list too long; used when the arguments passed to a new
+             # program being executed with one of the `exec' functions (*note
+             # Executing a File::.) occupy too much memory space.  This condition
+             # never arises in the GNU system.
+             #
+  ENOEXEC* = 8 # Invalid executable file format.  This condition is detected by the
+               # `exec' functions; see *Note Executing a File::.
+               #
+  EBADF* = 9 # Bad file descriptor; for example, I/O on a descriptor that has been
+             # closed or reading from a descriptor open only for writing (or vice
+             # versa).
+             #
+  ECHILD* = 10 # There are no child processes.  This error happens on operations
+               # that are supposed to manipulate child processes, when there aren't
+               # any processes to manipulate.
+               #
+  EDEADLK* = 11 # Deadlock avoided; allocating a system resource would have resulted
+                # in a deadlock situation.  The system does not guarantee that it
+                # will notice all such situations.  This error means you got lucky
+                # and the system noticed; it might just hang.  *Note File Locks::,
+                # for an example.
+                #
+  ENOMEM* = 12 # No memory available.  The system cannot allocate more virtual
+               # memory because its capacity is full.
+               #
+  EACCES* = 13 # Permission denied; the file permissions do not allow the attempted
+               # operation.
+               #
+  EFAULT* = 14 # Bad address; an invalid pointer was detected.  In the GNU system,
+               # this error never happens; you get a signal instead.
+               #
+  ENOTBLK* = 15 # A file that isn't a block special file was given in a situation
+                # that requires one.  For example, trying to mount an ordinary file
+                # as a file system in Unix gives this error.
+                #
+  EBUSY* = 16 # Resource busy; a system resource that can't be shared is already
+              # in use.  For example, if you try to delete a file that is the root
+              # of a currently mounted filesystem, you get this error.
+              #
+  EEXIST* = 17 # File exists; an existing file was specified in a context where it
+               # only makes sense to specify a new file.
+               #
+  EXDEV* = 18 # An attempt to make an improper link across file systems was
+              # detected.  This happens not only when you use `link' (*note Hard
+              # Links::.) but also when you rename a file with `rename' (*note
+              # Renaming Files::.).
+              #
+  ENODEV* = 19 # The wrong type of device was given to a function that expects a
+               # particular sort of device.
+               #
+  ENOTDIR* = 20 # A file that isn't a directory was specified when a directory is
+                # required.
+                #
+  EISDIR* = 21 # File is a directory; you cannot open a directory for writing, or
+               # create or remove hard links to it.
+               #
+  EINVAL* = 22 # Invalid argument.  This is used to indicate various kinds of
+               # problems with passing the wrong argument to a library function.
+               #
+  EMFILE* = 24 # The current process has too many files open and can't open any
+               # more.  Duplicate descriptors do count toward this limit.
+               #
+               # In BSD and GNU, the number of open files is controlled by a
+               # resource limit that can usually be increased.  If you get this
+               # error, you might want to increase the `RLIMIT_NOFILE' limit or
+               # make it unlimited; *note Limits on Resources::..
+               #
+  ENFILE* = 23 # There are too many distinct file openings in the entire system.
+               # Note that any number of linked channels count as just one file
+               # opening; see *Note Linked Channels::.  This error never occurs in
+               # the GNU system.
+               #
+  ENOTTY* = 25 # Inappropriate I/O control operation, such as trying to set terminal
+               # modes on an ordinary file.
+               #
+  ETXTBSY* = 26 # An attempt to execute a file that is currently open for writing, or
+                # write to a file that is currently being executed.  Often using a
+                # debugger to run a program is considered having it open for writing
+                # and will cause this error.  (The name stands for "text file
+                # busy".)  This is not an error in the GNU system; the text is
+                # copied as necessary.
+                #
+  EFBIG* = 27 # File too big; the size of a file would be larger than allowed by
+              # the system.
+              #
+  ENOSPC* = 28 # No space left on device; write operation on a file failed because
+               # the disk is full.
+               #
+  ESPIPE* = 29                # Invalid seek operation (such as on a pipe).  *
+  EROFS* = 30                 # An attempt was made to modify something on a read-only file system.  *
+  EMLINK* = 31 # Too many links; the link count of a single file would become too
+               # large.  `rename' can cause this error if the file being renamed
+               # already has as many links as it can take (*note Renaming Files::.).
+               #
+  EPIPE* = 32 # Broken pipe; there is no process reading from the other end of a
+              # pipe.  Every library function that returns this error code also
+              # generates a `SIGPIPE' signal; this signal terminates the program
+              # if not handled or blocked.  Thus, your program will never actually
+              # see `EPIPE' unless it has handled or blocked `SIGPIPE'.
+              #
+  EDOM* = 33 # Domain error; used by mathematical functions when an argument
+             # value does not fall into the domain over which the function is
+             # defined.
+             #
+  ERANGE* = 34 # Range error; used by mathematical functions when the result value
+               # is not representable because of overflow or underflow.
+               #
+  EAGAIN* = 35 # Resource temporarily unavailable; the call might work if you try
+               # again later.  The macro `EWOULDBLOCK' is another name for `EAGAIN';
+               # they are always the same in the GNU C library.
+               #
+  EWOULDBLOCK* = EAGAIN # In the GNU C library, this is another name for `EAGAIN' (above).
+                        # The values are always the same, on every operating system.
+                        # C libraries in many older Unix systems have `EWOULDBLOCK' as a
+                        # separate error code.
+                        #
+  EINPROGRESS* = 36 # An operation that cannot complete immediately was initiated on an
+                    # object that has non-blocking mode selected.  Some functions that
+                    # must always block (such as `connect'; *note Connecting::.) never
+                    # return `EAGAIN'.  Instead, they return `EINPROGRESS' to indicate
+                    # that the operation has begun and will take some time.  Attempts to
+                    # manipulate the object before the call completes return `EALREADY'.
+                    # You can use the `select' function to find out when the pending
+                    # operation has completed; *note Waiting for I/O::..
+                    #
+  EALREADY* = 37 # An operation is already in progress on an object that has
+                 # non-blocking mode selected.
+                 #
+  ENOTSOCK* = 38              # A file that isn't a socket was specified when a socket is required.  *
+  EDESTADDRREQ* = 39 # No default destination address was set for the socket.  You get
+                     # this error when you try to transmit data over a connectionless
+                     # socket, without first specifying a destination for the data with
+                     # `connect'.
+                     #
+  EMSGSIZE* = 40 # The size of a message sent on a socket was larger than the
+                 # supported maximum size.
+                 #
+  EPROTOTYPE* = 41 # The socket type does not support the requested communications
+                   # protocol.
+                   #
+  ENOPROTOOPT* = 42 # You specified a socket option that doesn't make sense for the
+                    # particular protocol being used by the socket.  *Note Socket
+                    # Options::.
+                    #
+  EPROTONOSUPPORT* = 43 # The socket domain does not support the requested communications
+                        # protocol (perhaps because the requested protocol is completely
+                        # invalid.) *Note Creating a Socket::.
+                        #
+  ESOCKTNOSUPPORT* = 44       # The socket type is not supported.  *
+  EOPNOTSUPP* = 45 # The operation you requested is not supported.  Some socket
+                   # functions don't make sense for all types of sockets, and others
+                   # may not be implemented for all communications protocols.  In the
+                   # GNU system, this error can happen for many calls when the object
+                   # does not support the particular operation; it is a generic
+                   # indication that the server knows nothing to do for that call.
+                   #
+  EPFNOSUPPORT* = 46 # The socket communications protocol family you requested is not
+                     # supported.
+                     #
+  EAFNOSUPPORT* = 47 # The address family specified for a socket is not supported; it is
+                     # inconsistent with the protocol being used on the socket.  *Note
+                     # Sockets::.
+                     #
+  EADDRINUSE* = 48 # The requested socket address is already in use.  *Note Socket
+                   # Addresses::.
+                   #
+  EADDRNOTAVAIL* = 49 # The requested socket address is not available; for example, you
+                      # tried to give a socket a name that doesn't match the local host
+                      # name.  *Note Socket Addresses::.
+                      #
+  ENETDOWN* = 50              # A socket operation failed because the network was down.  *
+  ENETUNREACH* = 51 # A socket operation failed because the subnet containing the remote
+                    # host was unreachable.
+                    #
+  ENETRESET* = 52             # A network connection was reset because the remote host crashed.  *
+  ECONNABORTED* = 53          # A network connection was aborted locally. *
+  ECONNRESET* = 54 # A network connection was closed for reasons outside the control of
+                   # the local host, such as by the remote machine rebooting or an
+                   # unrecoverable protocol violation.
+                   #
+  ENOBUFS* = 55 # The kernel's buffers for I/O operations are all in use.  In GNU,
+                # this error is always synonymous with `ENOMEM'; you may get one or
+                # the other from network operations.
+                #
+  EISCONN* = 56 # You tried to connect a socket that is already connected.  *Note
+                # Connecting::.
+                #
+  ENOTCONN* = 57 # The socket is not connected to anything.  You get this error when
+                 # you try to transmit data over a socket, without first specifying a
+                 # destination for the data.  For a connectionless socket (for
+                 # datagram protocols, such as UDP), you get `EDESTADDRREQ' instead.
+                 #
+  ESHUTDOWN* = 58             # The socket has already been shut down.  *
+  ETOOMANYREFS* = 59          # ???  *
+  ETIMEDOUT* = 60 # A socket operation with a specified timeout received no response
+                  # during the timeout period.
+                  #
+  ECONNREFUSED* = 61 # A remote host refused to allow the network connection (typically
+                     # because it is not running the requested service).
+                     #
+  ELOOP* = 62 # Too many levels of symbolic links were encountered in looking up a
+              # file name.  This often indicates a cycle of symbolic links.
+              #
+  ENAMETOOLONG* = 63 # Filename too long (longer than `PATH_MAX'; *note Limits for
+                     # Files::.) or host name too long (in `gethostname' or
+                     # `sethostname'; *note Host Identification::.).
+                     #
+  EHOSTDOWN* = 64             # The remote host for a requested network connection is down.  *
+  EHOSTUNREACH* = 65 # The remote host for a requested network connection is not
+                     # reachable.
+                     #
+  ENOTEMPTY* = 66 # Directory not empty, where an empty directory was expected.
+                  # Typically, this error occurs when you are trying to delete a
+                  # directory.
+                  #
+  EPROCLIM* = 67 # This means that the per-user limit on new process would be
+                 # exceeded by an attempted `fork'.  *Note Limits on Resources::, for
+                 # details on the `RLIMIT_NPROC' limit.
+                 #
+  EUSERS* = 68                # The file quota system is confused because there are too many users.  *
+  EDQUOT* = 69                # The user's disk quota was exceeded.  *
+  ESTALE* = 70 # Stale NFS file handle.  This indicates an internal confusion in
+               # the NFS system which is due to file system rearrangements on the
+               # server host.  Repairing this condition usually requires unmounting
+               # and remounting the NFS file system on the local host.
+               #
+  EREMOTE* = 71 # An attempt was made to NFS-mount a remote file system with a file
+                # name that already specifies an NFS-mounted file.  (This is an
+                # error on some operating systems, but we expect it to work properly
+                # on the GNU system, making this error code impossible.)
+                #
+  EBADRPC* = 72               # ???  *
+  ERPCMISMATCH* = 73          # ???  *
+  EPROGUNAVAIL* = 74          # ???  *
+  EPROGMISMATCH* = 75         # ???  *
+  EPROCUNAVAIL* = 76          # ???  *
+  ENOLCK* = 77 # No locks available.  This is used by the file locking facilities;
+               # see *Note File Locks::.  This error is never generated by the GNU
+               # system, but it can result from an operation to an NFS server
+               # running another operating system.
+               #
+  ENOSYS* = 78 # Function not implemented.  Some functions have commands or options
+               # defined that might not be supported in all implementations, and
+               # this is the kind of error you get if you request them and they are
+               # not supported.
+               #
+  EFTYPE* = 79 # Inappropriate file type or format.  The file was the wrong type
+               # for the operation, or a data file had the wrong format.
+               # On some systems `chmod' returns this error if you try to set the
+               # sticky bit on a non-directory file; *note Setting Permissions::..
+               #
+
+type 
+  Tcl_Argv* = cstringArray
+  Tcl_ClientData* = pointer
+  Tcl_FreeProc* = proc (theBlock: pointer){.cdecl.}
+  PTcl_Interp* = ptr Tcl_Interp
+  Tcl_Interp*{.final.} = object  #  Event Definitions  *
+    result*: cstring # Do not access this directly. Use
+                     #                          * Tcl_GetStringResult since result
+                     #                          * may be pointing to an object
+                     #                          *
+    freeProc*: Tcl_FreeProc
+    errorLine*: int
+
+  TTcl_EventSetupProc* = proc (clientData: Tcl_ClientData, flags: int){.cdecl.}
+  TTcl_EventCheckProc* = TTcl_EventSetupProc
+  PTcl_Event* = ptr Tcl_Event
+  TTcl_EventProc* = proc (evPtr: PTcl_Event, flags: int): int{.cdecl.}
+  Tcl_Event*{.final.} = object 
+    prc*: TTcl_EventProc
+    nextPtr*: PTcl_Event
+    ClientData*: TObject      # ClientData is just pointer.*
+  
+  PTcl_Time* = ptr Tcl_Time
+  Tcl_Time*{.final.} = object 
+    sec*: int32               # Seconds. * 
+    usec*: int32              # Microseconds. * 
+  
+  Tcl_TimerToken* = pointer
+  PInteger* = ptr int
+  PTcl_HashTable* = pointer
+  PTcl_HashEntry* = ptr Tcl_HashEntry
+  PPTcl_HashEntry* = ptr PTcl_HashEntry
+  Tcl_HashEntry*{.final.} = object  
+    nextPtr*: PTcl_HashEntry
+    tablePtr*: PTcl_HashTable
+    bucketPtr*: PPTcl_HashEntry
+    clientData*: Tcl_ClientData
+    key*: cstring
+
+  Tcl_HashFindProc* = proc (tablePtr: PTcl_HashTable, key: cstring): PTcl_HashEntry{.
+      cdecl.}
+  Tcl_HashCreateProc* = proc (tablePtr: PTcl_HashTable, key: cstring, 
+                              newPtr: PInteger): PTcl_HashEntry{.cdecl.}
+  PHashTable* = ptr Tcl_HashTable
+  Tcl_HashTable*{.final.} = object 
+    buckets*: ppTcl_HashEntry
+    staticBuckets*: array[0..TCL_SMALL_HASH_TABLE - 1, PTcl_HashEntry]
+    numBuckets*: int
+    numEntries*: int
+    rebuildSize*: int
+    downShift*: int
+    mask*: int
+    keyType*: int
+    findProc*: Tcl_HashFindProc
+    createProc*: Tcl_HashCreateProc
+
+  PTcl_HashSearch* = ptr Tcl_HashSearch
+  Tcl_HashSearch*{.final.} = object 
+    tablePtr*: PTcl_HashTable
+    nextIndex*: int
+    nextEntryPtr*: PTcl_HashEntry
+
+  TTclAppInitProc* = proc (interp: pTcl_Interp): int{.cdecl.}
+  TTclPackageInitProc* = proc (interp: pTcl_Interp): int{.cdecl.}
+  TTclCmdProc* = proc (clientData: Tcl_ClientData, interp: pTcl_Interp, 
+                       argc: int, argv: Tcl_Argv): int{.cdecl.}
+  TTclVarTraceProc* = proc (clientData: Tcl_ClientData, interp: pTcl_Interp, 
+                            varName: cstring, elemName: cstring, flags: int): cstring{.
+      cdecl.}
+  TTclFreeProc* = proc (theBlock: pointer){.cdecl.}
+  TTclInterpDeleteProc* = proc (clientData: Tcl_ClientData, interp: pTcl_Interp){.
+      cdecl.}
+  TTclCmdDeleteProc* = proc (clientData: Tcl_ClientData){.cdecl.}
+  TTclNamespaceDeleteProc* = proc (clientData: Tcl_ClientData){.cdecl.}
+
+const 
+  TCL_DSTRING_STATIC_SIZE* = 200
+
+type 
+  PTcl_DString* = ptr Tcl_DString
+  Tcl_DString*{.final.} = object 
+    str*: cstring
+    len*: int
+    spaceAvl*: int
+    staticSpace*: array[0..TCL_DSTRING_STATIC_SIZE - 1, char]
+
+  PTcl_Channel* = ptr Tcl_Channel
+  Tcl_Channel*{.final.} = object 
+  TTclDriverBlockModeProc* = proc (instanceData: Tcl_ClientData, mode: int): int{.
+      cdecl.}
+  TTclDriverCloseProc* = proc (instanceData: Tcl_ClientData, interp: PTcl_Interp): int{.
+      cdecl.}
+  TTclDriverInputProc* = proc (instanceData: Tcl_ClientData, buf: cstring, 
+                               toRead: int, errorCodePtr: PInteger): int{.cdecl.}
+  TTclDriverOutputProc* = proc (instanceData: Tcl_ClientData, buf: cstring, 
+                                toWrite: int, errorCodePtr: PInteger): int{.
+      cdecl.}
+  TTclDriverSeekProc* = proc (instanceData: Tcl_ClientData, offset: int32, 
+                              mode: int, errorCodePtr: PInteger): int{.cdecl.}
+  TTclDriverSetOptionProc* = proc (instanceData: Tcl_ClientData, 
+                                   interp: PTcl_Interp, optionName: cstring, 
+                                   value: cstring): int{.cdecl.}
+  TTclDriverGetOptionProc* = proc (instanceData: Tcl_ClientData, 
+                                   interp: pTcl_Interp, optionName: cstring, 
+                                   dsPtr: PTcl_DString): int{.cdecl.}
+  TTclDriverWatchProc* = proc (instanceData: Tcl_ClientData, mask: int){.cdecl.}
+  TTclDriverGetHandleProc* = proc (instanceData: Tcl_ClientData, direction: int, 
+                                   handlePtr: var Tcl_ClientData): int{.cdecl.}
+  PTcl_ChannelType* = ptr Tcl_ChannelType
+  Tcl_ChannelType*{.final.} = object 
+    typeName*: cstring
+    blockModeProc*: TTclDriverBlockModeProc
+    closeProc*: TTclDriverCloseProc
+    inputProc*: TTclDriverInputProc
+    ouputProc*: TTclDriverOutputProc
+    seekProc*: TTclDriverSeekProc
+    setOptionProc*: TTclDriverSetOptionProc
+    getOptionProc*: TTclDriverGetOptionProc
+    watchProc*: TTclDriverWatchProc
+    getHandleProc*: TTclDriverGetHandleProc
+
+  TTclChannelProc* = proc (clientData: Tcl_ClientData, mask: int){.cdecl.}
+  PTcl_Obj* = ptr Tcl_Obj
+  PPTcl_Obj* = ptr PTcl_Obj
+  Tcl_Obj*{.final.} = object 
+    refCount*: int            # ...
+  
+  TTclObjCmdProc* = proc (clientData: Tcl_ClientData, interp: PTcl_Interp, 
+                          objc: int, PPObj: PPTcl_Obj): int{.cdecl.}
+  PTcl_Namespace* = ptr Tcl_Namespace
+  Tcl_Namespace*{.final.} = object 
+    name*: cstring
+    fullName*: cstring
+    clientData*: Tcl_ClientData
+    deleteProc*: TTclNamespaceDeleteProc
+    parentPtr*: PTcl_Namespace
+
+  PTcl_CallFrame* = ptr Tcl_CallFrame
+  Tcl_CallFrame*{.final.} = object 
+    nsPtr*: PTcl_Namespace
+    dummy1*: int
+    dummy2*: int
+    dummy3*: cstring
+    dummy4*: cstring
+    dummy5*: cstring
+    dummy6*: int
+    dummy7*: cstring
+    dummy8*: cstring
+    dummy9*: int
+    dummy10*: cstring
+
+  PTcl_CmdInfo* = ptr Tcl_CmdInfo
+  Tcl_CmdInfo*{.final.} = object 
+    isNativeObjectProc*: int
+    objProc*: TTclObjCmdProc
+    objClientData*: Tcl_ClientData
+    prc*: TTclCmdProc
+    clientData*: Tcl_ClientData
+    deleteProc*: TTclCmdDeleteProc
+    deleteData*: Tcl_ClientData
+    namespacePtr*: pTcl_Namespace
+
+  pTcl_Command* = ptr Tcl_Command
+  Tcl_Command*{.final.} = object  #       hPtr            : pTcl_HashEntry;
+                                  #        nsPtr           : pTcl_Namespace;
+                                  #        refCount        : integer;
+                                  #        isCmdEpoch      : integer;
+                                  #        compileProc     : pointer;
+                                  #        objProc         : pointer;
+                                  #        objClientData   : Tcl_ClientData;
+                                  #        proc            : pointer;
+                                  #        clientData      : Tcl_ClientData;
+                                  #        deleteProc      : TTclCmdDeleteProc;
+                                  #        deleteData      : Tcl_ClientData;
+                                  #        deleted         : integer;
+                                  #        importRefPtr    : pointer;
+                                  #
+
+type 
+  TTclPanicProc* = proc (fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8: cstring){.
+      cdecl.}                 # 1/15/97 orig. Tcl style
+  TTclClientDataProc* = proc (clientData: Tcl_ClientData){.cdecl.}
+  TTclIdleProc* = proc (clientData: Tcl_ClientData){.cdecl.}
+  TTclTimerProc* = TTclIdleProc
+  TTclCreateCloseHandler* = proc (channel: pTcl_Channel, 
+                                  prc: TTclClientDataProc, 
+                                  clientData: Tcl_ClientData){.cdecl.}
+  TTclDeleteCloseHandler* = TTclCreateCloseHandler
+  TTclEventDeleteProc* = proc (evPtr: pTcl_Event, clientData: Tcl_ClientData): int{.
+      cdecl.}
+
+proc Tcl_Alloc*(size: int): cstring{.cdecl, dynlib: dllName, importc.}
+proc Tcl_CreateInterp*(): pTcl_Interp{.cdecl, dynlib: dllName, importc.}
+proc Tcl_DeleteInterp*(interp: pTcl_Interp){.cdecl, dynlib: dllName, importc.}
+proc Tcl_ResetResult*(interp: pTcl_Interp){.cdecl, dynlib: dllName, importc.}
+proc Tcl_Eval*(interp: pTcl_Interp, script: cstring): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_EvalFile*(interp: pTcl_Interp, filename: cstring): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_AddErrorInfo*(interp: pTcl_Interp, message: cstring){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_BackgroundError*(interp: pTcl_Interp){.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_CreateCommand*(interp: pTcl_Interp, name: cstring, 
+                        cmdProc: TTclCmdProc, clientData: Tcl_ClientData, 
+                        deleteProc: TTclCmdDeleteProc): pTcl_Command{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_DeleteCommand*(interp: pTcl_Interp, name: cstring): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_CallWhenDeleted*(interp: pTcl_Interp, prc: TTclInterpDeleteProc, 
+                          clientData: Tcl_ClientData){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_DontCallWhenDeleted*(interp: pTcl_Interp, prc: TTclInterpDeleteProc, 
+                              clientData: Tcl_ClientData){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_CommandComplete*(cmd: cstring): int{.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_LinkVar*(interp: pTcl_Interp, varName: cstring, varAddr: pointer, 
+                  typ: int): int{.cdecl, dynlib: dllName, importc.}
+proc Tcl_UnlinkVar*(interp: pTcl_Interp, varName: cstring){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_TraceVar*(interp: pTcl_Interp, varName: cstring, flags: int, 
+                   prc: TTclVarTraceProc, clientData: Tcl_ClientData): int{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_TraceVar2*(interp: pTcl_Interp, varName: cstring, elemName: cstring, 
+                    flags: int, prc: TTclVarTraceProc, 
+                    clientData: Tcl_ClientData): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_UntraceVar*(interp: pTcl_Interp, varName: cstring, flags: int, 
+                     prc: TTclVarTraceProc, clientData: Tcl_ClientData){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_UntraceVar2*(interp: pTcl_Interp, varName: cstring, elemName: cstring, 
+                      flags: int, prc: TTclVarTraceProc, 
+                      clientData: Tcl_ClientData){.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_GetVar*(interp: pTcl_Interp, varName: cstring, flags: int): cstring{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_GetVar2*(interp: pTcl_Interp, varName: cstring, elemName: cstring, 
+                  flags: int): cstring{.cdecl, dynlib: dllName, importc.}
+proc Tcl_SetVar*(interp: pTcl_Interp, varName: cstring, newValue: cstring, 
+                 flags: int): cstring{.cdecl, dynlib: dllName, importc.}
+proc Tcl_SetVar2*(interp: pTcl_Interp, varName: cstring, elemName: cstring, 
+                  newValue: cstring, flags: int): cstring{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_UnsetVar*(interp: pTcl_Interp, varName: cstring, flags: int): int{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_UnsetVar2*(interp: pTcl_Interp, varName: cstring, elemName: cstring, 
+                    flags: int): int{.cdecl, dynlib: dllName, importc.}
+proc Tcl_SetResult*(interp: pTcl_Interp, newValue: cstring, 
+                    freeProc: TTclFreeProc){.cdecl, dynlib: dllName, importc.}
+proc Tcl_FirstHashEntry*(hashTbl: pTcl_HashTable, searchInfo: var Tcl_HashSearch): pTcl_HashEntry{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_NextHashEntry*(searchInfo: var Tcl_HashSearch): pTcl_HashEntry{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_InitHashTable*(hashTbl: pTcl_HashTable, keyType: int){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_StringMatch*(str: cstring, pattern: cstring): int{.cdecl, 
+    dynlib: dllName, importc.}
+
+proc Tcl_GetErrno*(): int{.cdecl, dynlib: dllName, importc.}
+proc Tcl_SetErrno*(val: int){.cdecl, dynlib: dllName, importc.}
+proc Tcl_SetPanicProc*(prc: TTclPanicProc){.cdecl, dynlib: dllName, importc.}
+proc Tcl_PkgProvide*(interp: pTcl_Interp, name: cstring, version: cstring): int{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_StaticPackage*(interp: pTcl_Interp, pkgName: cstring, 
+                        initProc: TTclPackageInitProc, 
+                        safeInitProc: TTclPackageInitProc){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_CreateEventSource*(setupProc: TTcl_EventSetupProc, 
+                            checkProc: TTcl_EventCheckProc, 
+                            clientData: Tcl_ClientData){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_DeleteEventSource*(setupProc: TTcl_EventSetupProc, 
+                            checkProc: TTcl_EventCheckProc, 
+                            clientData: Tcl_ClientData){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_QueueEvent*(evPtr: pTcl_Event, pos: int){.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_SetMaxBlockTime*(timePtr: pTcl_Time){.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_DeleteEvents*(prc: TTclEventDeleteProc, clientData: Tcl_ClientData){.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_DoOneEvent*(flags: int): int{.cdecl, dynlib: dllName, importc.}
+proc Tcl_DoWhenIdle*(prc: TTclIdleProc, clientData: Tcl_ClientData){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_CancelIdleCall*(prc: TTclIdleProc, clientData: Tcl_ClientData){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_CreateTimerHandler*(milliseconds: int, prc: TTclTimerProc, 
+                             clientData: Tcl_ClientData): Tcl_TimerToken{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_DeleteTimerHandler*(token: Tcl_TimerToken){.cdecl, dynlib: dllName, 
+    importc.}
+  #    procedure Tcl_CreateModalTimeout(milliseconds: integer; prc: TTclTimerProc; clientData: Tcl_ClientData); cdecl; external dllName;
+  #    procedure Tcl_DeleteModalTimeout(prc: TTclTimerProc; clientData: Tcl_ClientData); cdecl; external dllName;
+proc Tcl_SplitList*(interp: pTcl_Interp, list: cstring, argcPtr: var int, 
+                    argvPtr: var Tcl_Argv): int{.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_Merge*(argc: int, argv: Tcl_Argv): cstring{.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_Free*(p: cstring){.cdecl, dynlib: dllName, importc.}
+proc Tcl_Init*(interp: pTcl_Interp): int{.cdecl, dynlib: dllName, importc.}
+  #    procedure Tcl_InterpDeleteProc(clientData: Tcl_ClientData; interp: pTcl_Interp); cdecl; external dllName;
+proc Tcl_GetAssocData*(interp: pTcl_Interp, key: cstring, 
+                       prc: var TTclInterpDeleteProc): Tcl_ClientData{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_DeleteAssocData*(interp: pTcl_Interp, key: cstring){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_SetAssocData*(interp: pTcl_Interp, key: cstring, 
+                       prc: TTclInterpDeleteProc, clientData: Tcl_ClientData){.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_IsSafe*(interp: pTcl_Interp): int{.cdecl, dynlib: dllName, importc.}
+proc Tcl_MakeSafe*(interp: pTcl_Interp): int{.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_CreateSlave*(interp: pTcl_Interp, slaveName: cstring, isSafe: int): pTcl_Interp{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_GetSlave*(interp: pTcl_Interp, slaveName: cstring): pTcl_Interp{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_GetMaster*(interp: pTcl_Interp): pTcl_Interp{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_GetInterpPath*(askingInterp: pTcl_Interp, slaveInterp: pTcl_Interp): int{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_CreateAlias*(slaveInterp: pTcl_Interp, srcCmd: cstring, 
+                      targetInterp: pTcl_Interp, targetCmd: cstring, argc: int, 
+                      argv: Tcl_Argv): int{.cdecl, dynlib: dllName, importc.}
+proc Tcl_GetAlias*(interp: pTcl_Interp, srcCmd: cstring, 
+                   targetInterp: var pTcl_Interp, targetCmd: var cstring, 
+                   argc: var int, argv: var Tcl_Argv): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_ExposeCommand*(interp: pTcl_Interp, hiddenCmdName: cstring, 
+                        cmdName: cstring): int{.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_HideCommand*(interp: pTcl_Interp, cmdName: cstring, 
+                      hiddenCmdName: cstring): int{.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_EventuallyFree*(clientData: Tcl_ClientData, freeProc: TTclFreeProc){.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_Preserve*(clientData: Tcl_ClientData){.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_Release*(clientData: Tcl_ClientData){.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_InterpDeleted*(interp: pTcl_Interp): int{.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_GetCommandInfo*(interp: pTcl_Interp, cmdName: cstring, 
+                         info: var Tcl_CmdInfo): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_SetCommandInfo*(interp: pTcl_Interp, cmdName: cstring, 
+                         info: var Tcl_CmdInfo): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_FindExecutable*(path: cstring){.cdecl, dynlib: dllName, importc.}
+proc Tcl_GetStringResult*(interp: pTcl_Interp): cstring{.cdecl, 
+    dynlib: dllName, importc.}
+  #v1.0
+proc Tcl_FindCommand*(interp: pTcl_Interp, cmdName: cstring, 
+                      contextNsPtr: pTcl_Namespace, flags: int): Tcl_Command{.
+    cdecl, dynlib: dllName, importc.}
+  #v1.0
+proc Tcl_DeleteCommandFromToken*(interp: pTcl_Interp, cmd: pTcl_Command): int{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_CreateNamespace*(interp: pTcl_Interp, name: cstring, 
+                          clientData: Tcl_ClientData, 
+                          deleteProc: TTclNamespaceDeleteProc): pTcl_Namespace{.
+    cdecl, dynlib: dllName, importc.}
+  #v1.0
+proc Tcl_DeleteNamespace*(namespacePtr: pTcl_Namespace){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_FindNamespace*(interp: pTcl_Interp, name: cstring, 
+                        contextNsPtr: pTcl_Namespace, flags: int): pTcl_Namespace{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_Export*(interp: pTcl_Interp, namespacePtr: pTcl_Namespace, 
+                 pattern: cstring, resetListFirst: int): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_Import*(interp: pTcl_Interp, namespacePtr: pTcl_Namespace, 
+                 pattern: cstring, allowOverwrite: int): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_GetCurrentNamespace*(interp: pTcl_Interp): pTcl_Namespace{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_GetGlobalNamespace*(interp: pTcl_Interp): pTcl_Namespace{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_PushCallFrame*(interp: pTcl_Interp, callFramePtr: var Tcl_CallFrame, 
+                        namespacePtr: pTcl_Namespace, isProcCallFrame: int): int{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_PopCallFrame*(interp: pTcl_Interp){.cdecl, dynlib: dllName, importc.}
+proc Tcl_VarEval*(interp: pTcl_Interp): int{.cdecl, varargs, 
+    dynlib: dllName, importc.}
+  # For TkConsole.c *
+proc Tcl_RecordAndEval*(interp: pTcl_Interp, cmd: cstring, flags: int): int{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_GlobalEval*(interp: pTcl_Interp, command: cstring): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_DStringFree*(dsPtr: pTcl_DString){.cdecl, dynlib: dllName, importc.}
+proc Tcl_DStringAppend*(dsPtr: pTcl_DString, str: cstring, length: int): cstring{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_DStringAppendElement*(dsPtr: pTcl_DString, str: cstring): cstring{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_DStringInit*(dsPtr: pTcl_DString){.cdecl, dynlib: dllName, importc.}
+proc Tcl_AppendResult*(interp: pTcl_Interp){.cdecl, varargs, 
+    dynlib: dllName, importc.}
+  # actually a "C" var array
+proc Tcl_SetStdChannel*(channel: pTcl_Channel, typ: int){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_SetChannelOption*(interp: pTcl_Interp, chan: pTcl_Channel, 
+                           optionName: cstring, newValue: cstring): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_GetChannelOption*(interp: pTcl_Interp, chan: pTcl_Channel, 
+                           optionName: cstring, dsPtr: pTcl_DString): int{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_CreateChannel*(typePtr: pTcl_ChannelType, chanName: cstring, 
+                        instanceData: Tcl_ClientData, mask: int): pTcl_Channel{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_RegisterChannel*(interp: pTcl_Interp, channel: pTcl_Channel){.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_UnregisterChannel*(interp: pTcl_Interp, channel: pTcl_Channel): int{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_CreateChannelHandler*(chan: pTcl_Channel, mask: int, 
+                               prc: TTclChannelProc, clientData: Tcl_ClientData){.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_GetChannel*(interp: pTcl_Interp, chanName: cstring, modePtr: pInteger): pTcl_Channel{.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_GetStdChannel*(typ: int): pTcl_Channel{.cdecl, dynlib: dllName, 
+    importc.}
+proc Tcl_Gets*(chan: pTcl_Channel, dsPtr: pTcl_DString): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_Write*(chan: pTcl_Channel, s: cstring, slen: int): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_Flush*(chan: pTcl_Channel): int{.cdecl, dynlib: dllName, importc.}
+  #    TclWinLoadLibrary      = function(name: PChar): HMODULE; cdecl; external dllName;
+proc Tcl_CreateExitHandler*(prc: TTclClientDataProc, clientData: Tcl_ClientData){.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_DeleteExitHandler*(prc: TTclClientDataProc, clientData: Tcl_ClientData){.
+    cdecl, dynlib: dllName, importc.}
+proc Tcl_GetStringFromObj*(pObj: pTcl_Obj, pLen: pInteger): cstring{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_CreateObjCommand*(interp: pTcl_Interp, name: cstring, 
+                           cmdProc: TTclObjCmdProc, clientData: Tcl_ClientData, 
+                           deleteProc: TTclCmdDeleteProc): pTcl_Command{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_NewStringObj*(bytes: cstring, length: int): pTcl_Obj{.cdecl, 
+    dynlib: dllName, importc.}
+  #    procedure TclFreeObj(pObj: pTcl_Obj); cdecl; external dllName;
+proc Tcl_EvalObj*(interp: pTcl_Interp, pObj: pTcl_Obj): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc Tcl_GlobalEvalObj*(interp: pTcl_Interp, pObj: pTcl_Obj): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc TclRegComp*(exp: cstring): pointer{.cdecl, dynlib: dllName, importc.}
+proc TclRegExec*(prog: pointer, str: cstring, start: cstring): int{.cdecl, 
+    dynlib: dllName, importc.}
+proc TclRegError*(msg: cstring){.cdecl, dynlib: dllName, importc.}
+proc TclGetRegError*(): cstring{.cdecl, dynlib: dllName, importc.}
+proc Tcl_RegExpRange*(prog: pointer, index: int, head: var cstring, 
+                      tail: var cstring){.cdecl, dynlib: dllName, importc.}
+
+proc Tcl_GetCommandTable*(interp: pTcl_Interp): pHashTable =
+  if interp != nil: 
+    result = cast[pHashTable](cast[int](interp) + sizeof(Tcl_Interp) + 
+      sizeof(pointer))
+
+proc Tcl_CreateHashEntry*(tablePtr: pTcl_HashTable, key: cstring, 
+                          newPtr: pInteger): pTcl_HashEntry =
+  result = cast[pHashTable](tablePtr).createProc(tablePtr, key, newPtr)
+                          
+proc Tcl_FindHashEntry*(tablePtr: pTcl_HashTable, 
+                        key: cstring): pTcl_HashEntry =
+  result = cast[pHashTable](tablePtr).findProc(tablePtr, key)
+
+proc Tcl_SetHashValue*(h: pTcl_HashEntry, clientData: Tcl_ClientData) =
+  h.clientData = clientData
+
+proc Tcl_GetHashValue*(h: pTcl_HashEntry): Tcl_ClientData =
+  result = h.clientData
+
+proc Tcl_IncrRefCount*(pObj: pTcl_Obj) =
+  inc(pObj.refCount)
+
+proc Tcl_DecrRefCount*(pObj: pTcl_Obj) =
+  dec(pObj.refCount)
+  if pObj.refCount <= 0: 
+    dealloc(pObj)
+
+proc Tcl_IsShared*(pObj: pTcl_Obj): bool = 
+  return pObj.refCount > 1
+
+proc Tcl_GetHashKey*(hashTbl: pTcl_HashTable, 
+                     hashEntry: pTcl_HashEntry): cstring = 
+  if hashTbl == nil or hashEntry == nil: 
+    result = nil
+  else: 
+    result = hashEntry.key
+  

lib/oldwrappers/x11/cursorfont.nim

@@ -0,0 +1,110 @@
+# $Xorg: cursorfont.h,v 1.4 2001/02/09 02:03:39 xorgcvs Exp $ 
+#
+#
+#Copyright 1987, 1998  The Open Group
+#
+#Permission to use, copy, modify, distribute, and sell this software and its
+#documentation for any purpose is hereby granted without fee, provided that
+#the above copyright notice appear in all copies and that both that
+#copyright notice and this permission notice appear in supporting
+#documentation.
+#
+#The above copyright notice and this permission notice shall be included
+#in all copies or substantial portions of the Software.
+#
+#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+#OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+#IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+#OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+#ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+#OTHER DEALINGS IN THE SOFTWARE.
+#
+#Except as contained in this notice, the name of The Open Group shall
+#not be used in advertising or otherwise to promote the sale, use or
+#other dealings in this Software without prior written authorization
+#from The Open Group.
+#
+#
+
+const 
+  XC_num_glyphs* = 154
+  XC_X_cursor* = 0
+  XC_arrow* = 2
+  XC_based_arrow_down* = 4
+  XC_based_arrow_up* = 6
+  XC_boat* = 8
+  XC_bogosity* = 10
+  XC_bottom_left_corner* = 12
+  XC_bottom_right_corner* = 14
+  XC_bottom_side* = 16
+  XC_bottom_tee* = 18
+  XC_box_spiral* = 20
+  XC_center_ptr* = 22
+  XC_circle* = 24
+  XC_clock* = 26
+  XC_coffee_mug* = 28
+  XC_cross* = 30
+  XC_cross_reverse* = 32
+  XC_crosshair* = 34
+  XC_diamond_cross* = 36
+  XC_dot* = 38
+  XC_dotbox* = 40
+  XC_double_arrow* = 42
+  XC_draft_large* = 44
+  XC_draft_small* = 46
+  XC_draped_box* = 48
+  XC_exchange* = 50
+  XC_fleur* = 52
+  XC_gobbler* = 54
+  XC_gumby* = 56
+  XC_hand1* = 58
+  XC_hand2* = 60
+  XC_heart* = 62
+  XC_icon* = 64
+  XC_iron_cross* = 66
+  XC_left_ptr* = 68
+  XC_left_side* = 70
+  XC_left_tee* = 72
+  XC_leftbutton* = 74
+  XC_ll_angle* = 76
+  XC_lr_angle* = 78
+  XC_man* = 80
+  XC_middlebutton* = 82
+  XC_mouse* = 84
+  XC_pencil* = 86
+  XC_pirate* = 88
+  XC_plus* = 90
+  XC_question_arrow* = 92
+  XC_right_ptr* = 94
+  XC_right_side* = 96
+  XC_right_tee* = 98
+  XC_rightbutton* = 100
+  XC_rtl_logo* = 102
+  XC_sailboat* = 104
+  XC_sb_down_arrow* = 106
+  XC_sb_h_double_arrow* = 108
+  XC_sb_left_arrow* = 110
+  XC_sb_right_arrow* = 112
+  XC_sb_up_arrow* = 114
+  XC_sb_v_double_arrow* = 116
+  XC_shuttle* = 118
+  XC_sizing* = 120
+  XC_spider* = 122
+  XC_spraycan* = 124
+  XC_star* = 126
+  XC_target* = 128
+  XC_tcross* = 130
+  XC_top_left_arrow* = 132
+  XC_top_left_corner* = 134
+  XC_top_right_corner* = 136
+  XC_top_side* = 138
+  XC_top_tee* = 140
+  XC_trek* = 142
+  XC_ul_angle* = 144
+  XC_umbrella* = 146
+  XC_ur_angle* = 148
+  XC_watch* = 150
+  XC_xterm* = 152
+
+# implementation

lib/oldwrappers/x11/x.nim

@@ -0,0 +1,399 @@
+
+#
+#  Automatically converted by H2Pas 0.99.15 from x.h
+#  The following command line parameters were used:
+#    -p
+#    -T
+#    -S
+#    -d
+#    -c
+#    x.h
+#
+# Pointers to basic pascal types, inserted by h2pas conversion program.
+
+const 
+  X_PROTOCOL* = 11
+  X_PROTOCOL_REVISION* = 0
+
+type
+  culong* = int
+  cuchar* = char
+  PXID* = ptr TXID
+  TXID* = culong
+  PMask* = ptr TMask
+  TMask* = culong
+  PPAtom* = ptr PAtom
+  PAtom* = ptr TAtom
+  TAtom* = culong
+  PVisualID* = ptr TVisualID
+  TVisualID* = culong
+  PTime* = ptr TTime
+  TTime* = culong
+  PPWindow* = ptr PWindow
+  PWindow* = ptr TWindow
+  TWindow* = TXID
+  PDrawable* = ptr TDrawable
+  TDrawable* = TXID
+  PFont* = ptr TFont
+  TFont* = TXID
+  PPixmap* = ptr TPixmap
+  TPixmap* = TXID
+  PCursor* = ptr TCursor
+  TCursor* = TXID
+  PColormap* = ptr TColormap
+  TColormap* = TXID
+  PGContext* = ptr TGContext
+  TGContext* = TXID
+  PKeySym* = ptr TKeySym
+  TKeySym* = TXID
+  PKeyCode* = ptr TKeyCode
+  TKeyCode* = cuchar
+
+const 
+  None* = 0
+  ParentRelative* = 1
+  CopyFromParent* = 0
+  PointerWindow* = 0
+  InputFocus* = 1
+  PointerRoot* = 1
+  AnyPropertyType* = 0
+  AnyKey* = 0
+  AnyButton* = 0
+  AllTemporary* = 0
+  CurrentTime* = 0
+  NoSymbol* = 0
+  NoEventMask* = 0
+  KeyPressMask* = 1 shl 0
+  KeyReleaseMask* = 1 shl 1
+  ButtonPressMask* = 1 shl 2
+  ButtonReleaseMask* = 1 shl 3
+  EnterWindowMask* = 1 shl 4
+  LeaveWindowMask* = 1 shl 5
+  PointerMotionMask* = 1 shl 6
+  PointerMotionHintMask* = 1 shl 7
+  Button1MotionMask* = 1 shl 8
+  Button2MotionMask* = 1 shl 9
+  Button3MotionMask* = 1 shl 10
+  Button4MotionMask* = 1 shl 11
+  Button5MotionMask* = 1 shl 12
+  ButtonMotionMask* = 1 shl 13
+  KeymapStateMask* = 1 shl 14
+  ExposureMask* = 1 shl 15
+  VisibilityChangeMask* = 1 shl 16
+  StructureNotifyMask* = 1 shl 17
+  ResizeRedirectMask* = 1 shl 18
+  SubstructureNotifyMask* = 1 shl 19
+  SubstructureRedirectMask* = 1 shl 20
+  FocusChangeMask* = 1 shl 21
+  PropertyChangeMask* = 1 shl 22
+  ColormapChangeMask* = 1 shl 23
+  OwnerGrabButtonMask* = 1 shl 24
+  KeyPress* = 2
+  KeyRelease* = 3
+  ButtonPress* = 4
+  ButtonRelease* = 5
+  MotionNotify* = 6
+  EnterNotify* = 7
+  LeaveNotify* = 8
+  FocusIn* = 9
+  FocusOut* = 10
+  KeymapNotify* = 11
+  Expose* = 12
+  GraphicsExpose* = 13
+  NoExpose* = 14
+  VisibilityNotify* = 15
+  CreateNotify* = 16
+  DestroyNotify* = 17
+  UnmapNotify* = 18
+  MapNotify* = 19
+  MapRequest* = 20
+  ReparentNotify* = 21
+  ConfigureNotify* = 22
+  ConfigureRequest* = 23
+  GravityNotify* = 24
+  ResizeRequest* = 25
+  CirculateNotify* = 26
+  CirculateRequest* = 27
+  PropertyNotify* = 28
+  SelectionClear* = 29
+  SelectionRequest* = 30
+  SelectionNotify* = 31
+  ColormapNotify* = 32
+  ClientMessage* = 33
+  MappingNotify* = 34
+  LASTEvent* = 35
+  ShiftMask* = 1 shl 0
+  LockMask* = 1 shl 1
+  ControlMask* = 1 shl 2
+  Mod1Mask* = 1 shl 3
+  Mod2Mask* = 1 shl 4
+  Mod3Mask* = 1 shl 5
+  Mod4Mask* = 1 shl 6
+  Mod5Mask* = 1 shl 7
+  ShiftMapIndex* = 0
+  LockMapIndex* = 1
+  ControlMapIndex* = 2
+  Mod1MapIndex* = 3
+  Mod2MapIndex* = 4
+  Mod3MapIndex* = 5
+  Mod4MapIndex* = 6
+  Mod5MapIndex* = 7
+  Button1Mask* = 1 shl 8
+  Button2Mask* = 1 shl 9
+  Button3Mask* = 1 shl 10
+  Button4Mask* = 1 shl 11
+  Button5Mask* = 1 shl 12
+  AnyModifier* = 1 shl 15
+  Button1* = 1
+  Button2* = 2
+  Button3* = 3
+  Button4* = 4
+  Button5* = 5
+  NotifyNormal* = 0
+  NotifyGrab* = 1
+  NotifyUngrab* = 2
+  NotifyWhileGrabbed* = 3
+  NotifyHint* = 1
+  NotifyAncestor* = 0
+  NotifyVirtual* = 1
+  NotifyInferior* = 2
+  NotifyNonlinear* = 3
+  NotifyNonlinearVirtual* = 4
+  NotifyPointer* = 5
+  NotifyPointerRoot* = 6
+  NotifyDetailNone* = 7
+  VisibilityUnobscured* = 0
+  VisibilityPartiallyObscured* = 1
+  VisibilityFullyObscured* = 2
+  PlaceOnTop* = 0
+  PlaceOnBottom* = 1
+  FamilyInternet* = 0
+  FamilyDECnet* = 1
+  FamilyChaos* = 2
+  FamilyInternet6* = 6
+  FamilyServerInterpreted* = 5
+  PropertyNewValue* = 0
+  PropertyDelete* = 1
+  ColormapUninstalled* = 0
+  ColormapInstalled* = 1
+  GrabModeSync* = 0
+  GrabModeAsync* = 1
+  GrabSuccess* = 0
+  AlreadyGrabbed* = 1
+  GrabInvalidTime* = 2
+  GrabNotViewable* = 3
+  GrabFrozen* = 4
+  AsyncPointer* = 0
+  SyncPointer* = 1
+  ReplayPointer* = 2
+  AsyncKeyboard* = 3
+  SyncKeyboard* = 4
+  ReplayKeyboard* = 5
+  AsyncBoth* = 6
+  SyncBoth* = 7
+  RevertToNone* = None
+  RevertToPointerRoot* = PointerRoot
+  RevertToParent* = 2
+  Success* = 0
+  BadRequest* = 1
+  BadValue* = 2
+  BadWindow* = 3
+  BadPixmap* = 4
+  BadAtom* = 5
+  BadCursor* = 6
+  BadFont* = 7
+  BadMatch* = 8
+  BadDrawable* = 9
+  BadAccess* = 10
+  BadAlloc* = 11
+  BadColor* = 12
+  BadGC* = 13
+  BadIDChoice* = 14
+  BadName* = 15
+  BadLength* = 16
+  BadImplementation* = 17
+  FirstExtensionError* = 128
+  LastExtensionError* = 255
+  InputOutput* = 1
+  InputOnly* = 2
+  CWBackPixmap* = 1 shl 0
+  CWBackPixel* = 1 shl 1
+  CWBorderPixmap* = 1 shl 2
+  CWBorderPixel* = 1 shl 3
+  CWBitGravity* = 1 shl 4
+  CWWinGravity* = 1 shl 5
+  CWBackingStore* = 1 shl 6
+  CWBackingPlanes* = 1 shl 7
+  CWBackingPixel* = 1 shl 8
+  CWOverrideRedirect* = 1 shl 9
+  CWSaveUnder* = 1 shl 10
+  CWEventMask* = 1 shl 11
+  CWDontPropagate* = 1 shl 12
+  CWColormap* = 1 shl 13
+  CWCursor* = 1 shl 14
+  CWX* = 1 shl 0
+  CWY* = 1 shl 1
+  CWWidth* = 1 shl 2
+  CWHeight* = 1 shl 3
+  CWBorderWidth* = 1 shl 4
+  CWSibling* = 1 shl 5
+  CWStackMode* = 1 shl 6
+  ForgetGravity* = 0
+  NorthWestGravity* = 1
+  NorthGravity* = 2
+  NorthEastGravity* = 3
+  WestGravity* = 4
+  CenterGravity* = 5
+  EastGravity* = 6
+  SouthWestGravity* = 7
+  SouthGravity* = 8
+  SouthEastGravity* = 9
+  StaticGravity* = 10
+  UnmapGravity* = 0
+  NotUseful* = 0
+  WhenMapped* = 1
+  Always* = 2
+  IsUnmapped* = 0
+  IsUnviewable* = 1
+  IsViewable* = 2
+  SetModeInsert* = 0
+  SetModeDelete* = 1
+  DestroyAll* = 0
+  RetainPermanent* = 1
+  RetainTemporary* = 2
+  Above* = 0
+  Below* = 1
+  TopIf* = 2
+  BottomIf* = 3
+  Opposite* = 4
+  RaiseLowest* = 0
+  LowerHighest* = 1
+  PropModeReplace* = 0
+  PropModePrepend* = 1
+  PropModeAppend* = 2
+  GXclear* = 0x00000000
+  GXand* = 0x00000001
+  GXandReverse* = 0x00000002
+  GXcopy* = 0x00000003
+  GXandInverted* = 0x00000004
+  GXnoop* = 0x00000005
+  GXxor* = 0x00000006
+  GXor* = 0x00000007
+  GXnor* = 0x00000008
+  GXequiv* = 0x00000009
+  GXinvert* = 0x0000000A
+  GXorReverse* = 0x0000000B
+  GXcopyInverted* = 0x0000000C
+  GXorInverted* = 0x0000000D
+  GXnand* = 0x0000000E
+  GXset* = 0x0000000F
+  LineSolid* = 0
+  LineOnOffDash* = 1
+  LineDoubleDash* = 2
+  CapNotLast* = 0
+  CapButt* = 1
+  CapRound* = 2
+  CapProjecting* = 3
+  JoinMiter* = 0
+  JoinRound* = 1
+  JoinBevel* = 2
+  FillSolid* = 0
+  FillTiled* = 1
+  FillStippled* = 2
+  FillOpaqueStippled* = 3
+  EvenOddRule* = 0
+  WindingRule* = 1
+  ClipByChildren* = 0
+  IncludeInferiors* = 1
+  Unsorted* = 0
+  YSorted* = 1
+  YXSorted* = 2
+  YXBanded* = 3
+  CoordModeOrigin* = 0
+  CoordModePrevious* = 1
+  Complex* = 0
+  Nonconvex* = 1
+  Convex* = 2
+  ArcChord* = 0
+  ArcPieSlice* = 1
+  GCFunction* = 1 shl 0
+  GCPlaneMask* = 1 shl 1
+  GCForeground* = 1 shl 2
+  GCBackground* = 1 shl 3
+  GCLineWidth* = 1 shl 4
+  GCLineStyle* = 1 shl 5
+  GCCapStyle* = 1 shl 6
+  GCJoinStyle* = 1 shl 7
+  GCFillStyle* = 1 shl 8
+  GCFillRule* = 1 shl 9
+  GCTile* = 1 shl 10
+  GCStipple* = 1 shl 11
+  GCTileStipXOrigin* = 1 shl 12
+  GCTileStipYOrigin* = 1 shl 13
+  GCFont* = 1 shl 14
+  GCSubwindowMode* = 1 shl 15
+  GCGraphicsExposures* = 1 shl 16
+  GCClipXOrigin* = 1 shl 17
+  GCClipYOrigin* = 1 shl 18
+  GCClipMask* = 1 shl 19
+  GCDashOffset* = 1 shl 20
+  GCDashList* = 1 shl 21
+  GCArcMode* = 1 shl 22
+  GCLastBit* = 22
+  FontLeftToRight* = 0
+  FontRightToLeft* = 1
+  FontChange* = 255
+  XYBitmap* = 0
+  XYPixmap* = 1
+  ZPixmap* = 2
+  AllocNone* = 0
+  AllocAll* = 1
+  DoRed* = 1 shl 0
+  DoGreen* = 1 shl 1
+  DoBlue* = 1 shl 2
+  CursorShape* = 0
+  TileShape* = 1
+  StippleShape* = 2
+  AutoRepeatModeOff* = 0
+  AutoRepeatModeOn* = 1
+  AutoRepeatModeDefault* = 2
+  LedModeOff* = 0
+  LedModeOn* = 1
+  KBKeyClickPercent* = 1 shl 0
+  KBBellPercent* = 1 shl 1
+  KBBellPitch* = 1 shl 2
+  KBBellDuration* = 1 shl 3
+  KBLed* = 1 shl 4
+  KBLedMode* = 1 shl 5
+  KBKey* = 1 shl 6
+  KBAutoRepeatMode* = 1 shl 7
+  MappingSuccess* = 0
+  MappingBusy* = 1
+  MappingFailed* = 2
+  MappingModifier* = 0
+  MappingKeyboard* = 1
+  MappingPointer* = 2
+  DontPreferBlanking* = 0
+  PreferBlanking* = 1
+  DefaultBlanking* = 2
+  DisableScreenSaver* = 0
+  DisableScreenInterval* = 0
+  DontAllowExposures* = 0
+  AllowExposures* = 1
+  DefaultExposures* = 2
+  ScreenSaverReset* = 0
+  ScreenSaverActive* = 1
+  HostInsert* = 0
+  HostDelete* = 1
+  EnableAccess* = 1
+  DisableAccess* = 0
+  StaticGray* = 0
+  GrayScale* = 1
+  StaticColor* = 2
+  PseudoColor* = 3
+  TrueColor* = 4
+  DirectColor* = 5
+  LSBFirst* = 0
+  MSBFirst* = 1
+
+# implementation

lib/oldwrappers/x11/xatom.nim

@@ -0,0 +1,81 @@
+#
+# THIS IS A GENERATED FILE
+#
+# Do not change!  Changing this file implies a protocol change!
+#
+
+import  
+  X
+
+const 
+  XA_PRIMARY* = TAtom(1)
+  XA_SECONDARY* = TAtom(2)
+  XA_ARC* = TAtom(3)
+  XA_ATOM* = TAtom(4)
+  XA_BITMAP* = TAtom(5)
+  XA_CARDINAL* = TAtom(6)
+  XA_COLORMAP* = TAtom(7)
+  XA_CURSOR* = TAtom(8)
+  XA_CUT_BUFFER0* = TAtom(9)
+  XA_CUT_BUFFER1* = TAtom(10)
+  XA_CUT_BUFFER2* = TAtom(11)
+  XA_CUT_BUFFER3* = TAtom(12)
+  XA_CUT_BUFFER4* = TAtom(13)
+  XA_CUT_BUFFER5* = TAtom(14)
+  XA_CUT_BUFFER6* = TAtom(15)
+  XA_CUT_BUFFER7* = TAtom(16)
+  XA_DRAWABLE* = TAtom(17)
+  XA_FONT* = TAtom(18)
+  XA_INTEGER* = TAtom(19)
+  XA_PIXMAP* = TAtom(20)
+  XA_POINT* = TAtom(21)
+  XA_RECTANGLE* = TAtom(22)
+  XA_RESOURCE_MANAGER* = TAtom(23)
+  XA_RGB_COLOR_MAP* = TAtom(24)
+  XA_RGB_BEST_MAP* = TAtom(25)
+  XA_RGB_BLUE_MAP* = TAtom(26)
+  XA_RGB_DEFAULT_MAP* = TAtom(27)
+  XA_RGB_GRAY_MAP* = TAtom(28)
+  XA_RGB_GREEN_MAP* = TAtom(29)
+  XA_RGB_RED_MAP* = TAtom(30)
+  XA_STRING* = TAtom(31)
+  XA_VISUALID* = TAtom(32)
+  XA_WINDOW* = TAtom(33)
+  XA_WM_COMMAND* = TAtom(34)
+  XA_WM_HINTS* = TAtom(35)
+  XA_WM_CLIENT_MACHINE* = TAtom(36)
+  XA_WM_ICON_NAME* = TAtom(37)
+  XA_WM_ICON_SIZE* = TAtom(38)
+  XA_WM_NAME* = TAtom(39)
+  XA_WM_NORMAL_HINTS* = TAtom(40)
+  XA_WM_SIZE_HINTS* = TAtom(41)
+  XA_WM_ZOOM_HINTS* = TAtom(42)
+  XA_MIN_SPACE* = TAtom(43)
+  XA_NORM_SPACE* = TAtom(44)
+  XA_MAX_SPACE* = TAtom(45)
+  XA_END_SPACE* = TAtom(46)
+  XA_SUPERSCRIPT_X* = TAtom(47)
+  XA_SUPERSCRIPT_Y* = TAtom(48)
+  XA_SUBSCRIPT_X* = TAtom(49)
+  XA_SUBSCRIPT_Y* = TAtom(50)
+  XA_UNDERLINE_POSITION* = TAtom(51)
+  XA_UNDERLINE_THICKNESS* = TAtom(52)
+  XA_STRIKEOUT_ASCENT* = TAtom(53)
+  XA_STRIKEOUT_DESCENT* = TAtom(54)
+  XA_ITALIC_ANGLE* = TAtom(55)
+  XA_X_HEIGHT* = TAtom(56)
+  XA_QUAD_WIDTH* = TAtom(57)
+  XA_WEIGHT* = TAtom(58)
+  XA_POINT_SIZE* = TAtom(59)
+  XA_RESOLUTION* = TAtom(60)
+  XA_COPYRIGHT* = TAtom(61)
+  XA_NOTICE* = TAtom(62)
+  XA_FONT_NAME* = TAtom(63)
+  XA_FAMILY_NAME* = TAtom(64)
+  XA_FULL_NAME* = TAtom(65)
+  XA_CAP_HEIGHT* = TAtom(66)
+  XA_WM_CLASS* = TAtom(67)
+  XA_WM_TRANSIENT_FOR* = TAtom(68)
+  XA_LAST_PREDEFINED* = TAtom(68)
+
+# implementation

lib/oldwrappers/x11/xcms.nim

@@ -0,0 +1,396 @@
+
+import 
+  x, xlib
+
+#const 
+#  libX11* = "X11" 
+
+#
+#  Automatically converted by H2Pas 0.99.15 from xcms.h
+#  The following command line parameters were used:
+#    -p
+#    -T
+#    -S
+#    -d
+#    -c
+#    xcms.h
+#
+
+const 
+  XcmsFailure* = 0
+  XcmsSuccess* = 1
+  XcmsSuccessWithCompression* = 2
+
+type 
+  PXcmsColorFormat* = ptr TXcmsColorFormat
+  TXcmsColorFormat* = int32
+
+proc XcmsUndefinedFormat*(): TXcmsColorFormat
+proc XcmsCIEXYZFormat*(): TXcmsColorFormat
+proc XcmsCIEuvYFormat*(): TXcmsColorFormat
+proc XcmsCIExyYFormat*(): TXcmsColorFormat
+proc XcmsCIELabFormat*(): TXcmsColorFormat
+proc XcmsCIELuvFormat*(): TXcmsColorFormat
+proc XcmsTekHVCFormat*(): TXcmsColorFormat
+proc XcmsRGBFormat*(): TXcmsColorFormat
+proc XcmsRGBiFormat*(): TXcmsColorFormat
+const 
+  XcmsInitNone* = 0x00000000
+  XcmsInitSuccess* = 0x00000001
+  XcmsInitFailure* = 0x000000FF
+
+when defined(MACROS): 
+  proc DisplayOfCCC*(ccc: int32): int32
+  proc ScreenNumberOfCCC*(ccc: int32): int32
+  proc VisualOfCCC*(ccc: int32): int32
+  proc ClientWhitePointOfCCC*(ccc: int32): int32
+  proc ScreenWhitePointOfCCC*(ccc: int32): int32
+  proc FunctionSetOfCCC*(ccc: int32): int32
+type 
+  PXcmsFloat* = ptr TXcmsFloat
+  TXcmsFloat* = float64
+  PXcmsRGB* = ptr TXcmsRGB
+  TXcmsRGB*{.final.} = object 
+    red*: int16
+    green*: int16
+    blue*: int16
+
+  PXcmsRGBi* = ptr TXcmsRGBi
+  TXcmsRGBi*{.final.} = object 
+    red*: TXcmsFloat
+    green*: TXcmsFloat
+    blue*: TXcmsFloat
+
+  PXcmsCIEXYZ* = ptr TXcmsCIEXYZ
+  TXcmsCIEXYZ*{.final.} = object 
+    X*: TXcmsFloat
+    Y*: TXcmsFloat
+    Z*: TXcmsFloat
+
+  PXcmsCIEuvY* = ptr TXcmsCIEuvY
+  TXcmsCIEuvY*{.final.} = object 
+    u_prime*: TXcmsFloat
+    v_prime*: TXcmsFloat
+    Y*: TXcmsFloat
+
+  PXcmsCIExyY* = ptr TXcmsCIExyY
+  TXcmsCIExyY*{.final.} = object 
+    x*: TXcmsFloat
+    y*: TXcmsFloat
+    theY*: TXcmsFloat
+
+  PXcmsCIELab* = ptr TXcmsCIELab
+  TXcmsCIELab*{.final.} = object 
+    L_star*: TXcmsFloat
+    a_star*: TXcmsFloat
+    b_star*: TXcmsFloat
+
+  PXcmsCIELuv* = ptr TXcmsCIELuv
+  TXcmsCIELuv*{.final.} = object 
+    L_star*: TXcmsFloat
+    u_star*: TXcmsFloat
+    v_star*: TXcmsFloat
+
+  PXcmsTekHVC* = ptr TXcmsTekHVC
+  TXcmsTekHVC*{.final.} = object 
+    H*: TXcmsFloat
+    V*: TXcmsFloat
+    C*: TXcmsFloat
+
+  PXcmsPad* = ptr TXcmsPad
+  TXcmsPad*{.final.} = object 
+    pad0*: TXcmsFloat
+    pad1*: TXcmsFloat
+    pad2*: TXcmsFloat
+    pad3*: TXcmsFloat
+
+  PXcmsColor* = ptr TXcmsColor
+  TXcmsColor*{.final.} = object  # spec : record
+                                 #            case longint of
+                                 #               0 : ( RGB : TXcmsRGB );
+                                 #               1 : ( RGBi : TXcmsRGBi );
+                                 #               2 : ( CIEXYZ : TXcmsCIEXYZ );
+                                 #               3 : ( CIEuvY : TXcmsCIEuvY );
+                                 #               4 : ( CIExyY : TXcmsCIExyY );
+                                 #               5 : ( CIELab : TXcmsCIELab );
+                                 #               6 : ( CIELuv : TXcmsCIELuv );
+                                 #               7 : ( TekHVC : TXcmsTekHVC );
+                                 #               8 : ( Pad : TXcmsPad ); 
+                                 #            end; 
+    pad*: TXcmsPad
+    pixel*: int32
+    format*: TXcmsColorFormat
+
+  PXcmsPerScrnInfo* = ptr TXcmsPerScrnInfo
+  TXcmsPerScrnInfo*{.final.} = object 
+    screenWhitePt*: TXcmsColor
+    functionSet*: TXPointer
+    screenData*: TXPointer
+    state*: int8
+    pad*: array[0..2, char]
+
+  PXcmsCCC* = ptr TXcmsCCC
+  TXcmsCompressionProc* = proc (para1: PXcmsCCC, para2: PXcmsColor, 
+                                para3: int32, para4: int32, para5: PBool): TStatus{.
+      cdecl.}
+  TXcmsWhiteAdjustProc* = proc (para1: PXcmsCCC, para2: PXcmsColor, 
+                                para3: PXcmsColor, para4: TXcmsColorFormat, 
+                                para5: PXcmsColor, para6: int32, para7: PBool): TStatus{.
+      cdecl.}
+  TXcmsCCC*{.final.} = object 
+    dpy*: PDisplay
+    screenNumber*: int32
+    visual*: PVisual
+    clientWhitePt*: TXcmsColor
+    gamutCompProc*: TXcmsCompressionProc
+    gamutCompClientData*: TXPointer
+    whitePtAdjProc*: TXcmsWhiteAdjustProc
+    whitePtAdjClientData*: TXPointer
+    pPerScrnInfo*: PXcmsPerScrnInfo
+
+  TXcmsCCCRec* = TXcmsCCC
+  PXcmsCCCRec* = ptr TXcmsCCCRec
+  TXcmsScreenInitProc* = proc (para1: PDisplay, para2: int32, 
+                               para3: PXcmsPerScrnInfo): TStatus{.cdecl.}
+  TXcmsScreenFreeProc* = proc (para1: TXPointer){.cdecl.}
+  TXcmsConversionProc* = proc (){.cdecl.}
+  PXcmsFuncListPtr* = ptr TXcmsFuncListPtr
+  TXcmsFuncListPtr* = TXcmsConversionProc
+  TXcmsParseStringProc* = proc (para1: cstring, para2: PXcmsColor): int32{.cdecl.}
+  PXcmsColorSpace* = ptr TXcmsColorSpace
+  TXcmsColorSpace*{.final.} = object 
+    prefix*: cstring
+    id*: TXcmsColorFormat
+    parseString*: TXcmsParseStringProc
+    to_CIEXYZ*: TXcmsFuncListPtr
+    from_CIEXYZ*: TXcmsFuncListPtr
+    inverse_flag*: int32
+
+  PXcmsFunctionSet* = ptr TXcmsFunctionSet
+  TXcmsFunctionSet*{.final.} = object  # error
+                                       #extern Status XcmsAddColorSpace (
+                                       #in declaration at line 323 
+    DDColorSpaces*: ptr PXcmsColorSpace
+    screenInitProc*: TXcmsScreenInitProc
+    screenFreeProc*: TXcmsScreenFreeProc
+
+
+proc XcmsAddFunctionSet*(para1: PXcmsFunctionSet): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsAllocColor*(para1: PDisplay, para2: TColormap, para3: PXcmsColor, 
+                     para4: TXcmsColorFormat): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsAllocNamedColor*(para1: PDisplay, para2: TColormap, para3: cstring, 
+                          para4: PXcmsColor, para5: PXcmsColor, 
+                          para6: TXcmsColorFormat): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsCCCOfColormap*(para1: PDisplay, para2: TColormap): TXcmsCCC{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsCIELabClipab*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                       para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsCIELabClipL*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                      para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsCIELabClipLab*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                        para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsCIELabQueryMaxC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, 
+                          para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsCIELabQueryMaxL*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, 
+                          para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsCIELabQueryMaxLC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: PXcmsColor): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsCIELabQueryMinL*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, 
+                          para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsCIELabToCIEXYZ*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsCIELabWhiteShiftColors*(para1: TXcmsCCC, para2: PXcmsColor, 
+                                 para3: PXcmsColor, para4: TXcmsColorFormat, 
+                                 para5: PXcmsColor, para6: int32, para7: PBool): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsCIELuvClipL*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                      para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsCIELuvClipLuv*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                        para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsCIELuvClipuv*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                       para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsCIELuvQueryMaxC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, 
+                          para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsCIELuvQueryMaxL*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, 
+                          para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsCIELuvQueryMaxLC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: PXcmsColor): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsCIELuvQueryMinL*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, 
+                          para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsCIELuvToCIEuvY*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsCIELuvWhiteShiftColors*(para1: TXcmsCCC, para2: PXcmsColor, 
+                                 para3: PXcmsColor, para4: TXcmsColorFormat, 
+                                 para5: PXcmsColor, para6: int32, para7: PBool): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsCIEXYZToCIELab*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsCIEXYZToCIEuvY*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsCIEXYZToCIExyY*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsCIEXYZToRGBi*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                       para4: PBool): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsCIEuvYToCIELuv*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsCIEuvYToCIEXYZ*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsCIEuvYToTekHVC*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsCIExyYToCIEXYZ*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsClientWhitePointOfCCC*(para1: TXcmsCCC): PXcmsColor{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsConvertColors*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                        para4: TXcmsColorFormat, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsCreateCCC*(para1: PDisplay, para2: int32, para3: PVisual, 
+                    para4: PXcmsColor, para5: TXcmsCompressionProc, 
+                    para6: TXPointer, para7: TXcmsWhiteAdjustProc, 
+                    para8: TXPointer): TXcmsCCC{.cdecl, dynlib: libX11, importc.}
+proc XcmsDefaultCCC*(para1: PDisplay, para2: int32): TXcmsCCC{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsDisplayOfCCC*(para1: TXcmsCCC): PDisplay{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsFormatOfPrefix*(para1: cstring): TXcmsColorFormat{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsFreeCCC*(para1: TXcmsCCC){.cdecl, dynlib: libX11, importc.}
+proc XcmsLookupColor*(para1: PDisplay, para2: TColormap, para3: cstring, 
+                      para4: PXcmsColor, para5: PXcmsColor, 
+                      para6: TXcmsColorFormat): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsPrefixOfFormat*(para1: TXcmsColorFormat): cstring{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsQueryBlack*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsQueryBlue*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsQueryColor*(para1: PDisplay, para2: TColormap, para3: PXcmsColor, 
+                     para4: TXcmsColorFormat): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsQueryColors*(para1: PDisplay, para2: TColormap, para3: PXcmsColor, 
+                      para4: int32, para5: TXcmsColorFormat): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsQueryGreen*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsQueryRed*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsQueryWhite*(para1: TXcmsCCC, para2: TXcmsColorFormat, para3: PXcmsColor): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsRGBiToCIEXYZ*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                       para4: PBool): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsRGBiToRGB*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                    para4: PBool): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsRGBToRGBi*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                    para4: PBool): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsScreenNumberOfCCC*(para1: TXcmsCCC): int32{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsScreenWhitePointOfCCC*(para1: TXcmsCCC): PXcmsColor{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsSetCCCOfColormap*(para1: PDisplay, para2: TColormap, para3: TXcmsCCC): TXcmsCCC{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsSetCompressionProc*(para1: TXcmsCCC, para2: TXcmsCompressionProc, 
+                             para3: TXPointer): TXcmsCompressionProc{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsSetWhiteAdjustProc*(para1: TXcmsCCC, para2: TXcmsWhiteAdjustProc, 
+                             para3: TXPointer): TXcmsWhiteAdjustProc{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsSetWhitePoint*(para1: TXcmsCCC, para2: PXcmsColor): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsStoreColor*(para1: PDisplay, para2: TColormap, para3: PXcmsColor): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsStoreColors*(para1: PDisplay, para2: TColormap, para3: PXcmsColor, 
+                      para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsTekHVCClipC*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                      para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsTekHVCClipV*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                      para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsTekHVCClipVC*(para1: TXcmsCCC, para2: PXcmsColor, para3: int32, 
+                       para4: int32, para5: PBool): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XcmsTekHVCQueryMaxC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, 
+                          para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsTekHVCQueryMaxV*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, 
+                          para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsTekHVCQueryMaxVC*(para1: TXcmsCCC, para2: TXcmsFloat, para3: PXcmsColor): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsTekHVCQueryMaxVSamples*(para1: TXcmsCCC, para2: TXcmsFloat, 
+                                 para3: PXcmsColor, para4: int32): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsTekHVCQueryMinV*(para1: TXcmsCCC, para2: TXcmsFloat, para3: TXcmsFloat, 
+                          para4: PXcmsColor): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XcmsTekHVCToCIEuvY*(para1: TXcmsCCC, para2: PXcmsColor, para3: PXcmsColor, 
+                         para4: int32): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XcmsTekHVCWhiteShiftColors*(para1: TXcmsCCC, para2: PXcmsColor, 
+                                 para3: PXcmsColor, para4: TXcmsColorFormat, 
+                                 para5: PXcmsColor, para6: int32, para7: PBool): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XcmsVisualOfCCC*(para1: TXcmsCCC): PVisual{.cdecl, dynlib: libX11, importc.}
+# implementation
+
+proc XcmsUndefinedFormat(): TXcmsColorFormat = 
+  result = 0x00000000'i32
+
+proc XcmsCIEXYZFormat(): TXcmsColorFormat = 
+  result = 0x00000001'i32
+
+proc XcmsCIEuvYFormat(): TXcmsColorFormat = 
+  result = 0x00000002'i32
+
+proc XcmsCIExyYFormat(): TXcmsColorFormat = 
+  result = 0x00000003'i32
+
+proc XcmsCIELabFormat(): TXcmsColorFormat = 
+  result = 0x00000004'i32
+
+proc XcmsCIELuvFormat(): TXcmsColorFormat = 
+  result = 0x00000005'i32
+
+proc XcmsTekHVCFormat(): TXcmsColorFormat = 
+  result = 0x00000006'i32
+
+proc XcmsRGBFormat(): TXcmsColorFormat = 
+  result = 0x80000000'i32
+
+proc XcmsRGBiFormat(): TXcmsColorFormat = 
+  result = 0x80000001'i32
+
+when defined(MACROS): 
+  proc DisplayOfCCC(ccc: int32): int32 = 
+    result = ccc.dpy
+
+  proc ScreenNumberOfCCC(ccc: int32): int32 = 
+    result = ccc.screenNumber
+
+  proc VisualOfCCC(ccc: int32): int32 = 
+    result = ccc.visual
+
+  proc ClientWhitePointOfCCC(ccc: int32): int32 = 
+    result = addr(ccc.clientWhitePt)
+
+  proc ScreenWhitePointOfCCC(ccc: int32): int32 = 
+    result = addr(ccc.pPerScrnInfo.screenWhitePt)
+
+  proc FunctionSetOfCCC(ccc: int32): int32 = 
+    result = ccc.pPerScrnInfo.functionSet

lib/oldwrappers/x11/xf86dga.nim

@@ -0,0 +1,235 @@
+#
+#   Copyright (c) 1999  XFree86 Inc
+#
+# $XFree86: xc/include/extensions/xf86dga.h,v 3.20 1999/10/13 04:20:48 dawes Exp $ 
+
+import 
+  x, xlib
+
+const 
+  libXxf86dga* = "libXxf86dga.so"
+
+#type 
+#  cfloat* = float32
+
+# $XFree86: xc/include/extensions/xf86dga1.h,v 1.2 1999/04/17 07:05:41 dawes Exp $ 
+#
+#
+#Copyright (c) 1995  Jon Tombs
+#Copyright (c) 1995  XFree86 Inc
+#
+#
+#************************************************************************
+#
+#   THIS IS THE OLD DGA API AND IS OBSOLETE.  PLEASE DO NOT USE IT ANYMORE
+#
+#************************************************************************
+
+type 
+  PPcchar* = ptr ptr cstring
+
+const 
+  X_XF86DGAQueryVersion* = 0
+  X_XF86DGAGetVideoLL* = 1
+  X_XF86DGADirectVideo* = 2
+  X_XF86DGAGetViewPortSize* = 3
+  X_XF86DGASetViewPort* = 4
+  X_XF86DGAGetVidPage* = 5
+  X_XF86DGASetVidPage* = 6
+  X_XF86DGAInstallColormap* = 7
+  X_XF86DGAQueryDirectVideo* = 8
+  X_XF86DGAViewPortChanged* = 9
+  XF86DGADirectPresent* = 0x00000001
+  XF86DGADirectGraphics* = 0x00000002
+  XF86DGADirectMouse* = 0x00000004
+  XF86DGADirectKeyb* = 0x00000008
+  XF86DGAHasColormap* = 0x00000100
+  XF86DGADirectColormap* = 0x00000200
+
+proc XF86DGAQueryVersion*(dpy: PDisplay, majorVersion: Pcint, 
+                          minorVersion: Pcint): TBool{.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XF86DGAQueryExtension*(dpy: PDisplay, event_base: Pcint, error_base: Pcint): TBool{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGAGetVideoLL*(dpy: PDisplay, screen: cint, base_addr: Pcint, 
+                        width: Pcint, bank_size: Pcint, ram_size: Pcint): TStatus{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGAGetVideo*(dpy: PDisplay, screen: cint, base_addr: PPcchar, 
+                      width: Pcint, bank_size: Pcint, ram_size: Pcint): TStatus{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGADirectVideo*(dpy: PDisplay, screen: cint, enable: cint): TStatus{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGADirectVideoLL*(dpy: PDisplay, screen: cint, enable: cint): TStatus{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGAGetViewPortSize*(dpy: PDisplay, screen: cint, width: Pcint, 
+                             height: Pcint): TStatus{.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XF86DGASetViewPort*(dpy: PDisplay, screen: cint, x: cint, y: cint): TStatus{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGAGetVidPage*(dpy: PDisplay, screen: cint, vid_page: Pcint): TStatus{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGASetVidPage*(dpy: PDisplay, screen: cint, vid_page: cint): TStatus{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGAInstallColormap*(dpy: PDisplay, screen: cint, Colormap: TColormap): TStatus{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGAForkApp*(screen: cint): cint{.CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGAQueryDirectVideo*(dpy: PDisplay, screen: cint, flags: Pcint): TStatus{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XF86DGAViewPortChanged*(dpy: PDisplay, screen: cint, n: cint): TBool{.
+    CDecl, dynlib: libXxf86dga, importc.}
+const 
+  X_XDGAQueryVersion* = 0     # 1 through 9 are in xf86dga1.pp 
+                              # 10 and 11 are reserved to avoid conflicts with rogue DGA extensions 
+  X_XDGAQueryModes* = 12
+  X_XDGASetMode* = 13
+  X_XDGASetViewport* = 14
+  X_XDGAInstallColormap* = 15
+  X_XDGASelectInput* = 16
+  X_XDGAFillRectangle* = 17
+  X_XDGACopyArea* = 18
+  X_XDGACopyTransparentArea* = 19
+  X_XDGAGetViewportStatus* = 20
+  X_XDGASync* = 21
+  X_XDGAOpenFramebuffer* = 22
+  X_XDGACloseFramebuffer* = 23
+  X_XDGASetClientVersion* = 24
+  X_XDGAChangePixmapMode* = 25
+  X_XDGACreateColormap* = 26
+  XDGAConcurrentAccess* = 0x00000001
+  XDGASolidFillRect* = 0x00000002
+  XDGABlitRect* = 0x00000004
+  XDGABlitTransRect* = 0x00000008
+  XDGAPixmap* = 0x00000010
+  XDGAInterlaced* = 0x00010000
+  XDGADoublescan* = 0x00020000
+  XDGAFlipImmediate* = 0x00000001
+  XDGAFlipRetrace* = 0x00000002
+  XDGANeedRoot* = 0x00000001
+  XF86DGANumberEvents* = 7
+  XDGAPixmapModeLarge* = 0
+  XDGAPixmapModeSmall* = 1
+  XF86DGAClientNotLocal* = 0
+  XF86DGANoDirectVideoMode* = 1
+  XF86DGAScreenNotActive* = 2
+  XF86DGADirectNotActivated* = 3
+  XF86DGAOperationNotSupported* = 4
+  XF86DGANumberErrors* = (XF86DGAOperationNotSupported + 1)
+
+type 
+  PXDGAMode* = ptr TXDGAMode
+  TXDGAMode*{.final.} = object 
+    num*: cint                # A unique identifier for the mode (num > 0) 
+    name*: cstring            # name of mode given in the XF86Config 
+    verticalRefresh*: cfloat
+    flags*: cint              # DGA_CONCURRENT_ACCESS, etc... 
+    imageWidth*: cint         # linear accessible portion (pixels) 
+    imageHeight*: cint
+    pixmapWidth*: cint        # Xlib accessible portion (pixels) 
+    pixmapHeight*: cint       # both fields ignored if no concurrent access 
+    bytesPerScanline*: cint
+    byteOrder*: cint          # MSBFirst, LSBFirst 
+    depth*: cint
+    bitsPerPixel*: cint
+    redMask*: culong
+    greenMask*: culong
+    blueMask*: culong
+    visualClass*: cshort
+    viewportWidth*: cint
+    viewportHeight*: cint
+    xViewportStep*: cint      # viewport position granularity 
+    yViewportStep*: cint
+    maxViewportX*: cint       # max viewport origin 
+    maxViewportY*: cint
+    viewportFlags*: cint      # types of page flipping possible 
+    reserved1*: cint
+    reserved2*: cint
+
+  PXDGADevice* = ptr TXDGADevice
+  TXDGADevice*{.final.} = object 
+    mode*: TXDGAMode
+    data*: Pcuchar
+    pixmap*: TPixmap
+
+  PXDGAButtonEvent* = ptr TXDGAButtonEvent
+  TXDGAButtonEvent*{.final.} = object 
+    theType*: cint
+    serial*: culong
+    display*: PDisplay
+    screen*: cint
+    time*: TTime
+    state*: cuint
+    button*: cuint
+
+  PXDGAKeyEvent* = ptr TXDGAKeyEvent
+  TXDGAKeyEvent*{.final.} = object 
+    theType*: cint
+    serial*: culong
+    display*: PDisplay
+    screen*: cint
+    time*: TTime
+    state*: cuint
+    keycode*: cuint
+
+  PXDGAMotionEvent* = ptr TXDGAMotionEvent
+  TXDGAMotionEvent*{.final.} = object 
+    theType*: cint
+    serial*: culong
+    display*: PDisplay
+    screen*: cint
+    time*: TTime
+    state*: cuint
+    dx*: cint
+    dy*: cint
+
+  PXDGAEvent* = ptr TXDGAEvent
+  TXDGAEvent*{.final.} = object 
+    pad*: array[0..23, clong] # sorry you have to cast if you want access
+                              #Case LongInt Of
+                              #      0 : (_type : cint);
+                              #      1 : (xbutton : TXDGAButtonEvent);
+                              #      2 : (xkey : TXDGAKeyEvent);
+                              #      3 : (xmotion : TXDGAMotionEvent);
+                              #      4 : (pad : Array[0..23] Of clong);
+  
+
+proc XDGAQueryExtension*(dpy: PDisplay, eventBase: Pcint, erroBase: Pcint): TBool{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XDGAQueryVersion*(dpy: PDisplay, majorVersion: Pcint, minorVersion: Pcint): TBool{.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XDGAQueryModes*(dpy: PDisplay, screen: cint, num: Pcint): PXDGAMode{.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGASetMode*(dpy: PDisplay, screen: cint, mode: cint): PXDGADevice{.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGAOpenFramebuffer*(dpy: PDisplay, screen: cint): TBool{.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGACloseFramebuffer*(dpy: PDisplay, screen: cint){.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGASetViewport*(dpy: PDisplay, screen: cint, x: cint, y: cint, flags: cint){.
+    CDecl, dynlib: libXxf86dga, importc.}
+proc XDGAInstallColormap*(dpy: PDisplay, screen: cint, cmap: TColormap){.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGACreateColormap*(dpy: PDisplay, screen: cint, device: PXDGADevice, 
+                         alloc: cint): TColormap{.CDecl, dynlib: libXxf86dga, 
+    importc.}
+proc XDGASelectInput*(dpy: PDisplay, screen: cint, event_mask: clong){.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGAFillRectangle*(dpy: PDisplay, screen: cint, x: cint, y: cint, 
+                        width: cuint, height: cuint, color: culong){.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGACopyArea*(dpy: PDisplay, screen: cint, srcx: cint, srcy: cint, 
+                   width: cuint, height: cuint, dstx: cint, dsty: cint){.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGACopyTransparentArea*(dpy: PDisplay, screen: cint, srcx: cint, 
+                              srcy: cint, width: cuint, height: cuint, 
+                              dstx: cint, dsty: cint, key: culong){.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGAGetViewportStatus*(dpy: PDisplay, screen: cint): cint{.CDecl, 
+    dynlib: libXxf86dga, importc.}
+proc XDGASync*(dpy: PDisplay, screen: cint){.CDecl, dynlib: libXxf86dga, importc.}
+proc XDGASetClientVersion*(dpy: PDisplay): TBool{.CDecl, dynlib: libXxf86dga, 
+    importc.}
+proc XDGAChangePixmapMode*(dpy: PDisplay, screen: cint, x: Pcint, y: Pcint, 
+                           mode: cint){.CDecl, dynlib: libXxf86dga, importc.}
+proc XDGAKeyEventToXKeyEvent*(dk: PXDGAKeyEvent, xk: PXKeyEvent){.CDecl, 
+    dynlib: libXxf86dga, importc.}
+# implementation

lib/oldwrappers/x11/xf86vmode.nim

@@ -0,0 +1,229 @@
+# $XFree86: xc/include/extensions/xf86vmode.h,v 3.30 2001/05/07 20:09:50 mvojkovi Exp $ 
+#
+#
+#Copyright 1995  Kaleb S. KEITHLEY
+#
+#Permission is hereby granted, free of charge, to any person obtaining
+#a copy of this software and associated documentation files (the
+#"Software"), to deal in the Software without restriction, including
+#without limitation the rights to use, copy, modify, merge, publish,
+#distribute, sublicense, and/or sell copies of the Software, and to
+#permit persons to whom the Software is furnished to do so, subject to
+#the following conditions:
+#
+#The above copyright notice and this permission notice shall be
+#included in all copies or substantial portions of the Software.
+#
+#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+#IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES 
+#OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+#ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+#OTHER DEALINGS IN THE SOFTWARE.
+#
+#Except as contained in this notice, the name of Kaleb S. KEITHLEY 
+#shall not be used in advertising or otherwise to promote the sale, use 
+#or other dealings in this Software without prior written authorization
+#from Kaleb S. KEITHLEY
+#
+#
+# $Xorg: xf86vmode.h,v 1.3 2000/08/18 04:05:46 coskrey Exp $ 
+# THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION 
+
+import 
+  x, xlib
+
+const 
+  libXxf86vm* = "libXxf86vm.so"
+
+type 
+  PINT32* = ptr int32
+
+const 
+  X_XF86VidModeQueryVersion* = 0
+  X_XF86VidModeGetModeLine* = 1
+  X_XF86VidModeModModeLine* = 2
+  X_XF86VidModeSwitchMode* = 3
+  X_XF86VidModeGetMonitor* = 4
+  X_XF86VidModeLockModeSwitch* = 5
+  X_XF86VidModeGetAllModeLines* = 6
+  X_XF86VidModeAddModeLine* = 7
+  X_XF86VidModeDeleteModeLine* = 8
+  X_XF86VidModeValidateModeLine* = 9
+  X_XF86VidModeSwitchToMode* = 10
+  X_XF86VidModeGetViewPort* = 11
+  X_XF86VidModeSetViewPort* = 12 # new for version 2.x of this extension 
+  X_XF86VidModeGetDotClocks* = 13
+  X_XF86VidModeSetClientVersion* = 14
+  X_XF86VidModeSetGamma* = 15
+  X_XF86VidModeGetGamma* = 16
+  X_XF86VidModeGetGammaRamp* = 17
+  X_XF86VidModeSetGammaRamp* = 18
+  X_XF86VidModeGetGammaRampSize* = 19
+  X_XF86VidModeGetPermissions* = 20
+  CLKFLAG_PROGRAMABLE* = 1
+
+when defined(XF86VIDMODE_EVENTS): 
+  const 
+    XF86VidModeNotify* = 0
+    XF86VidModeNumberEvents* = (XF86VidModeNotify + 1)
+    XF86VidModeNotifyMask* = 0x00000001
+    XF86VidModeNonEvent* = 0
+    XF86VidModeModeChange* = 1
+else: 
+  const 
+    XF86VidModeNumberEvents* = 0
+const 
+  XF86VidModeBadClock* = 0
+  XF86VidModeBadHTimings* = 1
+  XF86VidModeBadVTimings* = 2
+  XF86VidModeModeUnsuitable* = 3
+  XF86VidModeExtensionDisabled* = 4
+  XF86VidModeClientNotLocal* = 5
+  XF86VidModeZoomLocked* = 6
+  XF86VidModeNumberErrors* = (XF86VidModeZoomLocked + 1)
+  XF86VM_READ_PERMISSION* = 1
+  XF86VM_WRITE_PERMISSION* = 2
+
+type 
+  PXF86VidModeModeLine* = ptr TXF86VidModeModeLine
+  TXF86VidModeModeLine*{.final.} = object 
+    hdisplay*: cushort
+    hsyncstart*: cushort
+    hsyncend*: cushort
+    htotal*: cushort
+    hskew*: cushort
+    vdisplay*: cushort
+    vsyncstart*: cushort
+    vsyncend*: cushort
+    vtotal*: cushort
+    flags*: cuint
+    privsize*: cint
+    c_private*: PINT32
+
+  PPPXF86VidModeModeInfo* = ptr PPXF86VidModeModeInfo
+  PPXF86VidModeModeInfo* = ptr PXF86VidModeModeInfo
+  PXF86VidModeModeInfo* = ptr TXF86VidModeModeInfo
+  TXF86VidModeModeInfo*{.final.} = object 
+    dotclock*: cuint
+    hdisplay*: cushort
+    hsyncstart*: cushort
+    hsyncend*: cushort
+    htotal*: cushort
+    hskew*: cushort
+    vdisplay*: cushort
+    vsyncstart*: cushort
+    vsyncend*: cushort
+    vtotal*: cushort
+    flags*: cuint
+    privsize*: cint
+    c_private*: PINT32
+
+  PXF86VidModeSyncRange* = ptr TXF86VidModeSyncRange
+  TXF86VidModeSyncRange*{.final.} = object 
+    hi*: cfloat
+    lo*: cfloat
+
+  PXF86VidModeMonitor* = ptr TXF86VidModeMonitor
+  TXF86VidModeMonitor*{.final.} = object 
+    vendor*: cstring
+    model*: cstring
+    EMPTY*: cfloat
+    nhsync*: cuchar
+    hsync*: PXF86VidModeSyncRange
+    nvsync*: cuchar
+    vsync*: PXF86VidModeSyncRange
+
+  PXF86VidModeNotifyEvent* = ptr TXF86VidModeNotifyEvent
+  TXF86VidModeNotifyEvent*{.final.} = object 
+    theType*: cint            # of event 
+    serial*: culong           # # of last request processed by server 
+    send_event*: TBool        # true if this came from a SendEvent req 
+    display*: PDisplay        # Display the event was read from 
+    root*: TWindow            # root window of event screen 
+    state*: cint              # What happened 
+    kind*: cint               # What happened 
+    forced*: TBool            # extents of new region 
+    time*: TTime              # event timestamp 
+  
+  PXF86VidModeGamma* = ptr TXF86VidModeGamma
+  TXF86VidModeGamma*{.final.} = object 
+    red*: cfloat              # Red Gamma value 
+    green*: cfloat            # Green Gamma value 
+    blue*: cfloat             # Blue Gamma value 
+  
+
+when defined(MACROS): 
+  proc XF86VidModeSelectNextMode*(disp: PDisplay, scr: cint): TBool
+  proc XF86VidModeSelectPrevMode*(disp: PDisplay, scr: cint): TBool
+proc XF86VidModeQueryVersion*(dpy: PDisplay, majorVersion: Pcint, 
+                              minorVersion: Pcint): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeQueryExtension*(dpy: PDisplay, event_base: Pcint, 
+                                error_base: Pcint): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeSetClientVersion*(dpy: PDisplay): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeGetModeLine*(dpy: PDisplay, screen: cint, dotclock: Pcint, 
+                             modeline: PXF86VidModeModeLine): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeGetAllModeLines*(dpy: PDisplay, screen: cint, modecount: Pcint, 
+                                 modelinesPtr: PPPXF86VidModeModeInfo): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeAddModeLine*(dpy: PDisplay, screen: cint, 
+                             new_modeline: PXF86VidModeModeInfo, 
+                             after_modeline: PXF86VidModeModeInfo): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeDeleteModeLine*(dpy: PDisplay, screen: cint, 
+                                modeline: PXF86VidModeModeInfo): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeModModeLine*(dpy: PDisplay, screen: cint, 
+                             modeline: PXF86VidModeModeLine): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeValidateModeLine*(dpy: PDisplay, screen: cint, 
+                                  modeline: PXF86VidModeModeInfo): TStatus{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeSwitchMode*(dpy: PDisplay, screen: cint, zoom: cint): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeSwitchToMode*(dpy: PDisplay, screen: cint, 
+                              modeline: PXF86VidModeModeInfo): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeLockModeSwitch*(dpy: PDisplay, screen: cint, lock: cint): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeGetMonitor*(dpy: PDisplay, screen: cint, 
+                            monitor: PXF86VidModeMonitor): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeGetViewPort*(dpy: PDisplay, screen: cint, x_return: Pcint, 
+                             y_return: Pcint): TBool{.CDecl, dynlib: libXxf86vm, 
+    importc.}
+proc XF86VidModeSetViewPort*(dpy: PDisplay, screen: cint, x: cint, y: cint): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeGetDotClocks*(dpy: PDisplay, screen: cint, flags_return: Pcint, 
+                              number_of_clocks_return: Pcint, 
+                              max_dot_clock_return: Pcint, clocks_return: PPcint): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeGetGamma*(dpy: PDisplay, screen: cint, Gamma: PXF86VidModeGamma): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeSetGamma*(dpy: PDisplay, screen: cint, Gamma: PXF86VidModeGamma): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeSetGammaRamp*(dpy: PDisplay, screen: cint, size: cint, 
+                              red_array: Pcushort, green_array: Pcushort, 
+                              blue_array: Pcushort): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeGetGammaRamp*(dpy: PDisplay, screen: cint, size: cint, 
+                              red_array: Pcushort, green_array: Pcushort, 
+                              blue_array: Pcushort): TBool{.CDecl, 
+    dynlib: libXxf86vm, importc.}
+proc XF86VidModeGetGammaRampSize*(dpy: PDisplay, screen: cint, size: Pcint): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+proc XF86VidModeGetPermissions*(dpy: PDisplay, screen: cint, permissions: Pcint): TBool{.
+    CDecl, dynlib: libXxf86vm, importc.}
+# implementation
+
+when defined(MACROS): 
+  proc XF86VidModeSelectNextMode(disp: PDisplay, scr: cint): TBool = 
+    XF86VidModeSelectNextMode = XF86VidModeSwitchMode(disp, scr, 1)
+
+  proc XF86VidModeSelectPrevMode(disp: PDisplay, scr: cint): TBool = 
+    XF86VidModeSelectPrevMode = XF86VidModeSwitchMode(disp, scr, - 1)

lib/oldwrappers/x11/xi.nim

@@ -0,0 +1,307 @@
+#
+# $Xorg: XI.h,v 1.4 2001/02/09 02:03:23 xorgcvs Exp $
+#
+#************************************************************
+#
+#Copyright 1989, 1998  The Open Group
+#
+#Permission to use, copy, modify, distribute, and sell this software and its
+#documentation for any purpose is hereby granted without fee, provided that
+#the above copyright notice appear in all copies and that both that
+#copyright notice and this permission notice appear in supporting
+#documentation.
+#
+#The above copyright notice and this permission notice shall be included in
+#all copies or substantial portions of the Software.
+#
+#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+#OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+#AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+#CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+#Except as contained in this notice, the name of The Open Group shall not be
+#used in advertising or otherwise to promote the sale, use or other dealings
+#in this Software without prior written authorization from The Open Group.
+#
+#Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
+#
+#                        All Rights Reserved
+#
+#Permission to use, copy, modify, and distribute this software and its
+#documentation for any purpose and without fee is hereby granted,
+#provided that the above copyright notice appear in all copies and that
+#both that copyright notice and this permission notice appear in
+#supporting documentation, and that the name of Hewlett-Packard not be
+#used in advertising or publicity pertaining to distribution of the
+#software without specific, written prior permission.
+#
+#HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+#ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+#HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+#ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+#WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+#ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+#SOFTWARE.
+#
+#********************************************************/
+# $XFree86: xc/include/extensions/XI.h,v 1.5 2001/12/14 19:53:28 dawes Exp $
+#
+# Definitions used by the server, library and client
+#
+#        Pascal Convertion was made by Ido Kannner - kanerido@actcom.net.il
+#
+#Histroy:
+#        2004/10/15 - Fixed a bug of accessing second based records by removing "paced record" and chnaged it to
+#                     "reocrd" only.
+#        2004/10/07 - Removed the "uses X;" line. The unit does not need it.
+#        2004/10/03 - Conversion from C header to Pascal unit.
+#
+
+const 
+  sz_xGetExtensionVersionReq* = 8
+  sz_xGetExtensionVersionReply* = 32
+  sz_xListInputDevicesReq* = 4
+  sz_xListInputDevicesReply* = 32
+  sz_xOpenDeviceReq* = 8
+  sz_xOpenDeviceReply* = 32
+  sz_xCloseDeviceReq* = 8
+  sz_xSetDeviceModeReq* = 8
+  sz_xSetDeviceModeReply* = 32
+  sz_xSelectExtensionEventReq* = 12
+  sz_xGetSelectedExtensionEventsReq* = 8
+  sz_xGetSelectedExtensionEventsReply* = 32
+  sz_xChangeDeviceDontPropagateListReq* = 12
+  sz_xGetDeviceDontPropagateListReq* = 8
+  sz_xGetDeviceDontPropagateListReply* = 32
+  sz_xGetDeviceMotionEventsReq* = 16
+  sz_xGetDeviceMotionEventsReply* = 32
+  sz_xChangeKeyboardDeviceReq* = 8
+  sz_xChangeKeyboardDeviceReply* = 32
+  sz_xChangePointerDeviceReq* = 8
+  sz_xChangePointerDeviceReply* = 32
+  sz_xGrabDeviceReq* = 20
+  sz_xGrabDeviceReply* = 32
+  sz_xUngrabDeviceReq* = 12
+  sz_xGrabDeviceKeyReq* = 20
+  sz_xGrabDeviceKeyReply* = 32
+  sz_xUngrabDeviceKeyReq* = 16
+  sz_xGrabDeviceButtonReq* = 20
+  sz_xGrabDeviceButtonReply* = 32
+  sz_xUngrabDeviceButtonReq* = 16
+  sz_xAllowDeviceEventsReq* = 12
+  sz_xGetDeviceFocusReq* = 8
+  sz_xGetDeviceFocusReply* = 32
+  sz_xSetDeviceFocusReq* = 16
+  sz_xGetFeedbackControlReq* = 8
+  sz_xGetFeedbackControlReply* = 32
+  sz_xChangeFeedbackControlReq* = 12
+  sz_xGetDeviceKeyMappingReq* = 8
+  sz_xGetDeviceKeyMappingReply* = 32
+  sz_xChangeDeviceKeyMappingReq* = 8
+  sz_xGetDeviceModifierMappingReq* = 8
+  sz_xSetDeviceModifierMappingReq* = 8
+  sz_xSetDeviceModifierMappingReply* = 32
+  sz_xGetDeviceButtonMappingReq* = 8
+  sz_xGetDeviceButtonMappingReply* = 32
+  sz_xSetDeviceButtonMappingReq* = 8
+  sz_xSetDeviceButtonMappingReply* = 32
+  sz_xQueryDeviceStateReq* = 8
+  sz_xQueryDeviceStateReply* = 32
+  sz_xSendExtensionEventReq* = 16
+  sz_xDeviceBellReq* = 8
+  sz_xSetDeviceValuatorsReq* = 8
+  sz_xSetDeviceValuatorsReply* = 32
+  sz_xGetDeviceControlReq* = 8
+  sz_xGetDeviceControlReply* = 32
+  sz_xChangeDeviceControlReq* = 8
+  sz_xChangeDeviceControlReply* = 32
+
+const 
+  INAME* = "XInputExtension"
+
+const 
+  XI_KEYBOARD* = "KEYBOARD"
+  XI_MOUSE* = "MOUSE"
+  XI_TABLET* = "TABLET"
+  XI_TOUCHSCREEN* = "TOUCHSCREEN"
+  XI_TOUCHPAD* = "TOUCHPAD"
+  XI_BARCODE* = "BARCODE"
+  XI_BUTTONBOX* = "BUTTONBOX"
+  XI_KNOB_BOX* = "KNOB_BOX"
+  XI_ONE_KNOB* = "ONE_KNOB"
+  XI_NINE_KNOB* = "NINE_KNOB"
+  XI_TRACKBALL* = "TRACKBALL"
+  XI_QUADRATURE* = "QUADRATURE"
+  XI_ID_MODULE* = "ID_MODULE"
+  XI_SPACEBALL* = "SPACEBALL"
+  XI_DATAGLOVE* = "DATAGLOVE"
+  XI_EYETRACKER* = "EYETRACKER"
+  XI_CURSORKEYS* = "CURSORKEYS"
+  XI_FOOTMOUSE* = "FOOTMOUSE"
+
+const 
+  Dont_Check* = 0
+  XInput_Initial_Release* = 1
+  XInput_Add_XDeviceBell* = 2
+  XInput_Add_XSetDeviceValuators* = 3
+  XInput_Add_XChangeDeviceControl* = 4
+
+const 
+  XI_Absent* = 0
+  XI_Present* = 1
+
+const 
+  XI_Initial_Release_Major* = 1
+  XI_Initial_Release_Minor* = 0
+
+const 
+  XI_Add_XDeviceBell_Major* = 1
+  XI_Add_XDeviceBell_Minor* = 1
+
+const 
+  XI_Add_XSetDeviceValuators_Major* = 1
+  XI_Add_XSetDeviceValuators_Minor* = 2
+
+const 
+  XI_Add_XChangeDeviceControl_Major* = 1
+  XI_Add_XChangeDeviceControl_Minor* = 3
+
+const 
+  DEVICE_RESOLUTION* = 1
+
+const 
+  NoSuchExtension* = 1
+
+const 
+  COUNT* = 0
+  CREATE* = 1
+
+const 
+  NewPointer* = 0
+  NewKeyboard* = 1
+
+const 
+  XPOINTER* = 0
+  XKEYBOARD* = 1
+
+const 
+  UseXKeyboard* = 0x000000FF
+
+const 
+  IsXPointer* = 0
+  IsXKeyboard* = 1
+  IsXExtensionDevice* = 2
+
+const 
+  AsyncThisDevice* = 0
+  SyncThisDevice* = 1
+  ReplayThisDevice* = 2
+  AsyncOtherDevices* = 3
+  AsyncAll* = 4
+  SyncAll* = 5
+
+const 
+  FollowKeyboard* = 3
+  RevertToFollowKeyboard* = 3
+
+const 
+  DvAccelNum* = int(1) shl 0
+  DvAccelDenom* = int(1) shl 1
+  DvThreshold* = int(1) shl 2
+
+const 
+  DvKeyClickPercent* = int(1) shl 0
+  DvPercent* = int(1) shl 1
+  DvPitch* = int(1) shl 2
+  DvDuration* = int(1) shl 3
+  DvLed* = int(1) shl 4
+  DvLedMode* = int(1) shl 5
+  DvKey* = int(1) shl 6
+  DvAutoRepeatMode* = 1 shl 7
+
+const 
+  DvString* = int(1) shl 0
+
+const 
+  DvInteger* = int(1) shl 0
+
+const 
+  DeviceMode* = int(1) shl 0
+  Relative* = 0
+  Absolute* = 1               # Merged from Metrolink tree for XINPUT stuff 
+  TS_Raw* = 57
+  TS_Scaled* = 58
+  SendCoreEvents* = 59
+  DontSendCoreEvents* = 60    # End of merged section 
+
+const 
+  ProximityState* = int(1) shl 1
+  InProximity* = int(0) shl 1
+  OutOfProximity* = int(1) shl 1
+
+const 
+  AddToList* = 0
+  DeleteFromList* = 1
+
+const 
+  KeyClass* = 0
+  ButtonClass* = 1
+  ValuatorClass* = 2
+  FeedbackClass* = 3
+  ProximityClass* = 4
+  FocusClass* = 5
+  OtherClass* = 6
+
+const 
+  KbdFeedbackClass* = 0
+  PtrFeedbackClass* = 1
+  StringFeedbackClass* = 2
+  IntegerFeedbackClass* = 3
+  LedFeedbackClass* = 4
+  BellFeedbackClass* = 5
+
+const 
+  devicePointerMotionHint* = 0
+  deviceButton1Motion* = 1
+  deviceButton2Motion* = 2
+  deviceButton3Motion* = 3
+  deviceButton4Motion* = 4
+  deviceButton5Motion* = 5
+  deviceButtonMotion* = 6
+  deviceButtonGrab* = 7
+  deviceOwnerGrabButton* = 8
+  noExtensionEvent* = 9
+
+const 
+  XI_BadDevice* = 0
+  XI_BadEvent* = 1
+  XI_BadMode* = 2
+  XI_DeviceBusy* = 3
+  XI_BadClass* = 4 # Make XEventClass be a CARD32 for 64 bit servers.  Don't affect client
+                   #  definition of XEventClass since that would be a library interface change.
+                   #  See the top of X.h for more _XSERVER64 magic.
+                   #
+
+when defined(XSERVER64): 
+  type 
+    XEventClass* = CARD32
+else: 
+  type 
+    XEventClass* = int32
+#******************************************************************
+# *
+# * Extension version structure.
+# *
+# 
+
+type 
+  PXExtensionVersion* = ptr TXExtensionVersion
+  TXExtensionVersion*{.final.} = object 
+    present*: int16
+    major_version*: int16
+    minor_version*: int16
+
+
+# implementation

lib/oldwrappers/x11/xinerama.nim

@@ -0,0 +1,25 @@
+# Converted from X11/Xinerama.h 
+import                        
+  xlib
+
+const
+  xineramaLib = "libXinerama.so"
+
+type 
+  PXineramaScreenInfo* = ptr TXineramaScreenInfo
+  TXineramaScreenInfo*{.final.} = object 
+    screen_number*: cint
+    x_org*: int16
+    y_org*: int16
+    width*: int16
+    height*: int16
+
+
+proc XineramaQueryExtension*(dpy: PDisplay, event_base: Pcint, error_base: Pcint): TBool{.
+    cdecl, dynlib: xineramaLib, importc.}
+proc XineramaQueryVersion*(dpy: PDisplay, major: Pcint, minor: Pcint): TStatus{.
+    cdecl, dynlib: xineramaLib, importc.}
+proc XineramaIsActive*(dpy: PDisplay): TBool{.cdecl, dynlib: xineramaLib, importc.}
+proc XineramaQueryScreens*(dpy: PDisplay, number: Pcint): PXineramaScreenInfo{.
+    cdecl, dynlib: xineramaLib, importc.}
+

lib/oldwrappers/x11/xkblib.nim

@@ -0,0 +1,699 @@
+# $Xorg: XKBlib.h,v 1.6 2000/08/17 19:45:03 cpqbld Exp $
+#************************************************************
+#Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+#
+#Permission to use, copy, modify, and distribute this
+#software and its documentation for any purpose and without
+#fee is hereby granted, provided that the above copyright
+#notice appear in all copies and that both that copyright
+#notice and this permission notice appear in supporting
+#documentation, and that the name of Silicon Graphics not be
+#used in advertising or publicity pertaining to distribution
+#of the software without specific prior written permission.
+#Silicon Graphics makes no representation about the suitability
+#of this software for any purpose. It is provided "as is"
+#without any express or implied warranty.
+#
+#SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+#SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+#AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+#GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+#DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING `from` LOSS OF USE,
+#DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+#OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+#THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+#********************************************************/
+# $XFree86: xc/lib/X11/XKBlib.h,v 3.3 2001/08/01 00:44:38 tsi Exp $
+#
+# Pascal Convertion was made by Ido Kannner - kanerido@actcom.net.il
+#
+#Thanks:
+#         I want to thanks to oliebol for putting up with all of the problems that was found
+#         while translating this code. ;)
+#
+#         I want to thanks #fpc channel in freenode irc, for helping me, and to put up with my
+#         wierd questions ;)
+#
+#         Thanks for mmc in #xlib on freenode irc And so for the channel itself for the helping me to
+#         understanding some of the problems I had converting this headers and pointing me to resources
+#         that helped translating this headers.
+#
+# Ido
+#
+#History:
+#        2004/10/15        - Fixed a bug of accessing second based records by removing "paced record" and
+#                            chnaged it to "reocrd" only.
+#        2004/10/10        - Added to TXkbGetAtomNameFunc and TXkbInternAtomFunc the cdecl call.
+#        2004/10/06 - 09   - Convertion `from` the c header of XKBlib.h
+#
+#
+
+import 
+  X, Xlib, XKB
+
+type 
+  PXkbAnyEvent* = ptr TXkbAnyEvent
+  TXkbAnyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds;
+    xkb_type*: int16          # XKB event minor code
+    device*: int16            # device ID
+  
+
+type 
+  PXkbNewKeyboardNotifyEvent* = ptr TXkbNewKeyboardNotifyEvent
+  TXkbNewKeyboardNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbNewKeyboardNotify
+    device*: int16            # device ID
+    old_device*: int16        # device ID of previous keyboard
+    min_key_code*: int16      # minimum key code
+    max_key_code*: int16      # maximum key code
+    old_min_key_code*: int16  # min key code of previous kbd
+    old_max_key_code*: int16  # max key code of previous kbd
+    changed*: int16           # changed aspects of the keyboard
+    req_major*: int8          # major and minor opcode of req
+    req_minor*: int8          # that caused change, if applicable
+  
+
+type 
+  PXkbMapNotifyEvent* = ptr TXkbMapNotifyEvent
+  TXkbMapNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbMapNotify
+    device*: int16            # device ID
+    changed*: int16           # fields which have been changed
+    flags*: int16             # reserved
+    first_type*: int16        # first changed key type
+    num_types*: int16         # number of changed key types
+    min_key_code*: TKeyCode
+    max_key_code*: TKeyCode
+    first_key_sym*: TKeyCode
+    first_key_act*: TKeyCode
+    first_key_behavior*: TKeyCode
+    first_key_explicit*: TKeyCode
+    first_modmap_key*: TKeyCode
+    first_vmodmap_key*: TKeyCode
+    num_key_syms*: int16
+    num_key_acts*: int16
+    num_key_behaviors*: int16
+    num_key_explicit*: int16
+    num_modmap_keys*: int16
+    num_vmodmap_keys*: int16
+    vmods*: int16             # mask of changed virtual mods
+  
+
+type 
+  PXkbStateNotifyEvent* = ptr TXkbStateNotifyEvent
+  TXkbStateNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbStateNotify
+    device*: int16            # device ID
+    changed*: int16           # mask of changed state components
+    group*: int16             # keyboard group
+    base_group*: int16        # base keyboard group
+    latched_group*: int16     # latched keyboard group
+    locked_group*: int16      # locked keyboard group
+    mods*: int16              # modifier state
+    base_mods*: int16         # base modifier state
+    latched_mods*: int16      # latched modifiers
+    locked_mods*: int16       # locked modifiers
+    compat_state*: int16      # compatibility state
+    grab_mods*: int8          # mods used for grabs
+    compat_grab_mods*: int8   # grab mods for non-XKB clients
+    lookup_mods*: int8        # mods sent to clients
+    compat_lookup_mods*: int8 # mods sent to non-XKB clients
+    ptr_buttons*: int16       # pointer button state
+    keycode*: TKeyCode        # keycode that caused the change
+    event_type*: int8         # KeyPress or KeyRelease
+    req_major*: int8          # Major opcode of request
+    req_minor*: int8          # Minor opcode of request
+  
+
+type 
+  PXkbControlsNotifyEvent* = ptr TXkbControlsNotifyEvent
+  TXkbControlsNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbControlsNotify
+    device*: int16            # device ID
+    changed_ctrls*: int16     # controls with changed sub-values
+    enabled_ctrls*: int16     # controls currently enabled
+    enabled_ctrl_changes*: int16 # controls just {en,dis}abled
+    num_groups*: int16        # total groups on keyboard
+    keycode*: TKeyCode        # key that caused change or 0
+    event_type*: int8         # type of event that caused change
+    req_major*: int8          # if keycode==0, major and minor
+    req_minor*: int8          # opcode of req that caused change
+  
+
+type 
+  PXkbIndicatorNotifyEvent* = ptr TXkbIndicatorNotifyEvent
+  TXkbIndicatorNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbIndicatorNotify
+    device*: int16            # device
+    changed*: int16           # indicators with new state or map
+    state*: int16             # current state of all indicators
+  
+
+type 
+  PXkbNamesNotifyEvent* = ptr TXkbNamesNotifyEvent
+  TXkbNamesNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbNamesNotify
+    device*: int16            # device ID
+    changed*: int32           # names that have changed
+    first_type*: int16        # first key type with new name
+    num_types*: int16         # number of key types with new names
+    first_lvl*: int16         # first key type new new level names
+    num_lvls*: int16          # # of key types w/new level names
+    num_aliases*: int16       # total number of key aliases
+    num_radio_groups*: int16  # total number of radio groups
+    changed_vmods*: int16     # virtual modifiers with new names
+    changed_groups*: int16    # groups with new names
+    changed_indicators*: int16 # indicators with new names
+    first_key*: int16         # first key with new name
+    num_keys*: int16          # number of keys with new names
+  
+
+type 
+  PXkbCompatMapNotifyEvent* = ptr TXkbCompatMapNotifyEvent
+  TXkbCompatMapNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbCompatMapNotify
+    device*: int16            # device ID
+    changed_groups*: int16    # groups with new compat maps
+    first_si*: int16          # first new symbol interp
+    num_si*: int16            # number of new symbol interps
+    num_total_si*: int16      # total # of symbol interps
+  
+
+type 
+  PXkbBellNotifyEvent* = ptr TXkbBellNotifyEvent
+  TXkbBellNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbBellNotify
+    device*: int16            # device ID
+    percent*: int16           # requested volume as a % of maximum
+    pitch*: int16             # requested pitch in Hz
+    duration*: int16          # requested duration in useconds
+    bell_class*: int16        # (input extension) feedback class
+    bell_id*: int16           # (input extension) ID of feedback
+    name*: TAtom              # "name" of requested bell
+    window*: TWindow          # window associated with event
+    event_only*: bool         # "event only" requested
+  
+
+type 
+  PXkbActionMessageEvent* = ptr TXkbActionMessageEvent
+  TXkbActionMessageEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbActionMessage
+    device*: int16            # device ID
+    keycode*: TKeyCode        # key that generated the event
+    press*: bool              # true if act caused by key press
+    key_event_follows*: bool  # true if key event also generated
+    group*: int16             # effective group
+    mods*: int16              # effective mods
+    message*: array[0..XkbActionMessageLength, Char] # message -- leave space for NUL
+  
+
+type 
+  PXkbAccessXNotifyEvent* = ptr TXkbAccessXNotifyEvent
+  TXkbAccessXNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbAccessXNotify
+    device*: int16            # device ID
+    detail*: int16            # XkbAXN_*
+    keycode*: int16           # key of event
+    sk_delay*: int16          # current slow keys delay
+    debounce_delay*: int16    # current debounce delay
+  
+
+type 
+  PXkbExtensionDeviceNotifyEvent* = ptr TXkbExtensionDeviceNotifyEvent
+  TXkbExtensionDeviceNotifyEvent*{.final.} = object 
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: TTime              # milliseconds
+    xkb_type*: int16          # XkbExtensionDeviceNotify
+    device*: int16            # device ID
+    reason*: int16            # reason for the event
+    supported*: int16         # mask of supported features
+    unsupported*: int16       # mask of unsupported features
+                              # that some app tried to use
+    first_btn*: int16         # first button that changed
+    num_btns*: int16          # range of buttons changed
+    leds_defined*: int16      # indicators with names or maps
+    led_state*: int16         # current state of the indicators
+    led_class*: int16         # feedback class for led changes
+    led_id*: int16            # feedback id for led changes
+  
+
+type 
+  PXkbEvent* = ptr TXkbEvent
+  TXkbEvent*{.final.} = object 
+    theType*: int16
+    any*: TXkbAnyEvent
+    new_kbd*: TXkbNewKeyboardNotifyEvent
+    map*: TXkbMapNotifyEvent
+    state*: TXkbStateNotifyEvent
+    ctrls*: TXkbControlsNotifyEvent
+    indicators*: TXkbIndicatorNotifyEvent
+    names*: TXkbNamesNotifyEvent
+    compat*: TXkbCompatMapNotifyEvent
+    bell*: TXkbBellNotifyEvent
+    message*: TXkbActionMessageEvent
+    accessx*: TXkbAccessXNotifyEvent
+    device*: TXkbExtensionDeviceNotifyEvent
+    core*: TXEvent
+
+
+type
+  PXkbKbdDpyStatePtr* = ptr TXkbKbdDpyStateRec
+  TXkbKbdDpyStateRec*{.final.} = object  # XkbOpenDisplay error codes 
+
+const 
+  XkbOD_Success* = 0
+  XkbOD_BadLibraryVersion* = 1
+  XkbOD_ConnectionRefused* = 2
+  XkbOD_NonXkbServer* = 3
+  XkbOD_BadServerVersion* = 4 # Values for XlibFlags 
+
+const 
+  XkbLC_ForceLatin1Lookup* = 1 shl 0
+  XkbLC_ConsumeLookupMods* = 1 shl 1
+  XkbLC_AlwaysConsumeShiftAndLock* = 1 shl 2
+  XkbLC_IgnoreNewKeyboards* = 1 shl 3
+  XkbLC_ControlFallback* = 1 shl 4
+  XkbLC_ConsumeKeysOnComposeFail* = 1 shl 29
+  XkbLC_ComposeLED* = 1 shl 30
+  XkbLC_BeepOnComposeFail* = 1 shl 31
+  XkbLC_AllComposeControls* = 0xC0000000
+  XkbLC_AllControls* = 0xC000001F
+
+proc XkbIgnoreExtension*(ignore: bool): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbIgnoreExtension".}
+proc XkbOpenDisplay*(name: cstring, ev_rtrn, err_rtrn, major_rtrn, minor_rtrn, 
+                                    reason: ptr int16): PDisplay{.cdecl, 
+    dynlib: libX11, importc: "XkbOpenDisplay".}
+proc XkbQueryExtension*(dpy: PDisplay, opcodeReturn, eventBaseReturn, 
+                                       errorBaseReturn, majorRtrn, minorRtrn: ptr int16): bool{.
+    cdecl, dynlib: libX11, importc: "XkbQueryExtension".}
+proc XkbUseExtension*(dpy: PDisplay, major_rtrn, minor_rtrn: ptr int16): bool{.
+    cdecl, dynlib: libX11, importc: "XkbUseExtension".}
+proc XkbLibraryVersion*(libMajorRtrn, libMinorRtrn: ptr int16): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbLibraryVersion".}
+proc XkbSetXlibControls*(dpy: PDisplay, affect, values: int16): int16{.cdecl, 
+    dynlib: libX11, importc: "XkbSetXlibControls".}
+proc XkbGetXlibControls*(dpy: PDisplay): int16{.cdecl, dynlib: libX11, 
+    importc: "XkbGetXlibControls".}
+type 
+  TXkbInternAtomFunc* = proc (dpy: PDisplay, name: cstring, only_if_exists: bool): TAtom{.
+      cdecl.}
+
+type 
+  TXkbGetAtomNameFunc* = proc (dpy: PDisplay, atom: TAtom): cstring{.cdecl.}
+
+proc XkbSetAtomFuncs*(getAtom: TXkbInternAtomFunc, getName: TXkbGetAtomNameFunc){.
+    cdecl, dynlib: libX11, importc: "XkbSetAtomFuncs".}
+proc XkbKeycodeToKeysym*(dpy: PDisplay, kc: TKeyCode, group, level: int16): TKeySym{.
+    cdecl, dynlib: libX11, importc: "XkbKeycodeToKeysym".}
+proc XkbKeysymToModifiers*(dpy: PDisplay, ks: TKeySym): int16{.cdecl, 
+    dynlib: libX11, importc: "XkbKeysymToModifiers".}
+proc XkbLookupKeySym*(dpy: PDisplay, keycode: TKeyCode, 
+                      modifiers, modifiers_return: int16, keysym_return: PKeySym): bool{.
+    cdecl, dynlib: libX11, importc: "XkbLookupKeySym".}
+proc XkbLookupKeyBinding*(dpy: PDisplay, sym_rtrn: TKeySym, mods: int16, 
+                          buffer: cstring, nbytes: int16, extra_rtrn: ptr int16): int16{.
+    cdecl, dynlib: libX11, importc: "XkbLookupKeyBinding".}
+proc XkbTranslateKeyCode*(xkb: PXkbDescPtr, keycode: TKeyCode, 
+                          modifiers, modifiers_return: int16, 
+                          keysym_return: PKeySym): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbTranslateKeyCode".}
+proc XkbTranslateKeySym*(dpy: PDisplay, sym_return: TKeySym, modifiers: int16, 
+                         buffer: cstring, nbytes: int16, extra_rtrn: ptr int16): int16{.
+    cdecl, dynlib: libX11, importc: "XkbTranslateKeySym".}
+proc XkbSetAutoRepeatRate*(dpy: PDisplay, deviceSpec, delay, interval: int16): bool{.
+    cdecl, dynlib: libX11, importc: "XkbSetAutoRepeatRate".}
+proc XkbGetAutoRepeatRate*(dpy: PDisplay, deviceSpec: int16, 
+                           delayRtrn, intervalRtrn: PWord): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbGetAutoRepeatRate".}
+proc XkbChangeEnabledControls*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{.
+    cdecl, dynlib: libX11, importc: "XkbChangeEnabledControls".}
+proc XkbDeviceBell*(dpy: PDisplay, win: TWindow, 
+                    deviceSpec, bellClass, bellID, percent: int16, name: TAtom): bool{.
+    cdecl, dynlib: libX11, importc: "XkbDeviceBell".}
+proc XkbForceDeviceBell*(dpy: PDisplay, 
+                         deviceSpec, bellClass, bellID, percent: int16): bool{.
+    cdecl, dynlib: libX11, importc: "XkbForceDeviceBell".}
+proc XkbDeviceBellEvent*(dpy: PDisplay, win: TWindow, 
+                         deviceSpec, bellClass, bellID, percent: int16, 
+                         name: TAtom): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbDeviceBellEvent".}
+proc XkbBell*(dpy: PDisplay, win: TWindow, percent: int16, name: TAtom): bool{.
+    cdecl, dynlib: libX11, importc: "XkbBell".}
+proc XkbForceBell*(dpy: PDisplay, percent: int16): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbForceBell".}
+proc XkbBellEvent*(dpy: PDisplay, win: TWindow, percent: int16, name: TAtom): bool{.
+    cdecl, dynlib: libX11, importc: "XkbBellEvent".}
+proc XkbSelectEvents*(dpy: PDisplay, deviceID, affect, values: int16): bool{.
+    cdecl, dynlib: libX11, importc: "XkbSelectEvents".}
+proc XkbSelectEventDetails*(dpy: PDisplay, deviceID, eventType: int16, 
+                            affect, details: int32): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbSelectEventDetails".}
+proc XkbNoteMapChanges*(old: PXkbMapChangesPtr, new: PXkbMapNotifyEvent, 
+                        wanted: int16){.cdecl, dynlib: libX11, 
+                                        importc: "XkbNoteMapChanges".}
+proc XkbNoteNameChanges*(old: PXkbNameChangesPtr, new: PXkbNamesNotifyEvent, 
+                         wanted: int16){.cdecl, dynlib: libX11, 
+    importc: "XkbNoteNameChanges".}
+proc XkbGetIndicatorState*(dpy: PDisplay, deviceSpec: int16, pStateRtrn: PWord): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetIndicatorState".}
+proc XkbGetDeviceIndicatorState*(dpy: PDisplay, 
+                                 deviceSpec, ledClass, ledID: int16, 
+                                 pStateRtrn: PWord): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbGetDeviceIndicatorState".}
+proc XkbGetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetIndicatorMap".}
+proc XkbSetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{.
+    cdecl, dynlib: libX11, importc: "XkbSetIndicatorMap".}
+proc XkbNoteIndicatorMapChanges*(o, n: PXkbIndicatorChangesPtr, w: int16)
+proc XkbNoteIndicatorStateChanges*(o, n: PXkbIndicatorChangesPtr, w: int16)
+proc XkbGetIndicatorMapChanges*(d: PDisplay, x: PXkbDescPtr, 
+                                c: PXkbIndicatorChangesPtr): TStatus
+proc XkbChangeIndicatorMaps*(d: PDisplay, x: PXkbDescPtr, 
+                             c: PXkbIndicatorChangesPtr): bool
+proc XkbGetNamedIndicator*(dpy: PDisplay, name: TAtom, pNdxRtrn: ptr int16, 
+                           pStateRtrn: ptr bool, pMapRtrn: PXkbIndicatorMapPtr, 
+                           pRealRtrn: ptr bool): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbGetNamedIndicator".}
+proc XkbGetNamedDeviceIndicator*(dpy: PDisplay, 
+                                 deviceSpec, ledClass, ledID: int16, 
+                                 name: TAtom, pNdxRtrn: ptr int16, 
+                                 pStateRtrn: ptr bool, 
+                                 pMapRtrn: PXkbIndicatorMapPtr, 
+                                 pRealRtrn: ptr bool): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbGetNamedDeviceIndicator".}
+proc XkbSetNamedIndicator*(dpy: PDisplay, name: TAtom, 
+                           changeState, state, createNewMap: bool, 
+                           pMap: PXkbIndicatorMapPtr): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbSetNamedIndicator".}
+proc XkbSetNamedDeviceIndicator*(dpy: PDisplay, 
+                                 deviceSpec, ledClass, ledID: int16, 
+                                 name: TAtom, 
+                                 changeState, state, createNewMap: bool, 
+                                 pMap: PXkbIndicatorMapPtr): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbSetNamedDeviceIndicator".}
+proc XkbLockModifiers*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{.
+    cdecl, dynlib: libX11, importc: "XkbLockModifiers".}
+proc XkbLatchModifiers*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{.
+    cdecl, dynlib: libX11, importc: "XkbLatchModifiers".}
+proc XkbLockGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbLockGroup".}
+proc XkbLatchGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbLatchGroup".}
+proc XkbSetServerInternalMods*(dpy: PDisplay, deviceSpec, affectReal, 
+    realValues, affectVirtual, virtualValues: int16): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbSetServerInternalMods".}
+proc XkbSetIgnoreLockMods*(dpy: PDisplay, deviceSpec, affectReal, realValues, 
+    affectVirtual, virtualValues: int16): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbSetIgnoreLockMods".}
+proc XkbVirtualModsToReal*(dpy: PDisplay, virtual_mask: int16, mask_rtrn: PWord): bool{.
+    cdecl, dynlib: libX11, importc: "XkbVirtualModsToReal".}
+proc XkbComputeEffectiveMap*(xkb: PXkbDescPtr, theType: PXkbKeyTypePtr, 
+                             map_rtrn: PByte): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbComputeEffectiveMap".}
+proc XkbInitCanonicalKeyTypes*(xkb: PXkbDescPtr, which: int16, keypadVMod: int16): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbInitCanonicalKeyTypes".}
+proc XkbAllocKeyboard*(): PXkbDescPtr{.cdecl, dynlib: libX11, 
+                                       importc: "XkbAllocKeyboard".}
+proc XkbFreeKeyboard*(xkb: PXkbDescPtr, which: int16, freeDesc: bool){.cdecl, 
+    dynlib: libX11, importc: "XkbFreeKeyboard".}
+proc XkbAllocClientMap*(xkb: PXkbDescPtr, which, nTypes: int16): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbAllocClientMap".}
+proc XkbAllocServerMap*(xkb: PXkbDescPtr, which, nActions: int16): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbAllocServerMap".}
+proc XkbFreeClientMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.cdecl, 
+    dynlib: libX11, importc: "XkbFreeClientMap".}
+proc XkbFreeServerMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.cdecl, 
+    dynlib: libX11, importc: "XkbFreeServerMap".}
+proc XkbAddKeyType*(xkb: PXkbDescPtr, name: TAtom, map_count: int16, 
+                    want_preserve: bool, num_lvls: int16): PXkbKeyTypePtr{.
+    cdecl, dynlib: libX11, importc: "XkbAddKeyType".}
+proc XkbAllocIndicatorMaps*(xkb: PXkbDescPtr): TStatus{.cdecl, dynlib: libX11, 
+    importc: "XkbAllocIndicatorMaps".}
+proc XkbFreeIndicatorMaps*(xkb: PXkbDescPtr){.cdecl, dynlib: libX11, 
+    importc: "XkbFreeIndicatorMaps".}
+proc XkbGetMap*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{.cdecl, 
+    dynlib: libX11, importc: "XkbGetMap".}
+proc XkbGetUpdatedMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetUpdatedMap".}
+proc XkbGetMapChanges*(dpy: PDisplay, xkb: PXkbDescPtr, 
+                       changes: PXkbMapChangesPtr): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbGetMapChanges".}
+proc XkbRefreshKeyboardMapping*(event: PXkbMapNotifyEvent): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbRefreshKeyboardMapping".}
+proc XkbGetKeyTypes*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetKeyTypes".}
+proc XkbGetKeySyms*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetKeySyms".}
+proc XkbGetKeyActions*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetKeyActions".}
+proc XkbGetKeyBehaviors*(dpy: PDisplay, firstKey, nKeys: int16, 
+                         desc: PXkbDescPtr): TStatus{.cdecl, dynlib: libX11, 
+    importc: "XkbGetKeyBehaviors".}
+proc XkbGetVirtualMods*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetVirtualMods".}
+proc XkbGetKeyExplicitComponents*(dpy: PDisplay, firstKey, nKeys: int16, 
+                                  desc: PXkbDescPtr): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbGetKeyExplicitComponents".}
+proc XkbGetKeyModifierMap*(dpy: PDisplay, firstKey, nKeys: int16, 
+                           desc: PXkbDescPtr): TStatus{.cdecl, dynlib: libX11, 
+    importc: "XkbGetKeyModifierMap".}
+proc XkbAllocControls*(xkb: PXkbDescPtr, which: int16): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbAllocControls".}
+proc XkbFreeControls*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.cdecl, 
+    dynlib: libX11, importc: "XkbFreeControls".}
+proc XkbGetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetControls".}
+proc XkbSetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{.
+    cdecl, dynlib: libX11, importc: "XkbSetControls".}
+proc XkbNoteControlsChanges*(old: PXkbControlsChangesPtr, 
+                             new: PXkbControlsNotifyEvent, wanted: int16){.
+    cdecl, dynlib: libX11, importc: "XkbNoteControlsChanges".}
+proc XkbGetControlsChanges*(d: PDisplay, x: PXkbDescPtr, 
+                            c: PXkbControlsChangesPtr): TStatus
+proc XkbChangeControls*(d: PDisplay, x: PXkbDescPtr, c: PXkbControlsChangesPtr): bool
+proc XkbAllocCompatMap*(xkb: PXkbDescPtr, which, nInterpret: int16): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbAllocCompatMap".}
+proc XkbFreeCompatMap*(xkib: PXkbDescPtr, which: int16, freeMap: bool){.cdecl, 
+    dynlib: libX11, importc: "XkbFreeCompatMap".}
+proc XkbGetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetCompatMap".}
+proc XkbSetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr, 
+                      updateActions: bool): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbSetCompatMap".}
+proc XkbAddSymInterpret*(xkb: PXkbDescPtr, si: PXkbSymInterpretPtr, 
+                         updateMap: bool, changes: PXkbChangesPtr): PXkbSymInterpretPtr{.
+    cdecl, dynlib: libX11, importc: "XkbAddSymInterpret".}
+proc XkbAllocNames*(xkb: PXkbDescPtr, which: int16, 
+                    nTotalRG, nTotalAliases: int16): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbAllocNames".}
+proc XkbGetNames*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetNames".}
+proc XkbSetNames*(dpy: PDisplay, which, firstType, nTypes: int16, 
+                  desc: PXkbDescPtr): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbSetNames".}
+proc XkbChangeNames*(dpy: PDisplay, xkb: PXkbDescPtr, 
+                     changes: PXkbNameChangesPtr): bool{.cdecl, dynlib: libX11, 
+    importc: "XkbChangeNames".}
+proc XkbFreeNames*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.cdecl, 
+    dynlib: libX11, importc: "XkbFreeNames".}
+proc XkbGetState*(dpy: PDisplay, deviceSpec: int16, rtrnState: PXkbStatePtr): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbGetState".}
+proc XkbSetMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbSetMap".}
+proc XkbChangeMap*(dpy: PDisplay, desc: PXkbDescPtr, changes: PXkbMapChangesPtr): bool{.
+    cdecl, dynlib: libX11, importc: "XkbChangeMap".}
+proc XkbSetDetectableAutoRepeat*(dpy: PDisplay, detectable: bool, 
+                                 supported: ptr bool): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbSetDetectableAutoRepeat".}
+proc XkbGetDetectableAutoRepeat*(dpy: PDisplay, supported: ptr bool): bool{.
+    cdecl, dynlib: libX11, importc: "XkbGetDetectableAutoRepeat".}
+proc XkbSetAutoResetControls*(dpy: PDisplay, changes: int16, 
+                              auto_ctrls, auto_values: PWord): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbSetAutoResetControls".}
+proc XkbGetAutoResetControls*(dpy: PDisplay, auto_ctrls, auto_ctrl_values: PWord): bool{.
+    cdecl, dynlib: libX11, importc: "XkbGetAutoResetControls".}
+proc XkbSetPerClientControls*(dpy: PDisplay, change: int16, values: PWord): bool{.
+    cdecl, dynlib: libX11, importc: "XkbSetPerClientControls".}
+proc XkbGetPerClientControls*(dpy: PDisplay, ctrls: PWord): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbGetPerClientControls".}
+proc XkbCopyKeyType*(`from`, into: PXkbKeyTypePtr): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbCopyKeyType".}
+proc XkbCopyKeyTypes*(`from`, into: PXkbKeyTypePtr, num_types: int16): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbCopyKeyTypes".}
+proc XkbResizeKeyType*(xkb: PXkbDescPtr, type_ndx, map_count: int16, 
+                       want_preserve: bool, new_num_lvls: int16): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbResizeKeyType".}
+proc XkbResizeKeySyms*(desc: PXkbDescPtr, forKey, symsNeeded: int16): PKeySym{.
+    cdecl, dynlib: libX11, importc: "XkbResizeKeySyms".}
+proc XkbResizeKeyActions*(desc: PXkbDescPtr, forKey, actsNeeded: int16): PXkbAction{.
+    cdecl, dynlib: libX11, importc: "XkbResizeKeyActions".}
+proc XkbChangeTypesOfKey*(xkb: PXkbDescPtr, key, num_groups: int16, 
+                          groups: int16, newTypes: ptr int16, 
+                          pChanges: PXkbMapChangesPtr): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbChangeTypesOfKey".}
+    
+proc XkbListComponents*(dpy: PDisplay, deviceSpec: int16, 
+                        ptrns: PXkbComponentNamesPtr, max_inout: ptr int16): PXkbComponentListPtr{.
+    cdecl, dynlib: libX11, importc: "XkbListComponents".}
+proc XkbFreeComponentList*(list: PXkbComponentListPtr){.cdecl, dynlib: libX11, 
+    importc: "XkbFreeComponentList".}
+proc XkbGetKeyboard*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{.
+    cdecl, dynlib: libX11, importc: "XkbGetKeyboard".}
+proc XkbGetKeyboardByName*(dpy: PDisplay, deviceSpec: int16, 
+                           names: PXkbComponentNamesPtr, want, need: int16, 
+                           load: bool): PXkbDescPtr{.cdecl, dynlib: libX11, 
+    importc: "XkbGetKeyboardByName".}
+    
+proc XkbKeyTypesForCoreSymbols*(xkb: PXkbDescPtr, 
+                                map_width: int16,  # keyboard device
+                                core_syms: PKeySym,  # always mapWidth symbols
+                                protected: int16,  # explicit key types
+                                types_inout: ptr int16,  # always four type indices
+                                xkb_syms_rtrn: PKeySym): int16{.cdecl, 
+    dynlib: libX11, importc: "XkbKeyTypesForCoreSymbols".}
+  # must have enough space
+proc XkbApplyCompatMapToKey*(xkb: PXkbDescPtr,  
+                             key: TKeyCode,  # key to be updated
+                             changes: PXkbChangesPtr): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbApplyCompatMapToKey".}
+  # resulting changes to map
+proc XkbUpdateMapFromCore*(xkb: PXkbDescPtr,  
+                           first_key: TKeyCode,  # first changed key
+                           num_keys,
+                           map_width: int16, 
+                           core_keysyms: PKeySym,  # symbols `from` core keymap
+                           changes: PXkbChangesPtr): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbUpdateMapFromCore".}
+
+proc XkbAddDeviceLedInfo*(devi: PXkbDeviceInfoPtr, ledClass, ledId: int16): PXkbDeviceLedInfoPtr{.
+    cdecl, dynlib: libX11, importc: "XkbAddDeviceLedInfo".}
+proc XkbResizeDeviceButtonActions*(devi: PXkbDeviceInfoPtr, newTotal: int16): TStatus{.
+    cdecl, dynlib: libX11, importc: "XkbResizeDeviceButtonActions".}
+proc XkbAllocDeviceInfo*(deviceSpec, nButtons, szLeds: int16): PXkbDeviceInfoPtr{.
+    cdecl, dynlib: libX11, importc: "XkbAllocDeviceInfo".}
+proc XkbFreeDeviceInfo*(devi: PXkbDeviceInfoPtr, which: int16, freeDevI: bool){.
+    cdecl, dynlib: libX11, importc: "XkbFreeDeviceInfo".}
+proc XkbNoteDeviceChanges*(old: PXkbDeviceChangesPtr, 
+                           new: PXkbExtensionDeviceNotifyEvent, wanted: int16){.
+    cdecl, dynlib: libX11, importc: "XkbNoteDeviceChanges".}
+proc XkbGetDeviceInfo*(dpy: PDisplay, which, deviceSpec, ledClass, ledID: int16): PXkbDeviceInfoPtr{.
+    cdecl, dynlib: libX11, importc: "XkbGetDeviceInfo".}
+proc XkbGetDeviceInfoChanges*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
+                              changes: PXkbDeviceChangesPtr): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbGetDeviceInfoChanges".}
+proc XkbGetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
+                                all: bool, first, nBtns: int16): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbGetDeviceButtonActions".}
+proc XkbGetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
+                          ledClass, ledId, which: int16): TStatus{.cdecl, 
+    dynlib: libX11, importc: "XkbGetDeviceLedInfo".}
+proc XkbSetDeviceInfo*(dpy: PDisplay, which: int16, devi: PXkbDeviceInfoPtr): bool{.
+    cdecl, dynlib: libX11, importc: "XkbSetDeviceInfo".}
+proc XkbChangeDeviceInfo*(dpy: PDisplay, desc: PXkbDeviceInfoPtr, 
+                          changes: PXkbDeviceChangesPtr): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbChangeDeviceInfo".}
+proc XkbSetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
+                          ledClass, ledID, which: int16): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbSetDeviceLedInfo".}
+proc XkbSetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
+                                first, nBtns: int16): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbSetDeviceButtonActions".}
+
+proc XkbToControl*(c: int8): int8{.cdecl, dynlib: libX11, 
+                                   importc: "XkbToControl".}
+
+proc XkbSetDebuggingFlags*(dpy: PDisplay, mask, flags: int16, msg: cstring, 
+                           ctrls_mask, ctrls, rtrn_flags, rtrn_ctrls: int16): bool{.
+    cdecl, dynlib: libX11, importc: "XkbSetDebuggingFlags".}
+proc XkbApplyVirtualModChanges*(xkb: PXkbDescPtr, changed: int16, 
+                                changes: PXkbChangesPtr): bool{.cdecl, 
+    dynlib: libX11, importc: "XkbApplyVirtualModChanges".}
+
+# implementation
+
+proc XkbNoteIndicatorMapChanges(o, n: PXkbIndicatorChangesPtr, w: int16) = 
+  ##define XkbNoteIndicatorMapChanges(o,n,w) ((o)->map_changes|=((n)->map_changes&(w)))
+  o.map_changes = o.map_changes or (n.map_changes and w)
+
+proc XkbNoteIndicatorStateChanges(o, n: PXkbIndicatorChangesPtr, w: int16) = 
+  ##define XkbNoteIndicatorStateChanges(o,n,w) ((o)->state_changes|=((n)->state_changes&(w)))
+  o.state_changes = o.state_changes or (n.state_changes and (w))
+
+proc XkbGetIndicatorMapChanges(d: PDisplay, x: PXkbDescPtr, 
+                               c: PXkbIndicatorChangesPtr): TStatus = 
+  ##define XkbGetIndicatorMapChanges(d,x,c) (XkbGetIndicatorMap((d),(c)->map_changes,x)
+  Result = XkbGetIndicatorMap(d, c.map_changes, x)
+
+proc XkbChangeIndicatorMaps(d: PDisplay, x: PXkbDescPtr, 
+                            c: PXkbIndicatorChangesPtr): bool = 
+  ##define XkbChangeIndicatorMaps(d,x,c) (XkbSetIndicatorMap((d),(c)->map_changes,x))
+  Result = XkbSetIndicatorMap(d, c.map_changes, x)
+
+proc XkbGetControlsChanges(d: PDisplay, x: PXkbDescPtr, 
+                           c: PXkbControlsChangesPtr): TStatus = 
+  ##define XkbGetControlsChanges(d,x,c) XkbGetControls(d,(c)->changed_ctrls,x)
+  Result = XkbGetControls(d, c.changed_ctrls, x)
+
+proc XkbChangeControls(d: PDisplay, x: PXkbDescPtr, c: PXkbControlsChangesPtr): bool = 
+  ##define XkbChangeControls(d,x,c) XkbSetControls(d,(c)->changed_ctrls,x)
+  Result = XkbSetControls(d, c.changed_ctrls, x)

lib/oldwrappers/x11/xrandr.nim

@@ -0,0 +1,194 @@
+#
+#  $XFree86: xc/lib/Xrandr/Xrandr.h,v 1.9 2002/09/29 23:39:44 keithp Exp $
+# 
+#  Copyright (C) 2000 Compaq Computer Corporation, Inc.
+#  Copyright (C) 2002 Hewlett-Packard Company, Inc.
+# 
+#  Permission to use, copy, modify, distribute, and sell this software and its
+#  documentation for any purpose is hereby granted without fee, provided that
+#  the above copyright notice appear in all copies and that both that
+#  copyright notice and this permission notice appear in supporting
+#  documentation, and that the name of Compaq not be used in advertising or
+#  publicity pertaining to distribution of the software without specific,
+#  written prior permission.  HP makes no representations about the
+#  suitability of this software for any purpose.  It is provided "as is"
+#  without express or implied warranty.
+# 
+#  HP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL COMPAQ
+#  BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+#  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+#  OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+#  CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+# 
+#  Author:  Jim Gettys, HP Labs, HP.
+#
+
+import 
+  x, xlib
+
+const 
+  libXrandr* = "libXrandr.so"
+  
+# * $XFree86: xc/include/extensions/randr.h,v 1.4 2001/11/24 07:24:58 keithp Exp $
+# *
+# * Copyright (C) 2000, Compaq Computer Corporation, 
+# * Copyright (C) 2002, Hewlett Packard, Inc.
+# *
+# * Permission to use, copy, modify, distribute, and sell this software and its
+# * documentation for any purpose is hereby granted without fee, provided that
+# * the above copyright notice appear in all copies and that both that
+# * copyright notice and this permission notice appear in supporting
+# * documentation, and that the name of Compaq or HP not be used in advertising
+# * or publicity pertaining to distribution of the software without specific,
+# * written prior permission.  HP makes no representations about the
+# * suitability of this software for any purpose.  It is provided "as is"
+# * without express or implied warranty.
+# *
+# * HP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+# * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL HP
+# * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+# * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+# * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+# *
+# * Author:  Jim Gettys, HP Labs, Hewlett-Packard, Inc.
+# *
+
+type 
+  PRotation* = ptr TRotation
+  TRotation* = cushort
+  PSizeID* = ptr TSizeID
+  TSizeID* = cushort
+  PSubpixelOrder* = ptr TSubpixelOrder
+  TSubpixelOrder* = cushort
+
+const 
+  RANDR_NAME* = "RANDR"
+  RANDR_MAJOR* = 1
+  RANDR_MINOR* = 1
+  RRNumberErrors* = 0
+  RRNumberEvents* = 1
+  constX_RRQueryVersion* = 0 # we skip 1 to make old clients fail pretty immediately 
+  X_RROldGetScreenInfo* = 1
+  X_RR1_0SetScreenConfig* = 2 # V1.0 apps share the same set screen config request id 
+  constX_RRSetScreenConfig* = 2
+  X_RROldScreenChangeSelectInput* = 3 # 3 used to be ScreenChangeSelectInput; deprecated 
+  constX_RRSelectInput* = 4
+  constX_RRGetScreenInfo* = 5      # used in XRRSelectInput 
+  RRScreenChangeNotifyMask* = 1 shl 0
+  RRScreenChangeNotify* = 0   # used in the rotation field; rotation and reflection in 0.1 proto. 
+  RR_Rotate_0* = 1
+  RR_Rotate_90* = 2
+  RR_Rotate_180* = 4
+  RR_Rotate_270* = 8          # new in 1.0 protocol, to allow reflection of screen 
+  RR_Reflect_X* = 16
+  RR_Reflect_Y* = 32
+  RRSetConfigSuccess* = 0
+  RRSetConfigInvalidConfigTime* = 1
+  RRSetConfigInvalidTime* = 2
+  RRSetConfigFailed* = 3
+
+type 
+  PXRRScreenSize* = ptr TXRRScreenSize
+  TXRRScreenSize*{.final.} = object  #
+                                     #   Events.
+                                     #
+    width*, height*: cint
+    mwidth*, mheight*: cint
+
+  TXRRScreenChangeNotifyEvent*{.final.} = object  # internal representation is private to the library 
+    typ*: cint                # event base 
+    serial*: culong           # # of last request processed by server 
+    send_event*: TBool        # true if this came from a SendEvent request 
+    display*: PDisplay        # Display the event was read from 
+    window*: TWindow          # window which selected for this event 
+    root*: TWindow            # Root window for changed screen 
+    timestamp*: TTime         # when the screen change occurred 
+    config_timestamp*: TTime  # when the last configuration change 
+    size_index*: TSizeID
+    subpixel_order*: TSubpixelOrder
+    rotation*: TRotation
+    width*: cint
+    height*: cint
+    mwidth*: cint
+    mheight*: cint
+
+  PXRRScreenConfiguration* = ptr TXRRScreenConfiguration
+  TXRRScreenConfiguration*{.final.} = object 
+
+proc XRRQueryExtension*(dpy: PDisplay, event_basep, error_basep: Pcint): TBool{.
+    cdecl, dynlib: libXrandr, importc.}
+proc XRRQueryVersion*(dpy: PDisplay, major_versionp: Pcint, 
+                      minor_versionp: Pcint): TStatus{.cdecl, dynlib: libXrandr, 
+    importc.}
+proc XRRGetScreenInfo*(dpy: PDisplay, draw: TDrawable): PXRRScreenConfiguration{.
+    cdecl, dynlib: libXrandr, importc.}
+proc XRRFreeScreenConfigInfo*(config: PXRRScreenConfiguration){.cdecl, 
+    dynlib: libXrandr, importc.}
+  #
+  #  Note that screen configuration changes are only permitted if the client can
+  #  prove it has up to date configuration information.  We are trying to
+  #  insist that it become possible for screens to change dynamically, so
+  #  we want to ensure the client knows what it is talking about when requesting
+  #  changes.
+  #
+proc XRRSetScreenConfig*(dpy: PDisplay, config: PXRRScreenConfiguration, 
+                         draw: TDrawable, size_index: cint, rotation: TRotation, 
+                         timestamp: TTime): TStatus{.cdecl, dynlib: libXrandr, 
+    importc.}
+  # added in v1.1, sorry for the lame name 
+proc XRRSetScreenConfigAndRate*(dpy: PDisplay, config: PXRRScreenConfiguration, 
+                                draw: TDrawable, size_index: cint, 
+                                rotation: TRotation, rate: cshort, 
+                                timestamp: TTime): TStatus{.cdecl, 
+    dynlib: libXrandr, importc.}
+proc XRRConfigRotations*(config: PXRRScreenConfiguration, 
+                         current_rotation: PRotation): TRotation{.cdecl, 
+    dynlib: libXrandr, importc.}
+proc XRRConfigTimes*(config: PXRRScreenConfiguration, config_timestamp: PTime): TTime{.
+    cdecl, dynlib: libXrandr, importc.}
+proc XRRConfigSizes*(config: PXRRScreenConfiguration, nsizes: Pcint): PXRRScreenSize{.
+    cdecl, dynlib: libXrandr, importc.}
+proc XRRConfigRates*(config: PXRRScreenConfiguration, sizeID: cint, 
+                     nrates: Pcint): ptr int16{.cdecl, dynlib: libXrandr, importc.}
+proc XRRConfigCurrentConfiguration*(config: PXRRScreenConfiguration, 
+                                    rotation: PRotation): TSizeID{.cdecl, 
+    dynlib: libXrandr, importc.}
+proc XRRConfigCurrentRate*(config: PXRRScreenConfiguration): cshort{.cdecl, 
+    dynlib: libXrandr, importc.}
+proc XRRRootToScreen*(dpy: PDisplay, root: TWindow): cint{.cdecl, 
+    dynlib: libXrandr, importc.}
+  #
+  #  returns the screen configuration for the specified screen; does a lazy
+  #  evalution to delay getting the information, and caches the result.
+  #  These routines should be used in preference to XRRGetScreenInfo
+  #  to avoid unneeded round trips to the X server.  These are new
+  #  in protocol version 0.1.
+  #
+proc XRRScreenConfig*(dpy: PDisplay, screen: cint): PXRRScreenConfiguration{.
+    cdecl, dynlib: libXrandr, importc.}
+proc XRRConfig*(screen: PScreen): PXRRScreenConfiguration{.cdecl, 
+    dynlib: libXrandr, importc.}
+proc XRRSelectInput*(dpy: PDisplay, window: TWindow, mask: cint){.cdecl, 
+    dynlib: libXrandr, importc.}
+  #
+  #  the following are always safe to call, even if RandR is not implemented 
+  #  on a screen 
+  #
+proc XRRRotations*(dpy: PDisplay, screen: cint, current_rotation: PRotation): TRotation{.
+    cdecl, dynlib: libXrandr, importc.}
+proc XRRSizes*(dpy: PDisplay, screen: cint, nsizes: Pcint): PXRRScreenSize{.
+    cdecl, dynlib: libXrandr, importc.}
+proc XRRRates*(dpy: PDisplay, screen: cint, sizeID: cint, nrates: Pcint): ptr int16{.
+    cdecl, dynlib: libXrandr, importc.}
+proc XRRTimes*(dpy: PDisplay, screen: cint, config_timestamp: PTime): TTime{.
+    cdecl, dynlib: libXrandr, importc.}
+  #
+  #  intended to take RRScreenChangeNotify,  or 
+  #  ConfigureNotify (on the root window)
+  #  returns 1 if it is an event type it understands, 0 if not
+  #
+proc XRRUpdateConfiguration*(event: PXEvent): cint{.cdecl, dynlib: libXrandr, 
+    importc.}
+# implementation

lib/oldwrappers/x11/xrender.nim

@@ -0,0 +1,231 @@
+
+import 
+  x, xlib
+
+#const 
+#  libX11* = "libX11.so"
+
+#
+#  Automatically converted by H2Pas 0.99.15 from xrender.h
+#  The following command line parameters were used:
+#    -p
+#    -T
+#    -S
+#    -d
+#    -c
+#    xrender.h
+#
+
+type 
+  PGlyph* = ptr TGlyph
+  TGlyph* = int32
+  PGlyphSet* = ptr TGlyphSet
+  TGlyphSet* = int32
+  PPicture* = ptr TPicture
+  TPicture* = int32
+  PPictFormat* = ptr TPictFormat
+  TPictFormat* = int32
+
+const 
+  RENDER_NAME* = "RENDER"
+  RENDER_MAJOR* = 0
+  RENDER_MINOR* = 0
+  constX_RenderQueryVersion* = 0
+  X_RenderQueryPictFormats* = 1
+  X_RenderQueryPictIndexValues* = 2
+  X_RenderQueryDithers* = 3
+  constX_RenderCreatePicture* = 4
+  constX_RenderChangePicture* = 5
+  X_RenderSetPictureClipRectangles* = 6
+  constX_RenderFreePicture* = 7
+  constX_RenderComposite* = 8
+  X_RenderScale* = 9
+  X_RenderTrapezoids* = 10
+  X_RenderTriangles* = 11
+  X_RenderTriStrip* = 12
+  X_RenderTriFan* = 13
+  X_RenderColorTrapezoids* = 14
+  X_RenderColorTriangles* = 15
+  X_RenderTransform* = 16
+  constX_RenderCreateGlyphSet* = 17
+  constX_RenderReferenceGlyphSet* = 18
+  constX_RenderFreeGlyphSet* = 19
+  constX_RenderAddGlyphs* = 20
+  constX_RenderAddGlyphsFromPicture* = 21
+  constX_RenderFreeGlyphs* = 22
+  constX_RenderCompositeGlyphs8* = 23
+  constX_RenderCompositeGlyphs16* = 24
+  constX_RenderCompositeGlyphs32* = 25
+  BadPictFormat* = 0
+  BadPicture* = 1
+  BadPictOp* = 2
+  BadGlyphSet* = 3
+  BadGlyph* = 4
+  RenderNumberErrors* = BadGlyph + 1
+  PictTypeIndexed* = 0
+  PictTypeDirect* = 1
+  PictOpClear* = 0
+  PictOpSrc* = 1
+  PictOpDst* = 2
+  PictOpOver* = 3
+  PictOpOverReverse* = 4
+  PictOpIn* = 5
+  PictOpInReverse* = 6
+  PictOpOut* = 7
+  PictOpOutReverse* = 8
+  PictOpAtop* = 9
+  PictOpAtopReverse* = 10
+  PictOpXor* = 11
+  PictOpAdd* = 12
+  PictOpSaturate* = 13
+  PictOpMaximum* = 13
+  PolyEdgeSharp* = 0
+  PolyEdgeSmooth* = 1
+  PolyModePrecise* = 0
+  PolyModeImprecise* = 1
+  CPRepeat* = 1 shl 0
+  CPAlphaMap* = 1 shl 1
+  CPAlphaXOrigin* = 1 shl 2
+  CPAlphaYOrigin* = 1 shl 3
+  CPClipXOrigin* = 1 shl 4
+  CPClipYOrigin* = 1 shl 5
+  CPClipMask* = 1 shl 6
+  CPGraphicsExposure* = 1 shl 7
+  CPSubwindowMode* = 1 shl 8
+  CPPolyEdge* = 1 shl 9
+  CPPolyMode* = 1 shl 10
+  CPDither* = 1 shl 11
+  CPLastBit* = 11
+
+type 
+  PXRenderDirectFormat* = ptr TXRenderDirectFormat
+  TXRenderDirectFormat*{.final.} = object 
+    red*: int16
+    redMask*: int16
+    green*: int16
+    greenMask*: int16
+    blue*: int16
+    blueMask*: int16
+    alpha*: int16
+    alphaMask*: int16
+
+  PXRenderPictFormat* = ptr TXRenderPictFormat
+  TXRenderPictFormat*{.final.} = object 
+    id*: TPictFormat
+    thetype*: int32
+    depth*: int32
+    direct*: TXRenderDirectFormat
+    colormap*: TColormap
+
+
+const 
+  PictFormatID* = 1 shl 0
+  PictFormatType* = 1 shl 1
+  PictFormatDepth* = 1 shl 2
+  PictFormatRed* = 1 shl 3
+  PictFormatRedMask* = 1 shl 4
+  PictFormatGreen* = 1 shl 5
+  PictFormatGreenMask* = 1 shl 6
+  PictFormatBlue* = 1 shl 7
+  PictFormatBlueMask* = 1 shl 8
+  PictFormatAlpha* = 1 shl 9
+  PictFormatAlphaMask* = 1 shl 10
+  PictFormatColormap* = 1 shl 11
+
+type 
+  PXRenderVisual* = ptr TXRenderVisual
+  TXRenderVisual*{.final.} = object 
+    visual*: PVisual
+    format*: PXRenderPictFormat
+
+  PXRenderDepth* = ptr TXRenderDepth
+  TXRenderDepth*{.final.} = object 
+    depth*: int32
+    nvisuals*: int32
+    visuals*: PXRenderVisual
+
+  PXRenderScreen* = ptr TXRenderScreen
+  TXRenderScreen*{.final.} = object 
+    depths*: PXRenderDepth
+    ndepths*: int32
+    fallback*: PXRenderPictFormat
+
+  PXRenderInfo* = ptr TXRenderInfo
+  TXRenderInfo*{.final.} = object 
+    format*: PXRenderPictFormat
+    nformat*: int32
+    screen*: PXRenderScreen
+    nscreen*: int32
+    depth*: PXRenderDepth
+    ndepth*: int32
+    visual*: PXRenderVisual
+    nvisual*: int32
+
+  PXRenderPictureAttributes* = ptr TXRenderPictureAttributes
+  TXRenderPictureAttributes*{.final.} = object 
+    repeat*: TBool
+    alpha_map*: TPicture
+    alpha_x_origin*: int32
+    alpha_y_origin*: int32
+    clip_x_origin*: int32
+    clip_y_origin*: int32
+    clip_mask*: TPixmap
+    graphics_exposures*: TBool
+    subwindow_mode*: int32
+    poly_edge*: int32
+    poly_mode*: int32
+    dither*: TAtom
+
+  PXGlyphInfo* = ptr TXGlyphInfo
+  TXGlyphInfo*{.final.} = object 
+    width*: int16
+    height*: int16
+    x*: int16
+    y*: int16
+    xOff*: int16
+    yOff*: int16
+
+
+proc XRenderQueryExtension*(dpy: PDisplay, event_basep: ptr int32, 
+                            error_basep: ptr int32): TBool{.cdecl, 
+    dynlib: libX11, importc.}
+proc XRenderQueryVersion*(dpy: PDisplay, major_versionp: ptr int32, 
+                          minor_versionp: ptr int32): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XRenderQueryFormats*(dpy: PDisplay): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XRenderFindVisualFormat*(dpy: PDisplay, visual: PVisual): PXRenderPictFormat{.
+    cdecl, dynlib: libX11, importc.}
+proc XRenderFindFormat*(dpy: PDisplay, mask: int32, 
+                        `template`: PXRenderPictFormat, count: int32): PXRenderPictFormat{.
+    cdecl, dynlib: libX11, importc.}
+proc XRenderCreatePicture*(dpy: PDisplay, drawable: TDrawable, 
+                           format: PXRenderPictFormat, valuemask: int32, 
+                           attributes: PXRenderPictureAttributes): TPicture{.
+    cdecl, dynlib: libX11, importc.}
+proc XRenderChangePicture*(dpy: PDisplay, picture: TPicture, valuemask: int32, 
+                           attributes: PXRenderPictureAttributes){.cdecl, 
+    dynlib: libX11, importc.}
+proc XRenderFreePicture*(dpy: PDisplay, picture: TPicture){.cdecl, 
+    dynlib: libX11, importc.}
+proc XRenderComposite*(dpy: PDisplay, op: int32, src: TPicture, mask: TPicture, 
+                       dst: TPicture, src_x: int32, src_y: int32, mask_x: int32, 
+                       mask_y: int32, dst_x: int32, dst_y: int32, width: int32, 
+                       height: int32){.cdecl, dynlib: libX11, importc.}
+proc XRenderCreateGlyphSet*(dpy: PDisplay, format: PXRenderPictFormat): TGlyphSet{.
+    cdecl, dynlib: libX11, importc.}
+proc XRenderReferenceGlyphSet*(dpy: PDisplay, existing: TGlyphSet): TGlyphSet{.
+    cdecl, dynlib: libX11, importc.}
+proc XRenderFreeGlyphSet*(dpy: PDisplay, glyphset: TGlyphSet){.cdecl, 
+    dynlib: libX11, importc.}
+proc XRenderAddGlyphs*(dpy: PDisplay, glyphset: TGlyphSet, gids: PGlyph, 
+                       glyphs: PXGlyphInfo, nglyphs: int32, images: cstring, 
+                       nbyte_images: int32){.cdecl, dynlib: libX11, importc.}
+proc XRenderFreeGlyphs*(dpy: PDisplay, glyphset: TGlyphSet, gids: PGlyph, 
+                        nglyphs: int32){.cdecl, dynlib: libX11, importc.}
+proc XRenderCompositeString8*(dpy: PDisplay, op: int32, src: TPicture, 
+                              dst: TPicture, maskFormat: PXRenderPictFormat, 
+                              glyphset: TGlyphSet, xSrc: int32, ySrc: int32, 
+                              xDst: int32, yDst: int32, str: cstring, 
+                              nchar: int32){.cdecl, dynlib: libX11, importc.}
+# implementation

lib/oldwrappers/x11/xresource.nim

@@ -0,0 +1,200 @@
+
+import 
+  x, xlib
+
+#const 
+#  libX11* = "libX11.so"
+
+#
+#  Automatically converted by H2Pas 0.99.15 from xresource.h
+#  The following command line parameters were used:
+#    -p
+#    -T
+#    -S
+#    -d
+#    -c
+#    xresource.h
+#
+
+proc Xpermalloc*(para1: int32): cstring{.cdecl, dynlib: libX11, importc.}
+type 
+  PXrmQuark* = ptr TXrmQuark
+  TXrmQuark* = int32
+  TXrmQuarkList* = PXrmQuark
+  PXrmQuarkList* = ptr TXrmQuarkList
+
+proc NULLQUARK*(): TXrmQuark
+type 
+  PXrmString* = ptr TXrmString
+  TXrmString* = ptr char
+
+proc NULLSTRING*(): TXrmString
+proc XrmStringToQuark*(para1: cstring): TXrmQuark{.cdecl, dynlib: libX11, 
+    importc.}
+proc XrmPermStringToQuark*(para1: cstring): TXrmQuark{.cdecl, dynlib: libX11, 
+    importc.}
+proc XrmQuarkToString*(para1: TXrmQuark): TXrmString{.cdecl, dynlib: libX11, 
+    importc.}
+proc XrmUniqueQuark*(): TXrmQuark{.cdecl, dynlib: libX11, importc.}
+when defined(MACROS): 
+  proc XrmStringsEqual*(a1, a2: cstring): bool
+type 
+  PXrmBinding* = ptr TXrmBinding
+  TXrmBinding* = enum 
+    XrmBindTightly, XrmBindLoosely
+  TXrmBindingList* = PXrmBinding
+  PXrmBindingList* = ptr TXrmBindingList
+
+proc XrmStringToQuarkList*(para1: cstring, para2: TXrmQuarkList){.cdecl, 
+    dynlib: libX11, importc.}
+proc XrmStringToBindingQuarkList*(para1: cstring, para2: TXrmBindingList, 
+                                  para3: TXrmQuarkList){.cdecl, dynlib: libX11, 
+    importc.}
+type 
+  PXrmName* = ptr TXrmName
+  TXrmName* = TXrmQuark
+  PXrmNameList* = ptr TXrmNameList
+  TXrmNameList* = TXrmQuarkList
+
+when defined(MACROS): 
+  proc XrmNameToString*(name: int32): TXrmString
+  proc XrmStringToName*(str: cstring): int32
+  proc XrmStringToNameList*(str: cstring, name: PXrmQuark)
+type 
+  PXrmClass* = ptr TXrmClass
+  TXrmClass* = TXrmQuark
+  PXrmClassList* = ptr TXrmClassList
+  TXrmClassList* = TXrmQuarkList
+
+when defined(MACROS): 
+  proc XrmClassToString*(c_class: int32): TXrmString
+  proc XrmStringToClass*(c_class: cstring): int32
+  proc XrmStringToClassList*(str: cstring, c_class: PXrmQuark)
+type 
+  PXrmRepresentation* = ptr TXrmRepresentation
+  TXrmRepresentation* = TXrmQuark
+
+when defined(MACROS): 
+  proc XrmStringToRepresentation*(str: cstring): int32
+  proc XrmRepresentationToString*(thetype: int32): TXrmString
+type 
+  PXrmValue* = ptr TXrmValue
+  TXrmValue*{.final.} = object 
+    size*: int32
+    address*: TXPointer
+
+  TXrmValuePtr* = PXrmValue
+  PXrmValuePtr* = ptr TXrmValuePtr
+  PXrmHashBucketRec* = ptr TXrmHashBucketRec
+  TXrmHashBucketRec*{.final.} = object 
+  TXrmHashBucket* = PXrmHashBucketRec
+  PXrmHashBucket* = ptr TXrmHashBucket
+  PXrmHashTable* = ptr TXrmHashTable
+  TXrmHashTable* = ptr TXrmHashBucket
+  TXrmDatabase* = PXrmHashBucketRec
+  PXrmDatabase* = ptr TXrmDatabase
+
+proc XrmDestroyDatabase*(para1: TXrmDatabase){.cdecl, dynlib: libX11, importc.}
+proc XrmQPutResource*(para1: PXrmDatabase, para2: TXrmBindingList, 
+                      para3: TXrmQuarkList, para4: TXrmRepresentation, 
+                      para5: PXrmValue){.cdecl, dynlib: libX11, importc.}
+proc XrmPutResource*(para1: PXrmDatabase, para2: cstring, para3: cstring, 
+                     para4: PXrmValue){.cdecl, dynlib: libX11, importc.}
+proc XrmQPutStringResource*(para1: PXrmDatabase, para2: TXrmBindingList, 
+                            para3: TXrmQuarkList, para4: cstring){.cdecl, 
+    dynlib: libX11, importc.}
+proc XrmPutStringResource*(para1: PXrmDatabase, para2: cstring, para3: cstring){.
+    cdecl, dynlib: libX11, importc.}
+proc XrmPutLineResource*(para1: PXrmDatabase, para2: cstring){.cdecl, 
+    dynlib: libX11, importc.}
+proc XrmQGetResource*(para1: TXrmDatabase, para2: TXrmNameList, 
+                      para3: TXrmClassList, para4: PXrmRepresentation, 
+                      para5: PXrmValue): TBool{.cdecl, dynlib: libX11, importc.}
+proc XrmGetResource*(para1: TXrmDatabase, para2: cstring, para3: cstring, 
+                     para4: PPchar, para5: PXrmValue): TBool{.cdecl, 
+    dynlib: libX11, importc.}
+  # There is no definition of TXrmSearchList 
+  #function XrmQGetSearchList(para1:TXrmDatabase; para2:TXrmNameList; para3:TXrmClassList; para4:TXrmSearchList; para5:longint):TBool;cdecl;external libX11;
+  #function XrmQGetSearchResource(para1:TXrmSearchList; para2:TXrmName; para3:TXrmClass; para4:PXrmRepresentation; para5:PXrmValue):TBool;cdecl;external libX11;
+proc XrmSetDatabase*(para1: PDisplay, para2: TXrmDatabase){.cdecl, 
+    dynlib: libX11, importc.}
+proc XrmGetDatabase*(para1: PDisplay): TXrmDatabase{.cdecl, dynlib: libX11, 
+    importc.}
+proc XrmGetFileDatabase*(para1: cstring): TXrmDatabase{.cdecl, dynlib: libX11, 
+    importc.}
+proc XrmCombineFileDatabase*(para1: cstring, para2: PXrmDatabase, para3: TBool): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XrmGetStringDatabase*(para1: cstring): TXrmDatabase{.cdecl, dynlib: libX11, 
+    importc.}
+proc XrmPutFileDatabase*(para1: TXrmDatabase, para2: cstring){.cdecl, 
+    dynlib: libX11, importc.}
+proc XrmMergeDatabases*(para1: TXrmDatabase, para2: PXrmDatabase){.cdecl, 
+    dynlib: libX11, importc.}
+proc XrmCombineDatabase*(para1: TXrmDatabase, para2: PXrmDatabase, para3: TBool){.
+    cdecl, dynlib: libX11, importc.}
+const 
+  XrmEnumAllLevels* = 0
+  XrmEnumOneLevel* = 1
+
+type 
+  funcbool* = proc (): TBool
+
+proc XrmEnumerateDatabase*(para1: TXrmDatabase, para2: TXrmNameList, 
+                           para3: TXrmClassList, para4: int32, para5: funcbool, 
+                           para6: TXPointer): TBool{.cdecl, dynlib: libX11, 
+    importc.}
+proc XrmLocaleOfDatabase*(para1: TXrmDatabase): cstring{.cdecl, dynlib: libX11, 
+    importc.}
+type 
+  PXrmOptionKind* = ptr TXrmOptionKind
+  TXrmOptionKind* = enum 
+    XrmoptionNoArg, XrmoptionIsArg, XrmoptionStickyArg, XrmoptionSepArg, 
+    XrmoptionResArg, XrmoptionSkipArg, XrmoptionSkipLine, XrmoptionSkipNArgs
+  PXrmOptionDescRec* = ptr TXrmOptionDescRec
+  TXrmOptionDescRec*{.final.} = object 
+    option*: cstring
+    specifier*: cstring
+    argKind*: TXrmOptionKind
+    value*: TXPointer
+
+  TXrmOptionDescList* = PXrmOptionDescRec
+  PXrmOptionDescList* = ptr TXrmOptionDescList
+
+proc XrmParseCommand*(para1: PXrmDatabase, para2: TXrmOptionDescList, 
+                      para3: int32, para4: cstring, para5: ptr int32, 
+                      para6: PPchar){.cdecl, dynlib: libX11, importc.}
+# implementation
+
+proc NULLQUARK(): TXrmQuark = 
+  result = TXrmQuark(0)
+
+proc NULLSTRING(): TXrmString = 
+  result = nil
+
+when defined(MACROS): 
+  proc XrmStringsEqual(a1, a2: cstring): bool = 
+    result = (strcomp(a1, a2)) == 0
+
+  proc XrmNameToString(name: int32): TXrmString = 
+    result = XrmQuarkToString(name)
+
+  proc XrmStringToName(str: cstring): int32 = 
+    result = XrmStringToQuark(str)
+
+  proc XrmStringToNameList(str: cstring, name: PXrmQuark) = 
+    XrmStringToQuarkList(str, name)
+
+  proc XrmClassToString(c_class: int32): TXrmString = 
+    result = XrmQuarkToString(c_class)
+
+  proc XrmStringToClass(c_class: cstring): int32 = 
+    result = XrmStringToQuark(c_class)
+
+  proc XrmStringToClassList(str: cstring, c_class: PXrmQuark) = 
+    XrmStringToQuarkList(str, c_class)
+
+  proc XrmStringToRepresentation(str: cstring): int32 = 
+    result = XrmStringToQuark(str)
+
+  proc XrmRepresentationToString(thetype: int32): TXrmString = 
+    result = XrmQuarkToString(thetype)

lib/oldwrappers/x11/xshm.nim

@@ -0,0 +1,77 @@
+
+import 
+  x, xlib
+
+#const 
+#  libX11* = "libX11.so"
+
+#
+#  Automatically converted by H2Pas 0.99.15 from xshm.h
+#  The following command line parameters were used:
+#    -p
+#    -T
+#    -S
+#    -d
+#    -c
+#    xshm.h
+#
+
+const 
+  constX_ShmQueryVersion* = 0
+  constX_ShmAttach* = 1
+  constX_ShmDetach* = 2
+  constX_ShmPutImage* = 3
+  constX_ShmGetImage* = 4
+  constX_ShmCreatePixmap* = 5
+  ShmCompletion* = 0
+  ShmNumberEvents* = ShmCompletion + 1
+  BadShmSeg* = 0
+  ShmNumberErrors* = BadShmSeg + 1
+
+type 
+  PShmSeg* = ptr TShmSeg
+  TShmSeg* = culong
+  PXShmCompletionEvent* = ptr TXShmCompletionEvent
+  TXShmCompletionEvent*{.final.} = object 
+    theType*: cint
+    serial*: culong
+    send_event*: TBool
+    display*: PDisplay
+    drawable*: TDrawable
+    major_code*: cint
+    minor_code*: cint
+    shmseg*: TShmSeg
+    offset*: culong
+
+  PXShmSegmentInfo* = ptr TXShmSegmentInfo
+  TXShmSegmentInfo*{.final.} = object 
+    shmseg*: TShmSeg
+    shmid*: cint
+    shmaddr*: cstring
+    readOnly*: TBool
+
+
+proc XShmQueryExtension*(para1: PDisplay): TBool{.cdecl, dynlib: libX11, importc.}
+proc XShmGetEventBase*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
+proc XShmQueryVersion*(para1: PDisplay, para2: Pcint, para3: Pcint, para4: PBool): TBool{.
+    cdecl, dynlib: libX11, importc.}
+proc XShmPixmapFormat*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
+proc XShmAttach*(para1: PDisplay, para2: PXShmSegmentInfo): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XShmDetach*(para1: PDisplay, para2: PXShmSegmentInfo): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XShmPutImage*(para1: PDisplay, para2: TDrawable, para3: TGC, 
+                   para4: PXImage, para5: cint, para6: cint, para7: cint, 
+                   para8: cint, para9: cuint, para10: cuint, para11: TBool): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XShmGetImage*(para1: PDisplay, para2: TDrawable, para3: PXImage, 
+                   para4: cint, para5: cint, para6: culong): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XShmCreateImage*(para1: PDisplay, para2: PVisual, para3: cuint, 
+                      para4: cint, para5: cstring, para6: PXShmSegmentInfo, 
+                      para7: cuint, para8: cuint): PXImage{.cdecl, 
+    dynlib: libX11, importc.}
+proc XShmCreatePixmap*(para1: PDisplay, para2: TDrawable, para3: cstring, 
+                       para4: PXShmSegmentInfo, para5: cuint, para6: cuint, 
+                       para7: cuint): TPixmap{.cdecl, dynlib: libX11, importc.}
+# implementation

lib/oldwrappers/x11/xutil.nim

@@ -0,0 +1,412 @@
+
+import 
+  x, xlib, keysym
+
+#const 
+#  libX11* = "libX11.so"
+
+#
+#  Automatically converted by H2Pas 0.99.15 from xutil.h
+#  The following command line parameters were used:
+#    -p
+#    -T
+#    -S
+#    -d
+#    -c
+#    xutil.h
+#
+
+const 
+  NoValue* = 0x00000000
+  XValue* = 0x00000001
+  YValue* = 0x00000002
+  WidthValue* = 0x00000004
+  HeightValue* = 0x00000008
+  AllValues* = 0x0000000F
+  XNegative* = 0x00000010
+  YNegative* = 0x00000020
+
+type 
+  TCPoint*{.final.} = object 
+    x*: cint
+    y*: cint
+
+  PXSizeHints* = ptr TXSizeHints
+  TXSizeHints*{.final.} = object 
+    flags*: clong
+    x*, y*: cint
+    width*, height*: cint
+    min_width*, min_height*: cint
+    max_width*, max_height*: cint
+    width_inc*, height_inc*: cint
+    min_aspect*, max_aspect*: TCPoint
+    base_width*, base_height*: cint
+    win_gravity*: cint
+
+
+const 
+  USPosition* = 1 shl 0
+  USSize* = 1 shl 1
+  PPosition* = 1 shl 2
+  PSize* = 1 shl 3
+  PMinSize* = 1 shl 4
+  PMaxSize* = 1 shl 5
+  PResizeInc* = 1 shl 6
+  PAspect* = 1 shl 7
+  PBaseSize* = 1 shl 8
+  PWinGravity* = 1 shl 9
+  PAllHints* = PPosition or PSize or PMinSize or PMaxSize or PResizeInc or
+      PAspect
+
+type 
+  PXWMHints* = ptr TXWMHints
+  TXWMHints*{.final.} = object 
+    flags*: clong
+    input*: TBool
+    initial_state*: cint
+    icon_pixmap*: TPixmap
+    icon_window*: TWindow
+    icon_x*, icon_y*: cint
+    icon_mask*: TPixmap
+    window_group*: TXID
+
+
+const 
+  InputHint* = 1 shl 0
+  StateHint* = 1 shl 1
+  IconPixmapHint* = 1 shl 2
+  IconWindowHint* = 1 shl 3
+  IconPositionHint* = 1 shl 4
+  IconMaskHint* = 1 shl 5
+  WindowGroupHint* = 1 shl 6
+  AllHints* = InputHint or StateHint or IconPixmapHint or IconWindowHint or
+      IconPositionHint or IconMaskHint or WindowGroupHint
+  XUrgencyHint* = 1 shl 8
+  WithdrawnState* = 0
+  NormalState* = 1
+  IconicState* = 3
+  DontCareState* = 0
+  ZoomState* = 2
+  InactiveState* = 4
+
+type 
+  PXTextProperty* = ptr TXTextProperty
+  TXTextProperty*{.final.} = object 
+    value*: pcuchar
+    encoding*: TAtom
+    format*: cint
+    nitems*: culong
+
+
+const 
+  XNoMemory* = - 1
+  XLocaleNotSupported* = - 2
+  XConverterNotFound* = - 3
+
+type 
+  PXICCEncodingStyle* = ptr TXICCEncodingStyle
+  TXICCEncodingStyle* = enum 
+    XStringStyle, XCompoundTextStyle, XTextStyle, XStdICCTextStyle, 
+    XUTF8StringStyle
+  PPXIconSize* = ptr PXIconSize
+  PXIconSize* = ptr TXIconSize
+  TXIconSize*{.final.} = object 
+    min_width*, min_height*: cint
+    max_width*, max_height*: cint
+    width_inc*, height_inc*: cint
+
+  PXClassHint* = ptr TXClassHint
+  TXClassHint*{.final.} = object 
+    res_name*: cstring
+    res_class*: cstring
+
+
+type 
+  PXComposeStatus* = ptr TXComposeStatus
+  TXComposeStatus*{.final.} = object 
+    compose_ptr*: TXPointer
+    chars_matched*: cint
+
+
+type 
+  PXRegion* = ptr TXRegion
+  TXRegion*{.final.} = object 
+  TRegion* = PXRegion
+  PRegion* = ptr TRegion
+
+const 
+  RectangleOut* = 0
+  RectangleIn* = 1
+  RectanglePart* = 2
+
+type 
+  PXVisualInfo* = ptr TXVisualInfo
+  TXVisualInfo*{.final.} = object 
+    visual*: PVisual
+    visualid*: TVisualID
+    screen*: cint
+    depth*: cint
+    class*: cint
+    red_mask*: culong
+    green_mask*: culong
+    blue_mask*: culong
+    colormap_size*: cint
+    bits_per_rgb*: cint
+
+
+const 
+  VisualNoMask* = 0x00000000
+  VisualIDMask* = 0x00000001
+  VisualScreenMask* = 0x00000002
+  VisualDepthMask* = 0x00000004
+  VisualClassMask* = 0x00000008
+  VisualRedMaskMask* = 0x00000010
+  VisualGreenMaskMask* = 0x00000020
+  VisualBlueMaskMask* = 0x00000040
+  VisualColormapSizeMask* = 0x00000080
+  VisualBitsPerRGBMask* = 0x00000100
+  VisualAllMask* = 0x000001FF
+
+type 
+  PPXStandardColormap* = ptr PXStandardColormap
+  PXStandardColormap* = ptr TXStandardColormap
+  TXStandardColormap*{.final.} = object 
+    colormap*: TColormap
+    red_max*: culong
+    red_mult*: culong
+    green_max*: culong
+    green_mult*: culong
+    blue_max*: culong
+    blue_mult*: culong
+    base_pixel*: culong
+    visualid*: TVisualID
+    killid*: TXID
+
+
+const 
+  BitmapSuccess* = 0
+  BitmapOpenFailed* = 1
+  BitmapFileInvalid* = 2
+  BitmapNoMemory* = 3
+  XCSUCCESS* = 0
+  XCNOMEM* = 1
+  XCNOENT* = 2
+  ReleaseByFreeingColormap*: TXID = TXID(1)
+
+type 
+  PXContext* = ptr TXContext
+  TXContext* = cint
+
+proc XAllocClassHint*(): PXClassHint{.cdecl, dynlib: libX11, importc.}
+proc XAllocIconSize*(): PXIconSize{.cdecl, dynlib: libX11, importc.}
+proc XAllocSizeHints*(): PXSizeHints{.cdecl, dynlib: libX11, importc.}
+proc XAllocStandardColormap*(): PXStandardColormap{.cdecl, dynlib: libX11, 
+    importc.}
+proc XAllocWMHints*(): PXWMHints{.cdecl, dynlib: libX11, importc.}
+proc XClipBox*(para1: TRegion, para2: PXRectangle): cint{.cdecl, dynlib: libX11, 
+    importc.}
+proc XCreateRegion*(): TRegion{.cdecl, dynlib: libX11, importc.}
+proc XDefaultString*(): cstring{.cdecl, dynlib: libX11, importc.}
+proc XDeleteContext*(para1: PDisplay, para2: TXID, para3: TXContext): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc XDestroyRegion*(para1: TRegion): cint{.cdecl, dynlib: libX11, importc.}
+proc XEmptyRegion*(para1: TRegion): cint{.cdecl, dynlib: libX11, importc.}
+proc XEqualRegion*(para1: TRegion, para2: TRegion): cint{.cdecl, dynlib: libX11, 
+    importc.}
+proc XFindContext*(para1: PDisplay, para2: TXID, para3: TXContext, 
+                   para4: PXPointer): cint{.cdecl, dynlib: libX11, importc.}
+proc XGetClassHint*(para1: PDisplay, para2: TWindow, para3: PXClassHint): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XGetIconSizes*(para1: PDisplay, para2: TWindow, para3: PPXIconSize, 
+                    para4: Pcint): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XGetNormalHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XGetRGBColormaps*(para1: PDisplay, para2: TWindow, 
+                       para3: PPXStandardColormap, para4: Pcint, para5: TAtom): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XGetSizeHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, 
+                    para4: TAtom): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XGetStandardColormap*(para1: PDisplay, para2: TWindow, 
+                           para3: PXStandardColormap, para4: TAtom): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XGetTextProperty*(para1: PDisplay, para2: TWindow, para3: PXTextProperty, 
+                       para4: TAtom): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XGetVisualInfo*(para1: PDisplay, para2: clong, para3: PXVisualInfo, 
+                     para4: Pcint): PXVisualInfo{.cdecl, dynlib: libX11, importc.}
+proc XGetWMClientMachine*(para1: PDisplay, para2: TWindow, para3: PXTextProperty): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XGetWMHints*(para1: PDisplay, para2: TWindow): PXWMHints{.cdecl, 
+    dynlib: libX11, importc.}
+proc XGetWMIconName*(para1: PDisplay, para2: TWindow, para3: PXTextProperty): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XGetWMName*(para1: PDisplay, para2: TWindow, para3: PXTextProperty): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XGetWMNormalHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, 
+                        para4: ptr int): TStatus{.cdecl, dynlib: libX11, importc.}
+proc XGetWMSizeHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, 
+                      para4: ptr int, para5: TAtom): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XGetZoomHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints): TStatus{.
+    cdecl, dynlib: libX11, importc.}
+proc XIntersectRegion*(para1: TRegion, para2: TRegion, para3: TRegion): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc XConvertCase*(para1: TKeySym, para2: PKeySym, para3: PKeySym){.cdecl, 
+    dynlib: libX11, importc.}
+proc XLookupString*(para1: PXKeyEvent, para2: cstring, para3: cint, 
+                    para4: PKeySym, para5: PXComposeStatus): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XMatchVisualInfo*(para1: PDisplay, para2: cint, para3: cint, para4: cint, 
+                       para5: PXVisualInfo): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XOffsetRegion*(para1: TRegion, para2: cint, para3: cint): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XPointInRegion*(para1: TRegion, para2: cint, para3: cint): TBool{.cdecl, 
+    dynlib: libX11, importc.}
+proc XPolygonRegion*(para1: PXPoint, para2: cint, para3: cint): TRegion{.cdecl, 
+    dynlib: libX11, importc.}
+proc XRectInRegion*(para1: TRegion, para2: cint, para3: cint, para4: cuint, 
+                    para5: cuint): cint{.cdecl, dynlib: libX11, importc.}
+proc XSaveContext*(para1: PDisplay, para2: TXID, para3: TXContext, 
+                   para4: cstring): cint{.cdecl, dynlib: libX11, importc.}
+proc XSetClassHint*(para1: PDisplay, para2: TWindow, para3: PXClassHint): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc XSetIconSizes*(para1: PDisplay, para2: TWindow, para3: PXIconSize, 
+                    para4: cint): cint{.cdecl, dynlib: libX11, importc.}
+proc XSetNormalHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc XSetRGBColormaps*(para1: PDisplay, para2: TWindow, 
+                       para3: PXStandardColormap, para4: cint, para5: TAtom){.
+    cdecl, dynlib: libX11, importc.}
+proc XSetSizeHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, 
+                    para4: TAtom): cint{.cdecl, dynlib: libX11, importc.}
+proc XSetStandardProperties*(para1: PDisplay, para2: TWindow, para3: cstring, 
+                             para4: cstring, para5: TPixmap, para6: PPchar, 
+                             para7: cint, para8: PXSizeHints): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XSetTextProperty*(para1: PDisplay, para2: TWindow, para3: PXTextProperty, 
+                       para4: TAtom){.cdecl, dynlib: libX11, importc.}
+proc XSetWMClientMachine*(para1: PDisplay, para2: TWindow, para3: PXTextProperty){.
+    cdecl, dynlib: libX11, importc.}
+proc XSetWMHints*(para1: PDisplay, para2: TWindow, para3: PXWMHints): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc XSetWMIconName*(para1: PDisplay, para2: TWindow, para3: PXTextProperty){.
+    cdecl, dynlib: libX11, importc.}
+proc XSetWMName*(para1: PDisplay, para2: TWindow, para3: PXTextProperty){.cdecl, 
+    dynlib: libX11, importc.}
+proc XSetWMNormalHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints){.
+    cdecl, dynlib: libX11, importc.}
+proc XSetWMProperties*(para1: PDisplay, para2: TWindow, para3: PXTextProperty, 
+                       para4: PXTextProperty, para5: PPchar, para6: cint, 
+                       para7: PXSizeHints, para8: PXWMHints, para9: PXClassHint){.
+    cdecl, dynlib: libX11, importc.}
+proc XmbSetWMProperties*(para1: PDisplay, para2: TWindow, para3: cstring, 
+                         para4: cstring, para5: PPchar, para6: cint, 
+                         para7: PXSizeHints, para8: PXWMHints, 
+                         para9: PXClassHint){.cdecl, dynlib: libX11, importc.}
+proc Xutf8SetWMProperties*(para1: PDisplay, para2: TWindow, para3: cstring, 
+                           para4: cstring, para5: PPchar, para6: cint, 
+                           para7: PXSizeHints, para8: PXWMHints, 
+                           para9: PXClassHint){.cdecl, dynlib: libX11, importc.}
+proc XSetWMSizeHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints, 
+                      para4: TAtom){.cdecl, dynlib: libX11, importc.}
+proc XSetRegion*(para1: PDisplay, para2: TGC, para3: TRegion): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XSetStandardColormap*(para1: PDisplay, para2: TWindow, 
+                           para3: PXStandardColormap, para4: TAtom){.cdecl, 
+    dynlib: libX11, importc.}
+proc XSetZoomHints*(para1: PDisplay, para2: TWindow, para3: PXSizeHints): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc XShrinkRegion*(para1: TRegion, para2: cint, para3: cint): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XStringListToTextProperty*(para1: PPchar, para2: cint, 
+                                para3: PXTextProperty): TStatus{.cdecl, 
+    dynlib: libX11, importc.}
+proc XSubtractRegion*(para1: TRegion, para2: TRegion, para3: TRegion): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc XmbTextListToTextProperty*(para1: PDisplay, para2: PPchar, para3: cint, 
+                                para4: TXICCEncodingStyle, para5: PXTextProperty): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc XwcTextListToTextProperty*(para1: PDisplay, para2: ptr ptr int16, para3: cint, 
+                                para4: TXICCEncodingStyle, para5: PXTextProperty): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc Xutf8TextListToTextProperty*(para1: PDisplay, para2: PPchar, para3: cint, 
+                                  para4: TXICCEncodingStyle, 
+                                  para5: PXTextProperty): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XwcFreeStringList*(para1: ptr ptr int16){.cdecl, dynlib: libX11, importc.}
+proc XTextPropertyToStringList*(para1: PXTextProperty, para2: PPPchar, 
+                                para3: Pcint): TStatus{.cdecl, dynlib: libX11, 
+    importc.}
+proc XmbTextPropertyToTextList*(para1: PDisplay, para2: PXTextProperty, 
+                                para3: PPPchar, para4: Pcint): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XwcTextPropertyToTextList*(para1: PDisplay, para2: PXTextProperty, 
+                                para3: ptr ptr ptr int16, para4: Pcint): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc Xutf8TextPropertyToTextList*(para1: PDisplay, para2: PXTextProperty, 
+                                  para3: PPPchar, para4: Pcint): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XUnionRectWithRegion*(para1: PXRectangle, para2: TRegion, para3: TRegion): cint{.
+    cdecl, dynlib: libX11, importc.}
+proc XUnionRegion*(para1: TRegion, para2: TRegion, para3: TRegion): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XWMGeometry*(para1: PDisplay, para2: cint, para3: cstring, para4: cstring, 
+                  para5: cuint, para6: PXSizeHints, para7: Pcint, para8: Pcint, 
+                  para9: Pcint, para10: Pcint, para11: Pcint): cint{.cdecl, 
+    dynlib: libX11, importc.}
+proc XXorRegion*(para1: TRegion, para2: TRegion, para3: TRegion): cint{.cdecl, 
+    dynlib: libX11, importc.}
+when defined(MACROS): 
+  proc XDestroyImage*(ximage: PXImage): cint
+  proc XGetPixel*(ximage: PXImage, x, y: cint): culong
+  proc XPutPixel*(ximage: PXImage, x, y: cint, pixel: culong): cint
+  proc XSubImage*(ximage: PXImage, x, y: cint, width, height: cuint): PXImage
+  proc XAddPixel*(ximage: PXImage, value: clong): cint
+  proc IsKeypadKey*(keysym: TKeySym): bool
+  proc IsPrivateKeypadKey*(keysym: TKeySym): bool
+  proc IsCursorKey*(keysym: TKeySym): bool
+  proc IsPFKey*(keysym: TKeySym): bool
+  proc IsFunctionKey*(keysym: TKeySym): bool
+  proc IsMiscFunctionKey*(keysym: TKeySym): bool
+  proc IsModifierKey*(keysym: TKeySym): bool
+    #function XUniqueContext : TXContext;
+    #function XStringToContext(_string : Pchar) : TXContext;
+# implementation
+
+when defined(MACROS): 
+  proc XDestroyImage(ximage: PXImage): cint = 
+    XDestroyImage = ximage^ .f.destroy_image(ximage)
+
+  proc XGetPixel(ximage: PXImage, x, y: cint): culong = 
+    XGetPixel = ximage^ .f.get_pixel(ximage, x, y)
+
+  proc XPutPixel(ximage: PXImage, x, y: cint, pixel: culong): cint = 
+    XPutPixel = ximage^ .f.put_pixel(ximage, x, y, pixel)
+
+  proc XSubImage(ximage: PXImage, x, y: cint, width, height: cuint): PXImage = 
+    XSubImage = ximage^ .f.sub_image(ximage, x, y, width, height)
+
+  proc XAddPixel(ximage: PXImage, value: clong): cint = 
+    XAddPixel = ximage^ .f.add_pixel(ximage, value)
+
+  proc IsKeypadKey(keysym: TKeySym): bool = 
+    IsKeypadKey = (keysym >= XK_KP_Space) and (keysym <= XK_KP_Equal)
+
+  proc IsPrivateKeypadKey(keysym: TKeySym): bool = 
+    IsPrivateKeypadKey = (keysym >= 0x11000000) and (keysym <= 0x1100FFFF)
+
+  proc IsCursorKey(keysym: TKeySym): bool = 
+    IsCursorKey = (keysym >= XK_Home) and (keysym < XK_Select)
+
+  proc IsPFKey(keysym: TKeySym): bool = 
+    IsPFKey = (keysym >= XK_KP_F1) and (keysym <= XK_KP_F4)
+
+  proc IsFunctionKey(keysym: TKeySym): bool = 
+    IsFunctionKey = (keysym >= XK_F1) and (keysym <= XK_F35)
+
+  proc IsMiscFunctionKey(keysym: TKeySym): bool = 
+    IsMiscFunctionKey = (keysym >= XK_Select) and (keysym <= XK_Break)
+
+  proc IsModifierKey(keysym: TKeySym): bool = 
+    IsModifierKey = ((keysym >= XK_Shift_L) And (keysym <= XK_Hyper_R)) Or
+        (keysym == XK_Mode_switch) Or (keysym == XK_Num_Lock)

lib/oldwrappers/x11/xv.nim

@@ -0,0 +1,84 @@
+#***********************************************************
+#Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
+#and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+#
+#                        All Rights Reserved
+#
+#Permission to use, copy, modify, and distribute this software and its 
+#documentation for any purpose and without fee is hereby granted, 
+#provided that the above copyright notice appear in all copies and that
+#both that copyright notice and this permission notice appear in 
+#supporting documentation, and that the names of Digital or MIT not be
+#used in advertising or publicity pertaining to distribution of the
+#software without specific, written prior permission.  
+#
+#DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+#ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+#DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+#ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+#WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+#ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+#SOFTWARE.
+#
+#******************************************************************
+# $XFree86: xc/include/extensions/Xv.h,v 1.3 1999/05/23 06:33:22 dawes Exp $ 
+
+import 
+  x
+
+const 
+  XvName* = "libXVideo.so"
+  XvVersion* = 2
+  XvRevision* = 2             # Symbols 
+
+type 
+  TXvPortID* = TXID
+  TXvEncodingID* = TXID
+
+const 
+  XvNone* = 0
+  XvInput* = 0
+  XvOutput* = 1
+  XvInputMask* = 1 shl XvInput
+  XvOutputMask* = 1 shl XvOutput
+  XvVideoMask* = 0x00000004
+  XvStillMask* = 0x00000008
+  XvImageMask* = 0x00000010   # These two are not client viewable 
+  XvPixmapMask* = 0x00010000
+  XvWindowMask* = 0x00020000
+  XvGettable* = 0x00000001
+  XvSettable* = 0x00000002
+  XvRGB* = 0
+  XvYUV* = 1
+  XvPacked* = 0
+  XvPlanar* = 1
+  XvTopToBottom* = 0
+  XvBottomToTop* = 1          # Events 
+  XvVideoNotify* = 0
+  XvPortNotify* = 1
+  XvNumEvents* = 2            # Video Notify Reasons 
+  XvStarted* = 0
+  XvStopped* = 1
+  XvBusy* = 2
+  XvPreempted* = 3
+  XvHardError* = 4
+  XvLastReason* = 4
+  XvNumReasons* = XvLastReason + 1
+  XvStartedMask* = 1 shl XvStarted
+  XvStoppedMask* = 1 shl XvStopped
+  XvBusyMask* = 1 shl XvBusy
+  XvPreemptedMask* = 1 shl XvPreempted
+  XvHardErrorMask* = 1 shl XvHardError
+  XvAnyReasonMask* = (1 shl XvNumReasons) - 1
+  XvNoReasonMask* = 0         # Errors 
+  XvBadPort* = 0
+  XvBadEncoding* = 1
+  XvBadControl* = 2
+  XvNumErrors* = 3            # Status 
+  XvBadExtension* = 1
+  XvAlreadyGrabbed* = 2
+  XvInvalidTime* = 3
+  XvBadReply* = 4
+  XvBadAlloc* = 5
+
+# implementation

lib/oldwrappers/x11/xvlib.nim

@@ -0,0 +1,234 @@
+#***********************************************************
+#Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
+#and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+#
+#                        All Rights Reserved
+#
+#Permission to use, copy, modify, and distribute this software and its 
+#documentation for any purpose and without fee is hereby granted, 
+#provided that the above copyright notice appear in all copies and that
+#both that copyright notice and this permission notice appear in 
+#supporting documentation, and that the names of Digital or MIT not be
+#used in advertising or publicity pertaining to distribution of the
+#software without specific, written prior permission.  
+#
+#DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+#ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+#DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+#ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+#WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+#ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+#SOFTWARE.
+#
+#******************************************************************
+# $XFree86: xc/include/extensions/Xvlib.h,v 1.3 1999/12/11 19:28:48 mvojkovi Exp $ 
+#*
+#** File: 
+#**
+#**   Xvlib.h --- Xv library public header file
+#**
+#** Author: 
+#**
+#**   David Carver (Digital Workstation Engineering/Project Athena)
+#**
+#** Revisions:
+#**
+#**   26.06.91 Carver
+#**     - changed XvFreeAdaptors to XvFreeAdaptorInfo
+#**     - changed XvFreeEncodings to XvFreeEncodingInfo
+#**
+#**   11.06.91 Carver
+#**     - changed SetPortControl to SetPortAttribute
+#**     - changed GetPortControl to GetPortAttribute
+#**     - changed QueryBestSize
+#**
+#**   05.15.91 Carver
+#**     - version 2.0 upgrade
+#**
+#**   01.24.91 Carver
+#**     - version 1.4 upgrade
+#**
+#*
+
+import 
+  x, xlib, xshm, xv
+
+const 
+  libXv* = "libXv.so"
+
+type 
+  PXvRational* = ptr TXvRational
+  TXvRational*{.final.} = object 
+    numerator*: cint
+    denominator*: cint
+
+  PXvAttribute* = ptr TXvAttribute
+  TXvAttribute*{.final.} = object 
+    flags*: cint              # XvGettable, XvSettable 
+    min_value*: cint
+    max_value*: cint
+    name*: cstring
+
+  PPXvEncodingInfo* = ptr PXvEncodingInfo
+  PXvEncodingInfo* = ptr TXvEncodingInfo
+  TXvEncodingInfo*{.final.} = object 
+    encoding_id*: TXvEncodingID
+    name*: cstring
+    width*: culong
+    height*: culong
+    rate*: TXvRational
+    num_encodings*: culong
+
+  PXvFormat* = ptr TXvFormat
+  TXvFormat*{.final.} = object 
+    depth*: cchar
+    visual_id*: culong
+
+  PPXvAdaptorInfo* = ptr PXvAdaptorInfo
+  PXvAdaptorInfo* = ptr TXvAdaptorInfo
+  TXvAdaptorInfo*{.final.} = object 
+    base_id*: TXvPortID
+    num_ports*: culong
+    thetype*: cchar
+    name*: cstring
+    num_formats*: culong
+    formats*: PXvFormat
+    num_adaptors*: culong
+
+  PXvVideoNotifyEvent* = ptr TXvVideoNotifyEvent
+  TXvVideoNotifyEvent*{.final.} = object 
+    theType*: cint
+    serial*: culong           # # of last request processed by server 
+    send_event*: TBool        # true if this came from a SendEvent request 
+    display*: PDisplay        # Display the event was read from 
+    drawable*: TDrawable      # drawable 
+    reason*: culong           # what generated this event 
+    port_id*: TXvPortID       # what port 
+    time*: TTime              # milliseconds 
+  
+  PXvPortNotifyEvent* = ptr TXvPortNotifyEvent
+  TXvPortNotifyEvent*{.final.} = object 
+    theType*: cint
+    serial*: culong           # # of last request processed by server 
+    send_event*: TBool        # true if this came from a SendEvent request 
+    display*: PDisplay        # Display the event was read from 
+    port_id*: TXvPortID       # what port 
+    time*: TTime              # milliseconds 
+    attribute*: TAtom         # atom that identifies attribute 
+    value*: clong             # value of attribute 
+  
+  PXvEvent* = ptr TXvEvent
+  TXvEvent*{.final.} = object 
+    pad*: array[0..23, clong] #case longint of
+                              #      0 : (
+                              #            theType : cint;
+                              #	  );
+                              #      1 : (
+                              #            xvvideo : TXvVideoNotifyEvent;
+                              #          );
+                              #      2 : (
+                              #            xvport : TXvPortNotifyEvent;
+                              #          );
+                              #      3 : (
+                              #            
+                              #          );
+  
+  PXvImageFormatValues* = ptr TXvImageFormatValues
+  TXvImageFormatValues*{.final.} = object 
+    id*: cint                 # Unique descriptor for the format 
+    theType*: cint            # XvRGB, XvYUV 
+    byte_order*: cint         # LSBFirst, MSBFirst 
+    guid*: array[0..15, cchar] # Globally Unique IDentifier 
+    bits_per_pixel*: cint
+    format*: cint             # XvPacked, XvPlanar 
+    num_planes*: cint         # for RGB formats only 
+    depth*: cint
+    red_mask*: cuint
+    green_mask*: cuint
+    blue_mask*: cuint         # for YUV formats only 
+    y_sample_bits*: cuint
+    u_sample_bits*: cuint
+    v_sample_bits*: cuint
+    horz_y_period*: cuint
+    horz_u_period*: cuint
+    horz_v_period*: cuint
+    vert_y_period*: cuint
+    vert_u_period*: cuint
+    vert_v_period*: cuint
+    component_order*: array[0..31, char] # eg. UYVY 
+    scanline_order*: cint     # XvTopToBottom, XvBottomToTop 
+  
+  PXvImage* = ptr TXvImage
+  TXvImage*{.final.} = object 
+    id*: cint
+    width*, height*: cint
+    data_size*: cint          # bytes 
+    num_planes*: cint
+    pitches*: pcint           # bytes 
+    offsets*: pcint           # bytes 
+    data*: pointer
+    obdata*: TXPointer
+
+
+proc XvQueryExtension*(display: PDisplay, p_version, p_revision, p_requestBase, 
+    p_eventBase, p_errorBase: pcuint): cint{.cdecl, dynlib: libXv, importc.}
+proc XvQueryAdaptors*(display: PDisplay, window: TWindow, p_nAdaptors: pcuint, 
+                      p_pAdaptors: PPXvAdaptorInfo): cint{.cdecl, dynlib: libXv, 
+    importc.}
+proc XvQueryEncodings*(display: PDisplay, port: TXvPortID, p_nEncoding: pcuint, 
+                       p_pEncoding: PPXvEncodingInfo): cint{.cdecl, 
+    dynlib: libXv, importc.}
+proc XvPutVideo*(display: PDisplay, port: TXvPortID, d: TDrawable, gc: TGC, 
+                 vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{.
+    cdecl, dynlib: libXv, importc.}
+proc XvPutStill*(display: PDisplay, port: TXvPortID, d: TDrawable, gc: TGC, 
+                 vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{.
+    cdecl, dynlib: libXv, importc.}
+proc XvGetVideo*(display: PDisplay, port: TXvPortID, d: TDrawable, gc: TGC, 
+                 vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{.
+    cdecl, dynlib: libXv, importc.}
+proc XvGetStill*(display: PDisplay, port: TXvPortID, d: TDrawable, gc: TGC, 
+                 vx, vy: cint, vw, vh: cuint, dx, dy: cint, dw, dh: cuint): cint{.
+    cdecl, dynlib: libXv, importc.}
+proc XvStopVideo*(display: PDisplay, port: TXvPortID, drawable: TDrawable): cint{.
+    cdecl, dynlib: libXv, importc.}
+proc XvGrabPort*(display: PDisplay, port: TXvPortID, time: TTime): cint{.cdecl, 
+    dynlib: libXv, importc.}
+proc XvUngrabPort*(display: PDisplay, port: TXvPortID, time: TTime): cint{.
+    cdecl, dynlib: libXv, importc.}
+proc XvSelectVideoNotify*(display: PDisplay, drawable: TDrawable, onoff: TBool): cint{.
+    cdecl, dynlib: libXv, importc.}
+proc XvSelectPortNotify*(display: PDisplay, port: TXvPortID, onoff: TBool): cint{.
+    cdecl, dynlib: libXv, importc.}
+proc XvSetPortAttribute*(display: PDisplay, port: TXvPortID, attribute: TAtom, 
+                         value: cint): cint{.cdecl, dynlib: libXv, importc.}
+proc XvGetPortAttribute*(display: PDisplay, port: TXvPortID, attribute: TAtom, 
+                         p_value: pcint): cint{.cdecl, dynlib: libXv, importc.}
+proc XvQueryBestSize*(display: PDisplay, port: TXvPortID, motion: TBool, 
+                      vid_w, vid_h, drw_w, drw_h: cuint, 
+                      p_actual_width, p_actual_height: pcuint): cint{.cdecl, 
+    dynlib: libXv, importc.}
+proc XvQueryPortAttributes*(display: PDisplay, port: TXvPortID, number: pcint): PXvAttribute{.
+    cdecl, dynlib: libXv, importc.}
+proc XvFreeAdaptorInfo*(adaptors: PXvAdaptorInfo){.cdecl, dynlib: libXv, importc.}
+proc XvFreeEncodingInfo*(encodings: PXvEncodingInfo){.cdecl, dynlib: libXv, 
+    importc.}
+proc XvListImageFormats*(display: PDisplay, port_id: TXvPortID, 
+                         count_return: pcint): PXvImageFormatValues{.cdecl, 
+    dynlib: libXv, importc.}
+proc XvCreateImage*(display: PDisplay, port: TXvPortID, id: cint, data: pointer, 
+                    width, height: cint): PXvImage{.cdecl, dynlib: libXv, 
+    importc.}
+proc XvPutImage*(display: PDisplay, id: TXvPortID, d: TDrawable, gc: TGC, 
+                 image: PXvImage, src_x, src_y: cint, src_w, src_h: cuint, 
+                 dest_x, dest_y: cint, dest_w, dest_h: cuint): cint{.cdecl, 
+    dynlib: libXv, importc.}
+proc XvShmPutImage*(display: PDisplay, id: TXvPortID, d: TDrawable, gc: TGC, 
+                    image: PXvImage, src_x, src_y: cint, src_w, src_h: cuint, 
+                    dest_x, dest_y: cint, dest_w, dest_h: cuint, 
+                    send_event: TBool): cint{.cdecl, dynlib: libXv, importc.}
+proc XvShmCreateImage*(display: PDisplay, port: TXvPortID, id: cint, 
+                       data: pointer, width, height: cint, 
+                       shminfo: PXShmSegmentInfo): PXvImage{.cdecl, 
+    dynlib: libXv, importc.}
+# implementation

lib/oldwrappers/zip/libzip.nim

@@ -0,0 +1,241 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2008 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Interface to the `libzip <http://www.nih.at/libzip/index.html>`_ library by
+## Dieter Baron and Thomas Klausner. However, this does not need any external
+## library (DLL, lib*.so), as the source for this library is included and
+## compiled with this interface.
+
+#
+#  zip.h -- exported declarations.
+#  Copyright (C) 1999-2008 Dieter Baron and Thomas Klausner
+#
+#  This file is part of libzip, a library to manipulate ZIP archives.
+#  The authors can be contacted at <libzip@nih.at>
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#  1. Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in
+#     the documentation and/or other materials provided with the
+#     distribution.
+#  3. The names of the authors may not be used to endorse or promote
+#     products derived from this software without specific prior
+#     written permission.
+# 
+#  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+#  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+#  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+#  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
+#  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+#  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+#  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+#  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+#  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+#  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+import times
+
+{.compile: "libzip_all.c".}
+when defined(unix):
+  {.passl: "-lz".}
+
+type 
+  Tzip_source_cmd* = int32
+
+  Tzip_source_callback* = proc (state: pointer, data: pointer, length: int, 
+                                cmd: Tzip_source_cmd): int {.cdecl.}
+  Pzip_stat* = ptr Tzip_stat
+  Tzip_stat* {.final, pure.} = object 
+    name*: cstring            ## name of the file  
+    index*: int32             ## index within archive  
+    crc*: int32               ## crc of file data  
+    mtime*: TTime             ## modification time  
+    size*: int                ## size of file (uncompressed)  
+    comp_size*: int           ## size of file (compressed)  
+    comp_method*: int16       ## compression method used  
+    encryption_method*: int16 ## encryption method used  
+  
+  Tzip {.final, pure.} = object
+  Tzip_source {.final, pure.} = object 
+  Tzip_file {.final, pure.} = object
+
+  Pzip* = ptr Tzip ## represents a zip archive
+  Pzip_file* = ptr Tzip_file ## represents a file within an archive
+  Pzip_source* = ptr Tzip_source ## represents a source for an archive
+
+
+# flags for zip_name_locate, zip_fopen, zip_stat, ...  
+const 
+  ZIP_CREATE* = 1'i32
+  ZIP_EXCL* = 2'i32
+  ZIP_CHECKCONS* = 4'i32 
+  ZIP_FL_NOCASE* = 1'i32        ## ignore case on name lookup  
+  ZIP_FL_NODIR* = 2'i32         ## ignore directory component  
+  ZIP_FL_COMPRESSED* = 4'i32    ## read compressed data  
+  ZIP_FL_UNCHANGED* = 8'i32     ## use original data, ignoring changes  
+  ZIP_FL_RECOMPRESS* = 16'i32   ## force recompression of data  
+
+const  # archive global flags flags  
+  ZIP_AFL_TORRENT* = 1'i32      ##  torrent zipped  
+
+const # libzip error codes  
+  ZIP_ER_OK* = 0'i32            ## N No error  
+  ZIP_ER_MULTIDISK* = 1'i32     ## N Multi-disk zip archives not supported  
+  ZIP_ER_RENAME* = 2'i32        ## S Renaming temporary file failed  
+  ZIP_ER_CLOSE* = 3'i32         ## S Closing zip archive failed  
+  ZIP_ER_SEEK* = 4'i32          ## S Seek error  
+  ZIP_ER_READ* = 5'i32          ## S Read error  
+  ZIP_ER_WRITE* = 6'i32         ## S Write error  
+  ZIP_ER_CRC* = 7'i32           ## N CRC error  
+  ZIP_ER_ZIPCLOSED* = 8'i32     ## N Containing zip archive was closed  
+  ZIP_ER_NOENT* = 9'i32         ## N No such file  
+  ZIP_ER_EXISTS* = 10'i32       ## N File already exists  
+  ZIP_ER_OPEN* = 11'i32         ## S Can't open file  
+  ZIP_ER_TMPOPEN* = 12'i32      ## S Failure to create temporary file  
+  ZIP_ER_ZLIB* = 13'i32         ## Z Zlib error  
+  ZIP_ER_MEMORY* = 14'i32       ## N Malloc failure  
+  ZIP_ER_CHANGED* = 15'i32      ## N Entry has been changed  
+  ZIP_ER_COMPNOTSUPP* = 16'i32  ## N Compression method not supported  
+  ZIP_ER_EOF* = 17'i32          ## N Premature EOF  
+  ZIP_ER_INVAL* = 18'i32        ## N Invalid argument  
+  ZIP_ER_NOZIP* = 19'i32        ## N Not a zip archive  
+  ZIP_ER_INTERNAL* = 20'i32     ## N Internal error  
+  ZIP_ER_INCONS* = 21'i32       ## N Zip archive inconsistent  
+  ZIP_ER_REMOVE* = 22'i32       ## S Can't remove file  
+  ZIP_ER_DELETED* = 23'i32      ## N Entry has been deleted  
+   
+const # type of system error value  
+  ZIP_ET_NONE* = 0'i32          ## sys_err unused  
+  ZIP_ET_SYS* = 1'i32           ## sys_err is errno  
+  ZIP_ET_ZLIB* = 2'i32          ## sys_err is zlib error code  
+
+const # compression methods  
+  ZIP_CM_DEFAULT* = -1'i32      ## better of deflate or store  
+  ZIP_CM_STORE* = 0'i32         ## stored (uncompressed)  
+  ZIP_CM_SHRINK* = 1'i32        ## shrunk  
+  ZIP_CM_REDUCE_1* = 2'i32      ## reduced with factor 1  
+  ZIP_CM_REDUCE_2* = 3'i32      ## reduced with factor 2  
+  ZIP_CM_REDUCE_3* = 4'i32      ## reduced with factor 3  
+  ZIP_CM_REDUCE_4* = 5'i32      ## reduced with factor 4  
+  ZIP_CM_IMPLODE* = 6'i32       ## imploded  
+                                ## 7 - Reserved for Tokenizing compression algorithm  
+  ZIP_CM_DEFLATE* = 8'i32       ## deflated  
+  ZIP_CM_DEFLATE64* = 9'i32     ## deflate64  
+  ZIP_CM_PKWARE_IMPLODE* = 10'i32 ## PKWARE imploding  
+                                  ## 11 - Reserved by PKWARE  
+  ZIP_CM_BZIP2* = 12'i32        ## compressed using BZIP2 algorithm  
+                                ## 13 - Reserved by PKWARE  
+  ZIP_CM_LZMA* = 14'i32         ## LZMA (EFS)  
+                                ## 15-17 - Reserved by PKWARE  
+  ZIP_CM_TERSE* = 18'i32        ## compressed using IBM TERSE (new)  
+  ZIP_CM_LZ77* = 19'i32         ## IBM LZ77 z Architecture (PFS)  
+  ZIP_CM_WAVPACK* = 97'i32      ## WavPack compressed data  
+  ZIP_CM_PPMD* = 98'i32         ## PPMd version I, Rev 1  
+
+const  # encryption methods                              
+  ZIP_EM_NONE* = 0'i32            ## not encrypted  
+  ZIP_EM_TRAD_PKWARE* = 1'i32     ## traditional PKWARE encryption 
+
+const 
+  ZIP_EM_UNKNOWN* = 0x0000FFFF'i32 ## unknown algorithm  
+
+const 
+  ZIP_SOURCE_OPEN* = 0'i32        ## prepare for reading  
+  ZIP_SOURCE_READ* = 1'i32        ## read data  
+  ZIP_SOURCE_CLOSE* = 2'i32       ## reading is done  
+  ZIP_SOURCE_STAT* = 3'i32        ## get meta information  
+  ZIP_SOURCE_ERROR* = 4'i32       ## get error information  
+  constZIP_SOURCE_FREE* = 5'i32   ## cleanup and free resources  
+
+proc zip_add*(para1: Pzip, para2: cstring, para3: Pzip_source): int32 {.cdecl, 
+    importc: "zip_add".}
+proc zip_add_dir*(para1: Pzip, para2: cstring): int32 {.cdecl,  
+    importc: "zip_add_dir".}
+proc zip_close*(para1: Pzip) {.cdecl, importc: "zip_close".}
+proc zip_delete*(para1: Pzip, para2: int32): int32 {.cdecl,
+    importc: "zip_delete".}
+proc zip_error_clear*(para1: Pzip) {.cdecl, importc: "zip_error_clear".}
+proc zip_error_get*(para1: Pzip, para2: ptr int32, para3: ptr int32) {.cdecl, 
+    importc: "zip_error_get".}
+proc zip_error_get_sys_type*(para1: int32): int32 {.cdecl,  
+    importc: "zip_error_get_sys_type".}
+proc zip_error_to_str*(para1: cstring, para2: int, para3: int32, 
+                       para4: int32): int32 {.cdecl,
+    importc: "zip_error_to_str".}
+proc zip_fclose*(para1: Pzip_file) {.cdecl,
+    importc: "zip_fclose".}
+proc zip_file_error_clear*(para1: Pzip_file) {.cdecl, 
+    importc: "zip_file_error_clear".}
+proc zip_file_error_get*(para1: Pzip_file, para2: ptr int32, para3: ptr int32) {.
+    cdecl, importc: "zip_file_error_get".}
+proc zip_file_strerror*(para1: Pzip_file): cstring {.cdecl,
+    importc: "zip_file_strerror".}
+proc zip_fopen*(para1: Pzip, para2: cstring, para3: int32): Pzip_file {.cdecl, 
+    importc: "zip_fopen".}
+proc zip_fopen_index*(para1: Pzip, para2: int32, para3: int32): Pzip_file {.
+    cdecl, importc: "zip_fopen_index".}
+proc zip_fread*(para1: Pzip_file, para2: pointer, para3: int): int {.
+    cdecl, importc: "zip_fread".}
+proc zip_get_archive_comment*(para1: Pzip, para2: ptr int32, para3: int32): cstring {.
+    cdecl, importc: "zip_get_archive_comment".}
+proc zip_get_archive_flag*(para1: Pzip, para2: int32, para3: int32): int32 {.
+    cdecl, importc: "zip_get_archive_flag".}
+proc zip_get_file_comment*(para1: Pzip, para2: int32, para3: ptr int32, 
+                           para4: int32): cstring {.cdecl, 
+    importc: "zip_get_file_comment".}
+proc zip_get_name*(para1: Pzip, para2: int32, para3: int32): cstring {.cdecl, 
+    importc: "zip_get_name".}
+proc zip_get_num_files*(para1: Pzip): int32 {.cdecl,
+    importc: "zip_get_num_files".}
+proc zip_name_locate*(para1: Pzip, para2: cstring, para3: int32): int32 {.cdecl, 
+    importc: "zip_name_locate".}
+proc zip_open*(para1: cstring, para2: int32, para3: ptr int32): Pzip {.cdecl, 
+    importc: "zip_open".}
+proc zip_rename*(para1: Pzip, para2: int32, para3: cstring): int32 {.cdecl, 
+    importc: "zip_rename".}
+proc zip_replace*(para1: Pzip, para2: int32, para3: Pzip_source): int32 {.cdecl, 
+    importc: "zip_replace".}
+proc zip_set_archive_comment*(para1: Pzip, para2: cstring, para3: int32): int32 {.
+    cdecl, importc: "zip_set_archive_comment".}
+proc zip_set_archive_flag*(para1: Pzip, para2: int32, para3: int32): int32 {.
+    cdecl, importc: "zip_set_archive_flag".}
+proc zip_set_file_comment*(para1: Pzip, para2: int32, para3: cstring, 
+                           para4: int32): int32 {.cdecl, 
+    importc: "zip_set_file_comment".}
+proc zip_source_buffer*(para1: Pzip, para2: pointer, para3: int, para4: int32): Pzip_source {.
+    cdecl, importc: "zip_source_buffer".}
+proc zip_source_file*(para1: Pzip, para2: cstring, para3: int, para4: int): Pzip_source {.
+    cdecl, importc: "zip_source_file".}
+proc zip_source_filep*(para1: Pzip, para2: TFile, para3: int, para4: int): Pzip_source {.
+    cdecl, importc: "zip_source_filep".}
+proc zip_source_free*(para1: Pzip_source) {.cdecl, 
+    importc: "zip_source_free".}
+proc zip_source_function*(para1: Pzip, para2: Tzip_source_callback, 
+                          para3: pointer): Pzip_source {.cdecl, 
+    importc: "zip_source_function".}
+proc zip_source_zip*(para1: Pzip, para2: Pzip, para3: int32, para4: int32, 
+                     para5: int, para6: int): Pzip_source {.cdecl, 
+    importc: "zip_source_zip".}
+proc zip_stat*(para1: Pzip, para2: cstring, para3: int32, para4: Pzip_stat): int32 {.
+    cdecl, importc: "zip_stat".}
+proc zip_stat_index*(para1: Pzip, para2: int32, para3: int32, para4: Pzip_stat): int32 {.
+    cdecl, importc: "zip_stat_index".}
+proc zip_stat_init*(para1: Pzip_stat) {.cdecl, importc: "zip_stat_init".}
+proc zip_strerror*(para1: Pzip): cstring {.cdecl, importc: "zip_strerror".}
+proc zip_unchange*(para1: Pzip, para2: int32): int32 {.cdecl,
+    importc: "zip_unchange".}
+proc zip_unchange_all*(para1: Pzip): int32 {.cdecl, importc: "zip_unchange_all".}
+proc zip_unchange_archive*(para1: Pzip): int32 {.cdecl, 
+    importc: "zip_unchange_archive".}

lib/oldwrappers/zip/zlib.nim

@@ -0,0 +1,181 @@
+# Converted from Pascal
+
+## Interface to the zlib http://www.zlib.net/ compression library.
+
+when defined(windows):
+  const libz = "zlib1.dll"
+elif defined(macosx):
+  const libz = "libz.dylib"
+else:
+  const libz = "libz.so"
+
+type
+  Uint* = int32
+  Ulong* = int
+  Ulongf* = int
+  Pulongf* = ptr Ulongf
+  z_off_t* = int32
+  pbyte* = cstring
+  pbytef* = cstring
+  TAllocfunc* = proc (p: pointer, items: uInt, size: uInt): pointer{.cdecl.}
+  TFreeFunc* = proc (p: pointer, address: pointer){.cdecl.}
+  TInternalState*{.final, pure.} = object 
+  PInternalState* = ptr TInternalstate
+  TZStream*{.final, pure.} = object 
+    next_in*: pbytef
+    avail_in*: uInt
+    total_in*: uLong
+    next_out*: pbytef
+    avail_out*: uInt
+    total_out*: uLong
+    msg*: pbytef
+    state*: PInternalState
+    zalloc*: TAllocFunc
+    zfree*: TFreeFunc
+    opaque*: pointer
+    data_type*: int32
+    adler*: uLong
+    reserved*: uLong
+
+  TZStreamRec* = TZStream
+  PZstream* = ptr TZStream
+  gzFile* = pointer
+
+const 
+  Z_NO_FLUSH* = 0
+  Z_PARTIAL_FLUSH* = 1
+  Z_SYNC_FLUSH* = 2
+  Z_FULL_FLUSH* = 3
+  Z_FINISH* = 4
+  Z_OK* = 0
+  Z_STREAM_END* = 1
+  Z_NEED_DICT* = 2
+  Z_ERRNO* = -1
+  Z_STREAM_ERROR* = -2
+  Z_DATA_ERROR* = -3
+  Z_MEM_ERROR* = -4
+  Z_BUF_ERROR* = -5
+  Z_VERSION_ERROR* = -6
+  Z_NO_COMPRESSION* = 0
+  Z_BEST_SPEED* = 1
+  Z_BEST_COMPRESSION* = 9
+  Z_DEFAULT_COMPRESSION* = -1
+  Z_FILTERED* = 1
+  Z_HUFFMAN_ONLY* = 2
+  Z_DEFAULT_STRATEGY* = 0
+  Z_BINARY* = 0
+  Z_ASCII* = 1
+  Z_UNKNOWN* = 2
+  Z_DEFLATED* = 8
+  Z_NULL* = 0
+
+proc zlibVersion*(): cstring{.cdecl, dynlib: libz, importc: "zlibVersion".}
+proc deflate*(strm: var TZStream, flush: int32): int32{.cdecl, dynlib: libz, 
+    importc: "deflate".}
+proc deflateEnd*(strm: var TZStream): int32{.cdecl, dynlib: libz, 
+    importc: "deflateEnd".}
+proc inflate*(strm: var TZStream, flush: int32): int32{.cdecl, dynlib: libz, 
+    importc: "inflate".}
+proc inflateEnd*(strm: var TZStream): int32{.cdecl, dynlib: libz, 
+    importc: "inflateEnd".}
+proc deflateSetDictionary*(strm: var TZStream, dictionary: pbytef, 
+                           dictLength: uInt): int32{.cdecl, dynlib: libz, 
+    importc: "deflateSetDictionary".}
+proc deflateCopy*(dest, source: var TZstream): int32{.cdecl, dynlib: libz, 
+    importc: "deflateCopy".}
+proc deflateReset*(strm: var TZStream): int32{.cdecl, dynlib: libz, 
+    importc: "deflateReset".}
+proc deflateParams*(strm: var TZStream, level: int32, strategy: int32): int32{.
+    cdecl, dynlib: libz, importc: "deflateParams".}
+proc inflateSetDictionary*(strm: var TZStream, dictionary: pbytef, 
+                           dictLength: uInt): int32{.cdecl, dynlib: libz, 
+    importc: "inflateSetDictionary".}
+proc inflateSync*(strm: var TZStream): int32{.cdecl, dynlib: libz, 
+    importc: "inflateSync".}
+proc inflateReset*(strm: var TZStream): int32{.cdecl, dynlib: libz, 
+    importc: "inflateReset".}
+proc compress*(dest: pbytef, destLen: puLongf, source: pbytef, sourceLen: uLong): cint{.
+    cdecl, dynlib: libz, importc: "compress".}
+proc compress2*(dest: pbytef, destLen: puLongf, source: pbytef, 
+                sourceLen: uLong, level: cint): cint{.cdecl, dynlib: libz, 
+    importc: "compress2".}
+proc uncompress*(dest: pbytef, destLen: puLongf, source: pbytef, 
+                 sourceLen: uLong): cint{.cdecl, dynlib: libz, 
+    importc: "uncompress".}
+proc gzopen*(path: cstring, mode: cstring): gzFile{.cdecl, dynlib: libz, 
+    importc: "gzopen".}
+proc gzdopen*(fd: int32, mode: cstring): gzFile{.cdecl, dynlib: libz, 
+    importc: "gzdopen".}
+proc gzsetparams*(thefile: gzFile, level: int32, strategy: int32): int32{.cdecl, 
+    dynlib: libz, importc: "gzsetparams".}
+proc gzread*(thefile: gzFile, buf: pointer, length: int): int32{.cdecl, 
+    dynlib: libz, importc: "gzread".}
+proc gzwrite*(thefile: gzFile, buf: pointer, length: int): int32{.cdecl, 
+    dynlib: libz, importc: "gzwrite".}
+proc gzprintf*(thefile: gzFile, format: pbytef): int32{.varargs, cdecl, 
+    dynlib: libz, importc: "gzprintf".}
+proc gzputs*(thefile: gzFile, s: pbytef): int32{.cdecl, dynlib: libz, 
+    importc: "gzputs".}
+proc gzgets*(thefile: gzFile, buf: pbytef, length: int32): pbytef{.cdecl, 
+    dynlib: libz, importc: "gzgets".}
+proc gzputc*(thefile: gzFile, c: char): char{.cdecl, dynlib: libz, 
+    importc: "gzputc".}
+proc gzgetc*(thefile: gzFile): char{.cdecl, dynlib: libz, importc: "gzgetc".}
+proc gzflush*(thefile: gzFile, flush: int32): int32{.cdecl, dynlib: libz, 
+    importc: "gzflush".}
+proc gzseek*(thefile: gzFile, offset: z_off_t, whence: int32): z_off_t{.cdecl, 
+    dynlib: libz, importc: "gzseek".}
+proc gzrewind*(thefile: gzFile): int32{.cdecl, dynlib: libz, importc: "gzrewind".}
+proc gztell*(thefile: gzFile): z_off_t{.cdecl, dynlib: libz, importc: "gztell".}
+proc gzeof*(thefile: gzFile): int {.cdecl, dynlib: libz, importc: "gzeof".}
+proc gzclose*(thefile: gzFile): int32{.cdecl, dynlib: libz, importc: "gzclose".}
+proc gzerror*(thefile: gzFile, errnum: var int32): pbytef{.cdecl, dynlib: libz, 
+    importc: "gzerror".}
+proc adler32*(adler: uLong, buf: pbytef, length: uInt): uLong{.cdecl, 
+    dynlib: libz, importc: "adler32".}
+proc crc32*(crc: uLong, buf: pbytef, length: uInt): uLong{.cdecl, dynlib: libz, 
+    importc: "crc32".}
+proc deflateInitu*(strm: var TZStream, level: int32, version: cstring, 
+                   stream_size: int32): int32{.cdecl, dynlib: libz, 
+    importc: "deflateInit_".}
+proc inflateInitu*(strm: var TZStream, version: cstring,
+                   stream_size: int32): int32 {.
+    cdecl, dynlib: libz, importc: "inflateInit_".}
+proc deflateInit*(strm: var TZStream, level: int32): int32
+proc inflateInit*(strm: var TZStream): int32
+proc deflateInit2u*(strm: var TZStream, level: int32, `method`: int32, 
+                    windowBits: int32, memLevel: int32, strategy: int32, 
+                    version: cstring, stream_size: int32): int32 {.cdecl, 
+                    dynlib: libz, importc: "deflateInit2_".}
+proc inflateInit2u*(strm: var TZStream, windowBits: int32, version: cstring, 
+                    stream_size: int32): int32{.cdecl, dynlib: libz, 
+    importc: "inflateInit2_".}
+proc deflateInit2*(strm: var TZStream, 
+                   level, `method`, windowBits, memLevel,
+                   strategy: int32): int32
+proc inflateInit2*(strm: var TZStream, windowBits: int32): int32
+proc zError*(err: int32): cstring{.cdecl, dynlib: libz, importc: "zError".}
+proc inflateSyncPoint*(z: PZstream): int32{.cdecl, dynlib: libz, 
+    importc: "inflateSyncPoint".}
+proc get_crc_table*(): pointer{.cdecl, dynlib: libz, importc: "get_crc_table".}
+
+proc deflateInit(strm: var TZStream, level: int32): int32 = 
+  result = deflateInitu(strm, level, ZLIB_VERSION(), sizeof(TZStream))
+
+proc inflateInit(strm: var TZStream): int32 = 
+  result = inflateInitu(strm, ZLIB_VERSION(), sizeof(TZStream))
+
+proc deflateInit2(strm: var TZStream, 
+                  level, `method`, windowBits, memLevel,
+                  strategy: int32): int32 = 
+  result = deflateInit2u(strm, level, `method`, windowBits, memLevel, 
+                         strategy, ZLIB_VERSION(), sizeof(TZStream))
+
+proc inflateInit2(strm: var TZStream, windowBits: int32): int32 = 
+  result = inflateInit2u(strm, windowBits, ZLIB_VERSION(), sizeof(TZStream))
+
+proc zlibAllocMem*(AppData: Pointer, Items, Size: int): Pointer {.cdecl.} = 
+  result = Alloc(Items * Size)
+
+proc zlibFreeMem*(AppData, `Block`: Pointer) {.cdecl.} = 
+  dealloc(`Block`)

lib/oldwrappers/zip/zzip.nim

@@ -0,0 +1,172 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2008 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## This module is an interface to the zzip library. 
+
+#   Author: 
+#   Guido Draheim <guidod@gmx.de>
+#   Tomi Ollila <Tomi.Ollila@iki.fi>
+#   Copyright (c) 1999,2000,2001,2002,2003,2004 Guido Draheim
+#          All rights reserved, 
+#             usage allowed under the restrictions of the
+#         Lesser GNU General Public License 
+#             or alternatively the restrictions 
+#             of the Mozilla Public License 1.1
+
+when defined(windows):
+  const
+    dllname = "zzip.dll"
+else:
+  const 
+    dllname = "libzzip.so"
+
+type 
+  TZZipError* = int32
+const
+  ZZIP_ERROR* = -4096'i32
+  ZZIP_NO_ERROR* = 0'i32            # no error, may be used if user sets it.
+  ZZIP_OUTOFMEM* = ZZIP_ERROR - 20'i32  # out of memory  
+  ZZIP_DIR_OPEN* = ZZIP_ERROR - 21'i32  # failed to open zipfile, see errno for details 
+  ZZIP_DIR_STAT* = ZZIP_ERROR - 22'i32  # failed to fstat zipfile, see errno for details
+  ZZIP_DIR_SEEK* = ZZIP_ERROR - 23'i32  # failed to lseek zipfile, see errno for details
+  ZZIP_DIR_READ* = ZZIP_ERROR - 24'i32  # failed to read zipfile, see errno for details  
+  ZZIP_DIR_TOO_SHORT* = ZZIP_ERROR - 25'i32
+  ZZIP_DIR_EDH_MISSING* = ZZIP_ERROR - 26'i32
+  ZZIP_DIRSIZE* = ZZIP_ERROR - 27'i32
+  ZZIP_ENOENT* = ZZIP_ERROR - 28'i32
+  ZZIP_UNSUPP_COMPR* = ZZIP_ERROR - 29'i32
+  ZZIP_CORRUPTED* = ZZIP_ERROR - 31'i32
+  ZZIP_UNDEF* = ZZIP_ERROR - 32'i32
+  ZZIP_DIR_LARGEFILE* = ZZIP_ERROR - 33'i32
+
+  ZZIP_CASELESS* = 1'i32 shl 12'i32
+  ZZIP_NOPATHS* = 1'i32 shl 13'i32
+  ZZIP_PREFERZIP* = 1'i32 shl 14'i32
+  ZZIP_ONLYZIP* = 1'i32 shl 16'i32
+  ZZIP_FACTORY* = 1'i32 shl 17'i32
+  ZZIP_ALLOWREAL* = 1'i32 shl 18'i32
+  ZZIP_THREADED* = 1'i32 shl 19'i32
+  
+type
+  TZZipDir* {.final, pure.} = object
+  TZZipFile* {.final, pure.} = object
+  TZZipPluginIO* {.final, pure.} = object
+
+  TZZipDirent* {.final, pure.} = object  
+    d_compr*: int32  ## compression method
+    d_csize*: int32  ## compressed size  
+    st_size*: int32  ## file size / decompressed size
+    d_name*: cstring ## file name / strdupped name
+
+  TZZipStat* = TZZipDirent    
+
+proc zzip_strerror*(errcode: int32): cstring  {.cdecl, dynlib: dllname, 
+    importc: "zzip_strerror".}
+proc zzip_strerror_of*(dir: ptr TZZipDir): cstring  {.cdecl, dynlib: dllname, 
+    importc: "zzip_strerror_of".}
+proc zzip_errno*(errcode: int32): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_errno".}
+
+proc zzip_geterror*(dir: ptr TZZipDir): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_error".}
+proc zzip_seterror*(dir: ptr TZZipDir, errcode: int32) {.cdecl, dynlib: dllname, 
+    importc: "zzip_seterror".}
+proc zzip_compr_str*(compr: int32): cstring {.cdecl, dynlib: dllname, 
+    importc: "zzip_compr_str".}
+proc zzip_dirhandle*(fp: ptr TZZipFile): ptr TZZipDir {.cdecl, dynlib: dllname, 
+    importc: "zzip_dirhandle".}
+proc zzip_dirfd*(dir: ptr TZZipDir): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_dirfd".}
+proc zzip_dir_real*(dir: ptr TZZipDir): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_dir_real".}
+proc zzip_file_real*(fp: ptr TZZipFile): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_file_real".}
+proc zzip_realdir*(dir: ptr TZZipDir): pointer {.cdecl, dynlib: dllname, 
+    importc: "zzip_realdir".}
+proc zzip_realfd*(fp: ptr TZZipFile): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_realfd".}
+
+proc zzip_dir_alloc*(fileext: cstringArray): ptr TZZipDir {.cdecl, 
+    dynlib: dllname, importc: "zzip_dir_alloc".}
+proc zzip_dir_free*(para1: ptr TZZipDir): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_dir_free".}
+
+proc zzip_dir_fdopen*(fd: int32, errcode_p: ptr TZZipError): ptr TZZipDir {.cdecl, 
+    dynlib: dllname, importc: "zzip_dir_fdopen".}
+proc zzip_dir_open*(filename: cstring, errcode_p: ptr TZZipError): ptr TZZipDir {.
+    cdecl, dynlib: dllname, importc: "zzip_dir_open".}
+proc zzip_dir_close*(dir: ptr TZZipDir) {.cdecl, dynlib: dllname, 
+    importc: "zzip_dir_close".}
+proc zzip_dir_read*(dir: ptr TZZipDir, dirent: ptr TZZipDirent): int32 {.cdecl, 
+    dynlib: dllname, importc: "zzip_dir_read".}
+
+proc zzip_opendir*(filename: cstring): ptr TZZipDir {.cdecl, dynlib: dllname, 
+    importc: "zzip_opendir".}
+proc zzip_closedir*(dir: ptr TZZipDir) {.cdecl, dynlib: dllname, 
+    importc: "zzip_closedir".}
+proc zzip_readdir*(dir: ptr TZZipDir): ptr TZZipDirent {.cdecl, dynlib: dllname, 
+    importc: "zzip_readdir".}
+proc zzip_rewinddir*(dir: ptr TZZipDir) {.cdecl, dynlib: dllname, 
+                                      importc: "zzip_rewinddir".}
+proc zzip_telldir*(dir: ptr TZZipDir): int {.cdecl, dynlib: dllname, 
+    importc: "zzip_telldir".}
+proc zzip_seekdir*(dir: ptr TZZipDir, offset: int) {.cdecl, dynlib: dllname, 
+    importc: "zzip_seekdir".}
+
+proc zzip_file_open*(dir: ptr TZZipDir, name: cstring, flags: int32): ptr TZZipFile {.
+    cdecl, dynlib: dllname, importc: "zzip_file_open".}
+proc zzip_file_close*(fp: ptr TZZipFile) {.cdecl, dynlib: dllname, 
+    importc: "zzip_file_close".}
+proc zzip_file_read*(fp: ptr TZZipFile, buf: pointer, length: int): int {.
+    cdecl, dynlib: dllname, importc: "zzip_file_read".}
+proc zzip_open*(name: cstring, flags: int32): ptr TZZipFile {.cdecl, 
+    dynlib: dllname, importc: "zzip_open".}
+proc zzip_close*(fp: ptr TZZipFile) {.cdecl, dynlib: dllname, 
+    importc: "zzip_close".}
+proc zzip_read*(fp: ptr TZZipFile, buf: pointer, length: int): int {.
+    cdecl, dynlib: dllname, importc: "zzip_read".}
+
+proc zzip_freopen*(name: cstring, mode: cstring, para3: ptr TZZipFile): ptr TZZipFile {.
+    cdecl, dynlib: dllname, importc: "zzip_freopen".}
+proc zzip_fopen*(name: cstring, mode: cstring): ptr TZZipFile {.cdecl, 
+    dynlib: dllname, importc: "zzip_fopen".}
+proc zzip_fread*(p: pointer, size: int, nmemb: int, 
+                 file: ptr TZZipFile): int {.cdecl, dynlib: dllname, 
+    importc: "zzip_fread".}
+proc zzip_fclose*(fp: ptr TZZipFile) {.cdecl, dynlib: dllname, 
+    importc: "zzip_fclose".}
+
+proc zzip_rewind*(fp: ptr TZZipFile): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_rewind".}
+proc zzip_seek*(fp: ptr TZZipFile, offset: int, whence: int32): int {.
+    cdecl, dynlib: dllname, importc: "zzip_seek".}
+proc zzip_tell*(fp: ptr TZZipFile): int {.cdecl, dynlib: dllname, 
+    importc: "zzip_tell".}
+
+proc zzip_dir_stat*(dir: ptr TZZipDir, name: cstring, zs: ptr TZZipStat, 
+                    flags: int32): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_dir_stat".}
+proc zzip_file_stat*(fp: ptr TZZipFile, zs: ptr TZZipStat): int32 {.cdecl, 
+    dynlib: dllname, importc: "zzip_file_stat".}
+proc zzip_fstat*(fp: ptr TZZipFile, zs: ptr TZZipStat): int32 {.cdecl, dynlib: dllname, 
+    importc: "zzip_fstat".}
+
+proc zzip_open_shared_io*(stream: ptr TZZipFile, name: cstring, 
+                          o_flags: int32, o_modes: int32, ext: cstringArray, 
+                          io: ptr TZZipPluginIO): ptr TZZipFile {.cdecl, 
+    dynlib: dllname, importc: "zzip_open_shared_io".}
+proc zzip_open_ext_io*(name: cstring, o_flags: int32, o_modes: int32, 
+                       ext: cstringArray, io: ptr TZZipPluginIO): ptr TZZipFile {.
+    cdecl, dynlib: dllname, importc: "zzip_open_ext_io".}
+proc zzip_opendir_ext_io*(name: cstring, o_modes: int32, 
+                          ext: cstringArray, io: ptr TZZipPluginIO): ptr TZZipDir {.
+    cdecl, dynlib: dllname, importc: "zzip_opendir_ext_io".}
+proc zzip_dir_open_ext_io*(filename: cstring, errcode_p: ptr TZZipError, 
+                           ext: cstringArray, io: ptr TZZipPluginIO): ptr TZZipDir {.
+    cdecl, dynlib: dllname, importc: "zzip_dir_open_ext_io".}