Merge pull request #523 from exhu/x11fix

X11, cairo bindings fixes

10 files changed, 951 insertions, 1159 deletions

diff --git a/lib/wrappers/cairo/cairo.nim b/lib/wrappers/cairo/cairo.nim
index 8ba5d8b1f..172880529 100644
--- a/lib/wrappers/cairo/cairo.nim
+++ b/lib/wrappers/cairo/cairo.nim
@@ -48,12 +48,7 @@
 #  October 2007
 #
 
-when defined(windows): 
-  const LIB_CAIRO* = "libcairo-2.dll"
-elif defined(macosx):
-  const LIB_CAIRO* = "libcairo.dylib"
-else: 
-  const LIB_CAIRO* = "libcairo.so(|.2)"
+include "cairo_pragma.nim"
 
 type 
   PByte = cstring
@@ -220,499 +215,499 @@ type
     num_rectangles: int32
 
 
-proc version*(): int32{.cdecl, importc: "cairo_version", dynlib: LIB_CAIRO.}
+proc version*(): int32{.cdecl, importc: "cairo_version", libcairo.}
 proc version_string*(): cstring{.cdecl, importc: "cairo_version_string", 
-                                 dynlib: LIB_CAIRO.}
+                                 libcairo.}
   #Helper function to retrieve decoded version
 proc version*(major, minor, micro: var int32)
   #* Functions for manipulating state objects
 proc create*(target: PSurface): PContext{.cdecl, importc: "cairo_create", 
-                                   dynlib: LIB_CAIRO.}
-proc reference*(cr: PContext): PContext{.cdecl, importc: "cairo_reference", dynlib: LIB_CAIRO.}
-proc destroy*(cr: PContext){.cdecl, importc: "cairo_destroy", dynlib: LIB_CAIRO.}
+                                   libcairo.}
+proc reference*(cr: PContext): PContext{.cdecl, importc: "cairo_reference", libcairo.}
+proc destroy*(cr: PContext){.cdecl, importc: "cairo_destroy", libcairo.}
 proc get_reference_count*(cr: PContext): int32{.cdecl, 
-    importc: "cairo_get_reference_count", dynlib: LIB_CAIRO.}
+    importc: "cairo_get_reference_count", libcairo.}
 proc get_user_data*(cr: PContext, key: PUserDataKey): pointer{.cdecl, 
-    importc: "cairo_get_user_data", dynlib: LIB_CAIRO.}
+    importc: "cairo_get_user_data", libcairo.}
 proc set_user_data*(cr: PContext, key: PUserDataKey, user_data: Pointer, 
                     destroy: TDestroyFunc): TStatus{.cdecl, 
-    importc: "cairo_set_user_data", dynlib: LIB_CAIRO.}
-proc save*(cr: PContext){.cdecl, importc: "cairo_save", dynlib: LIB_CAIRO.}
-proc restore*(cr: PContext){.cdecl, importc: "cairo_restore", dynlib: LIB_CAIRO.}
-proc push_group*(cr: PContext){.cdecl, importc: "cairo_push_group", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_user_data", libcairo.}
+proc save*(cr: PContext){.cdecl, importc: "cairo_save", libcairo.}
+proc restore*(cr: PContext){.cdecl, importc: "cairo_restore", libcairo.}
+proc push_group*(cr: PContext){.cdecl, importc: "cairo_push_group", libcairo.}
 proc push_group_with_content*(cr: PContext, content: TContent){.cdecl, 
-    importc: "cairo_push_group_with_content", dynlib: LIB_CAIRO.}
+    importc: "cairo_push_group_with_content", libcairo.}
 proc pop_group*(cr: PContext): PPattern{.cdecl, importc: "cairo_pop_group", 
-                                  dynlib: LIB_CAIRO.}
+                                  libcairo.}
 proc pop_group_to_source*(cr: PContext){.cdecl, importc: "cairo_pop_group_to_source", 
-                                  dynlib: LIB_CAIRO.}
+                                  libcairo.}
   #* Modify state
 proc set_operator*(cr: PContext, op: TOperator){.cdecl, importc: "cairo_set_operator", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc set_source*(cr: PContext, source: PPattern){.cdecl, importc: "cairo_set_source", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc set_source_rgb*(cr: PContext, red, green, blue: float64){.cdecl, 
-    importc: "cairo_set_source_rgb", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_source_rgb", libcairo.}
 proc set_source_rgba*(cr: PContext, red, green, blue, alpha: float64){.cdecl, 
-    importc: "cairo_set_source_rgba", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_source_rgba", libcairo.}
 proc set_source*(cr: PContext, surface: PSurface, x, y: float64){.cdecl, 
-    importc: "cairo_set_source_surface", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_source_surface", libcairo.}
 proc set_tolerance*(cr: PContext, tolerance: float64){.cdecl, 
-    importc: "cairo_set_tolerance", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_tolerance", libcairo.}
 proc set_antialias*(cr: PContext, antialias: TAntialias){.cdecl, 
-    importc: "cairo_set_antialias", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_antialias", libcairo.}
 proc set_fill_rule*(cr: PContext, fill_rule: TFillRule){.cdecl, 
-    importc: "cairo_set_fill_rule", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_fill_rule", libcairo.}
 proc set_line_width*(cr: PContext, width: float64){.cdecl, 
-    importc: "cairo_set_line_width", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_line_width", libcairo.}
 proc set_line_cap*(cr: PContext, line_cap: TLineCap){.cdecl, 
-    importc: "cairo_set_line_cap", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_line_cap", libcairo.}
 proc set_line_join*(cr: PContext, line_join: TLineJoin){.cdecl, 
-    importc: "cairo_set_line_join", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_line_join", libcairo.}
 proc set_dash*(cr: PContext, dashes: openarray[float64], offset: float64){.cdecl, 
-    importc: "cairo_set_dash", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_dash", libcairo.}
 proc set_miter_limit*(cr: PContext, limit: float64){.cdecl, 
-    importc: "cairo_set_miter_limit", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_miter_limit", libcairo.}
 proc translate*(cr: PContext, tx, ty: float64){.cdecl, importc: "cairo_translate", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc scale*(cr: PContext, sx, sy: float64){.cdecl, importc: "cairo_scale", 
-                                     dynlib: LIB_CAIRO.}
+                                     libcairo.}
 proc rotate*(cr: PContext, angle: float64){.cdecl, importc: "cairo_rotate", 
-                                     dynlib: LIB_CAIRO.}
+                                     libcairo.}
 proc transform*(cr: PContext, matrix: PMatrix){.cdecl, importc: "cairo_transform", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc set_matrix*(cr: PContext, matrix: PMatrix){.cdecl, importc: "cairo_set_matrix", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc identity_matrix*(cr: PContext){.cdecl, importc: "cairo_identity_matrix", 
-                              dynlib: LIB_CAIRO.}
+                              libcairo.}
 proc user_to_device*(cr: PContext, x, y: var float64){.cdecl, 
-    importc: "cairo_user_to_device", dynlib: LIB_CAIRO.}
+    importc: "cairo_user_to_device", libcairo.}
 proc user_to_device_distance*(cr: PContext, dx, dy: var float64){.cdecl, 
-    importc: "cairo_user_to_device_distance", dynlib: LIB_CAIRO.}
+    importc: "cairo_user_to_device_distance", libcairo.}
 proc device_to_user*(cr: PContext, x, y: var float64){.cdecl, 
-    importc: "cairo_device_to_user", dynlib: LIB_CAIRO.}
+    importc: "cairo_device_to_user", libcairo.}
 proc device_to_user_distance*(cr: PContext, dx, dy: var float64){.cdecl, 
-    importc: "cairo_device_to_user_distance", dynlib: LIB_CAIRO.}
+    importc: "cairo_device_to_user_distance", libcairo.}
   #* Path creation functions
-proc new_path*(cr: PContext){.cdecl, importc: "cairo_new_path", dynlib: LIB_CAIRO.}
+proc new_path*(cr: PContext){.cdecl, importc: "cairo_new_path", libcairo.}
 proc move_to*(cr: PContext, x, y: float64){.cdecl, importc: "cairo_move_to", 
-                                     dynlib: LIB_CAIRO.}
+                                     libcairo.}
 proc new_sub_path*(cr: PContext){.cdecl, importc: "cairo_new_sub_path", 
-                           dynlib: LIB_CAIRO.}
+                           libcairo.}
 proc line_to*(cr: PContext, x, y: float64){.cdecl, importc: "cairo_line_to", 
-                                     dynlib: LIB_CAIRO.}
+                                     libcairo.}
 proc curve_to*(cr: PContext, x1, y1, x2, y2, x3, y3: float64){.cdecl, 
-    importc: "cairo_curve_to", dynlib: LIB_CAIRO.}
+    importc: "cairo_curve_to", libcairo.}
 proc arc*(cr: PContext, xc, yc, radius, angle1, angle2: float64){.cdecl, 
-    importc: "cairo_arc", dynlib: LIB_CAIRO.}
+    importc: "cairo_arc", libcairo.}
 proc arc_negative*(cr: PContext, xc, yc, radius, angle1, angle2: float64){.cdecl, 
-    importc: "cairo_arc_negative", dynlib: LIB_CAIRO.}
+    importc: "cairo_arc_negative", libcairo.}
 proc rel_move_to*(cr: PContext, dx, dy: float64){.cdecl, importc: "cairo_rel_move_to", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc rel_line_to*(cr: PContext, dx, dy: float64){.cdecl, importc: "cairo_rel_line_to", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc rel_curve_to*(cr: PContext, dx1, dy1, dx2, dy2, dx3, dy3: float64){.cdecl, 
-    importc: "cairo_rel_curve_to", dynlib: LIB_CAIRO.}
+    importc: "cairo_rel_curve_to", libcairo.}
 proc rectangle*(cr: PContext, x, y, width, height: float64){.cdecl, 
-    importc: "cairo_rectangle", dynlib: LIB_CAIRO.}
-proc close_path*(cr: PContext){.cdecl, importc: "cairo_close_path", dynlib: LIB_CAIRO.}
+    importc: "cairo_rectangle", libcairo.}
+proc close_path*(cr: PContext){.cdecl, importc: "cairo_close_path", libcairo.}
   #* Painting functions
-proc paint*(cr: PContext){.cdecl, importc: "cairo_paint", dynlib: LIB_CAIRO.}
+proc paint*(cr: PContext){.cdecl, importc: "cairo_paint", libcairo.}
 proc paint_with_alpha*(cr: PContext, alpha: float64){.cdecl, 
-    importc: "cairo_paint_with_alpha", dynlib: LIB_CAIRO.}
+    importc: "cairo_paint_with_alpha", libcairo.}
 proc mask*(cr: PContext, pattern: PPattern){.cdecl, importc: "cairo_mask", 
-                                      dynlib: LIB_CAIRO.}
+                                      libcairo.}
 proc mask*(cr: PContext, surface: PSurface, surface_x, surface_y: float64){.
-    cdecl, importc: "cairo_mask_surface", dynlib: LIB_CAIRO.}
-proc stroke*(cr: PContext){.cdecl, importc: "cairo_stroke", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_mask_surface", libcairo.}
+proc stroke*(cr: PContext){.cdecl, importc: "cairo_stroke", libcairo.}
 proc stroke_preserve*(cr: PContext){.cdecl, importc: "cairo_stroke_preserve", 
-                              dynlib: LIB_CAIRO.}
-proc fill*(cr: PContext){.cdecl, importc: "cairo_fill", dynlib: LIB_CAIRO.}
+                              libcairo.}
+proc fill*(cr: PContext){.cdecl, importc: "cairo_fill", libcairo.}
 proc fill_preserve*(cr: PContext){.cdecl, importc: "cairo_fill_preserve", 
-                            dynlib: LIB_CAIRO.}
-proc copy_page*(cr: PContext){.cdecl, importc: "cairo_copy_page", dynlib: LIB_CAIRO.}
-proc show_page*(cr: PContext){.cdecl, importc: "cairo_show_page", dynlib: LIB_CAIRO.}
+                            libcairo.}
+proc copy_page*(cr: PContext){.cdecl, importc: "cairo_copy_page", libcairo.}
+proc show_page*(cr: PContext){.cdecl, importc: "cairo_show_page", libcairo.}
   #* Insideness testing
 proc in_stroke*(cr: PContext, x, y: float64): TBool{.cdecl, importc: "cairo_in_stroke", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc in_fill*(cr: PContext, x, y: float64): TBool{.cdecl, importc: "cairo_in_fill", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
   #* Rectangular extents
 proc stroke_extents*(cr: PContext, x1, y1, x2, y2: var float64){.cdecl, 
-    importc: "cairo_stroke_extents", dynlib: LIB_CAIRO.}
+    importc: "cairo_stroke_extents", libcairo.}
 proc fill_extents*(cr: PContext, x1, y1, x2, y2: var float64){.cdecl, 
-    importc: "cairo_fill_extents", dynlib: LIB_CAIRO.}
+    importc: "cairo_fill_extents", libcairo.}
   #* Clipping
-proc reset_clip*(cr: PContext){.cdecl, importc: "cairo_reset_clip", dynlib: LIB_CAIRO.}
-proc clip*(cr: PContext){.cdecl, importc: "cairo_clip", dynlib: LIB_CAIRO.}
+proc reset_clip*(cr: PContext){.cdecl, importc: "cairo_reset_clip", libcairo.}
+proc clip*(cr: PContext){.cdecl, importc: "cairo_clip", libcairo.}
 proc clip_preserve*(cr: PContext){.cdecl, importc: "cairo_clip_preserve", 
-                            dynlib: LIB_CAIRO.}
+                            libcairo.}
 proc clip_extents*(cr: PContext, x1, y1, x2, y2: var float64){.cdecl, 
-    importc: "cairo_clip_extents", dynlib: LIB_CAIRO.}
+    importc: "cairo_clip_extents", libcairo.}
 proc copy_clip_rectangle_list*(cr: PContext): PRectangleList{.cdecl, 
-    importc: "cairo_copy_clip_rectangle_list", dynlib: LIB_CAIRO.}
+    importc: "cairo_copy_clip_rectangle_list", libcairo.}
 proc rectangle_list_destroy*(rectangle_list: PRectangleList){.cdecl, 
-    importc: "cairo_rectangle_list_destroy", dynlib: LIB_CAIRO.}
+    importc: "cairo_rectangle_list_destroy", libcairo.}
   #* Font/Text functions
 proc font_options_create*(): PFontOptions{.cdecl, 
-    importc: "cairo_font_options_create", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_create", libcairo.}
 proc copy*(original: PFontOptions): PFontOptions{.cdecl, 
-    importc: "cairo_font_options_copy", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_copy", libcairo.}
 proc destroy*(options: PFontOptions){.cdecl, 
-    importc: "cairo_font_options_destroy", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_destroy", libcairo.}
 proc status*(options: PFontOptions): TStatus{.cdecl, 
-    importc: "cairo_font_options_status", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_status", libcairo.}
 proc merge*(options, other: PFontOptions){.cdecl, 
-    importc: "cairo_font_options_merge", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_merge", libcairo.}
 proc equal*(options, other: PFontOptions): TBool{.cdecl, 
-    importc: "cairo_font_options_equal", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_equal", libcairo.}
 proc hash*(options: PFontOptions): int32{.cdecl, 
-    importc: "cairo_font_options_hash", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_hash", libcairo.}
 proc set_antialias*(options: PFontOptions, antialias: TAntialias){.
-    cdecl, importc: "cairo_font_options_set_antialias", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_font_options_set_antialias", libcairo.}
 proc get_antialias*(options: PFontOptions): TAntialias{.cdecl, 
-    importc: "cairo_font_options_get_antialias", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_get_antialias", libcairo.}
 proc set_subpixel_order*(options: PFontOptions, 
                                       subpixel_order: TSubpixelOrder){.cdecl, 
-    importc: "cairo_font_options_set_subpixel_order", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_set_subpixel_order", libcairo.}
 proc get_subpixel_order*(options: PFontOptions): TSubpixelOrder{.
-    cdecl, importc: "cairo_font_options_get_subpixel_order", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_font_options_get_subpixel_order", libcairo.}
 proc set_hint_style*(options: PFontOptions, hint_style: THintStyle){.
-    cdecl, importc: "cairo_font_options_set_hint_style", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_font_options_set_hint_style", libcairo.}
 proc get_hint_style*(options: PFontOptions): THintStyle{.cdecl, 
-    importc: "cairo_font_options_get_hint_style", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_get_hint_style", libcairo.}
 proc set_hint_metrics*(options: PFontOptions, 
                                     hint_metrics: THintMetrics){.cdecl, 
-    importc: "cairo_font_options_set_hint_metrics", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_set_hint_metrics", libcairo.}
 proc get_hint_metrics*(options: PFontOptions): THintMetrics{.cdecl, 
-    importc: "cairo_font_options_get_hint_metrics", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_options_get_hint_metrics", libcairo.}
   #* This interface is for dealing with text as text, not caring about the
   #   font object inside the the TCairo.
 proc select_font_face*(cr: PContext, family: cstring, slant: TFontSlant, 
                        weight: TFontWeight){.cdecl, 
-    importc: "cairo_select_font_face", dynlib: LIB_CAIRO.}
+    importc: "cairo_select_font_face", libcairo.}
 proc set_font_size*(cr: PContext, size: float64){.cdecl, 
-    importc: "cairo_set_font_size", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_font_size", libcairo.}
 proc set_font_matrix*(cr: PContext, matrix: PMatrix){.cdecl, 
-    importc: "cairo_set_font_matrix", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_font_matrix", libcairo.}
 proc get_font_matrix*(cr: PContext, matrix: PMatrix){.cdecl, 
-    importc: "cairo_get_font_matrix", dynlib: LIB_CAIRO.}
+    importc: "cairo_get_font_matrix", libcairo.}
 proc set_font_options*(cr: PContext, options: PFontOptions){.cdecl, 
-    importc: "cairo_set_font_options", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_font_options", libcairo.}
 proc get_font_options*(cr: PContext, options: PFontOptions){.cdecl, 
-    importc: "cairo_get_font_options", dynlib: LIB_CAIRO.}
+    importc: "cairo_get_font_options", libcairo.}
 proc set_font_face*(cr: PContext, font_face: PFontFace){.cdecl, 
-    importc: "cairo_set_font_face", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_font_face", libcairo.}
 proc get_font_face*(cr: PContext): PFontFace{.cdecl, importc: "cairo_get_font_face", 
-                                       dynlib: LIB_CAIRO.}
+                                       libcairo.}
 proc set_scaled_font*(cr: PContext, scaled_font: PScaledFont){.cdecl, 
-    importc: "cairo_set_scaled_font", dynlib: LIB_CAIRO.}
+    importc: "cairo_set_scaled_font", libcairo.}
 proc get_scaled_font*(cr: PContext): PScaledFont{.cdecl, 
-    importc: "cairo_get_scaled_font", dynlib: LIB_CAIRO.}
+    importc: "cairo_get_scaled_font", libcairo.}
 proc show_text*(cr: PContext, utf8: cstring){.cdecl, importc: "cairo_show_text", 
-                                       dynlib: LIB_CAIRO.}
+                                       libcairo.}
 proc show_glyphs*(cr: PContext, glyphs: PGlyph, num_glyphs: int32){.cdecl, 
-    importc: "cairo_show_glyphs", dynlib: LIB_CAIRO.}
+    importc: "cairo_show_glyphs", libcairo.}
 proc text_path*(cr: PContext, utf8: cstring){.cdecl, importc: "cairo_text_path", 
-                                       dynlib: LIB_CAIRO.}
+                                       libcairo.}
 proc glyph_path*(cr: PContext, glyphs: PGlyph, num_glyphs: int32){.cdecl, 
-    importc: "cairo_glyph_path", dynlib: LIB_CAIRO.}
+    importc: "cairo_glyph_path", libcairo.}
 proc text_extents*(cr: PContext, utf8: cstring, extents: PTextExtents){.cdecl, 
-    importc: "cairo_text_extents", dynlib: LIB_CAIRO.}
+    importc: "cairo_text_extents", libcairo.}
 proc glyph_extents*(cr: PContext, glyphs: PGlyph, num_glyphs: int32, 
                     extents: PTextExtents){.cdecl, 
-    importc: "cairo_glyph_extents", dynlib: LIB_CAIRO.}
+    importc: "cairo_glyph_extents", libcairo.}
 proc font_extents*(cr: PContext, extents: PFontExtents){.cdecl, 
-    importc: "cairo_font_extents", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_extents", libcairo.}
   #* Generic identifier for a font style
 proc reference*(font_face: PFontFace): PFontFace{.cdecl, 
-    importc: "cairo_font_face_reference", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_face_reference", libcairo.}
 proc destroy*(font_face: PFontFace){.cdecl, 
-    importc: "cairo_font_face_destroy", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_face_destroy", libcairo.}
 proc get_reference_count*(font_face: PFontFace): int32{.cdecl, 
-    importc: "cairo_font_face_get_reference_count", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_face_get_reference_count", libcairo.}
 proc status*(font_face: PFontFace): TStatus{.cdecl, 
-    importc: "cairo_font_face_status", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_face_status", libcairo.}
 proc get_type*(font_face: PFontFace): TFontType{.cdecl, 
-    importc: "cairo_font_face_get_type", dynlib: LIB_CAIRO.}
+    importc: "cairo_font_face_get_type", libcairo.}
 proc get_user_data*(font_face: PFontFace, key: PUserDataKey): pointer{.
-    cdecl, importc: "cairo_font_face_get_user_data", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_font_face_get_user_data", libcairo.}
 proc set_user_data*(font_face: PFontFace, key: PUserDataKey, 
                     user_data: pointer, destroy: TDestroyFunc): TStatus{.
-    cdecl, importc: "cairo_font_face_set_user_data", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_font_face_set_user_data", libcairo.}
   #* Portable interface to general font features
 proc scaled_font_create*(font_face: PFontFace, font_matrix: PMatrix, 
                          ctm: PMatrix, options: PFontOptions): PScaledFont{.
-    cdecl, importc: "cairo_scaled_font_create", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_scaled_font_create", libcairo.}
 proc reference*(scaled_font: PScaledFont): PScaledFont{.cdecl, 
-    importc: "cairo_scaled_font_reference", dynlib: LIB_CAIRO.}
+    importc: "cairo_scaled_font_reference", libcairo.}
 proc destroy*(scaled_font: PScaledFont){.cdecl, 
-    importc: "cairo_scaled_font_destroy", dynlib: LIB_CAIRO.}
+    importc: "cairo_scaled_font_destroy", libcairo.}
 proc get_reference_count*(scaled_font: PScaledFont): int32{.cdecl, 
-    importc: "cairo_scaled_font_get_reference_count", dynlib: LIB_CAIRO.}
+    importc: "cairo_scaled_font_get_reference_count", libcairo.}
 proc status*(scaled_font: PScaledFont): TStatus{.cdecl, 
-    importc: "cairo_scaled_font_status", dynlib: LIB_CAIRO.}
+    importc: "cairo_scaled_font_status", libcairo.}
 proc get_type*(scaled_font: PScaledFont): TFontType{.cdecl, 
-    importc: "cairo_scaled_font_get_type", dynlib: LIB_CAIRO.}
+    importc: "cairo_scaled_font_get_type", libcairo.}
 proc get_user_data*(scaled_font: PScaledFont, key: PUserDataKey): Pointer{.
-    cdecl, importc: "cairo_scaled_font_get_user_data", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_scaled_font_get_user_data", libcairo.}
 proc set_user_data*(scaled_font: PScaledFont, key: PUserDataKey, 
                     user_data: Pointer, destroy: TDestroyFunc): TStatus{.
-    cdecl, importc: "cairo_scaled_font_set_user_data", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_scaled_font_set_user_data", libcairo.}
 proc extents*(scaled_font: PScaledFont, extents: PFontExtents){.
-    cdecl, importc: "cairo_scaled_font_extents", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_scaled_font_extents", libcairo.}
 proc text_extents*(scaled_font: PScaledFont, utf8: cstring, 
                    extents: PTextExtents){.cdecl, 
-    importc: "cairo_scaled_font_text_extents", dynlib: LIB_CAIRO.}
+    importc: "cairo_scaled_font_text_extents", libcairo.}
 proc glyph_extents*(scaled_font: PScaledFont, glyphs: PGlyph, 
                                 num_glyphs: int32, extents: PTextExtents){.
-    cdecl, importc: "cairo_scaled_font_glyph_extents", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_scaled_font_glyph_extents", libcairo.}
 proc get_font_face*(scaled_font: PScaledFont): PFontFace{.cdecl, 
-    importc: "cairo_scaled_font_get_font_face", dynlib: LIB_CAIRO.}
+    importc: "cairo_scaled_font_get_font_face", libcairo.}
 proc get_font_matrix*(scaled_font: PScaledFont, font_matrix: PMatrix){.
-    cdecl, importc: "cairo_scaled_font_get_font_matrix", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_scaled_font_get_font_matrix", libcairo.}
 proc get_ctm*(scaled_font: PScaledFont, ctm: PMatrix){.cdecl, 
-    importc: "cairo_scaled_font_get_ctm", dynlib: LIB_CAIRO.}
+    importc: "cairo_scaled_font_get_ctm", libcairo.}
 proc get_font_options*(scaled_font: PScaledFont, 
                                    options: PFontOptions){.cdecl, 
-    importc: "cairo_scaled_font_get_font_options", dynlib: LIB_CAIRO.}
+    importc: "cairo_scaled_font_get_font_options", libcairo.}
   #* Query functions
 proc get_operator*(cr: PContext): TOperator{.cdecl, importc: "cairo_get_operator", 
-                                      dynlib: LIB_CAIRO.}
+                                      libcairo.}
 proc get_source*(cr: PContext): PPattern{.cdecl, importc: "cairo_get_source", 
-                                   dynlib: LIB_CAIRO.}
+                                   libcairo.}
 proc get_tolerance*(cr: PContext): float64{.cdecl, importc: "cairo_get_tolerance", 
-                                     dynlib: LIB_CAIRO.}
+                                     libcairo.}
 proc get_antialias*(cr: PContext): TAntialias{.cdecl, importc: "cairo_get_antialias", 
-                                        dynlib: LIB_CAIRO.}
+                                        libcairo.}
 proc get_current_point*(cr: PContext, x, y: var float64){.cdecl, 
-    importc: "cairo_get_current_point", dynlib: LIB_CAIRO.}
+    importc: "cairo_get_current_point", libcairo.}
 proc get_fill_rule*(cr: PContext): TFillRule{.cdecl, importc: "cairo_get_fill_rule", 
-                                       dynlib: LIB_CAIRO.}
+                                       libcairo.}
 proc get_line_width*(cr: PContext): float64{.cdecl, importc: "cairo_get_line_width", 
-                                      dynlib: LIB_CAIRO.}
+                                      libcairo.}
 proc get_line_cap*(cr: PContext): TLineCap{.cdecl, importc: "cairo_get_line_cap", 
-                                     dynlib: LIB_CAIRO.}
+                                     libcairo.}
 proc get_line_join*(cr: PContext): TLineJoin{.cdecl, importc: "cairo_get_line_join", 
-                                       dynlib: LIB_CAIRO.}
+                                       libcairo.}
 proc get_miter_limit*(cr: PContext): float64{.cdecl, importc: "cairo_get_miter_limit", 
-                                       dynlib: LIB_CAIRO.}
+                                       libcairo.}
 proc get_dash_count*(cr: PContext): int32{.cdecl, importc: "cairo_get_dash_count", 
-                                    dynlib: LIB_CAIRO.}
+                                    libcairo.}
 proc get_dash*(cr: PContext, dashes, offset: var float64){.cdecl, 
-    importc: "cairo_get_dash", dynlib: LIB_CAIRO.}
+    importc: "cairo_get_dash", libcairo.}
 proc get_matrix*(cr: PContext, matrix: PMatrix){.cdecl, importc: "cairo_get_matrix", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc get_target*(cr: PContext): PSurface{.cdecl, importc: "cairo_get_target", 
-                                   dynlib: LIB_CAIRO.}
+                                   libcairo.}
 proc get_group_target*(cr: PContext): PSurface{.cdecl, 
-    importc: "cairo_get_group_target", dynlib: LIB_CAIRO.}
+    importc: "cairo_get_group_target", libcairo.}
 proc copy_path*(cr: PContext): PPath{.cdecl, importc: "cairo_copy_path", 
-                               dynlib: LIB_CAIRO.}
+                               libcairo.}
 proc copy_path_flat*(cr: PContext): PPath{.cdecl, importc: "cairo_copy_path_flat", 
-                                    dynlib: LIB_CAIRO.}
+                                    libcairo.}
 proc append_path*(cr: PContext, path: PPath){.cdecl, importc: "cairo_append_path", 
-                                       dynlib: LIB_CAIRO.}
+                                       libcairo.}
 proc destroy*(path: PPath){.cdecl, importc: "cairo_path_destroy", 
-                                 dynlib: LIB_CAIRO.}
+                                 libcairo.}
   #* Error status queries
-proc status*(cr: PContext): TStatus{.cdecl, importc: "cairo_status", dynlib: LIB_CAIRO.}
+proc status*(cr: PContext): TStatus{.cdecl, importc: "cairo_status", libcairo.}
 proc status_to_string*(status: TStatus): cstring{.cdecl, 
-    importc: "cairo_status_to_string", dynlib: LIB_CAIRO.}
+    importc: "cairo_status_to_string", libcairo.}
   #* Surface manipulation
 proc surface_create_similar*(other: PSurface, content: TContent, 
                              width, height: int32): PSurface{.cdecl, 
-    importc: "cairo_surface_create_similar", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_create_similar", libcairo.}
 proc reference*(surface: PSurface): PSurface{.cdecl, 
-    importc: "cairo_surface_reference", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_reference", libcairo.}
 proc finish*(surface: PSurface){.cdecl, importc: "cairo_surface_finish", 
-    dynlib: LIB_CAIRO.}
+    libcairo.}
 proc destroy*(surface: PSurface){.cdecl, 
-    importc: "cairo_surface_destroy", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_destroy", libcairo.}
 proc get_reference_count*(surface: PSurface): int32{.cdecl, 
-    importc: "cairo_surface_get_reference_count", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_get_reference_count", libcairo.}
 proc status*(surface: PSurface): TStatus{.cdecl, 
-    importc: "cairo_surface_status", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_status", libcairo.}
 proc get_type*(surface: PSurface): TSurfaceType{.cdecl, 
-    importc: "cairo_surface_get_type", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_get_type", libcairo.}
 proc get_content*(surface: PSurface): TContent{.cdecl, 
-    importc: "cairo_surface_get_content", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_get_content", libcairo.}
 proc write_to_png*(surface: PSurface, filename: cstring): TStatus{.
-    cdecl, importc: "cairo_surface_write_to_png", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_surface_write_to_png", libcairo.}
 proc write_to_png*(surface: PSurface, write_func: TWriteFunc, 
                    closure: pointer): TStatus{.cdecl, 
-    importc: "cairo_surface_write_to_png_stream", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_write_to_png_stream", libcairo.}
 proc get_user_data*(surface: PSurface, key: PUserDataKey): pointer{.
-    cdecl, importc: "cairo_surface_get_user_data", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_surface_get_user_data", libcairo.}
 proc set_user_data*(surface: PSurface, key: PUserDataKey, 
                             user_data: pointer, destroy: TDestroyFunc): TStatus{.
-    cdecl, importc: "cairo_surface_set_user_data", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_surface_set_user_data", libcairo.}
 proc get_font_options*(surface: PSurface, options: PFontOptions){.cdecl, 
-    importc: "cairo_surface_get_font_options", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_get_font_options", libcairo.}
 proc flush*(surface: PSurface){.cdecl, importc: "cairo_surface_flush", 
-                                        dynlib: LIB_CAIRO.}
+                                        libcairo.}
 proc mark_dirty*(surface: PSurface){.cdecl, 
-    importc: "cairo_surface_mark_dirty", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_mark_dirty", libcairo.}
 proc mark_dirty_rectangle*(surface: PSurface, x, y, width, height: int32){.
-    cdecl, importc: "cairo_surface_mark_dirty_rectangle", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_surface_mark_dirty_rectangle", libcairo.}
 proc set_device_offset*(surface: PSurface, x_offset, y_offset: float64){.
-    cdecl, importc: "cairo_surface_set_device_offset", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_surface_set_device_offset", libcairo.}
 proc get_device_offset*(surface: PSurface, 
                                 x_offset, y_offset: var float64){.cdecl, 
-    importc: "cairo_surface_get_device_offset", dynlib: LIB_CAIRO.}
+    importc: "cairo_surface_get_device_offset", libcairo.}
 proc set_fallback_resolution*(surface: PSurface, x_pixels_per_inch, 
     y_pixels_per_inch: float64){.cdecl, importc: "cairo_surface_set_fallback_resolution", 
-                                 dynlib: LIB_CAIRO.}
+                                 libcairo.}
   #* Image-surface functions
 proc image_surface_create*(format: TFormat, width, height: int32): PSurface{.
-    cdecl, importc: "cairo_image_surface_create", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_image_surface_create", libcairo.}
 proc image_surface_create*(data: Pbyte, format: TFormat, 
                            width, height, stride: int32): PSurface{.
-    cdecl, importc: "cairo_image_surface_create_for_data", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_image_surface_create_for_data", libcairo.}
 proc get_data*(surface: PSurface): cstring{.cdecl, 
-    importc: "cairo_image_surface_get_data", dynlib: LIB_CAIRO.}
+    importc: "cairo_image_surface_get_data", libcairo.}
 proc get_format*(surface: PSurface): TFormat{.cdecl, 
-    importc: "cairo_image_surface_get_format", dynlib: LIB_CAIRO.}
+    importc: "cairo_image_surface_get_format", libcairo.}
 proc get_width*(surface: PSurface): int32{.cdecl, 
-    importc: "cairo_image_surface_get_width", dynlib: LIB_CAIRO.}
+    importc: "cairo_image_surface_get_width", libcairo.}
 proc get_height*(surface: PSurface): int32{.cdecl, 
-    importc: "cairo_image_surface_get_height", dynlib: LIB_CAIRO.}
+    importc: "cairo_image_surface_get_height", libcairo.}
 proc get_stride*(surface: PSurface): int32{.cdecl, 
-    importc: "cairo_image_surface_get_stride", dynlib: LIB_CAIRO.}
+    importc: "cairo_image_surface_get_stride", libcairo.}
 proc image_surface_create_from_png*(filename: cstring): PSurface{.cdecl, 
-    importc: "cairo_image_surface_create_from_png", dynlib: LIB_CAIRO.}
+    importc: "cairo_image_surface_create_from_png", libcairo.}
 proc image_surface_create_from_png*(read_func: TReadFunc, 
     closure: pointer): PSurface{.cdecl, importc: "cairo_image_surface_create_from_png_stream", 
-                                 dynlib: LIB_CAIRO.}
+                                 libcairo.}
   #* Pattern creation functions
 proc pattern_create_rgb*(red, green, blue: float64): PPattern{.cdecl, 
-    importc: "cairo_pattern_create_rgb", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_create_rgb", libcairo.}
 proc pattern_create_rgba*(red, green, blue, alpha: float64): PPattern{.cdecl, 
-    importc: "cairo_pattern_create_rgba", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_create_rgba", libcairo.}
 proc pattern_create_for_surface*(surface: PSurface): PPattern{.cdecl, 
-    importc: "cairo_pattern_create_for_surface", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_create_for_surface", libcairo.}
 proc pattern_create_linear*(x0, y0, x1, y1: float64): PPattern{.cdecl, 
-    importc: "cairo_pattern_create_linear", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_create_linear", libcairo.}
 proc pattern_create_radial*(cx0, cy0, radius0, cx1, cy1, radius1: float64): PPattern{.
-    cdecl, importc: "cairo_pattern_create_radial", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_create_radial", libcairo.}
 proc reference*(pattern: PPattern): PPattern{.cdecl, 
-    importc: "cairo_pattern_reference", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_reference", libcairo.}
 proc destroy*(pattern: PPattern){.cdecl, 
-    importc: "cairo_pattern_destroy", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_destroy", libcairo.}
 proc get_reference_count*(pattern: PPattern): int32{.cdecl, 
-    importc: "cairo_pattern_get_reference_count", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_get_reference_count", libcairo.}
 proc status*(pattern: PPattern): TStatus{.cdecl, 
-    importc: "cairo_pattern_status", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_status", libcairo.}
 proc get_user_data*(pattern: PPattern, key: PUserDataKey): Pointer{.
-    cdecl, importc: "cairo_pattern_get_user_data", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_get_user_data", libcairo.}
 proc set_user_data*(pattern: PPattern, key: PUserDataKey, 
                     user_data: Pointer, destroy: TDestroyFunc): TStatus{.
-    cdecl, importc: "cairo_pattern_set_user_data", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_set_user_data", libcairo.}
 proc get_type*(pattern: PPattern): TPatternType{.cdecl, 
-    importc: "cairo_pattern_get_type", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_get_type", libcairo.}
 proc add_color_stop_rgb*(pattern: PPattern, 
                                  offset, red, green, blue: float64){.cdecl, 
-    importc: "cairo_pattern_add_color_stop_rgb", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_add_color_stop_rgb", libcairo.}
 proc add_color_stop_rgba*(pattern: PPattern, 
                                   offset, red, green, blue, alpha: float64){.
-    cdecl, importc: "cairo_pattern_add_color_stop_rgba", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_add_color_stop_rgba", libcairo.}
 proc set_matrix*(pattern: PPattern, matrix: PMatrix){.cdecl, 
-    importc: "cairo_pattern_set_matrix", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_set_matrix", libcairo.}
 proc get_matrix*(pattern: PPattern, matrix: PMatrix){.cdecl, 
-    importc: "cairo_pattern_get_matrix", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_get_matrix", libcairo.}
 proc set_extend*(pattern: PPattern, extend: TExtend){.cdecl, 
-    importc: "cairo_pattern_set_extend", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_set_extend", libcairo.}
 proc get_extend*(pattern: PPattern): TExtend{.cdecl, 
-    importc: "cairo_pattern_get_extend", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_get_extend", libcairo.}
 proc set_filter*(pattern: PPattern, filter: TFilter){.cdecl, 
-    importc: "cairo_pattern_set_filter", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_set_filter", libcairo.}
 proc get_filter*(pattern: PPattern): TFilter{.cdecl, 
-    importc: "cairo_pattern_get_filter", dynlib: LIB_CAIRO.}
+    importc: "cairo_pattern_get_filter", libcairo.}
 proc get_rgba*(pattern: PPattern, 
                red, green, blue, alpha: var float64): TStatus{.
-    cdecl, importc: "cairo_pattern_get_rgba", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_get_rgba", libcairo.}
 proc get_surface*(pattern: PPattern, surface: PPSurface): TStatus{.
-    cdecl, importc: "cairo_pattern_get_surface", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_get_surface", libcairo.}
 proc get_color_stop_rgba*(pattern: PPattern, index: int32, 
                        offset, red, green, blue, alpha: var float64): TStatus{.
-    cdecl, importc: "cairo_pattern_get_color_stop_rgba", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_get_color_stop_rgba", libcairo.}
 proc get_color_stop_count*(pattern: PPattern, count: var int32): TStatus{.
-    cdecl, importc: "cairo_pattern_get_color_stop_count", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_get_color_stop_count", libcairo.}
 proc get_linear_points*(pattern: PPattern, 
                         x0, y0, x1, y1: var float64): TStatus{.
-    cdecl, importc: "cairo_pattern_get_linear_points", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_get_linear_points", libcairo.}
 proc get_radial_circles*(pattern: PPattern, 
                          x0, y0, r0, x1, y1, r1: var float64): TStatus{.
-    cdecl, importc: "cairo_pattern_get_radial_circles", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pattern_get_radial_circles", libcairo.}
   #* Matrix functions
 proc init*(matrix: PMatrix, xx, yx, xy, yy, x0, y0: float64){.cdecl, 
-    importc: "cairo_matrix_init", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_init", libcairo.}
 proc init_identity*(matrix: PMatrix){.cdecl, 
-    importc: "cairo_matrix_init_identity", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_init_identity", libcairo.}
 proc init_translate*(matrix: PMatrix, tx, ty: float64){.cdecl, 
-    importc: "cairo_matrix_init_translate", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_init_translate", libcairo.}
 proc init_scale*(matrix: PMatrix, sx, sy: float64){.cdecl, 
-    importc: "cairo_matrix_init_scale", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_init_scale", libcairo.}
 proc init_rotate*(matrix: PMatrix, radians: float64){.cdecl, 
-    importc: "cairo_matrix_init_rotate", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_init_rotate", libcairo.}
 proc translate*(matrix: PMatrix, tx, ty: float64){.cdecl, 
-    importc: "cairo_matrix_translate", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_translate", libcairo.}
 proc scale*(matrix: PMatrix, sx, sy: float64){.cdecl, 
-    importc: "cairo_matrix_scale", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_scale", libcairo.}
 proc rotate*(matrix: PMatrix, radians: float64){.cdecl, 
-    importc: "cairo_matrix_rotate", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_rotate", libcairo.}
 proc invert*(matrix: PMatrix): TStatus{.cdecl, 
-    importc: "cairo_matrix_invert", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_invert", libcairo.}
 proc multiply*(result, a, b: PMatrix){.cdecl, 
-    importc: "cairo_matrix_multiply", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_multiply", libcairo.}
 proc transform_distance*(matrix: PMatrix, dx, dy: var float64){.cdecl, 
-    importc: "cairo_matrix_transform_distance", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_transform_distance", libcairo.}
 proc transform_point*(matrix: PMatrix, x, y: var float64){.cdecl, 
-    importc: "cairo_matrix_transform_point", dynlib: LIB_CAIRO.}
+    importc: "cairo_matrix_transform_point", libcairo.}
   #* PDF functions
 proc pdf_surface_create*(filename: cstring, 
                          width_in_points, height_in_points: float64): PSurface{.
-    cdecl, importc: "cairo_pdf_surface_create", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pdf_surface_create", libcairo.}
 proc pdf_surface_create_for_stream*(write_func: TWriteFunc, closure: Pointer, 
                                     width_in_points, height_in_points: float64): PSurface{.
-    cdecl, importc: "cairo_pdf_surface_create_for_stream", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_pdf_surface_create_for_stream", libcairo.}
 proc pdf_surface_set_size*(surface: PSurface, 
                            width_in_points, height_in_points: float64){.cdecl, 
-    importc: "cairo_pdf_surface_set_size", dynlib: LIB_CAIRO.}
+    importc: "cairo_pdf_surface_set_size", libcairo.}
   #* PS functions
 proc ps_surface_create*(filename: cstring, 
                         width_in_points, height_in_points: float64): PSurface{.
-    cdecl, importc: "cairo_ps_surface_create", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_ps_surface_create", libcairo.}
 proc ps_surface_create_for_stream*(write_func: TWriteFunc, closure: Pointer, 
                                    width_in_points, height_in_points: float64): PSurface{.
-    cdecl, importc: "cairo_ps_surface_create_for_stream", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_ps_surface_create_for_stream", libcairo.}
 proc ps_surface_set_size*(surface: PSurface, 
                           width_in_points, height_in_points: float64){.cdecl, 
-    importc: "cairo_ps_surface_set_size", dynlib: LIB_CAIRO.}
+    importc: "cairo_ps_surface_set_size", libcairo.}
 proc ps_surface_dsc_comment*(surface: PSurface, comment: cstring){.cdecl, 
-    importc: "cairo_ps_surface_dsc_comment", dynlib: LIB_CAIRO.}
+    importc: "cairo_ps_surface_dsc_comment", libcairo.}
 proc ps_surface_dsc_begin_setup*(surface: PSurface){.cdecl, 
-    importc: "cairo_ps_surface_dsc_begin_setup", dynlib: LIB_CAIRO.}
+    importc: "cairo_ps_surface_dsc_begin_setup", libcairo.}
 proc ps_surface_dsc_begin_page_setup*(surface: PSurface){.cdecl, 
-    importc: "cairo_ps_surface_dsc_begin_page_setup", dynlib: LIB_CAIRO.}
+    importc: "cairo_ps_surface_dsc_begin_page_setup", libcairo.}
   #* SVG functions
 proc svg_surface_create*(filename: cstring, 
                          width_in_points, height_in_points: float64): PSurface{.
-    cdecl, importc: "cairo_svg_surface_create", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_svg_surface_create", libcairo.}
 proc svg_surface_create_for_stream*(write_func: TWriteFunc, closure: Pointer, 
                                     width_in_points, height_in_points: float64): PSurface{.
-    cdecl, importc: "cairo_svg_surface_create_for_stream", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_svg_surface_create_for_stream", libcairo.}
 proc svg_surface_restrict_to_version*(surface: PSurface, version: TSvgVersion){.
-    cdecl, importc: "cairo_svg_surface_restrict_to_version", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_svg_surface_restrict_to_version", libcairo.}
   #todo: see how translate this
   #procedure cairo_svg_get_versions(TCairoSvgVersion const	**versions,
   #                        int                      	 *num_versions);
 proc svg_version_to_string*(version: TSvgVersion): cstring{.cdecl, 
-    importc: "cairo_svg_version_to_string", dynlib: LIB_CAIRO.}
+    importc: "cairo_svg_version_to_string", libcairo.}
   #* Functions to be used while debugging (not intended for use in production code)
 proc debug_reset_static_data*(){.cdecl, 
                                  importc: "cairo_debug_reset_static_data", 
-                                 dynlib: LIB_CAIRO.}
+                                 libcairo.}
 # implementation
 
 proc version(major, minor, micro: var int32) = 
diff --git a/lib/wrappers/cairo/cairo_pragma.nim b/lib/wrappers/cairo/cairo_pragma.nim
new file mode 100644
index 000000000..11bf237f9
--- /dev/null
+++ b/lib/wrappers/cairo/cairo_pragma.nim
@@ -0,0 +1,16 @@
+# included by cairo bindings
+
+when defined(use_pkg_config) or defined(use_pkg_config_static):
+    {.pragma: libcairo, cdecl.}
+    when defined(use_pkg_config_static):
+        {.passl: gorge("pkg-config cairo --libs --static").}
+    else:
+        {.passl: gorge("pkg-config cairo --libs").}
+else:
+    when defined(windows): 
+      const LIB_CAIRO* = "libcairo-2.dll"
+    elif defined(macosx):
+      const LIB_CAIRO* = "libcairo.dylib"
+    else: 
+      const LIB_CAIRO* = "libcairo.so(|.2)"
+    {.pragma: libcairo, cdecl, dynlib: LIB_CAIRO.}
diff --git a/lib/wrappers/cairo/cairoft.nim b/lib/wrappers/cairo/cairoft.nim
index 16a80e7f7..5f4e47662 100644
--- a/lib/wrappers/cairo/cairoft.nim
+++ b/lib/wrappers/cairo/cairoft.nim
@@ -7,6 +7,7 @@
 import 
   cairo, freetypeh
 
+include "cairo_pragma.nim"
 #todo: properly define FcPattern:
 #It will require translate FontConfig header
 
@@ -23,13 +24,13 @@ type
   FcPattern* = Pointer
   PFcPattern* = ptr FcPattern
 
-proc ft_font_face_create_for_pattern*(pattern: PFcPattern): PFontFace{.cdecl, 
-    importc: "cairo_ft_font_face_create_for_pattern", dynlib: LIB_CAIRO.}
+proc ft_font_face_create_for_pattern*(pattern: PFcPattern): PFontFace{.libcairo,
+    importc: "cairo_ft_font_face_create_for_pattern".}
 proc ft_font_options_substitute*(options: PFontOptions, pattern: PFcPattern){.
-    cdecl, importc: "cairo_ft_font_options_substitute", dynlib: LIB_CAIRO.}
-proc ft_font_face_create_for_ft_face*(face: TFT_Face, load_flags: int32): PFontFace{.
-    cdecl, importc: "cairo_ft_font_face_create_for_ft_face", dynlib: LIB_CAIRO.}
-proc ft_scaled_font_lock_face*(scaled_font: PScaledFont): TFT_Face{.cdecl, 
-    importc: "cairo_ft_scaled_font_lock_face", dynlib: LIB_CAIRO.}
-proc ft_scaled_font_unlock_face*(scaled_font: PScaledFont){.cdecl, 
-    importc: "cairo_ft_scaled_font_unlock_face", dynlib: LIB_CAIRO.}
+    libcairo, importc: "cairo_ft_font_options_substitute".}
+proc ft_font_face_create_for_ft_face*(face: TFT_Face, load_flags: int32): PFontFace{.libcairo,
+    importc: "cairo_ft_font_face_create_for_ft_face".}
+proc ft_scaled_font_lock_face*(scaled_font: PScaledFont): TFT_Face{.libcairo,
+    importc: "cairo_ft_scaled_font_lock_face".}
+proc ft_scaled_font_unlock_face*(scaled_font: PScaledFont){.libcairo,
+    importc: "cairo_ft_scaled_font_unlock_face".}
diff --git a/lib/wrappers/cairo/cairoxlib.nim b/lib/wrappers/cairo/cairoxlib.nim
index 861c55527..273a8b42f 100644
--- a/lib/wrappers/cairo/cairoxlib.nim
+++ b/lib/wrappers/cairo/cairoxlib.nim
@@ -7,33 +7,35 @@
 import 
   cairo, x, xlib, xrender
 
+include "cairo_pragma.nim"
+
 proc xlib_surface_create*(dpy: PDisplay, drawable: TDrawable, visual: PVisual, 
                           width, height: int32): PSurface{.cdecl, 
-    importc: "cairo_xlib_surface_create", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_create", libcairo.}
 proc xlib_surface_create_for_bitmap*(dpy: PDisplay, bitmap: TPixmap, 
                                      screen: PScreen, width, height: int32): PSurface{.
-    cdecl, importc: "cairo_xlib_surface_create_for_bitmap", dynlib: LIB_CAIRO.}
+    cdecl, importc: "cairo_xlib_surface_create_for_bitmap", libcairo.}
 proc xlib_surface_create_with_xrender_format*(dpy: PDisplay, 
     drawable: TDrawable, screen: PScreen, format: PXRenderPictFormat, 
     width, height: int32): PSurface{.cdecl, importc: "cairo_xlib_surface_create_with_xrender_format", 
-                                     dynlib: LIB_CAIRO.}
+                                     libcairo.}
 proc xlib_surface_get_depth*(surface: PSurface): int32{.cdecl, 
-    importc: "cairo_xlib_surface_get_depth", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_get_depth", libcairo.}
 proc xlib_surface_get_display*(surface: PSurface): PDisplay{.cdecl, 
-    importc: "cairo_xlib_surface_get_display", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_get_display", libcairo.}
 proc xlib_surface_get_drawable*(surface: PSurface): TDrawable{.cdecl, 
-    importc: "cairo_xlib_surface_get_drawable", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_get_drawable", libcairo.}
 proc xlib_surface_get_height*(surface: PSurface): int32{.cdecl, 
-    importc: "cairo_xlib_surface_get_height", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_get_height", libcairo.}
 proc xlib_surface_get_screen*(surface: PSurface): PScreen{.cdecl, 
-    importc: "cairo_xlib_surface_get_screen", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_get_screen", libcairo.}
 proc xlib_surface_get_visual*(surface: PSurface): PVisual{.cdecl, 
-    importc: "cairo_xlib_surface_get_visual", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_get_visual", libcairo.}
 proc xlib_surface_get_width*(surface: PSurface): int32{.cdecl, 
-    importc: "cairo_xlib_surface_get_width", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_get_width", libcairo.}
 proc xlib_surface_set_size*(surface: PSurface, width, height: int32){.cdecl, 
-    importc: "cairo_xlib_surface_set_size", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_set_size", libcairo.}
 proc xlib_surface_set_drawable*(surface: PSurface, drawable: TDrawable, 
                                 width, height: int32){.cdecl, 
-    importc: "cairo_xlib_surface_set_drawable", dynlib: LIB_CAIRO.}
+    importc: "cairo_xlib_surface_set_drawable", libcairo.}
 # implementation
diff --git a/lib/wrappers/x11/x.nim b/lib/wrappers/x11/x.nim
index 5763f9f16..2eefe311f 100644
--- a/lib/wrappers/x11/x.nim
+++ b/lib/wrappers/x11/x.nim
@@ -10,6 +10,7 @@
 #    x.h
 #
 # Pointers to basic pascal types, inserted by h2pas conversion program.
+import unsigned
 
 const 
   X_PROTOCOL* = 11
@@ -47,6 +48,9 @@ type
   PKeyCode* = ptr TKeyCode
   TKeyCode* = cuchar
 
+proc `==`*(a, b: TAtom): bool =
+    return unsigned.`==`(a,b)
+
 const 
   None* = 0
   ParentRelative* = 1
diff --git a/lib/wrappers/x11/x11pragma.nim b/lib/wrappers/x11/x11pragma.nim
new file mode 100644
index 000000000..bc88fb004
--- /dev/null
+++ b/lib/wrappers/x11/x11pragma.nim
@@ -0,0 +1,20 @@
+# included from xlib bindings
+
+
+when defined(use_pkg_config) or defined(use_pkg_config_static):
+    {.pragma: libx11, cdecl, importc.}
+    {.pragma: libx11c, cdecl.}
+    when defined(use_pkg_config_static):
+        {.passl: gorge("pkg-config x11 --static --libs").}
+    else:
+        {.passl: gorge("pkg-config x11 --libs").}
+else:
+    when defined(macosx):
+        const 
+          libX11* = "libX11.dylib"
+    else:
+        const 
+          libX11* = "libX11.so"
+
+    {.pragma: libx11, cdecl, dynlib: libX11, importc.}
+    {.pragma: libx11c, cdecl, dynlib: libX11.}
diff --git a/lib/wrappers/x11/xkb.nim b/lib/wrappers/x11/xkb.nim
index f1b0448a8..86296430a 100644
--- a/lib/wrappers/x11/xkb.nim
+++ b/lib/wrappers/x11/xkb.nim
@@ -71,6 +71,8 @@
 import 
   X, Xlib
 
+include "x11pragma.nim"
+
 proc XkbCharToInt*(v: int8): int16
 proc XkbIntTo2Chars*(i: int16, h, L: var int8)
 proc Xkb2CharsToInt*(h, L: int8): int16
@@ -1700,224 +1702,200 @@ proc XkbSetKeyShape*(g: PXkbGeometryPtr, k: PXkbKeyPtr, s: PXkbShapeDoodadPtr)
 proc XkbSetKeyColor*(g: PXkbGeometryPtr, k: PXkbKeyPtr, c: PXkbColorPtr)
 proc XkbGeomColorIndex*(g: PXkbGeometryPtr, c: PXkbColorPtr): int32
 proc XkbAddGeomProperty*(geom: PXkbGeometryPtr, name: cstring, value: cstring): PXkbPropertyPtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddGeomProperty".}
+    libx11c, importc: "XkbAddGeomProperty".}
 proc XkbAddGeomKeyAlias*(geom: PXkbGeometryPtr, alias: cstring, float: cstring): PXkbKeyAliasPtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddGeomKeyAlias".}
+    libx11c, importc: "XkbAddGeomKeyAlias".}
 proc XkbAddGeomColor*(geom: PXkbGeometryPtr, spec: cstring, pixel: int16): PXkbColorPtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddGeomColor".}
+    libx11c, importc: "XkbAddGeomColor".}
 proc XkbAddGeomOutline*(shape: PXkbShapePtr, sz_points: int16): PXkbOutlinePtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddGeomOutline".}
+    libx11c, importc: "XkbAddGeomOutline".}
 proc XkbAddGeomShape*(geom: PXkbGeometryPtr, name: TAtom, sz_outlines: int16): PXkbShapePtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddGeomShape".}
-proc XkbAddGeomKey*(row: PXkbRowPtr): PXkbKeyPtr{.cdecl, dynlib: libX11, 
+    libx11c, importc: "XkbAddGeomShape".}
+proc XkbAddGeomKey*(row: PXkbRowPtr): PXkbKeyPtr{.libx11c, 
     importc: "XkbAddGeomKey".}
-proc XkbAddGeomRow*(section: PXkbSectionPtr, sz_keys: int16): PXkbRowPtr{.cdecl, 
-    dynlib: libX11, importc: "XkbAddGeomRow".}
+proc XkbAddGeomRow*(section: PXkbSectionPtr, sz_keys: int16): PXkbRowPtr{.libx11c, importc: "XkbAddGeomRow".}
 proc XkbAddGeomSection*(geom: PXkbGeometryPtr, name: TAtom, sz_rows: int16, 
                         sz_doodads: int16, sz_overlays: int16): PXkbSectionPtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddGeomSection".}
+    libx11c, importc: "XkbAddGeomSection".}
 proc XkbAddGeomOverlay*(section: PXkbSectionPtr, name: TAtom, sz_rows: int16): PXkbOverlayPtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddGeomOverlay".}
+    libx11c, importc: "XkbAddGeomOverlay".}
 proc XkbAddGeomOverlayRow*(overlay: PXkbOverlayPtr, row_under: int16, 
-                           sz_keys: int16): PXkbOverlayRowPtr{.cdecl, 
-    dynlib: libX11, importc: "XkbAddGeomOverlayRow".}
+                           sz_keys: int16): PXkbOverlayRowPtr{.libx11c, importc: "XkbAddGeomOverlayRow".}
 proc XkbAddGeomOverlayKey*(overlay: PXkbOverlayPtr, row: PXkbOverlayRowPtr, 
                            over: cstring, under: cstring): PXkbOverlayKeyPtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddGeomOverlayKey".}
+    libx11c, importc: "XkbAddGeomOverlayKey".}
 proc XkbAddGeomDoodad*(geom: PXkbGeometryPtr, section: PXkbSectionPtr, 
-                       name: TAtom): PXkbDoodadPtr{.cdecl, dynlib: libX11, 
+                       name: TAtom): PXkbDoodadPtr{.libx11c, 
     importc: "XkbAddGeomDoodad".}
 proc XkbFreeGeomKeyAliases*(geom: PXkbGeometryPtr, first: int16, count: int16, 
-                            freeAll: bool){.cdecl, dynlib: libX11, 
+                            freeAll: bool){.libx11c, 
     importc: "XkbFreeGeomKeyAliases".}
 proc XkbFreeGeomColors*(geom: PXkbGeometryPtr, first: int16, count: int16, 
-                        freeAll: bool){.cdecl, dynlib: libX11, 
+                        freeAll: bool){.libx11c, 
                                         importc: "XkbFreeGeomColors".}
 proc XkbFreeGeomDoodads*(doodads: PXkbDoodadPtr, nDoodads: int16, freeAll: bool){.
-    cdecl, dynlib: libX11, importc: "XkbFreeGeomDoodads".}
+    libx11c, importc: "XkbFreeGeomDoodads".}
 proc XkbFreeGeomProperties*(geom: PXkbGeometryPtr, first: int16, count: int16, 
-                            freeAll: bool){.cdecl, dynlib: libX11, 
+                            freeAll: bool){.libx11c, 
     importc: "XkbFreeGeomProperties".}
 proc XkbFreeGeomOverlayKeys*(row: PXkbOverlayRowPtr, first: int16, count: int16, 
-                             freeAll: bool){.cdecl, dynlib: libX11, 
+                             freeAll: bool){.libx11c, 
     importc: "XkbFreeGeomOverlayKeys".}
 proc XkbFreeGeomOverlayRows*(overlay: PXkbOverlayPtr, first: int16, 
-                             count: int16, freeAll: bool){.cdecl, 
-    dynlib: libX11, importc: "XkbFreeGeomOverlayRows".}
+                             count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlayRows".}
 proc XkbFreeGeomOverlays*(section: PXkbSectionPtr, first: int16, count: int16, 
-                          freeAll: bool){.cdecl, dynlib: libX11, 
+                          freeAll: bool){.libx11c, 
     importc: "XkbFreeGeomOverlays".}
 proc XkbFreeGeomKeys*(row: PXkbRowPtr, first: int16, count: int16, freeAll: bool){.
-    cdecl, dynlib: libX11, importc: "XkbFreeGeomKeys".}
+    libx11c, importc: "XkbFreeGeomKeys".}
 proc XkbFreeGeomRows*(section: PXkbSectionPtr, first: int16, count: int16, 
-                      freeAll: bool){.cdecl, dynlib: libX11, 
+                      freeAll: bool){.libx11c, 
                                       importc: "XkbFreeGeomRows".}
 proc XkbFreeGeomSections*(geom: PXkbGeometryPtr, first: int16, count: int16, 
-                          freeAll: bool){.cdecl, dynlib: libX11, 
+                          freeAll: bool){.libx11c, 
     importc: "XkbFreeGeomSections".}
 proc XkbFreeGeomPoints*(outline: PXkbOutlinePtr, first: int16, count: int16, 
-                        freeAll: bool){.cdecl, dynlib: libX11, 
+                        freeAll: bool){.libx11c, 
                                         importc: "XkbFreeGeomPoints".}
 proc XkbFreeGeomOutlines*(shape: PXkbShapePtr, first: int16, count: int16, 
-                          freeAll: bool){.cdecl, dynlib: libX11, 
+                          freeAll: bool){.libx11c, 
     importc: "XkbFreeGeomOutlines".}
 proc XkbFreeGeomShapes*(geom: PXkbGeometryPtr, first: int16, count: int16, 
-                        freeAll: bool){.cdecl, dynlib: libX11, 
+                        freeAll: bool){.libx11c, 
                                         importc: "XkbFreeGeomShapes".}
 proc XkbFreeGeometry*(geom: PXkbGeometryPtr, which: int16, freeMap: bool){.
-    cdecl, dynlib: libX11, importc: "XkbFreeGeometry".}
-proc XkbAllocGeomProps*(geom: PXkbGeometryPtr, nProps: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbAllocGeomProps".}
+    libx11c, importc: "XkbFreeGeometry".}
+proc XkbAllocGeomProps*(geom: PXkbGeometryPtr, nProps: int16): TStatus{.libx11c, importc: "XkbAllocGeomProps".}
 proc XkbAllocGeomKeyAliases*(geom: PXkbGeometryPtr, nAliases: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbAllocGeomKeyAliases".}
-proc XkbAllocGeomColors*(geom: PXkbGeometryPtr, nColors: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbAllocGeomColors".}
-proc XkbAllocGeomShapes*(geom: PXkbGeometryPtr, nShapes: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbAllocGeomShapes".}
+    libx11c, importc: "XkbAllocGeomKeyAliases".}
+proc XkbAllocGeomColors*(geom: PXkbGeometryPtr, nColors: int16): TStatus{.libx11c, importc: "XkbAllocGeomColors".}
+proc XkbAllocGeomShapes*(geom: PXkbGeometryPtr, nShapes: int16): TStatus{.libx11c, importc: "XkbAllocGeomShapes".}
 proc XkbAllocGeomSections*(geom: PXkbGeometryPtr, nSections: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbAllocGeomSections".}
+    libx11c, importc: "XkbAllocGeomSections".}
 proc XkbAllocGeomOverlays*(section: PXkbSectionPtr, num_needed: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbAllocGeomOverlays".}
+    libx11c, importc: "XkbAllocGeomOverlays".}
 proc XkbAllocGeomOverlayRows*(overlay: PXkbOverlayPtr, num_needed: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbAllocGeomOverlayRows".}
+    libx11c, importc: "XkbAllocGeomOverlayRows".}
 proc XkbAllocGeomOverlayKeys*(row: PXkbOverlayRowPtr, num_needed: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbAllocGeomOverlayKeys".}
+    libx11c, importc: "XkbAllocGeomOverlayKeys".}
 proc XkbAllocGeomDoodads*(geom: PXkbGeometryPtr, nDoodads: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbAllocGeomDoodads".}
+    libx11c, importc: "XkbAllocGeomDoodads".}
 proc XkbAllocGeomSectionDoodads*(section: PXkbSectionPtr, nDoodads: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbAllocGeomSectionDoodads".}
-proc XkbAllocGeomOutlines*(shape: PXkbShapePtr, nOL: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbAllocGeomOutlines".}
-proc XkbAllocGeomRows*(section: PXkbSectionPtr, nRows: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbAllocGeomRows".}
-proc XkbAllocGeomPoints*(ol: PXkbOutlinePtr, nPts: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbAllocGeomPoints".}
-proc XkbAllocGeomKeys*(row: PXkbRowPtr, nKeys: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbAllocGeomKeys".}
+    libx11c, importc: "XkbAllocGeomSectionDoodads".}
+proc XkbAllocGeomOutlines*(shape: PXkbShapePtr, nOL: int16): TStatus{.libx11c, importc: "XkbAllocGeomOutlines".}
+proc XkbAllocGeomRows*(section: PXkbSectionPtr, nRows: int16): TStatus{.libx11c, importc: "XkbAllocGeomRows".}
+proc XkbAllocGeomPoints*(ol: PXkbOutlinePtr, nPts: int16): TStatus{.libx11c, importc: "XkbAllocGeomPoints".}
+proc XkbAllocGeomKeys*(row: PXkbRowPtr, nKeys: int16): TStatus{.libx11c, importc: "XkbAllocGeomKeys".}
 proc XkbAllocGeometry*(xkb: PXkbDescPtr, sizes: PXkbGeometrySizesPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbAllocGeometry".}
+    libx11c, importc: "XkbAllocGeometry".}
 proc XkbSetGeometryProc*(dpy: PDisplay, deviceSpec: int16, geom: PXkbGeometryPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbSetGeometry".}
+    libx11c, importc: "XkbSetGeometry".}
 proc XkbComputeShapeTop*(shape: PXkbShapePtr, bounds: PXkbBoundsPtr): bool{.
-    cdecl, dynlib: libX11, importc: "XkbComputeShapeTop".}
-proc XkbComputeShapeBounds*(shape: PXkbShapePtr): bool{.cdecl, dynlib: libX11, 
+    libx11c, importc: "XkbComputeShapeTop".}
+proc XkbComputeShapeBounds*(shape: PXkbShapePtr): bool{.libx11c, 
     importc: "XkbComputeShapeBounds".}
 proc XkbComputeRowBounds*(geom: PXkbGeometryPtr, section: PXkbSectionPtr, 
-                          row: PXkbRowPtr): bool{.cdecl, dynlib: libX11, 
+                          row: PXkbRowPtr): bool{.libx11c, 
     importc: "XkbComputeRowBounds".}
 proc XkbComputeSectionBounds*(geom: PXkbGeometryPtr, section: PXkbSectionPtr): bool{.
-    cdecl, dynlib: libX11, importc: "XkbComputeSectionBounds".}
+    libx11c, importc: "XkbComputeSectionBounds".}
 proc XkbFindOverlayForKey*(geom: PXkbGeometryPtr, wanted: PXkbSectionPtr, 
-                           under: cstring): cstring{.cdecl, dynlib: libX11, 
+                           under: cstring): cstring{.libx11c, 
     importc: "XkbFindOverlayForKey".}
-proc XkbGetGeometryProc*(dpy: PDisplay, xkb: PXkbDescPtr): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbGetGeometry".}
+proc XkbGetGeometryProc*(dpy: PDisplay, xkb: PXkbDescPtr): TStatus{.libx11c, importc: "XkbGetGeometry".}
 proc XkbGetNamedGeometry*(dpy: PDisplay, xkb: PXkbDescPtr, name: TAtom): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetNamedGeometry".}
+    libx11c, importc: "XkbGetNamedGeometry".}
 when defined(XKB_IN_SERVER): 
   proc SrvXkbAddGeomKeyAlias*(geom: PXkbGeometryPtr, alias: cstring, 
-                              float: cstring): PXkbKeyAliasPtr{.cdecl, 
-      dynlib: libX11, importc: "XkbAddGeomKeyAlias".}
+                              float: cstring): PXkbKeyAliasPtr{.libx11c, importc: "XkbAddGeomKeyAlias".}
   proc SrvXkbAddGeomColor*(geom: PXkbGeometryPtr, spec: cstring, pixel: int16): PXkbColorPtr{.
-      cdecl, dynlib: libX11, importc: "XkbAddGeomColor".}
+      libx11c, importc: "XkbAddGeomColor".}
   proc SrvXkbAddGeomDoodad*(geom: PXkbGeometryPtr, section: PXkbSectionPtr, 
-                            name: TAtom): PXkbDoodadPtr{.cdecl, dynlib: libX11, 
+                            name: TAtom): PXkbDoodadPtr{.libx11c, 
       importc: "XkbAddGeomDoodad".}
   proc SrvXkbAddGeomKey*(geom: PXkbGeometryPtr, alias: cstring, float: cstring): PXkbKeyAliasPtr{.
-      cdecl, dynlib: libX11, importc: "XkbAddGeomKeyAlias".}
+      libx11c, importc: "XkbAddGeomKeyAlias".}
   proc SrvXkbAddGeomOutline*(shape: PXkbShapePtr, sz_points: int16): PXkbOutlinePtr{.
-      cdecl, dynlib: libX11, importc: "XkbAddGeomOutline".}
+      libx11c, importc: "XkbAddGeomOutline".}
   proc SrvXkbAddGeomOverlay*(overlay: PXkbOverlayPtr, row: PXkbOverlayRowPtr, 
                              over: cstring, under: cstring): PXkbOverlayKeyPtr{.
-      cdecl, dynlib: libX11, importc: "XkbAddGeomOverlayKey".}
+      libx11c, importc: "XkbAddGeomOverlayKey".}
   proc SrvXkbAddGeomOverlayRow*(overlay: PXkbOverlayPtr, row_under: int16, 
-                                sz_keys: int16): PXkbOverlayRowPtr{.cdecl, 
-      dynlib: libX11, importc: "XkbAddGeomOverlayRow".}
+                                sz_keys: int16): PXkbOverlayRowPtr{.libx11c, importc: "XkbAddGeomOverlayRow".}
   proc SrvXkbAddGeomOverlayKey*(overlay: PXkbOverlayPtr, row: PXkbOverlayRowPtr, 
                                 over: cstring, under: cstring): PXkbOverlayKeyPtr{.
-      cdecl, dynlib: libX11, importc: "XkbAddGeomOverlayKey".}
+      libx11c, importc: "XkbAddGeomOverlayKey".}
   proc SrvXkbAddGeomProperty*(geom: PXkbGeometryPtr, name: cstring, 
-                              value: cstring): PXkbPropertyPtr{.cdecl, 
-      dynlib: libX11, importc: "XkbAddGeomProperty".}
+                              value: cstring): PXkbPropertyPtr{.libx11c, importc: "XkbAddGeomProperty".}
   proc SrvXkbAddGeomRow*(section: PXkbSectionPtr, sz_keys: int16): PXkbRowPtr{.
-      cdecl, dynlib: libX11, importc: "XkbAddGeomRow".}
+      libx11c, importc: "XkbAddGeomRow".}
   proc SrvXkbAddGeomSection*(geom: PXkbGeometryPtr, name: TAtom, sz_rows: int16, 
                              sz_doodads: int16, sz_overlays: int16): PXkbSectionPtr{.
-      cdecl, dynlib: libX11, importc: "XkbAddGeomSection".}
+      libx11c, importc: "XkbAddGeomSection".}
   proc SrvXkbAddGeomShape*(geom: PXkbGeometryPtr, name: TAtom, 
-                           sz_outlines: int16): PXkbShapePtr{.cdecl, 
-      dynlib: libX11, importc: "XkbAddGeomShape".}
+                           sz_outlines: int16): PXkbShapePtr{.libx11c, importc: "XkbAddGeomShape".}
   proc SrvXkbAllocGeomKeyAliases*(geom: PXkbGeometryPtr, nAliases: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomKeyAliases".}
+      libx11c, importc: "XkbAllocGeomKeyAliases".}
   proc SrvXkbAllocGeomColors*(geom: PXkbGeometryPtr, nColors: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomColors".}
+      libx11c, importc: "XkbAllocGeomColors".}
   proc SrvXkbAllocGeomDoodads*(geom: PXkbGeometryPtr, nDoodads: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomDoodads".}
-  proc SrvXkbAllocGeomKeys*(row: PXkbRowPtr, nKeys: int16): TStatus{.cdecl, 
-      dynlib: libX11, importc: "XkbAllocGeomKeys".}
+      libx11c, importc: "XkbAllocGeomDoodads".}
+  proc SrvXkbAllocGeomKeys*(row: PXkbRowPtr, nKeys: int16): TStatus{.libx11c, importc: "XkbAllocGeomKeys".}
   proc SrvXkbAllocGeomOutlines*(shape: PXkbShapePtr, nOL: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomOutlines".}
-  proc SrvXkbAllocGeomPoints*(ol: PXkbOutlinePtr, nPts: int16): TStatus{.cdecl, 
-      dynlib: libX11, importc: "XkbAllocGeomPoints".}
+      libx11c, importc: "XkbAllocGeomOutlines".}
+  proc SrvXkbAllocGeomPoints*(ol: PXkbOutlinePtr, nPts: int16): TStatus{.libx11c, importc: "XkbAllocGeomPoints".}
   proc SrvXkbAllocGeomProps*(geom: PXkbGeometryPtr, nProps: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomProps".}
+      libx11c, importc: "XkbAllocGeomProps".}
   proc SrvXkbAllocGeomRows*(section: PXkbSectionPtr, nRows: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomRows".}
+      libx11c, importc: "XkbAllocGeomRows".}
   proc SrvXkbAllocGeomSectionDoodads*(section: PXkbSectionPtr, nDoodads: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomSectionDoodads".}
+      libx11c, importc: "XkbAllocGeomSectionDoodads".}
   proc SrvXkbAllocGeomSections*(geom: PXkbGeometryPtr, nSections: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomSections".}
+      libx11c, importc: "XkbAllocGeomSections".}
   proc SrvXkbAllocGeomOverlays*(section: PXkbSectionPtr, num_needed: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomOverlays".}
+      libx11c, importc: "XkbAllocGeomOverlays".}
   proc SrvXkbAllocGeomOverlayRows*(overlay: PXkbOverlayPtr, num_needed: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomOverlayRows".}
+      libx11c, importc: "XkbAllocGeomOverlayRows".}
   proc SrvXkbAllocGeomOverlayKeys*(row: PXkbOverlayRowPtr, num_needed: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomOverlayKeys".}
+      libx11c, importc: "XkbAllocGeomOverlayKeys".}
   proc SrvXkbAllocGeomShapes*(geom: PXkbGeometryPtr, nShapes: int16): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeomShapes".}
+      libx11c, importc: "XkbAllocGeomShapes".}
   proc SrvXkbAllocGeometry*(xkb: PXkbDescPtr, sizes: PXkbGeometrySizesPtr): TStatus{.
-      cdecl, dynlib: libX11, importc: "XkbAllocGeometry".}
+      libx11c, importc: "XkbAllocGeometry".}
   proc SrvXkbFreeGeomKeyAliases*(geom: PXkbGeometryPtr, first: int16, 
-                                 count: int16, freeAll: bool){.cdecl, 
-      dynlib: libX11, importc: "XkbFreeGeomKeyAliases".}
+                                 count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomKeyAliases".}
   proc SrvXkbFreeGeomColors*(geom: PXkbGeometryPtr, first: int16, count: int16, 
-                             freeAll: bool){.cdecl, dynlib: libX11, 
+                             freeAll: bool){.libx11c, 
       importc: "XkbFreeGeomColors".}
   proc SrvXkbFreeGeomDoodads*(doodads: PXkbDoodadPtr, nDoodads: int16, 
-                              freeAll: bool){.cdecl, dynlib: libX11, 
+                              freeAll: bool){.libx11c, 
       importc: "XkbFreeGeomDoodads".}
   proc SrvXkbFreeGeomProperties*(geom: PXkbGeometryPtr, first: int16, 
-                                 count: int16, freeAll: bool){.cdecl, 
-      dynlib: libX11, importc: "XkbFreeGeomProperties".}
+                                 count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomProperties".}
   proc SrvXkbFreeGeomOverlayKeys*(row: PXkbOverlayRowPtr, first: int16, 
-                                  count: int16, freeAll: bool){.cdecl, 
-      dynlib: libX11, importc: "XkbFreeGeomOverlayKeys".}
+                                  count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlayKeys".}
   proc SrvXkbFreeGeomOverlayRows*(overlay: PXkbOverlayPtr, first: int16, 
-                                  count: int16, freeAll: bool){.cdecl, 
-      dynlib: libX11, importc: "XkbFreeGeomOverlayRows".}
+                                  count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlayRows".}
   proc SrvXkbFreeGeomOverlays*(section: PXkbSectionPtr, first: int16, 
-                               count: int16, freeAll: bool){.cdecl, 
-      dynlib: libX11, importc: "XkbFreeGeomOverlays".}
+                               count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlays".}
   proc SrvXkbFreeGeomKeys*(row: PXkbRowPtr, first: int16, count: int16, 
-                           freeAll: bool){.cdecl, dynlib: libX11, 
+                           freeAll: bool){.libx11c, 
       importc: "XkbFreeGeomKeys".}
   proc SrvXkbFreeGeomRows*(section: PXkbSectionPtr, first: int16, count: int16, 
-                           freeAll: bool){.cdecl, dynlib: libX11, 
+                           freeAll: bool){.libx11c, 
       importc: "XkbFreeGeomRows".}
   proc SrvXkbFreeGeomSections*(geom: PXkbGeometryPtr, first: int16, 
-                               count: int16, freeAll: bool){.cdecl, 
-      dynlib: libX11, importc: "XkbFreeGeomSections".}
+                               count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomSections".}
   proc SrvXkbFreeGeomPoints*(outline: PXkbOutlinePtr, first: int16, 
-                             count: int16, freeAll: bool){.cdecl, 
-      dynlib: libX11, importc: "XkbFreeGeomPoints".}
+                             count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomPoints".}
   proc SrvXkbFreeGeomOutlines*(shape: PXkbShapePtr, first: int16, count: int16, 
-                               freeAll: bool){.cdecl, dynlib: libX11, 
+                               freeAll: bool){.libx11c, 
       importc: "XkbFreeGeomOutlines".}
   proc SrvXkbFreeGeomShapes*(geom: PXkbGeometryPtr, first: int16, count: int16, 
-                             freeAll: bool){.cdecl, dynlib: libX11, 
+                             freeAll: bool){.libx11c, 
       importc: "XkbFreeGeomShapes".}
   proc SrvXkbFreeGeometry*(geom: PXkbGeometryPtr, which: int16, freeMap: bool){.
-      cdecl, dynlib: libX11, importc: "XkbFreeGeometry".}
+      libx11c, importc: "XkbFreeGeometry".}
 # implementation
 
 import                        #************************************ xkb ************************************
diff --git a/lib/wrappers/x11/xkblib.nim b/lib/wrappers/x11/xkblib.nim
index 92d438a60..1b450f289 100644
--- a/lib/wrappers/x11/xkblib.nim
+++ b/lib/wrappers/x11/xkblib.nim
@@ -52,6 +52,10 @@
 import 
   X, Xlib, XKB
 
+
+include "x11pragma.nim"
+
+
 type 
   PXkbAnyEvent* = ptr TXkbAnyEvent
   TXkbAnyEvent*{.final.} = object 
@@ -338,21 +342,18 @@ const
   XkbLC_AllComposeControls* = 0xC0000000
   XkbLC_AllControls* = 0xC000001F
 
-proc XkbIgnoreExtension*(ignore: bool): bool{.cdecl, dynlib: libX11, 
+proc XkbIgnoreExtension*(ignore: bool): bool{.libx11c, 
     importc: "XkbIgnoreExtension".}
 proc XkbOpenDisplay*(name: cstring, ev_rtrn, err_rtrn, major_rtrn, minor_rtrn, 
-                                    reason: ptr int16): PDisplay{.cdecl, 
-    dynlib: libX11, importc: "XkbOpenDisplay".}
+                                    reason: ptr int16): PDisplay{.libx11c, importc: "XkbOpenDisplay".}
 proc XkbQueryExtension*(dpy: PDisplay, opcodeReturn, eventBaseReturn, 
                                        errorBaseReturn, majorRtrn, minorRtrn: ptr int16): bool{.
-    cdecl, dynlib: libX11, importc: "XkbQueryExtension".}
+    libx11c, 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, 
+    libx11c, importc: "XkbUseExtension".}
+proc XkbLibraryVersion*(libMajorRtrn, libMinorRtrn: ptr int16): bool{.libx11c, importc: "XkbLibraryVersion".}
+proc XkbSetXlibControls*(dpy: PDisplay, affect, values: int16): int16{.libx11c, importc: "XkbSetXlibControls".}
+proc XkbGetXlibControls*(dpy: PDisplay): int16{.libx11c, 
     importc: "XkbGetXlibControls".}
 type 
   TXkbInternAtomFunc* = proc (dpy: PDisplay, name: cstring, only_if_exists: bool): TAtom{.
@@ -362,68 +363,64 @@ type
   TXkbGetAtomNameFunc* = proc (dpy: PDisplay, atom: TAtom): cstring{.cdecl.}
 
 proc XkbSetAtomFuncs*(getAtom: TXkbInternAtomFunc, getName: TXkbGetAtomNameFunc){.
-    cdecl, dynlib: libX11, importc: "XkbSetAtomFuncs".}
+    libx11c, 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".}
+    libx11c, importc: "XkbKeycodeToKeysym".}
+proc XkbKeysymToModifiers*(dpy: PDisplay, ks: TKeySym): int16{.libx11c, importc: "XkbKeysymToModifiers".}
 proc XkbLookupKeySym*(dpy: PDisplay, keycode: TKeyCode, 
                       modifiers, modifiers_return: int16, keysym_return: PKeySym): bool{.
-    cdecl, dynlib: libX11, importc: "XkbLookupKeySym".}
+    libx11c, 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".}
+    libx11c, importc: "XkbLookupKeyBinding".}
 proc XkbTranslateKeyCode*(xkb: PXkbDescPtr, keycode: TKeyCode, 
                           modifiers, modifiers_return: int16, 
-                          keysym_return: PKeySym): bool{.cdecl, dynlib: libX11, 
+                          keysym_return: PKeySym): bool{.libx11c, 
     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".}
+    libx11c, importc: "XkbTranslateKeySym".}
 proc XkbSetAutoRepeatRate*(dpy: PDisplay, deviceSpec, delay, interval: int16): bool{.
-    cdecl, dynlib: libX11, importc: "XkbSetAutoRepeatRate".}
+    libx11c, importc: "XkbSetAutoRepeatRate".}
 proc XkbGetAutoRepeatRate*(dpy: PDisplay, deviceSpec: int16, 
-                           delayRtrn, intervalRtrn: PWord): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbGetAutoRepeatRate".}
+                           delayRtrn, intervalRtrn: PWord): bool{.libx11c, importc: "XkbGetAutoRepeatRate".}
 proc XkbChangeEnabledControls*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{.
-    cdecl, dynlib: libX11, importc: "XkbChangeEnabledControls".}
+    libx11c, importc: "XkbChangeEnabledControls".}
 proc XkbDeviceBell*(dpy: PDisplay, win: TWindow, 
                     deviceSpec, bellClass, bellID, percent: int16, name: TAtom): bool{.
-    cdecl, dynlib: libX11, importc: "XkbDeviceBell".}
+    libx11c, importc: "XkbDeviceBell".}
 proc XkbForceDeviceBell*(dpy: PDisplay, 
                          deviceSpec, bellClass, bellID, percent: int16): bool{.
-    cdecl, dynlib: libX11, importc: "XkbForceDeviceBell".}
+    libx11c, importc: "XkbForceDeviceBell".}
 proc XkbDeviceBellEvent*(dpy: PDisplay, win: TWindow, 
                          deviceSpec, bellClass, bellID, percent: int16, 
-                         name: TAtom): bool{.cdecl, dynlib: libX11, 
+                         name: TAtom): bool{.libx11c, 
     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, 
+    libx11c, importc: "XkbBell".}
+proc XkbForceBell*(dpy: PDisplay, percent: int16): bool{.libx11c, 
     importc: "XkbForceBell".}
 proc XkbBellEvent*(dpy: PDisplay, win: TWindow, percent: int16, name: TAtom): bool{.
-    cdecl, dynlib: libX11, importc: "XkbBellEvent".}
+    libx11c, importc: "XkbBellEvent".}
 proc XkbSelectEvents*(dpy: PDisplay, deviceID, affect, values: int16): bool{.
-    cdecl, dynlib: libX11, importc: "XkbSelectEvents".}
+    libx11c, importc: "XkbSelectEvents".}
 proc XkbSelectEventDetails*(dpy: PDisplay, deviceID, eventType: int16, 
-                            affect, details: int32): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbSelectEventDetails".}
+                            affect, details: int32): bool{.libx11c, importc: "XkbSelectEventDetails".}
 proc XkbNoteMapChanges*(old: PXkbMapChangesPtr, new: PXkbMapNotifyEvent, 
-                        wanted: int16){.cdecl, dynlib: libX11, 
+                        wanted: int16){.libx11c, 
                                         importc: "XkbNoteMapChanges".}
 proc XkbNoteNameChanges*(old: PXkbNameChangesPtr, new: PXkbNamesNotifyEvent, 
-                         wanted: int16){.cdecl, dynlib: libX11, 
+                         wanted: int16){.libx11c, 
     importc: "XkbNoteNameChanges".}
 proc XkbGetIndicatorState*(dpy: PDisplay, deviceSpec: int16, pStateRtrn: PWord): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetIndicatorState".}
+    libx11c, importc: "XkbGetIndicatorState".}
 proc XkbGetDeviceIndicatorState*(dpy: PDisplay, 
                                  deviceSpec, ledClass, ledID: int16, 
-                                 pStateRtrn: PWord): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbGetDeviceIndicatorState".}
+                                 pStateRtrn: PWord): TStatus{.libx11c, importc: "XkbGetDeviceIndicatorState".}
 proc XkbGetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetIndicatorMap".}
+    libx11c, importc: "XkbGetIndicatorMap".}
 proc XkbSetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{.
-    cdecl, dynlib: libX11, importc: "XkbSetIndicatorMap".}
+    libx11c, importc: "XkbSetIndicatorMap".}
 proc XkbNoteIndicatorMapChanges*(o, n: PXkbIndicatorChangesPtr, w: int16)
 proc XkbNoteIndicatorStateChanges*(o, n: PXkbIndicatorChangesPtr, w: int16)
 proc XkbGetIndicatorMapChanges*(d: PDisplay, x: PXkbDescPtr, 
@@ -432,176 +429,151 @@ 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, 
+                           pRealRtrn: ptr bool): bool{.libx11c, 
     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".}
+                                 pRealRtrn: ptr bool): bool{.libx11c, importc: "XkbGetNamedDeviceIndicator".}
 proc XkbSetNamedIndicator*(dpy: PDisplay, name: TAtom, 
                            changeState, state, createNewMap: bool, 
-                           pMap: PXkbIndicatorMapPtr): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbSetNamedIndicator".}
+                           pMap: PXkbIndicatorMapPtr): bool{.libx11c, importc: "XkbSetNamedIndicator".}
 proc XkbSetNamedDeviceIndicator*(dpy: PDisplay, 
                                  deviceSpec, ledClass, ledID: int16, 
                                  name: TAtom, 
                                  changeState, state, createNewMap: bool, 
-                                 pMap: PXkbIndicatorMapPtr): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbSetNamedDeviceIndicator".}
+                                 pMap: PXkbIndicatorMapPtr): bool{.libx11c, importc: "XkbSetNamedDeviceIndicator".}
 proc XkbLockModifiers*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{.
-    cdecl, dynlib: libX11, importc: "XkbLockModifiers".}
+    libx11c, 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".}
+    libx11c, importc: "XkbLatchModifiers".}
+proc XkbLockGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.libx11c, importc: "XkbLockGroup".}
+proc XkbLatchGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.libx11c, importc: "XkbLatchGroup".}
 proc XkbSetServerInternalMods*(dpy: PDisplay, deviceSpec, affectReal, 
-    realValues, affectVirtual, virtualValues: int16): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbSetServerInternalMods".}
+    realValues, affectVirtual, virtualValues: int16): bool{.libx11c, importc: "XkbSetServerInternalMods".}
 proc XkbSetIgnoreLockMods*(dpy: PDisplay, deviceSpec, affectReal, realValues, 
-    affectVirtual, virtualValues: int16): bool{.cdecl, dynlib: libX11, 
+    affectVirtual, virtualValues: int16): bool{.libx11c, 
     importc: "XkbSetIgnoreLockMods".}
 proc XkbVirtualModsToReal*(dpy: PDisplay, virtual_mask: int16, mask_rtrn: PWord): bool{.
-    cdecl, dynlib: libX11, importc: "XkbVirtualModsToReal".}
+    libx11c, importc: "XkbVirtualModsToReal".}
 proc XkbComputeEffectiveMap*(xkb: PXkbDescPtr, theType: PXkbKeyTypePtr, 
-                             map_rtrn: PByte): bool{.cdecl, dynlib: libX11, 
+                             map_rtrn: PByte): bool{.libx11c, 
     importc: "XkbComputeEffectiveMap".}
 proc XkbInitCanonicalKeyTypes*(xkb: PXkbDescPtr, which: int16, keypadVMod: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbInitCanonicalKeyTypes".}
-proc XkbAllocKeyboard*(): PXkbDescPtr{.cdecl, dynlib: libX11, 
+    libx11c, importc: "XkbInitCanonicalKeyTypes".}
+proc XkbAllocKeyboard*(): PXkbDescPtr{.libx11c, 
                                        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 XkbFreeKeyboard*(xkb: PXkbDescPtr, which: int16, freeDesc: bool){.libx11c, importc: "XkbFreeKeyboard".}
+proc XkbAllocClientMap*(xkb: PXkbDescPtr, which, nTypes: int16): TStatus{.libx11c, 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".}
+    libx11c, importc: "XkbAllocServerMap".}
+proc XkbFreeClientMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.libx11c, importc: "XkbFreeClientMap".}
+proc XkbFreeServerMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.libx11c, 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, 
+    libx11c, importc: "XkbAddKeyType".}
+proc XkbAllocIndicatorMaps*(xkb: PXkbDescPtr): TStatus{.libx11c, 
     importc: "XkbAllocIndicatorMaps".}
-proc XkbFreeIndicatorMaps*(xkb: PXkbDescPtr){.cdecl, dynlib: libX11, 
+proc XkbFreeIndicatorMaps*(xkb: PXkbDescPtr){.libx11c, 
     importc: "XkbFreeIndicatorMaps".}
-proc XkbGetMap*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{.cdecl, 
-    dynlib: libX11, importc: "XkbGetMap".}
+proc XkbGetMap*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{.libx11c, importc: "XkbGetMap".}
 proc XkbGetUpdatedMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetUpdatedMap".}
+    libx11c, 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".}
+                       changes: PXkbMapChangesPtr): TStatus{.libx11c, importc: "XkbGetMapChanges".}
+proc XkbRefreshKeyboardMapping*(event: PXkbMapNotifyEvent): TStatus{.libx11c, importc: "XkbRefreshKeyboardMapping".}
 proc XkbGetKeyTypes*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetKeyTypes".}
+    libx11c, importc: "XkbGetKeyTypes".}
 proc XkbGetKeySyms*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetKeySyms".}
+    libx11c, importc: "XkbGetKeySyms".}
 proc XkbGetKeyActions*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetKeyActions".}
+    libx11c, importc: "XkbGetKeyActions".}
 proc XkbGetKeyBehaviors*(dpy: PDisplay, firstKey, nKeys: int16, 
-                         desc: PXkbDescPtr): TStatus{.cdecl, dynlib: libX11, 
+                         desc: PXkbDescPtr): TStatus{.libx11c, 
     importc: "XkbGetKeyBehaviors".}
 proc XkbGetVirtualMods*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetVirtualMods".}
+    libx11c, importc: "XkbGetVirtualMods".}
 proc XkbGetKeyExplicitComponents*(dpy: PDisplay, firstKey, nKeys: int16, 
-                                  desc: PXkbDescPtr): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbGetKeyExplicitComponents".}
+                                  desc: PXkbDescPtr): TStatus{.libx11c, importc: "XkbGetKeyExplicitComponents".}
 proc XkbGetKeyModifierMap*(dpy: PDisplay, firstKey, nKeys: int16, 
-                           desc: PXkbDescPtr): TStatus{.cdecl, dynlib: libX11, 
+                           desc: PXkbDescPtr): TStatus{.libx11c, 
     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 XkbAllocControls*(xkb: PXkbDescPtr, which: int16): TStatus{.libx11c, importc: "XkbAllocControls".}
+proc XkbFreeControls*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeControls".}
 proc XkbGetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetControls".}
+    libx11c, importc: "XkbGetControls".}
 proc XkbSetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{.
-    cdecl, dynlib: libX11, importc: "XkbSetControls".}
+    libx11c, importc: "XkbSetControls".}
 proc XkbNoteControlsChanges*(old: PXkbControlsChangesPtr, 
                              new: PXkbControlsNotifyEvent, wanted: int16){.
-    cdecl, dynlib: libX11, importc: "XkbNoteControlsChanges".}
+    libx11c, 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".}
+    libx11c, importc: "XkbAllocCompatMap".}
+proc XkbFreeCompatMap*(xkib: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeCompatMap".}
 proc XkbGetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetCompatMap".}
+    libx11c, importc: "XkbGetCompatMap".}
 proc XkbSetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr, 
-                      updateActions: bool): bool{.cdecl, dynlib: libX11, 
+                      updateActions: bool): bool{.libx11c, 
     importc: "XkbSetCompatMap".}
 proc XkbAddSymInterpret*(xkb: PXkbDescPtr, si: PXkbSymInterpretPtr, 
                          updateMap: bool, changes: PXkbChangesPtr): PXkbSymInterpretPtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddSymInterpret".}
+    libx11c, importc: "XkbAddSymInterpret".}
 proc XkbAllocNames*(xkb: PXkbDescPtr, which: int16, 
-                    nTotalRG, nTotalAliases: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbAllocNames".}
+                    nTotalRG, nTotalAliases: int16): TStatus{.libx11c, importc: "XkbAllocNames".}
 proc XkbGetNames*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbGetNames".}
+    libx11c, importc: "XkbGetNames".}
 proc XkbSetNames*(dpy: PDisplay, which, firstType, nTypes: int16, 
-                  desc: PXkbDescPtr): bool{.cdecl, dynlib: libX11, 
+                  desc: PXkbDescPtr): bool{.libx11c, 
     importc: "XkbSetNames".}
 proc XkbChangeNames*(dpy: PDisplay, xkb: PXkbDescPtr, 
-                     changes: PXkbNameChangesPtr): bool{.cdecl, dynlib: libX11, 
+                     changes: PXkbNameChangesPtr): bool{.libx11c, 
     importc: "XkbChangeNames".}
-proc XkbFreeNames*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.cdecl, 
-    dynlib: libX11, importc: "XkbFreeNames".}
+proc XkbFreeNames*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, 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".}
+    libx11c, importc: "XkbGetState".}
+proc XkbSetMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): bool{.libx11c, importc: "XkbSetMap".}
 proc XkbChangeMap*(dpy: PDisplay, desc: PXkbDescPtr, changes: PXkbMapChangesPtr): bool{.
-    cdecl, dynlib: libX11, importc: "XkbChangeMap".}
+    libx11c, importc: "XkbChangeMap".}
 proc XkbSetDetectableAutoRepeat*(dpy: PDisplay, detectable: bool, 
-                                 supported: ptr bool): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbSetDetectableAutoRepeat".}
+                                 supported: ptr bool): bool{.libx11c, importc: "XkbSetDetectableAutoRepeat".}
 proc XkbGetDetectableAutoRepeat*(dpy: PDisplay, supported: ptr bool): bool{.
-    cdecl, dynlib: libX11, importc: "XkbGetDetectableAutoRepeat".}
+    libx11c, importc: "XkbGetDetectableAutoRepeat".}
 proc XkbSetAutoResetControls*(dpy: PDisplay, changes: int16, 
-                              auto_ctrls, auto_values: PWord): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbSetAutoResetControls".}
+                              auto_ctrls, auto_values: PWord): bool{.libx11c, importc: "XkbSetAutoResetControls".}
 proc XkbGetAutoResetControls*(dpy: PDisplay, auto_ctrls, auto_ctrl_values: PWord): bool{.
-    cdecl, dynlib: libX11, importc: "XkbGetAutoResetControls".}
+    libx11c, 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".}
+    libx11c, importc: "XkbSetPerClientControls".}
+proc XkbGetPerClientControls*(dpy: PDisplay, ctrls: PWord): bool{.libx11c, importc: "XkbGetPerClientControls".}
+proc XkbCopyKeyType*(`from`, into: PXkbKeyTypePtr): TStatus{.libx11c, importc: "XkbCopyKeyType".}
 proc XkbCopyKeyTypes*(`from`, into: PXkbKeyTypePtr, num_types: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbCopyKeyTypes".}
+    libx11c, importc: "XkbCopyKeyTypes".}
 proc XkbResizeKeyType*(xkb: PXkbDescPtr, type_ndx, map_count: int16, 
                        want_preserve: bool, new_num_lvls: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbResizeKeyType".}
+    libx11c, importc: "XkbResizeKeyType".}
 proc XkbResizeKeySyms*(desc: PXkbDescPtr, forKey, symsNeeded: int16): PKeySym{.
-    cdecl, dynlib: libX11, importc: "XkbResizeKeySyms".}
+    libx11c, importc: "XkbResizeKeySyms".}
 proc XkbResizeKeyActions*(desc: PXkbDescPtr, forKey, actsNeeded: int16): PXkbAction{.
-    cdecl, dynlib: libX11, importc: "XkbResizeKeyActions".}
+    libx11c, importc: "XkbResizeKeyActions".}
 proc XkbChangeTypesOfKey*(xkb: PXkbDescPtr, key, num_groups: int16, 
                           groups: int16, newTypes: ptr int16, 
-                          pChanges: PXkbMapChangesPtr): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbChangeTypesOfKey".}
+                          pChanges: PXkbMapChangesPtr): TStatus{.libx11c, 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, 
+    libx11c, importc: "XkbListComponents".}
+proc XkbFreeComponentList*(list: PXkbComponentListPtr){.libx11c, 
     importc: "XkbFreeComponentList".}
 proc XkbGetKeyboard*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{.
-    cdecl, dynlib: libX11, importc: "XkbGetKeyboard".}
+    libx11c, importc: "XkbGetKeyboard".}
 proc XkbGetKeyboardByName*(dpy: PDisplay, deviceSpec: int16, 
                            names: PXkbComponentNamesPtr, want, need: int16, 
-                           load: bool): PXkbDescPtr{.cdecl, dynlib: libX11, 
+                           load: bool): PXkbDescPtr{.libx11c, 
     importc: "XkbGetKeyboardByName".}
     
 proc XkbKeyTypesForCoreSymbols*(xkb: PXkbDescPtr, 
@@ -609,65 +581,55 @@ proc XkbKeyTypesForCoreSymbols*(xkb: PXkbDescPtr,
                                 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".}
+                                xkb_syms_rtrn: PKeySym): int16{.libx11c, importc: "XkbKeyTypesForCoreSymbols".}
   # must have enough space
 proc XkbApplyCompatMapToKey*(xkb: PXkbDescPtr,  
                              key: TKeyCode,  # key to be updated
-                             changes: PXkbChangesPtr): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbApplyCompatMapToKey".}
+                             changes: PXkbChangesPtr): bool{.libx11c, 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".}
+                           changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbUpdateMapFromCore".}
 
 proc XkbAddDeviceLedInfo*(devi: PXkbDeviceInfoPtr, ledClass, ledId: int16): PXkbDeviceLedInfoPtr{.
-    cdecl, dynlib: libX11, importc: "XkbAddDeviceLedInfo".}
+    libx11c, importc: "XkbAddDeviceLedInfo".}
 proc XkbResizeDeviceButtonActions*(devi: PXkbDeviceInfoPtr, newTotal: int16): TStatus{.
-    cdecl, dynlib: libX11, importc: "XkbResizeDeviceButtonActions".}
+    libx11c, importc: "XkbResizeDeviceButtonActions".}
 proc XkbAllocDeviceInfo*(deviceSpec, nButtons, szLeds: int16): PXkbDeviceInfoPtr{.
-    cdecl, dynlib: libX11, importc: "XkbAllocDeviceInfo".}
+    libx11c, importc: "XkbAllocDeviceInfo".}
 proc XkbFreeDeviceInfo*(devi: PXkbDeviceInfoPtr, which: int16, freeDevI: bool){.
-    cdecl, dynlib: libX11, importc: "XkbFreeDeviceInfo".}
+    libx11c, importc: "XkbFreeDeviceInfo".}
 proc XkbNoteDeviceChanges*(old: PXkbDeviceChangesPtr, 
                            new: PXkbExtensionDeviceNotifyEvent, wanted: int16){.
-    cdecl, dynlib: libX11, importc: "XkbNoteDeviceChanges".}
+    libx11c, importc: "XkbNoteDeviceChanges".}
 proc XkbGetDeviceInfo*(dpy: PDisplay, which, deviceSpec, ledClass, ledID: int16): PXkbDeviceInfoPtr{.
-    cdecl, dynlib: libX11, importc: "XkbGetDeviceInfo".}
+    libx11c, importc: "XkbGetDeviceInfo".}
 proc XkbGetDeviceInfoChanges*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
-                              changes: PXkbDeviceChangesPtr): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbGetDeviceInfoChanges".}
+                              changes: PXkbDeviceChangesPtr): TStatus{.libx11c, importc: "XkbGetDeviceInfoChanges".}
 proc XkbGetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
-                                all: bool, first, nBtns: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbGetDeviceButtonActions".}
+                                all: bool, first, nBtns: int16): TStatus{.libx11c, importc: "XkbGetDeviceButtonActions".}
 proc XkbGetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
-                          ledClass, ledId, which: int16): TStatus{.cdecl, 
-    dynlib: libX11, importc: "XkbGetDeviceLedInfo".}
+                          ledClass, ledId, which: int16): TStatus{.libx11c, importc: "XkbGetDeviceLedInfo".}
 proc XkbSetDeviceInfo*(dpy: PDisplay, which: int16, devi: PXkbDeviceInfoPtr): bool{.
-    cdecl, dynlib: libX11, importc: "XkbSetDeviceInfo".}
+    libx11c, importc: "XkbSetDeviceInfo".}
 proc XkbChangeDeviceInfo*(dpy: PDisplay, desc: PXkbDeviceInfoPtr, 
-                          changes: PXkbDeviceChangesPtr): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbChangeDeviceInfo".}
+                          changes: PXkbDeviceChangesPtr): bool{.libx11c, importc: "XkbChangeDeviceInfo".}
 proc XkbSetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
-                          ledClass, ledID, which: int16): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbSetDeviceLedInfo".}
+                          ledClass, ledID, which: int16): bool{.libx11c, importc: "XkbSetDeviceLedInfo".}
 proc XkbSetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr, 
-                                first, nBtns: int16): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbSetDeviceButtonActions".}
+                                first, nBtns: int16): bool{.libx11c, importc: "XkbSetDeviceButtonActions".}
 
-proc XkbToControl*(c: int8): int8{.cdecl, dynlib: libX11, 
+proc XkbToControl*(c: int8): int8{.libx11c, 
                                    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".}
+    libx11c, importc: "XkbSetDebuggingFlags".}
 proc XkbApplyVirtualModChanges*(xkb: PXkbDescPtr, changed: int16, 
-                                changes: PXkbChangesPtr): bool{.cdecl, 
-    dynlib: libX11, importc: "XkbApplyVirtualModChanges".}
+                                changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbApplyVirtualModChanges".}
 
 # implementation
 
diff --git a/lib/wrappers/x11/xlib.nim b/lib/wrappers/x11/xlib.nim
index 946f9566a..e6010feb7 100644
--- a/lib/wrappers/x11/xlib.nim
+++ b/lib/wrappers/x11/xlib.nim
@@ -2,8 +2,7 @@
 import 
   x
 
-const 
-  libX11* = "libX11.so"
+include "x11pragma.nim"
 
 type
   cunsigned* = cint
@@ -684,7 +683,8 @@ type
     window*: TWindow
     message_type*: TAtom
     format*: cint
-    data*: array[0..19, char]
+    data*: array[0..4, clong] # using clong here to be 32/64-bit dependent
+        # as the original C union
 
   PXMappingEvent* = ptr TXMappingEvent
   TXMappingEvent*{.final.} = object 
@@ -756,6 +756,13 @@ type
                               #          
   
 
+proc xclient*(e: PXEvent): PXClientMessageEvent =
+    ## Treats XEvent as XClientMessageEvent
+    return cast[PXClientMessageEvent](e)
+
+proc xclient*(e: var TXEvent): PXClientMessageEvent =
+    return xclient(PXEvent(e.addr))
+
 type 
   PXCharStruct* = ptr TXCharStruct
   TXCharStruct*{.final.} = object 
@@ -1120,889 +1127,686 @@ type
 const 
   AllPlanes*: culong = culong(not 0)
 
-proc XLoadQueryFont*(para1: PDisplay, para2: cstring): PXFontStruct{.cdecl, 
-    dynlib: libX11, importc.}
-proc XQueryFont*(para1: PDisplay, para2: TXID): PXFontStruct{.cdecl, 
-    dynlib: libX11, importc.}
+proc XLoadQueryFont*(para1: PDisplay, para2: cstring): PXFontStruct{.libx11.}
+proc XQueryFont*(para1: PDisplay, para2: TXID): PXFontStruct{.libx11.}
 proc XGetMotionEvents*(para1: PDisplay, para2: TWindow, para3: TTime, 
-                       para4: TTime, para5: Pcint): PXTimeCoord{.cdecl, 
-    dynlib: libX11, importc.}
+                       para4: TTime, para5: Pcint): PXTimeCoord{.libx11.}
 proc XDeleteModifiermapEntry*(para1: PXModifierKeymap, para2: TKeyCode, 
-                              para3: cint): PXModifierKeymap{.cdecl, 
-    dynlib: libX11, importc.}
-proc XGetModifierMapping*(para1: PDisplay): PXModifierKeymap{.cdecl, 
-    dynlib: libX11, importc.}
+                              para3: cint): PXModifierKeymap{.libx11.}
+proc XGetModifierMapping*(para1: PDisplay): PXModifierKeymap{.libx11.}
 proc XInsertModifiermapEntry*(para1: PXModifierKeymap, para2: TKeyCode, 
-                              para3: cint): PXModifierKeymap{.cdecl, 
-    dynlib: libX11, importc.}
-proc XNewModifiermap*(para1: cint): PXModifierKeymap{.cdecl, dynlib: libX11, 
-    importc.}
+                              para3: cint): PXModifierKeymap{.libx11.}
+proc XNewModifiermap*(para1: cint): PXModifierKeymap{.libx11.}
 proc XCreateImage*(para1: PDisplay, para2: PVisual, para3: cuint, para4: cint, 
                    para5: cint, para6: cstring, para7: cuint, para8: cuint, 
-                   para9: cint, para10: cint): PXImage{.cdecl, dynlib: libX11, 
-    importc.}
-proc XInitImage*(para1: PXImage): TStatus{.cdecl, dynlib: libX11, importc.}
+                   para9: cint, para10: cint): PXImage{.libx11.}
+proc XInitImage*(para1: PXImage): TStatus{.libx11.}
 proc XGetImage*(para1: PDisplay, para2: TDrawable, para3: cint, para4: cint, 
                 para5: cuint, para6: cuint, para7: culong, para8: cint): PXImage{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetSubImage*(para1: PDisplay, para2: TDrawable, para3: cint, para4: cint, 
                    para5: cuint, para6: cuint, para7: culong, para8: cint, 
-                   para9: PXImage, para10: cint, para11: cint): PXImage{.cdecl, 
-    dynlib: libX11, importc.}
-proc XOpenDisplay*(para1: cstring): PDisplay{.cdecl, dynlib: libX11, importc.}
-proc XrmInitialize*(){.cdecl, dynlib: libX11, importc.}
-proc XFetchBytes*(para1: PDisplay, para2: Pcint): cstring{.cdecl, 
-    dynlib: libX11, importc.}
-proc XFetchBuffer*(para1: PDisplay, para2: Pcint, para3: cint): cstring{.cdecl, 
-    dynlib: libX11, importc.}
-proc XGetAtomName*(para1: PDisplay, para2: TAtom): cstring{.cdecl, 
-    dynlib: libX11, importc.}
+                   para9: PXImage, para10: cint, para11: cint): PXImage{.libx11.}
+proc XOpenDisplay*(para1: cstring): PDisplay{.libx11.}
+proc XrmInitialize*(){.libx11.}
+proc XFetchBytes*(para1: PDisplay, para2: Pcint): cstring{.libx11.}
+proc XFetchBuffer*(para1: PDisplay, para2: Pcint, para3: cint): cstring{.libx11.}
+proc XGetAtomName*(para1: PDisplay, para2: TAtom): cstring{.libx11.}
 proc XGetAtomNames*(para1: PDisplay, para2: PAtom, para3: cint, para4: PPchar): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetDefault*(para1: PDisplay, para2: cstring, para3: cstring): cstring{.
-    cdecl, dynlib: libX11, importc.}
-proc XDisplayName*(para1: cstring): cstring{.cdecl, dynlib: libX11, importc.}
-proc XKeysymToString*(para1: TKeySym): cstring{.cdecl, dynlib: libX11, importc.}
-proc XSynchronize*(para1: PDisplay, para2: TBool): funcdisp{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetAfterFunction*(para1: PDisplay, para2: funcdisp): funcdisp{.cdecl, 
-    dynlib: libX11, importc.}
-proc XInternAtom*(para1: PDisplay, para2: cstring, para3: TBool): TAtom{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XDisplayName*(para1: cstring): cstring{.libx11.}
+proc XKeysymToString*(para1: TKeySym): cstring{.libx11.}
+proc XSynchronize*(para1: PDisplay, para2: TBool): funcdisp{.libx11.}
+proc XSetAfterFunction*(para1: PDisplay, para2: funcdisp): funcdisp{.libx11.}
+proc XInternAtom*(para1: PDisplay, para2: cstring, para3: TBool): TAtom{.libx11.}
 proc XInternAtoms*(para1: PDisplay, para2: PPchar, para3: cint, para4: TBool, 
-                   para5: PAtom): TStatus{.cdecl, dynlib: libX11, importc.}
-proc XCopyColormapAndFree*(para1: PDisplay, para2: TColormap): TColormap{.cdecl, 
-    dynlib: libX11, importc.}
+                   para5: PAtom): TStatus{.libx11.}
+proc XCopyColormapAndFree*(para1: PDisplay, para2: TColormap): TColormap{.libx11.}
 proc XCreateColormap*(para1: PDisplay, para2: TWindow, para3: PVisual, 
-                      para4: cint): TColormap{.cdecl, dynlib: libX11, importc.}
+                      para4: cint): TColormap{.libx11.}
 proc XCreatePixmapCursor*(para1: PDisplay, para2: TPixmap, para3: TPixmap, 
                           para4: PXColor, para5: PXColor, para6: cuint, 
-                          para7: cuint): TCursor{.cdecl, dynlib: libX11, importc.}
+                          para7: cuint): TCursor{.libx11.}
 proc XCreateGlyphCursor*(para1: PDisplay, para2: TFont, para3: TFont, 
                          para4: cuint, para5: cuint, para6: PXColor, 
-                         para7: PXColor): TCursor{.cdecl, dynlib: libX11, 
-    importc.}
-proc XCreateFontCursor*(para1: PDisplay, para2: cuint): TCursor{.cdecl, 
-    dynlib: libX11, importc.}
-proc XLoadFont*(para1: PDisplay, para2: cstring): TFont{.cdecl, dynlib: libX11, 
-    importc.}
+                         para7: PXColor): TCursor{.libx11.}
+proc XCreateFontCursor*(para1: PDisplay, para2: cuint): TCursor{.libx11.}
+proc XLoadFont*(para1: PDisplay, para2: cstring): TFont{.libx11.}
 proc XCreateGC*(para1: PDisplay, para2: TDrawable, para3: culong, 
-                para4: PXGCValues): TGC{.cdecl, dynlib: libX11, importc.}
-proc XGContextFromGC*(para1: TGC): TGContext{.cdecl, dynlib: libX11, importc.}
-proc XFlushGC*(para1: PDisplay, para2: TGC){.cdecl, dynlib: libX11, importc.}
+                para4: PXGCValues): TGC{.libx11.}
+proc XGContextFromGC*(para1: TGC): TGContext{.libx11.}
+proc XFlushGC*(para1: PDisplay, para2: TGC){.libx11.}
 proc XCreatePixmap*(para1: PDisplay, para2: TDrawable, para3: cuint, 
-                    para4: cuint, para5: cuint): TPixmap{.cdecl, dynlib: libX11, 
-    importc.}
+                    para4: cuint, para5: cuint): TPixmap{.libx11.}
 proc XCreateBitmapFromData*(para1: PDisplay, para2: TDrawable, para3: cstring, 
-                            para4: cuint, para5: cuint): TPixmap{.cdecl, 
-    dynlib: libX11, importc.}
+                            para4: cuint, para5: cuint): TPixmap{.libx11.}
 proc XCreatePixmapFromBitmapData*(para1: PDisplay, para2: TDrawable, 
                                   para3: cstring, para4: cuint, para5: cuint, 
                                   para6: culong, para7: culong, para8: cuint): TPixmap{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XCreateSimpleWindow*(para1: PDisplay, para2: TWindow, para3: cint, 
                           para4: cint, para5: cuint, para6: cuint, para7: cuint, 
-                          para8: culong, para9: culong): TWindow{.cdecl, 
-    dynlib: libX11, importc.}
-proc XGetSelectionOwner*(para1: PDisplay, para2: TAtom): TWindow{.cdecl, 
-    dynlib: libX11, importc.}
+                          para8: culong, para9: culong): TWindow{.libx11.}
+proc XGetSelectionOwner*(para1: PDisplay, para2: TAtom): TWindow{.libx11.}
 proc XCreateWindow*(para1: PDisplay, para2: TWindow, para3: cint, para4: cint, 
                     para5: cuint, para6: cuint, para7: cuint, para8: cint, 
                     para9: cuint, para10: PVisual, para11: culong, 
-                    para12: PXSetWindowAttributes): TWindow{.cdecl, 
-    dynlib: libX11, importc.}
+                    para12: PXSetWindowAttributes): TWindow{.libx11.}
 proc XListInstalledColormaps*(para1: PDisplay, para2: TWindow, para3: Pcint): PColormap{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XListFonts*(para1: PDisplay, para2: cstring, para3: cint, para4: Pcint): PPChar{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XListFontsWithInfo*(para1: PDisplay, para2: cstring, para3: cint, 
-                         para4: Pcint, para5: PPXFontStruct): PPChar{.cdecl, 
-    dynlib: libX11, importc.}
-proc XGetFontPath*(para1: PDisplay, para2: Pcint): PPChar{.cdecl, 
-    dynlib: libX11, importc.}
-proc XListExtensions*(para1: PDisplay, para2: Pcint): PPChar{.cdecl, 
-    dynlib: libX11, importc.}
+                         para4: Pcint, para5: PPXFontStruct): PPChar{.libx11.}
+proc XGetFontPath*(para1: PDisplay, para2: Pcint): PPChar{.libx11.}
+proc XListExtensions*(para1: PDisplay, para2: Pcint): PPChar{.libx11.}
 proc XListProperties*(para1: PDisplay, para2: TWindow, para3: Pcint): PAtom{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XListHosts*(para1: PDisplay, para2: Pcint, para3: PBool): PXHostAddress{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XKeycodeToKeysym*(para1: PDisplay, para2: TKeyCode, para3: cint): TKeySym{.
-    cdecl, dynlib: libX11, importc.}
-proc XLookupKeysym*(para1: PXKeyEvent, para2: cint): TKeySym{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XLookupKeysym*(para1: PXKeyEvent, para2: cint): TKeySym{.libx11.}
 proc XGetKeyboardMapping*(para1: PDisplay, para2: TKeyCode, para3: cint, 
-                          para4: Pcint): PKeySym{.cdecl, dynlib: libX11, importc.}
-proc XStringToKeysym*(para1: cstring): TKeySym{.cdecl, dynlib: libX11, importc.}
-proc XMaxRequestSize*(para1: PDisplay): clong{.cdecl, dynlib: libX11, importc.}
-proc XExtendedMaxRequestSize*(para1: PDisplay): clong{.cdecl, dynlib: libX11, 
-    importc.}
-proc XResourceManagerString*(para1: PDisplay): cstring{.cdecl, dynlib: libX11, 
-    importc.}
-proc XScreenResourceString*(para1: PScreen): cstring{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDisplayMotionBufferSize*(para1: PDisplay): culong{.cdecl, dynlib: libX11, 
-    importc.}
-proc XVisualIDFromVisual*(para1: PVisual): TVisualID{.cdecl, dynlib: libX11, 
-    importc.}
-proc XInitThreads*(): TStatus{.cdecl, dynlib: libX11, importc.}
-proc XLockDisplay*(para1: PDisplay){.cdecl, dynlib: libX11, importc.}
-proc XUnlockDisplay*(para1: PDisplay){.cdecl, dynlib: libX11, importc.}
-proc XInitExtension*(para1: PDisplay, para2: cstring): PXExtCodes{.cdecl, 
-    dynlib: libX11, importc.}
-proc XAddExtension*(para1: PDisplay): PXExtCodes{.cdecl, dynlib: libX11, importc.}
-proc XFindOnExtensionList*(para1: PPXExtData, para2: cint): PXExtData{.cdecl, 
-    dynlib: libX11, importc.}
-proc XEHeadOfExtensionList*(para1: TXEDataObject): PPXExtData{.cdecl, 
-    dynlib: libX11, importc.}
-proc XRootWindow*(para1: PDisplay, para2: cint): TWindow{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDefaultRootWindow*(para1: PDisplay): TWindow{.cdecl, dynlib: libX11, 
-    importc.}
-proc XRootWindowOfScreen*(para1: PScreen): TWindow{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDefaultVisual*(para1: PDisplay, para2: cint): PVisual{.cdecl, 
-    dynlib: libX11, importc.}
-proc XDefaultVisualOfScreen*(para1: PScreen): PVisual{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDefaultGC*(para1: PDisplay, para2: cint): TGC{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDefaultGCOfScreen*(para1: PScreen): TGC{.cdecl, dynlib: libX11, importc.}
-proc XBlackPixel*(para1: PDisplay, para2: cint): culong{.cdecl, dynlib: libX11, 
-    importc.}
-proc XWhitePixel*(para1: PDisplay, para2: cint): culong{.cdecl, dynlib: libX11, 
-    importc.}
-proc XAllPlanes*(): culong{.cdecl, dynlib: libX11, importc.}
-proc XBlackPixelOfScreen*(para1: PScreen): culong{.cdecl, dynlib: libX11, 
-    importc.}
-proc XWhitePixelOfScreen*(para1: PScreen): culong{.cdecl, dynlib: libX11, 
-    importc.}
-proc XNextRequest*(para1: PDisplay): culong{.cdecl, dynlib: libX11, importc.}
-proc XLastKnownRequestProcessed*(para1: PDisplay): culong{.cdecl, 
-    dynlib: libX11, importc.}
-proc XServerVendor*(para1: PDisplay): cstring{.cdecl, dynlib: libX11, importc.}
-proc XDisplayString*(para1: PDisplay): cstring{.cdecl, dynlib: libX11, importc.}
-proc XDefaultColormap*(para1: PDisplay, para2: cint): TColormap{.cdecl, 
-    dynlib: libX11, importc.}
-proc XDefaultColormapOfScreen*(para1: PScreen): TColormap{.cdecl, 
-    dynlib: libX11, importc.}
-proc XDisplayOfScreen*(para1: PScreen): PDisplay{.cdecl, dynlib: libX11, importc.}
-proc XScreenOfDisplay*(para1: PDisplay, para2: cint): PScreen{.cdecl, 
-    dynlib: libX11, importc.}
-proc XDefaultScreenOfDisplay*(para1: PDisplay): PScreen{.cdecl, dynlib: libX11, 
-    importc.}
-proc XEventMaskOfScreen*(para1: PScreen): clong{.cdecl, dynlib: libX11, importc.}
-proc XScreenNumberOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                          para4: Pcint): PKeySym{.libx11.}
+proc XStringToKeysym*(para1: cstring): TKeySym{.libx11.}
+proc XMaxRequestSize*(para1: PDisplay): clong{.libx11.}
+proc XExtendedMaxRequestSize*(para1: PDisplay): clong{.libx11.}
+proc XResourceManagerString*(para1: PDisplay): cstring{.libx11.}
+proc XScreenResourceString*(para1: PScreen): cstring{.libx11.}
+proc XDisplayMotionBufferSize*(para1: PDisplay): culong{.libx11.}
+proc XVisualIDFromVisual*(para1: PVisual): TVisualID{.libx11.}
+proc XInitThreads*(): TStatus{.libx11.}
+proc XLockDisplay*(para1: PDisplay){.libx11.}
+proc XUnlockDisplay*(para1: PDisplay){.libx11.}
+proc XInitExtension*(para1: PDisplay, para2: cstring): PXExtCodes{.libx11.}
+proc XAddExtension*(para1: PDisplay): PXExtCodes{.libx11.}
+proc XFindOnExtensionList*(para1: PPXExtData, para2: cint): PXExtData{.libx11.}
+proc XEHeadOfExtensionList*(para1: TXEDataObject): PPXExtData{.libx11.}
+proc XRootWindow*(para1: PDisplay, para2: cint): TWindow{.libx11.}
+proc XDefaultRootWindow*(para1: PDisplay): TWindow{.libx11.}
+proc XRootWindowOfScreen*(para1: PScreen): TWindow{.libx11.}
+proc XDefaultVisual*(para1: PDisplay, para2: cint): PVisual{.libx11.}
+proc XDefaultVisualOfScreen*(para1: PScreen): PVisual{.libx11.}
+proc XDefaultGC*(para1: PDisplay, para2: cint): TGC{.libx11.}
+proc XDefaultGCOfScreen*(para1: PScreen): TGC{.libx11.}
+proc XBlackPixel*(para1: PDisplay, para2: cint): culong{.libx11.}
+proc XWhitePixel*(para1: PDisplay, para2: cint): culong{.libx11.}
+proc XAllPlanes*(): culong{.libx11.}
+proc XBlackPixelOfScreen*(para1: PScreen): culong{.libx11.}
+proc XWhitePixelOfScreen*(para1: PScreen): culong{.libx11.}
+proc XNextRequest*(para1: PDisplay): culong{.libx11.}
+proc XLastKnownRequestProcessed*(para1: PDisplay): culong{.libx11.}
+proc XServerVendor*(para1: PDisplay): cstring{.libx11.}
+proc XDisplayString*(para1: PDisplay): cstring{.libx11.}
+proc XDefaultColormap*(para1: PDisplay, para2: cint): TColormap{.libx11.}
+proc XDefaultColormapOfScreen*(para1: PScreen): TColormap{.libx11.}
+proc XDisplayOfScreen*(para1: PScreen): PDisplay{.libx11.}
+proc XScreenOfDisplay*(para1: PDisplay, para2: cint): PScreen{.libx11.}
+proc XDefaultScreenOfDisplay*(para1: PDisplay): PScreen{.libx11.}
+proc XEventMaskOfScreen*(para1: PScreen): clong{.libx11.}
+proc XScreenNumberOfScreen*(para1: PScreen): cint{.libx11.}
 type 
   TXErrorHandler* = proc (para1: PDisplay, para2: PXErrorEvent): cint{.cdecl.}
 
-proc XSetErrorHandler*(para1: TXErrorHandler): TXErrorHandler{.cdecl, 
-    dynlib: libX11, importc.}
+proc XSetErrorHandler*(para1: TXErrorHandler): TXErrorHandler{.libx11.}
 type 
   TXIOErrorHandler* = proc (para1: PDisplay): cint{.cdecl.}
 
-proc XSetIOErrorHandler*(para1: TXIOErrorHandler): TXIOErrorHandler{.cdecl, 
-    dynlib: libX11, importc.}
+proc XSetIOErrorHandler*(para1: TXIOErrorHandler): TXIOErrorHandler{.libx11.}
 proc XListPixmapFormats*(para1: PDisplay, para2: Pcint): PXPixmapFormatValues{.
-    cdecl, dynlib: libX11, importc.}
-proc XListDepths*(para1: PDisplay, para2: cint, para3: Pcint): Pcint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XListDepths*(para1: PDisplay, para2: cint, para3: Pcint): Pcint{.libx11.}
 proc XReconfigureWMWindow*(para1: PDisplay, para2: TWindow, para3: cint, 
                            para4: cuint, para5: PXWindowChanges): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetWMProtocols*(para1: PDisplay, para2: TWindow, para3: PPAtom, 
-                      para4: Pcint): TStatus{.cdecl, dynlib: libX11, importc.}
+                      para4: Pcint): TStatus{.libx11.}
 proc XSetWMProtocols*(para1: PDisplay, para2: TWindow, para3: PAtom, para4: cint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XIconifyWindow*(para1: PDisplay, para2: TWindow, para3: cint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XWithdrawWindow*(para1: PDisplay, para2: TWindow, para3: cint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetCommand*(para1: PDisplay, para2: TWindow, para3: PPPchar, para4: Pcint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetWMColormapWindows*(para1: PDisplay, para2: TWindow, para3: PPWindow, 
-                            para4: Pcint): TStatus{.cdecl, dynlib: libX11, 
-    importc.}
+                            para4: Pcint): TStatus{.libx11.}
 proc XSetWMColormapWindows*(para1: PDisplay, para2: TWindow, para3: PWindow, 
-                            para4: cint): TStatus{.cdecl, dynlib: libX11, 
-    importc.}
-proc XFreeStringList*(para1: PPchar){.cdecl, dynlib: libX11, importc.}
+                            para4: cint): TStatus{.libx11.}
+proc XFreeStringList*(para1: PPchar){.libx11.}
 proc XSetTransientForHint*(para1: PDisplay, para2: TWindow, para3: TWindow): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XActivateScreenSaver*(para1: PDisplay): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XAddHost*(para1: PDisplay, para2: PXHostAddress): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XActivateScreenSaver*(para1: PDisplay): cint{.libx11.}
+proc XAddHost*(para1: PDisplay, para2: PXHostAddress): cint{.libx11.}
 proc XAddHosts*(para1: PDisplay, para2: PXHostAddress, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XAddToExtensionList*(para1: PPXExtData, para2: PXExtData): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XAddToSaveSet*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XAddToExtensionList*(para1: PPXExtData, para2: PXExtData): cint{.libx11.}
+proc XAddToSaveSet*(para1: PDisplay, para2: TWindow): cint{.libx11.}
 proc XAllocColor*(para1: PDisplay, para2: TColormap, para3: PXColor): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XAllocColorCells*(para1: PDisplay, para2: TColormap, para3: TBool, 
                        para4: Pculong, para5: cuint, para6: Pculong, 
-                       para7: cuint): TStatus{.cdecl, dynlib: libX11, importc.}
+                       para7: cuint): TStatus{.libx11.}
 proc XAllocColorPlanes*(para1: PDisplay, para2: TColormap, para3: TBool, 
                         para4: Pculong, para5: cint, para6: cint, para7: cint, 
                         para8: cint, para9: Pculong, para10: Pculong, 
-                        para11: Pculong): TStatus{.cdecl, dynlib: libX11, 
-    importc.}
+                        para11: Pculong): TStatus{.libx11.}
 proc XAllocNamedColor*(para1: PDisplay, para2: TColormap, para3: cstring, 
-                       para4: PXColor, para5: PXColor): TStatus{.cdecl, 
-    dynlib: libX11, importc.}
-proc XAllowEvents*(para1: PDisplay, para2: cint, para3: TTime): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XAutoRepeatOff*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XAutoRepeatOn*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XBell*(para1: PDisplay, para2: cint): cint{.cdecl, dynlib: libX11, importc.}
-proc XBitmapBitOrder*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XBitmapPad*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XBitmapUnit*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XCellsOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, importc.}
+                       para4: PXColor, para5: PXColor): TStatus{.libx11.}
+proc XAllowEvents*(para1: PDisplay, para2: cint, para3: TTime): cint{.libx11.}
+proc XAutoRepeatOff*(para1: PDisplay): cint{.libx11.}
+proc XAutoRepeatOn*(para1: PDisplay): cint{.libx11.}
+proc XBell*(para1: PDisplay, para2: cint): cint{.libx11.}
+proc XBitmapBitOrder*(para1: PDisplay): cint{.libx11.}
+proc XBitmapPad*(para1: PDisplay): cint{.libx11.}
+proc XBitmapUnit*(para1: PDisplay): cint{.libx11.}
+proc XCellsOfScreen*(para1: PScreen): cint{.libx11.}
 proc XChangeActivePointerGrab*(para1: PDisplay, para2: cuint, para3: TCursor, 
-                               para4: TTime): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                               para4: TTime): cint{.libx11.}
 proc XChangeGC*(para1: PDisplay, para2: TGC, para3: culong, para4: PXGCValues): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XChangeKeyboardControl*(para1: PDisplay, para2: culong, 
-                             para3: PXKeyboardControl): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                             para3: PXKeyboardControl): cint{.libx11.}
 proc XChangeKeyboardMapping*(para1: PDisplay, para2: cint, para3: cint, 
-                             para4: PKeySym, para5: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                             para4: PKeySym, para5: cint): cint{.libx11.}
 proc XChangePointerControl*(para1: PDisplay, para2: TBool, para3: TBool, 
-                            para4: cint, para5: cint, para6: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                            para4: cint, para5: cint, para6: cint): cint{.libx11.}
 proc XChangeProperty*(para1: PDisplay, para2: TWindow, para3: TAtom, 
                       para4: TAtom, para5: cint, para6: cint, para7: Pcuchar, 
-                      para8: cint): cint{.cdecl, dynlib: libX11, importc.}
-proc XChangeSaveSet*(para1: PDisplay, para2: TWindow, para3: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                      para8: cint): cint{.libx11.}
+proc XChangeSaveSet*(para1: PDisplay, para2: TWindow, para3: cint): cint{.libx11.}
 proc XChangeWindowAttributes*(para1: PDisplay, para2: TWindow, para3: culong, 
-                              para4: PXSetWindowAttributes): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                              para4: PXSetWindowAttributes): cint{.libx11.}
 proc XCheckIfEvent*(para1: PDisplay, para2: PXEvent, para3: funcifevent, 
-                    para4: TXPointer): TBool{.cdecl, dynlib: libX11, importc.}
+                    para4: TXPointer): TBool{.libx11.}
 proc XCheckMaskEvent*(para1: PDisplay, para2: clong, para3: PXEvent): TBool{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XCheckTypedEvent*(para1: PDisplay, para2: cint, para3: PXEvent): TBool{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XCheckTypedWindowEvent*(para1: PDisplay, para2: TWindow, para3: cint, 
-                             para4: PXEvent): TBool{.cdecl, dynlib: libX11, 
-    importc.}
+                             para4: PXEvent): TBool{.libx11.}
 proc XCheckWindowEvent*(para1: PDisplay, para2: TWindow, para3: clong, 
-                        para4: PXEvent): TBool{.cdecl, dynlib: libX11, importc.}
+                        para4: PXEvent): TBool{.libx11.}
 proc XCirculateSubwindows*(para1: PDisplay, para2: TWindow, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XCirculateSubwindowsDown*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XCirculateSubwindowsUp*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XCirculateSubwindowsDown*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XCirculateSubwindowsUp*(para1: PDisplay, para2: TWindow): cint{.libx11.}
 proc XClearArea*(para1: PDisplay, para2: TWindow, para3: cint, para4: cint, 
-                 para5: cuint, para6: cuint, para7: TBool): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XClearWindow*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XCloseDisplay*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
+                 para5: cuint, para6: cuint, para7: TBool): cint{.libx11.}
+proc XClearWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XCloseDisplay*(para1: PDisplay): cint{.libx11.}
 proc XConfigureWindow*(para1: PDisplay, para2: TWindow, para3: cuint, 
-                       para4: PXWindowChanges): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XConnectionNumber*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
+                       para4: PXWindowChanges): cint{.libx11.}
+proc XConnectionNumber*(para1: PDisplay): cint{.libx11.}
 proc XConvertSelection*(para1: PDisplay, para2: TAtom, para3: TAtom, 
                         para4: TAtom, para5: TWindow, para6: TTime): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XCopyArea*(para1: PDisplay, para2: TDrawable, para3: TDrawable, para4: TGC, 
                 para5: cint, para6: cint, para7: cuint, para8: cuint, 
-                para9: cint, para10: cint): cint{.cdecl, dynlib: libX11, importc.}
+                para9: cint, para10: cint): cint{.libx11.}
 proc XCopyGC*(para1: PDisplay, para2: TGC, para3: culong, para4: TGC): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XCopyPlane*(para1: PDisplay, para2: TDrawable, para3: TDrawable, 
                  para4: TGC, para5: cint, para6: cint, para7: cuint, 
                  para8: cuint, para9: cint, para10: cint, para11: culong): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XDefaultDepth*(para1: PDisplay, para2: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDefaultDepthOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDefaultScreen*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
+    libx11.}
+proc XDefaultDepth*(para1: PDisplay, para2: cint): cint{.libx11.}
+proc XDefaultDepthOfScreen*(para1: PScreen): cint{.libx11.}
+proc XDefaultScreen*(para1: PDisplay): cint{.libx11.}
 proc XDefineCursor*(para1: PDisplay, para2: TWindow, para3: TCursor): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XDeleteProperty*(para1: PDisplay, para2: TWindow, para3: TAtom): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XDestroyWindow*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XDestroySubwindows*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XDoesBackingStore*(para1: PScreen): cint{.cdecl, dynlib: libX11, importc.}
-proc XDoesSaveUnders*(para1: PScreen): TBool{.cdecl, dynlib: libX11, importc.}
-proc XDisableAccessControl*(para1: PDisplay): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDisplayCells*(para1: PDisplay, para2: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDisplayHeight*(para1: PDisplay, para2: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDisplayHeightMM*(para1: PDisplay, para2: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XDestroyWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XDestroySubwindows*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XDoesBackingStore*(para1: PScreen): cint{.libx11.}
+proc XDoesSaveUnders*(para1: PScreen): TBool{.libx11.}
+proc XDisableAccessControl*(para1: PDisplay): cint{.libx11.}
+proc XDisplayCells*(para1: PDisplay, para2: cint): cint{.libx11.}
+proc XDisplayHeight*(para1: PDisplay, para2: cint): cint{.libx11.}
+proc XDisplayHeightMM*(para1: PDisplay, para2: cint): cint{.libx11.}
 proc XDisplayKeycodes*(para1: PDisplay, para2: Pcint, para3: Pcint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XDisplayPlanes*(para1: PDisplay, para2: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDisplayWidth*(para1: PDisplay, para2: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDisplayWidthMM*(para1: PDisplay, para2: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XDisplayPlanes*(para1: PDisplay, para2: cint): cint{.libx11.}
+proc XDisplayWidth*(para1: PDisplay, para2: cint): cint{.libx11.}
+proc XDisplayWidthMM*(para1: PDisplay, para2: cint): cint{.libx11.}
 proc XDrawArc*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
                para5: cint, para6: cuint, para7: cuint, para8: cint, para9: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XDrawArcs*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXArc, 
-                para5: cint): cint{.cdecl, dynlib: libX11, importc.}
+                para5: cint): cint{.libx11.}
 proc XDrawImageString*(para1: PDisplay, para2: TDrawable, para3: TGC, 
                        para4: cint, para5: cint, para6: cstring, para7: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XDrawImageString16*(para1: PDisplay, para2: TDrawable, para3: TGC, 
                          para4: cint, para5: cint, para6: PXChar2b, para7: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XDrawLine*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                para5: cint, para6: cint, para7: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                para5: cint, para6: cint, para7: cint): cint{.libx11.}
 proc XDrawLines*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXPoint, 
-                 para5: cint, para6: cint): cint{.cdecl, dynlib: libX11, importc.}
+                 para5: cint, para6: cint): cint{.libx11.}
 proc XDrawPoint*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                 para5: cint): cint{.cdecl, dynlib: libX11, importc.}
+                 para5: cint): cint{.libx11.}
 proc XDrawPoints*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXPoint, 
-                  para5: cint, para6: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                  para5: cint, para6: cint): cint{.libx11.}
 proc XDrawRectangle*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                     para5: cint, para6: cuint, para7: cuint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                     para5: cint, para6: cuint, para7: cuint): cint{.libx11.}
 proc XDrawRectangles*(para1: PDisplay, para2: TDrawable, para3: TGC, 
-                      para4: PXRectangle, para5: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                      para4: PXRectangle, para5: cint): cint{.libx11.}
 proc XDrawSegments*(para1: PDisplay, para2: TDrawable, para3: TGC, 
-                    para4: PXSegment, para5: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                    para4: PXSegment, para5: cint): cint{.libx11.}
 proc XDrawString*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                  para5: cint, para6: cstring, para7: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                  para5: cint, para6: cstring, para7: cint): cint{.libx11.}
 proc XDrawString16*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                    para5: cint, para6: PXChar2b, para7: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                    para5: cint, para6: PXChar2b, para7: cint): cint{.libx11.}
 proc XDrawText*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                para5: cint, para6: PXTextItem, para7: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                para5: cint, para6: PXTextItem, para7: cint): cint{.libx11.}
 proc XDrawText16*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                  para5: cint, para6: PXTextItem16, para7: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XEnableAccessControl*(para1: PDisplay): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XEventsQueued*(para1: PDisplay, para2: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                  para5: cint, para6: PXTextItem16, para7: cint): cint{.libx11.}
+proc XEnableAccessControl*(para1: PDisplay): cint{.libx11.}
+proc XEventsQueued*(para1: PDisplay, para2: cint): cint{.libx11.}
 proc XFetchName*(para1: PDisplay, para2: TWindow, para3: PPchar): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XFillArc*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
                para5: cint, para6: cuint, para7: cuint, para8: cint, para9: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XFillArcs*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXArc, 
-                para5: cint): cint{.cdecl, dynlib: libX11, importc.}
+                para5: cint): cint{.libx11.}
 proc XFillPolygon*(para1: PDisplay, para2: TDrawable, para3: TGC, 
                    para4: PXPoint, para5: cint, para6: cint, para7: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XFillRectangle*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                     para5: cint, para6: cuint, para7: cuint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                     para5: cint, para6: cuint, para7: cuint): cint{.libx11.}
 proc XFillRectangles*(para1: PDisplay, para2: TDrawable, para3: TGC, 
-                      para4: PXRectangle, para5: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XFlush*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XForceScreenSaver*(para1: PDisplay, para2: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XFree*(para1: pointer): cint{.cdecl, dynlib: libX11, importc.}
-proc XFreeColormap*(para1: PDisplay, para2: TColormap): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                      para4: PXRectangle, para5: cint): cint{.libx11.}
+proc XFlush*(para1: PDisplay): cint{.libx11.}
+proc XForceScreenSaver*(para1: PDisplay, para2: cint): cint{.libx11.}
+proc XFree*(para1: pointer): cint{.libx11.}
+proc XFreeColormap*(para1: PDisplay, para2: TColormap): cint{.libx11.}
 proc XFreeColors*(para1: PDisplay, para2: TColormap, para3: Pculong, 
-                  para4: cint, para5: culong): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XFreeCursor*(para1: PDisplay, para2: TCursor): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XFreeExtensionList*(para1: PPchar): cint{.cdecl, dynlib: libX11, importc.}
-proc XFreeFont*(para1: PDisplay, para2: PXFontStruct): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                  para4: cint, para5: culong): cint{.libx11.}
+proc XFreeCursor*(para1: PDisplay, para2: TCursor): cint{.libx11.}
+proc XFreeExtensionList*(para1: PPchar): cint{.libx11.}
+proc XFreeFont*(para1: PDisplay, para2: PXFontStruct): cint{.libx11.}
 proc XFreeFontInfo*(para1: PPchar, para2: PXFontStruct, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XFreeFontNames*(para1: PPchar): cint{.cdecl, dynlib: libX11, importc.}
-proc XFreeFontPath*(para1: PPchar): cint{.cdecl, dynlib: libX11, importc.}
-proc XFreeGC*(para1: PDisplay, para2: TGC): cint{.cdecl, dynlib: libX11, importc.}
-proc XFreeModifiermap*(para1: PXModifierKeymap): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XFreePixmap*(para1: PDisplay, para2: TPixmap): cint{.cdecl, dynlib: libX11, 
-    importc.}
+    libx11.}
+proc XFreeFontNames*(para1: PPchar): cint{.libx11.}
+proc XFreeFontPath*(para1: PPchar): cint{.libx11.}
+proc XFreeGC*(para1: PDisplay, para2: TGC): cint{.libx11.}
+proc XFreeModifiermap*(para1: PXModifierKeymap): cint{.libx11.}
+proc XFreePixmap*(para1: PDisplay, para2: TPixmap): cint{.libx11.}
 proc XGeometry*(para1: PDisplay, para2: cint, para3: cstring, para4: cstring, 
                 para5: cuint, para6: cuint, para7: cuint, para8: cint, 
                 para9: cint, para10: Pcint, para11: Pcint, para12: Pcint, 
-                para13: Pcint): cint{.cdecl, dynlib: libX11, importc.}
+                para13: Pcint): cint{.libx11.}
 proc XGetErrorDatabaseText*(para1: PDisplay, para2: cstring, para3: cstring, 
                             para4: cstring, para5: cstring, para6: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetErrorText*(para1: PDisplay, para2: cint, para3: cstring, para4: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetFontProperty*(para1: PXFontStruct, para2: TAtom, para3: Pculong): TBool{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetGCValues*(para1: PDisplay, para2: TGC, para3: culong, para4: PXGCValues): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetGeometry*(para1: PDisplay, para2: TDrawable, para3: PWindow, 
                    para4: Pcint, para5: Pcint, para6: Pcuint, para7: Pcuint, 
-                   para8: Pcuint, para9: Pcuint): TStatus{.cdecl, 
-    dynlib: libX11, importc.}
+                   para8: Pcuint, para9: Pcuint): TStatus{.libx11.}
 proc XGetIconName*(para1: PDisplay, para2: TWindow, para3: PPchar): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetInputFocus*(para1: PDisplay, para2: PWindow, para3: Pcint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XGetKeyboardControl*(para1: PDisplay, para2: PXKeyboardState): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XGetKeyboardControl*(para1: PDisplay, para2: PXKeyboardState): cint{.libx11.}
 proc XGetPointerControl*(para1: PDisplay, para2: Pcint, para3: Pcint, 
-                         para4: Pcint): cint{.cdecl, dynlib: libX11, importc.}
+                         para4: Pcint): cint{.libx11.}
 proc XGetPointerMapping*(para1: PDisplay, para2: Pcuchar, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetScreenSaver*(para1: PDisplay, para2: Pcint, para3: Pcint, para4: Pcint, 
-                      para5: Pcint): cint{.cdecl, dynlib: libX11, importc.}
+                      para5: Pcint): cint{.libx11.}
 proc XGetTransientForHint*(para1: PDisplay, para2: TWindow, para3: PWindow): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XGetWindowProperty*(para1: PDisplay, para2: TWindow, para3: TAtom, 
                          para4: clong, para5: clong, para6: TBool, para7: TAtom, 
                          para8: PAtom, para9: Pcint, para10: Pculong, 
-                         para11: Pculong, para12: PPcuchar): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                         para11: Pculong, para12: PPcuchar): cint{.libx11.}
 proc XGetWindowAttributes*(para1: PDisplay, para2: TWindow, 
-                           para3: PXWindowAttributes): TStatus{.cdecl, 
-    dynlib: libX11, importc.}
+                           para3: PXWindowAttributes): TStatus{.libx11.}
 proc XGrabButton*(para1: PDisplay, para2: cuint, para3: cuint, para4: TWindow, 
                   para5: TBool, para6: cuint, para7: cint, para8: cint, 
-                  para9: TWindow, para10: TCursor): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                  para9: TWindow, para10: TCursor): cint{.libx11.}
 proc XGrabKey*(para1: PDisplay, para2: cint, para3: cuint, para4: TWindow, 
-               para5: TBool, para6: cint, para7: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+               para5: TBool, para6: cint, para7: cint): cint{.libx11.}
 proc XGrabKeyboard*(para1: PDisplay, para2: TWindow, para3: TBool, para4: cint, 
-                    para5: cint, para6: TTime): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                    para5: cint, para6: TTime): cint{.libx11.}
 proc XGrabPointer*(para1: PDisplay, para2: TWindow, para3: TBool, para4: cuint, 
                    para5: cint, para6: cint, para7: TWindow, para8: TCursor, 
-                   para9: TTime): cint{.cdecl, dynlib: libX11, importc.}
-proc XGrabServer*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XHeightMMOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, importc.}
-proc XHeightOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, importc.}
+                   para9: TTime): cint{.libx11.}
+proc XGrabServer*(para1: PDisplay): cint{.libx11.}
+proc XHeightMMOfScreen*(para1: PScreen): cint{.libx11.}
+proc XHeightOfScreen*(para1: PScreen): cint{.libx11.}
 proc XIfEvent*(para1: PDisplay, para2: PXEvent, para3: funcifevent, 
-               para4: TXPointer): cint{.cdecl, dynlib: libX11, importc.}
-proc XImageByteOrder*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XInstallColormap*(para1: PDisplay, para2: TColormap): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XKeysymToKeycode*(para1: PDisplay, para2: TKeySym): TKeyCode{.cdecl, 
-    dynlib: libX11, importc.}
-proc XKillClient*(para1: PDisplay, para2: TXID): cint{.cdecl, dynlib: libX11, 
-    importc.}
+               para4: TXPointer): cint{.libx11.}
+proc XImageByteOrder*(para1: PDisplay): cint{.libx11.}
+proc XInstallColormap*(para1: PDisplay, para2: TColormap): cint{.libx11.}
+proc XKeysymToKeycode*(para1: PDisplay, para2: TKeySym): TKeyCode{.libx11.}
+proc XKillClient*(para1: PDisplay, para2: TXID): cint{.libx11.}
 proc XLookupColor*(para1: PDisplay, para2: TColormap, para3: cstring, 
-                   para4: PXColor, para5: PXColor): TStatus{.cdecl, 
-    dynlib: libX11, importc.}
-proc XLowerWindow*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XMapRaised*(para1: PDisplay, para2: TWindow): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XMapSubwindows*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XMapWindow*(para1: PDisplay, para2: TWindow): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XMaskEvent*(para1: PDisplay, para2: clong, para3: PXEvent): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XMaxCmapsOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, importc.}
-proc XMinCmapsOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, importc.}
+                   para4: PXColor, para5: PXColor): TStatus{.libx11.}
+proc XLowerWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XMapRaised*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XMapSubwindows*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XMapWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XMaskEvent*(para1: PDisplay, para2: clong, para3: PXEvent): cint{.libx11.}
+proc XMaxCmapsOfScreen*(para1: PScreen): cint{.libx11.}
+proc XMinCmapsOfScreen*(para1: PScreen): cint{.libx11.}
 proc XMoveResizeWindow*(para1: PDisplay, para2: TWindow, para3: cint, 
-                        para4: cint, para5: cuint, para6: cuint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                        para4: cint, para5: cuint, para6: cuint): cint{.libx11.}
 proc XMoveWindow*(para1: PDisplay, para2: TWindow, para3: cint, para4: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XNextEvent*(para1: PDisplay, para2: PXEvent): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XNoOp*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
+    libx11.}
+proc XNextEvent*(para1: PDisplay, para2: PXEvent): cint{.libx11.}
+proc XNoOp*(para1: PDisplay): cint{.libx11.}
 proc XParseColor*(para1: PDisplay, para2: TColormap, para3: cstring, 
-                  para4: PXColor): TStatus{.cdecl, dynlib: libX11, importc.}
+                  para4: PXColor): TStatus{.libx11.}
 proc XParseGeometry*(para1: cstring, para2: Pcint, para3: Pcint, para4: Pcuint, 
-                     para5: Pcuint): cint{.cdecl, dynlib: libX11, importc.}
-proc XPeekEvent*(para1: PDisplay, para2: PXEvent): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                     para5: Pcuint): cint{.libx11.}
+proc XPeekEvent*(para1: PDisplay, para2: PXEvent): cint{.libx11.}
 proc XPeekIfEvent*(para1: PDisplay, para2: PXEvent, para3: funcifevent, 
-                   para4: TXPointer): cint{.cdecl, dynlib: libX11, importc.}
-proc XPending*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XPlanesOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, importc.}
-proc XProtocolRevision*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XProtocolVersion*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XPutBackEvent*(para1: PDisplay, para2: PXEvent): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                   para4: TXPointer): cint{.libx11.}
+proc XPending*(para1: PDisplay): cint{.libx11.}
+proc XPlanesOfScreen*(para1: PScreen): cint{.libx11.}
+proc XProtocolRevision*(para1: PDisplay): cint{.libx11.}
+proc XProtocolVersion*(para1: PDisplay): cint{.libx11.}
+proc XPutBackEvent*(para1: PDisplay, para2: PXEvent): cint{.libx11.}
 proc XPutImage*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: PXImage, 
                 para5: cint, para6: cint, para7: cint, para8: cint, 
-                para9: cuint, para10: cuint): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XQLength*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
+                para9: cuint, para10: cuint): cint{.libx11.}
+proc XQLength*(para1: PDisplay): cint{.libx11.}
 proc XQueryBestCursor*(para1: PDisplay, para2: TDrawable, para3: cuint, 
                        para4: cuint, para5: Pcuint, para6: Pcuint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XQueryBestSize*(para1: PDisplay, para2: cint, para3: TDrawable, 
                      para4: cuint, para5: cuint, para6: Pcuint, para7: Pcuint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XQueryBestStipple*(para1: PDisplay, para2: TDrawable, para3: cuint, 
                         para4: cuint, para5: Pcuint, para6: Pcuint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XQueryBestTile*(para1: PDisplay, para2: TDrawable, para3: cuint, 
                      para4: cuint, para5: Pcuint, para6: Pcuint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XQueryColor*(para1: PDisplay, para2: TColormap, para3: PXColor): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XQueryColors*(para1: PDisplay, para2: TColormap, para3: PXColor, 
-                   para4: cint): cint{.cdecl, dynlib: libX11, importc.}
+                   para4: cint): cint{.libx11.}
 proc XQueryExtension*(para1: PDisplay, para2: cstring, para3: Pcint, 
-                      para4: Pcint, para5: Pcint): TBool{.cdecl, dynlib: libX11, 
-    importc.}
+                      para4: Pcint, para5: Pcint): TBool{.libx11.}
   #?
-proc XQueryKeymap*(para1: PDisplay, para2: chararr32): cint{.cdecl, 
-    dynlib: libX11, importc.}
+proc XQueryKeymap*(para1: PDisplay, para2: chararr32): cint{.libx11.}
 proc XQueryPointer*(para1: PDisplay, para2: TWindow, para3: PWindow, 
                     para4: PWindow, para5: Pcint, para6: Pcint, para7: Pcint, 
-                    para8: Pcint, para9: Pcuint): TBool{.cdecl, dynlib: libX11, 
-    importc.}
+                    para8: Pcint, para9: Pcuint): TBool{.libx11.}
 proc XQueryTextExtents*(para1: PDisplay, para2: TXID, para3: cstring, 
                         para4: cint, para5: Pcint, para6: Pcint, para7: Pcint, 
-                        para8: PXCharStruct): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                        para8: PXCharStruct): cint{.libx11.}
 proc XQueryTextExtents16*(para1: PDisplay, para2: TXID, para3: PXChar2b, 
                           para4: cint, para5: Pcint, para6: Pcint, para7: Pcint, 
-                          para8: PXCharStruct): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                          para8: PXCharStruct): cint{.libx11.}
 proc XQueryTree*(para1: PDisplay, para2: TWindow, para3: PWindow, 
                  para4: PWindow, para5: PPWindow, para6: Pcuint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
-proc XRaiseWindow*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XRaiseWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.}
 proc XReadBitmapFile*(para1: PDisplay, para2: TDrawable, para3: cstring, 
                       para4: Pcuint, para5: Pcuint, para6: PPixmap, 
-                      para7: Pcint, para8: Pcint): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                      para7: Pcint, para8: Pcint): cint{.libx11.}
 proc XReadBitmapFileData*(para1: cstring, para2: Pcuint, para3: Pcuint, 
                           para4: PPcuchar, para5: Pcint, para6: Pcint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XRebindKeysym*(para1: PDisplay, para2: TKeySym, para3: PKeySym, 
-                    para4: cint, para5: Pcuchar, para6: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                    para4: cint, para5: Pcuchar, para6: cint): cint{.libx11.}
 proc XRecolorCursor*(para1: PDisplay, para2: TCursor, para3: PXColor, 
-                     para4: PXColor): cint{.cdecl, dynlib: libX11, importc.}
-proc XRefreshKeyboardMapping*(para1: PXMappingEvent): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XRemoveFromSaveSet*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XRemoveHost*(para1: PDisplay, para2: PXHostAddress): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                     para4: PXColor): cint{.libx11.}
+proc XRefreshKeyboardMapping*(para1: PXMappingEvent): cint{.libx11.}
+proc XRemoveFromSaveSet*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XRemoveHost*(para1: PDisplay, para2: PXHostAddress): cint{.libx11.}
 proc XRemoveHosts*(para1: PDisplay, para2: PXHostAddress, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XReparentWindow*(para1: PDisplay, para2: TWindow, para3: TWindow, 
-                      para4: cint, para5: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XResetScreenSaver*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
+                      para4: cint, para5: cint): cint{.libx11.}
+proc XResetScreenSaver*(para1: PDisplay): cint{.libx11.}
 proc XResizeWindow*(para1: PDisplay, para2: TWindow, para3: cuint, para4: cuint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XRestackWindows*(para1: PDisplay, para2: PWindow, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XRotateBuffers*(para1: PDisplay, para2: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
+    libx11.}
+proc XRotateBuffers*(para1: PDisplay, para2: cint): cint{.libx11.}
 proc XRotateWindowProperties*(para1: PDisplay, para2: TWindow, para3: PAtom, 
-                              para4: cint, para5: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XScreenCount*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XSelectInput*(para1: PDisplay, para2: TWindow, para3: clong): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                              para4: cint, para5: cint): cint{.libx11.}
+proc XScreenCount*(para1: PDisplay): cint{.libx11.}
+proc XSelectInput*(para1: PDisplay, para2: TWindow, para3: clong): cint{.libx11.}
 proc XSendEvent*(para1: PDisplay, para2: TWindow, para3: TBool, para4: clong, 
-                 para5: PXEvent): TStatus{.cdecl, dynlib: libX11, importc.}
-proc XSetAccessControl*(para1: PDisplay, para2: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetArcMode*(para1: PDisplay, para2: TGC, para3: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetBackground*(para1: PDisplay, para2: TGC, para3: culong): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetClipMask*(para1: PDisplay, para2: TGC, para3: TPixmap): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                 para5: PXEvent): TStatus{.libx11.}
+proc XSetAccessControl*(para1: PDisplay, para2: cint): cint{.libx11.}
+proc XSetArcMode*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.}
+proc XSetBackground*(para1: PDisplay, para2: TGC, para3: culong): cint{.libx11.}
+proc XSetClipMask*(para1: PDisplay, para2: TGC, para3: TPixmap): cint{.libx11.}
 proc XSetClipOrigin*(para1: PDisplay, para2: TGC, para3: cint, para4: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetClipRectangles*(para1: PDisplay, para2: TGC, para3: cint, para4: cint, 
                          para5: PXRectangle, para6: cint, para7: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XSetCloseDownMode*(para1: PDisplay, para2: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XSetCloseDownMode*(para1: PDisplay, para2: cint): cint{.libx11.}
 proc XSetCommand*(para1: PDisplay, para2: TWindow, para3: PPchar, para4: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetDashes*(para1: PDisplay, para2: TGC, para3: cint, para4: cstring, 
-                 para5: cint): cint{.cdecl, dynlib: libX11, importc.}
-proc XSetFillRule*(para1: PDisplay, para2: TGC, para3: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetFillStyle*(para1: PDisplay, para2: TGC, para3: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetFont*(para1: PDisplay, para2: TGC, para3: TFont): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetFontPath*(para1: PDisplay, para2: PPchar, para3: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetForeground*(para1: PDisplay, para2: TGC, para3: culong): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetFunction*(para1: PDisplay, para2: TGC, para3: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                 para5: cint): cint{.libx11.}
+proc XSetFillRule*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.}
+proc XSetFillStyle*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.}
+proc XSetFont*(para1: PDisplay, para2: TGC, para3: TFont): cint{.libx11.}
+proc XSetFontPath*(para1: PDisplay, para2: PPchar, para3: cint): cint{.libx11.}
+proc XSetForeground*(para1: PDisplay, para2: TGC, para3: culong): cint{.libx11.}
+proc XSetFunction*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.}
 proc XSetGraphicsExposures*(para1: PDisplay, para2: TGC, para3: TBool): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetIconName*(para1: PDisplay, para2: TWindow, para3: cstring): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetInputFocus*(para1: PDisplay, para2: TWindow, para3: cint, para4: TTime): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetLineAttributes*(para1: PDisplay, para2: TGC, para3: cuint, para4: cint, 
-                         para5: cint, para6: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
+                         para5: cint, para6: cint): cint{.libx11.}
 proc XSetModifierMapping*(para1: PDisplay, para2: PXModifierKeymap): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XSetPlaneMask*(para1: PDisplay, para2: TGC, para3: culong): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XSetPlaneMask*(para1: PDisplay, para2: TGC, para3: culong): cint{.libx11.}
 proc XSetPointerMapping*(para1: PDisplay, para2: Pcuchar, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetScreenSaver*(para1: PDisplay, para2: cint, para3: cint, para4: cint, 
-                      para5: cint): cint{.cdecl, dynlib: libX11, importc.}
+                      para5: cint): cint{.libx11.}
 proc XSetSelectionOwner*(para1: PDisplay, para2: TAtom, para3: TWindow, 
-                         para4: TTime): cint{.cdecl, dynlib: libX11, importc.}
+                         para4: TTime): cint{.libx11.}
 proc XSetState*(para1: PDisplay, para2: TGC, para3: culong, para4: culong, 
-                para5: cint, para6: culong): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XSetStipple*(para1: PDisplay, para2: TGC, para3: TPixmap): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XSetSubwindowMode*(para1: PDisplay, para2: TGC, para3: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                para5: cint, para6: culong): cint{.libx11.}
+proc XSetStipple*(para1: PDisplay, para2: TGC, para3: TPixmap): cint{.libx11.}
+proc XSetSubwindowMode*(para1: PDisplay, para2: TGC, para3: cint): cint{.libx11.}
 proc XSetTSOrigin*(para1: PDisplay, para2: TGC, para3: cint, para4: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XSetTile*(para1: PDisplay, para2: TGC, para3: TPixmap): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XSetTile*(para1: PDisplay, para2: TGC, para3: TPixmap): cint{.libx11.}
 proc XSetWindowBackground*(para1: PDisplay, para2: TWindow, para3: culong): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetWindowBackgroundPixmap*(para1: PDisplay, para2: TWindow, para3: TPixmap): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetWindowBorder*(para1: PDisplay, para2: TWindow, para3: culong): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetWindowBorderPixmap*(para1: PDisplay, para2: TWindow, para3: TPixmap): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetWindowBorderWidth*(para1: PDisplay, para2: TWindow, para3: cuint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XSetWindowColormap*(para1: PDisplay, para2: TWindow, para3: TColormap): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XStoreBuffer*(para1: PDisplay, para2: cstring, para3: cint, para4: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XStoreBytes*(para1: PDisplay, para2: cstring, para3: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XStoreBytes*(para1: PDisplay, para2: cstring, para3: cint): cint{.libx11.}
 proc XStoreColor*(para1: PDisplay, para2: TColormap, para3: PXColor): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XStoreColors*(para1: PDisplay, para2: TColormap, para3: PXColor, 
-                   para4: cint): cint{.cdecl, dynlib: libX11, importc.}
-proc XStoreName*(para1: PDisplay, para2: TWindow, para3: cstring): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                   para4: cint): cint{.libx11.}
+proc XStoreName*(para1: PDisplay, para2: TWindow, para3: cstring): cint{.libx11.}
 proc XStoreNamedColor*(para1: PDisplay, para2: TColormap, para3: cstring, 
-                       para4: culong, para5: cint): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XSync*(para1: PDisplay, para2: TBool): cint{.cdecl, dynlib: libX11, importc.}
+                       para4: culong, para5: cint): cint{.libx11.}
+proc XSync*(para1: PDisplay, para2: TBool): cint{.libx11.}
 proc XTextExtents*(para1: PXFontStruct, para2: cstring, para3: cint, 
                    para4: Pcint, para5: Pcint, para6: Pcint, para7: PXCharStruct): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XTextExtents16*(para1: PXFontStruct, para2: PXChar2b, para3: cint, 
                      para4: Pcint, para5: Pcint, para6: Pcint, 
-                     para7: PXCharStruct): cint{.cdecl, dynlib: libX11, importc.}
-proc XTextWidth*(para1: PXFontStruct, para2: cstring, para3: cint): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                     para7: PXCharStruct): cint{.libx11.}
+proc XTextWidth*(para1: PXFontStruct, para2: cstring, para3: cint): cint{.libx11.}
 proc XTextWidth16*(para1: PXFontStruct, para2: PXChar2b, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XTranslateCoordinates*(para1: PDisplay, para2: TWindow, para3: TWindow, 
                             para4: cint, para5: cint, para6: Pcint, 
-                            para7: Pcint, para8: PWindow): TBool{.cdecl, 
-    dynlib: libX11, importc.}
-proc XUndefineCursor*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                            para7: Pcint, para8: PWindow): TBool{.libx11.}
+proc XUndefineCursor*(para1: PDisplay, para2: TWindow): cint{.libx11.}
 proc XUngrabButton*(para1: PDisplay, para2: cuint, para3: cuint, para4: TWindow): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XUngrabKey*(para1: PDisplay, para2: cint, para3: cuint, para4: TWindow): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XUngrabKeyboard*(para1: PDisplay, para2: TTime): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XUngrabPointer*(para1: PDisplay, para2: TTime): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XUngrabServer*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
-proc XUninstallColormap*(para1: PDisplay, para2: TColormap): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XUnloadFont*(para1: PDisplay, para2: TFont): cint{.cdecl, dynlib: libX11, 
-    importc.}
-proc XUnmapSubwindows*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XUnmapWindow*(para1: PDisplay, para2: TWindow): cint{.cdecl, 
-    dynlib: libX11, importc.}
-proc XVendorRelease*(para1: PDisplay): cint{.cdecl, dynlib: libX11, importc.}
+    libx11.}
+proc XUngrabKeyboard*(para1: PDisplay, para2: TTime): cint{.libx11.}
+proc XUngrabPointer*(para1: PDisplay, para2: TTime): cint{.libx11.}
+proc XUngrabServer*(para1: PDisplay): cint{.libx11.}
+proc XUninstallColormap*(para1: PDisplay, para2: TColormap): cint{.libx11.}
+proc XUnloadFont*(para1: PDisplay, para2: TFont): cint{.libx11.}
+proc XUnmapSubwindows*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XUnmapWindow*(para1: PDisplay, para2: TWindow): cint{.libx11.}
+proc XVendorRelease*(para1: PDisplay): cint{.libx11.}
 proc XWarpPointer*(para1: PDisplay, para2: TWindow, para3: TWindow, para4: cint, 
                    para5: cint, para6: cuint, para7: cuint, para8: cint, 
-                   para9: cint): cint{.cdecl, dynlib: libX11, importc.}
-proc XWidthMMOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, importc.}
-proc XWidthOfScreen*(para1: PScreen): cint{.cdecl, dynlib: libX11, importc.}
+                   para9: cint): cint{.libx11.}
+proc XWidthMMOfScreen*(para1: PScreen): cint{.libx11.}
+proc XWidthOfScreen*(para1: PScreen): cint{.libx11.}
 proc XWindowEvent*(para1: PDisplay, para2: TWindow, para3: clong, para4: PXEvent): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XWriteBitmapFile*(para1: PDisplay, para2: cstring, para3: TPixmap, 
                        para4: cuint, para5: cuint, para6: cint, para7: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XSupportsLocale*(): TBool{.cdecl, dynlib: libX11, importc.}
-proc XSetLocaleModifiers*(para1: cstring): cstring{.cdecl, dynlib: libX11, 
-    importc.}
+    libx11.}
+proc XSupportsLocale*(): TBool{.libx11.}
+proc XSetLocaleModifiers*(para1: cstring): cstring{.libx11.}
 proc XOpenOM*(para1: PDisplay, para2: PXrmHashBucketRec, para3: cstring, 
-              para4: cstring): TXOM{.cdecl, dynlib: libX11, importc.}
-proc XCloseOM*(para1: TXOM): TStatus{.cdecl, dynlib: libX11, importc.}
-proc XSetOMValues*(para1: TXOM): cstring{.varargs, cdecl, dynlib: libX11, 
-    importc.}
-proc XGetOMValues*(para1: TXOM): cstring{.varargs, cdecl, dynlib: libX11, 
-    importc.}
-proc XDisplayOfOM*(para1: TXOM): PDisplay{.cdecl, dynlib: libX11, importc.}
-proc XLocaleOfOM*(para1: TXOM): cstring{.cdecl, dynlib: libX11, importc.}
-proc XCreateOC*(para1: TXOM): TXOC{.varargs, cdecl, dynlib: libX11, importc.}
-proc XDestroyOC*(para1: TXOC){.cdecl, dynlib: libX11, importc.}
-proc XOMOfOC*(para1: TXOC): TXOM{.cdecl, dynlib: libX11, importc.}
-proc XSetOCValues*(para1: TXOC): cstring{.varargs, cdecl, dynlib: libX11, 
-    importc.}
-proc XGetOCValues*(para1: TXOC): cstring{.varargs, cdecl, dynlib: libX11, 
-    importc.}
+              para4: cstring): TXOM{.libx11.}
+proc XCloseOM*(para1: TXOM): TStatus{.libx11.}
+proc XSetOMValues*(para1: TXOM): cstring{.varargs, libx11.}
+proc XGetOMValues*(para1: TXOM): cstring{.varargs, libx11.}
+proc XDisplayOfOM*(para1: TXOM): PDisplay{.libx11.}
+proc XLocaleOfOM*(para1: TXOM): cstring{.libx11.}
+proc XCreateOC*(para1: TXOM): TXOC{.varargs, libx11.}
+proc XDestroyOC*(para1: TXOC){.libx11.}
+proc XOMOfOC*(para1: TXOC): TXOM{.libx11.}
+proc XSetOCValues*(para1: TXOC): cstring{.varargs, libx11.}
+proc XGetOCValues*(para1: TXOC): cstring{.varargs, libx11.}
 proc XCreateFontSet*(para1: PDisplay, para2: cstring, para3: PPPchar, 
-                     para4: Pcint, para5: PPchar): TXFontSet{.cdecl, 
-    dynlib: libX11, importc.}
-proc XFreeFontSet*(para1: PDisplay, para2: TXFontSet){.cdecl, dynlib: libX11, 
-    importc.}
+                     para4: Pcint, para5: PPchar): TXFontSet{.libx11.}
+proc XFreeFontSet*(para1: PDisplay, para2: TXFontSet){.libx11.}
 proc XFontsOfFontSet*(para1: TXFontSet, para2: PPPXFontStruct, para3: PPPchar): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XBaseFontNameListOfFontSet*(para1: TXFontSet): cstring{.cdecl, 
-    dynlib: libX11, importc.}
-proc XLocaleOfFontSet*(para1: TXFontSet): cstring{.cdecl, dynlib: libX11, 
-    importc.}
-proc XContextDependentDrawing*(para1: TXFontSet): TBool{.cdecl, dynlib: libX11, 
-    importc.}
-proc XDirectionalDependentDrawing*(para1: TXFontSet): TBool{.cdecl, 
-    dynlib: libX11, importc.}
-proc XContextualDrawing*(para1: TXFontSet): TBool{.cdecl, dynlib: libX11, 
-    importc.}
-proc XExtentsOfFontSet*(para1: TXFontSet): PXFontSetExtents{.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XBaseFontNameListOfFontSet*(para1: TXFontSet): cstring{.libx11.}
+proc XLocaleOfFontSet*(para1: TXFontSet): cstring{.libx11.}
+proc XContextDependentDrawing*(para1: TXFontSet): TBool{.libx11.}
+proc XDirectionalDependentDrawing*(para1: TXFontSet): TBool{.libx11.}
+proc XContextualDrawing*(para1: TXFontSet): TBool{.libx11.}
+proc XExtentsOfFontSet*(para1: TXFontSet): PXFontSetExtents{.libx11.}
 proc XmbTextEscapement*(para1: TXFontSet, para2: cstring, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XwcTextEscapement*(para1: TXFontSet, para2: PWideChar, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc Xutf8TextEscapement*(para1: TXFontSet, para2: cstring, para3: cint): cint{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XmbTextExtents*(para1: TXFontSet, para2: cstring, para3: cint, 
-                     para4: PXRectangle, para5: PXRectangle): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                     para4: PXRectangle, para5: PXRectangle): cint{.libx11.}
 proc XwcTextExtents*(para1: TXFontSet, para2: PWideChar, para3: cint, 
-                     para4: PXRectangle, para5: PXRectangle): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                     para4: PXRectangle, para5: PXRectangle): cint{.libx11.}
 proc Xutf8TextExtents*(para1: TXFontSet, para2: cstring, para3: cint, 
-                       para4: PXRectangle, para5: PXRectangle): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                       para4: PXRectangle, para5: PXRectangle): cint{.libx11.}
 proc XmbTextPerCharExtents*(para1: TXFontSet, para2: cstring, para3: cint, 
                             para4: PXRectangle, para5: PXRectangle, para6: cint, 
                             para7: Pcint, para8: PXRectangle, para9: PXRectangle): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XwcTextPerCharExtents*(para1: TXFontSet, para2: PWideChar, para3: cint, 
                             para4: PXRectangle, para5: PXRectangle, para6: cint, 
                             para7: Pcint, para8: PXRectangle, para9: PXRectangle): TStatus{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc Xutf8TextPerCharExtents*(para1: TXFontSet, para2: cstring, para3: cint, 
                               para4: PXRectangle, para5: PXRectangle, 
                               para6: cint, para7: Pcint, para8: PXRectangle, 
-                              para9: PXRectangle): TStatus{.cdecl, 
-    dynlib: libX11, importc.}
+                              para9: PXRectangle): TStatus{.libx11.}
 proc XmbDrawText*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                  para5: cint, para6: PXmbTextItem, para7: cint){.cdecl, 
-    dynlib: libX11, importc.}
+                  para5: cint, para6: PXmbTextItem, para7: cint){.libx11.}
 proc XwcDrawText*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                  para5: cint, para6: PXwcTextItem, para7: cint){.cdecl, 
-    dynlib: libX11, importc.}
+                  para5: cint, para6: PXwcTextItem, para7: cint){.libx11.}
 proc Xutf8DrawText*(para1: PDisplay, para2: TDrawable, para3: TGC, para4: cint, 
-                    para5: cint, para6: PXmbTextItem, para7: cint){.cdecl, 
-    dynlib: libX11, importc.}
+                    para5: cint, para6: PXmbTextItem, para7: cint){.libx11.}
 proc XmbDrawString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, 
                     para4: TGC, para5: cint, para6: cint, para7: cstring, 
-                    para8: cint){.cdecl, dynlib: libX11, importc.}
+                    para8: cint){.libx11.}
 proc XwcDrawString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, 
                     para4: TGC, para5: cint, para6: cint, para7: PWideChar, 
-                    para8: cint){.cdecl, dynlib: libX11, importc.}
+                    para8: cint){.libx11.}
 proc Xutf8DrawString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, 
                       para4: TGC, para5: cint, para6: cint, para7: cstring, 
-                      para8: cint){.cdecl, dynlib: libX11, importc.}
+                      para8: cint){.libx11.}
 proc XmbDrawImageString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, 
                          para4: TGC, para5: cint, para6: cint, para7: cstring, 
-                         para8: cint){.cdecl, dynlib: libX11, importc.}
+                         para8: cint){.libx11.}
 proc XwcDrawImageString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, 
                          para4: TGC, para5: cint, para6: cint, para7: PWideChar, 
-                         para8: cint){.cdecl, dynlib: libX11, importc.}
+                         para8: cint){.libx11.}
 proc Xutf8DrawImageString*(para1: PDisplay, para2: TDrawable, para3: TXFontSet, 
                            para4: TGC, para5: cint, para6: cint, para7: cstring, 
-                           para8: cint){.cdecl, dynlib: libX11, importc.}
+                           para8: cint){.libx11.}
 proc XOpenIM*(para1: PDisplay, para2: PXrmHashBucketRec, para3: cstring, 
-              para4: cstring): TXIM{.cdecl, dynlib: libX11, importc.}
-proc XCloseIM*(para1: TXIM): TStatus{.cdecl, dynlib: libX11, importc.}
-proc XGetIMValues*(para1: TXIM): cstring{.varargs, cdecl, dynlib: libX11, 
-    importc.}
-proc XSetIMValues*(para1: TXIM): cstring{.varargs, cdecl, dynlib: libX11, 
-    importc.}
-proc XDisplayOfIM*(para1: TXIM): PDisplay{.cdecl, dynlib: libX11, importc.}
-proc XLocaleOfIM*(para1: TXIM): cstring{.cdecl, dynlib: libX11, importc.}
-proc XCreateIC*(para1: TXIM): TXIC{.varargs, cdecl, dynlib: libX11, importc.}
-proc XDestroyIC*(para1: TXIC){.cdecl, dynlib: libX11, importc.}
-proc XSetICFocus*(para1: TXIC){.cdecl, dynlib: libX11, importc.}
-proc XUnsetICFocus*(para1: TXIC){.cdecl, dynlib: libX11, importc.}
-proc XwcResetIC*(para1: TXIC): PWideChar{.cdecl, dynlib: libX11, importc.}
-proc XmbResetIC*(para1: TXIC): cstring{.cdecl, dynlib: libX11, importc.}
-proc Xutf8ResetIC*(para1: TXIC): cstring{.cdecl, dynlib: libX11, importc.}
-proc XSetICValues*(para1: TXIC): cstring{.varargs, cdecl, dynlib: libX11, 
-    importc.}
-proc XGetICValues*(para1: TXIC): cstring{.varargs, cdecl, dynlib: libX11, 
-    importc.}
-proc XIMOfIC*(para1: TXIC): TXIM{.cdecl, dynlib: libX11, importc.}
-proc XFilterEvent*(para1: PXEvent, para2: TWindow): TBool{.cdecl, 
-    dynlib: libX11, importc.}
+              para4: cstring): TXIM{.libx11.}
+proc XCloseIM*(para1: TXIM): TStatus{.libx11.}
+proc XGetIMValues*(para1: TXIM): cstring{.varargs, libx11.}
+proc XSetIMValues*(para1: TXIM): cstring{.varargs, libx11.}
+proc XDisplayOfIM*(para1: TXIM): PDisplay{.libx11.}
+proc XLocaleOfIM*(para1: TXIM): cstring{.libx11.}
+proc XCreateIC*(para1: TXIM): TXIC{.varargs, libx11.}
+proc XDestroyIC*(para1: TXIC){.libx11.}
+proc XSetICFocus*(para1: TXIC){.libx11.}
+proc XUnsetICFocus*(para1: TXIC){.libx11.}
+proc XwcResetIC*(para1: TXIC): PWideChar{.libx11.}
+proc XmbResetIC*(para1: TXIC): cstring{.libx11.}
+proc Xutf8ResetIC*(para1: TXIC): cstring{.libx11.}
+proc XSetICValues*(para1: TXIC): cstring{.varargs, libx11.}
+proc XGetICValues*(para1: TXIC): cstring{.varargs, libx11.}
+proc XIMOfIC*(para1: TXIC): TXIM{.libx11.}
+proc XFilterEvent*(para1: PXEvent, para2: TWindow): TBool{.libx11.}
 proc XmbLookupString*(para1: TXIC, para2: PXKeyPressedEvent, para3: cstring, 
-                      para4: cint, para5: PKeySym, para6: PStatus): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                      para4: cint, para5: PKeySym, para6: PStatus): cint{.libx11.}
 proc XwcLookupString*(para1: TXIC, para2: PXKeyPressedEvent, para3: PWideChar, 
-                      para4: cint, para5: PKeySym, para6: PStatus): cint{.cdecl, 
-    dynlib: libX11, importc.}
+                      para4: cint, para5: PKeySym, para6: PStatus): cint{.libx11.}
 proc Xutf8LookupString*(para1: TXIC, para2: PXKeyPressedEvent, para3: cstring, 
                         para4: cint, para5: PKeySym, para6: PStatus): cint{.
-    cdecl, dynlib: libX11, importc.}
-proc XVaCreateNestedList*(unused: cint): TXVaNestedList{.varargs, cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XVaCreateNestedList*(unused: cint): TXVaNestedList{.varargs, libx11.}
 proc XRegisterIMInstantiateCallback*(para1: PDisplay, para2: PXrmHashBucketRec, 
                                      para3: cstring, para4: cstring, 
                                      para5: TXIDProc, para6: TXPointer): TBool{.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
 proc XUnregisterIMInstantiateCallback*(para1: PDisplay, 
                                        para2: PXrmHashBucketRec, para3: cstring, 
                                        para4: cstring, para5: TXIDProc, 
-                                       para6: TXPointer): TBool{.cdecl, 
-    dynlib: libX11, importc.}
+                                       para6: TXPointer): TBool{.libx11.}
 type 
   TXConnectionWatchProc* = proc (para1: PDisplay, para2: TXPointer, para3: cint, 
                                  para4: TBool, para5: PXPointer){.cdecl.}
 
 proc XInternalConnectionNumbers*(para1: PDisplay, para2: PPcint, para3: Pcint): TStatus{.
-    cdecl, dynlib: libX11, importc.}
-proc XProcessInternalConnection*(para1: PDisplay, para2: cint){.cdecl, 
-    dynlib: libX11, importc.}
+    libx11.}
+proc XProcessInternalConnection*(para1: PDisplay, para2: cint){.libx11.}
 proc XAddConnectionWatch*(para1: PDisplay, para2: TXConnectionWatchProc, 
-                          para3: TXPointer): TStatus{.cdecl, dynlib: libX11, 
-    importc.}
+                          para3: TXPointer): TStatus{.libx11.}
 proc XRemoveConnectionWatch*(para1: PDisplay, para2: TXConnectionWatchProc, 
-                             para3: TXPointer){.cdecl, dynlib: libX11, importc.}
+                             para3: TXPointer){.libx11.}
 proc XSetAuthorization*(para1: cstring, para2: cint, para3: cstring, para4: cint){.
-    cdecl, dynlib: libX11, importc.}
+    libx11.}
   #
   #  _Xmbtowc?
   #  _Xwctomb?
diff --git a/lib/wrappers/x11/xrender.nim b/lib/wrappers/x11/xrender.nim
index 7b85fc9a7..c4b2b364d 100644
--- a/lib/wrappers/x11/xrender.nim
+++ b/lib/wrappers/x11/xrender.nim
@@ -2,8 +2,24 @@
 import 
   x, xlib
 
+when defined(use_pkg_config) or defined(use_pkg_config_static):
+    {.pragma: libxrender, cdecl, importc.}
+    when defined(use_pkg_config):
+        {.passl: gorge("pkg-config xrender --libs").}
+    else:
+        {.passl: gorge("pkg-config xrender --static --libs").}
+else:
+    when defined(macosx):
+        const 
+          libXrender* = "libXrender.dylib"
+    else:
+        const 
+          libXrender* = "libXrender.so"
+
+    
+    {.pragma: libxrender, dynlib: libXrender, cdecl, importc.}
 #const 
-#  libX11* = "libX11.so"
+#  libXrender* = "libXrender.so"
 
 #
 #  Automatically converted by H2Pas 0.99.15 from xrender.h
@@ -187,45 +203,39 @@ type
 
 
 proc XRenderQueryExtension*(dpy: PDisplay, event_basep: ptr int32, 
-                            error_basep: ptr int32): TBool{.cdecl, 
-    dynlib: libX11, importc.}
+                            error_basep: ptr int32): TBool{.libxrender.}
 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.}
+                          minor_versionp: ptr int32): TStatus{.libxrender.}
+proc XRenderQueryFormats*(dpy: PDisplay): TStatus{.libxrender.}
 proc XRenderFindVisualFormat*(dpy: PDisplay, visual: PVisual): PXRenderPictFormat{.
-    cdecl, dynlib: libX11, importc.}
+    libxrender.}
 proc XRenderFindFormat*(dpy: PDisplay, mask: int32, 
                         `template`: PXRenderPictFormat, count: int32): PXRenderPictFormat{.
-    cdecl, dynlib: libX11, importc.}
+    libxrender.}
 proc XRenderCreatePicture*(dpy: PDisplay, drawable: TDrawable, 
                            format: PXRenderPictFormat, valuemask: int32, 
                            attributes: PXRenderPictureAttributes): TPicture{.
-    cdecl, dynlib: libX11, importc.}
+    libxrender.}
 proc XRenderChangePicture*(dpy: PDisplay, picture: TPicture, valuemask: int32, 
-                           attributes: PXRenderPictureAttributes){.cdecl, 
-    dynlib: libX11, importc.}
-proc XRenderFreePicture*(dpy: PDisplay, picture: TPicture){.cdecl, 
-    dynlib: libX11, importc.}
+                           attributes: PXRenderPictureAttributes){.libxrender.}
+proc XRenderFreePicture*(dpy: PDisplay, picture: TPicture){.libxrender.}
 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.}
+                       height: int32){.libxrender.}
 proc XRenderCreateGlyphSet*(dpy: PDisplay, format: PXRenderPictFormat): TGlyphSet{.
-    cdecl, dynlib: libX11, importc.}
+    libxrender.}
 proc XRenderReferenceGlyphSet*(dpy: PDisplay, existing: TGlyphSet): TGlyphSet{.
-    cdecl, dynlib: libX11, importc.}
-proc XRenderFreeGlyphSet*(dpy: PDisplay, glyphset: TGlyphSet){.cdecl, 
-    dynlib: libX11, importc.}
+    libxrender.}
+proc XRenderFreeGlyphSet*(dpy: PDisplay, glyphset: TGlyphSet){.libxrender.}
 proc XRenderAddGlyphs*(dpy: PDisplay, glyphset: TGlyphSet, gids: PGlyph, 
                        glyphs: PXGlyphInfo, nglyphs: int32, images: cstring, 
-                       nbyte_images: int32){.cdecl, dynlib: libX11, importc.}
+                       nbyte_images: int32){.libxrender.}
 proc XRenderFreeGlyphs*(dpy: PDisplay, glyphset: TGlyphSet, gids: PGlyph, 
-                        nglyphs: int32){.cdecl, dynlib: libX11, importc.}
+                        nglyphs: int32){.libxrender.}
 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.}
+                              nchar: int32){.libxrender.}
 # implementation