Added pkg-config support to xlib, xrender, cairo, cairoxlib

lib/wrappers/cairo/cairo.nim

@@ -47,13 +47,17 @@
 #  By Luiz Américo Pereira Câmara
 #  October 2007
 #
-
+when defined(pkclibcairo):
-when defined(windows): 
+    {.passl: gorge("pkg-config cairo --libs").}
-  const LIB_CAIRO* = "libcairo-2.dll"
+    {.pragma: libcairo, cdecl.}
-elif defined(macosx):
-  const LIB_CAIRO* = "libcairo.dylib"
 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.}
 
 type 
   PByte = cstring
@@ -220,499 +224,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.}
+                                   libcairo.}
-proc reference*(cr: PContext): PContext{.cdecl, importc: "cairo_reference", dynlib: LIB_CAIRO.}
+proc reference*(cr: PContext): PContext{.cdecl, importc: "cairo_reference", libcairo.}
-proc destroy*(cr: PContext){.cdecl, importc: "cairo_destroy", dynlib: LIB_CAIRO.}
+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.}
+    importc: "cairo_set_user_data", libcairo.}
-proc save*(cr: PContext){.cdecl, importc: "cairo_save", dynlib: LIB_CAIRO.}
+proc save*(cr: PContext){.cdecl, importc: "cairo_save", libcairo.}
-proc restore*(cr: PContext){.cdecl, importc: "cairo_restore", dynlib: LIB_CAIRO.}
+proc restore*(cr: PContext){.cdecl, importc: "cairo_restore", libcairo.}
-proc push_group*(cr: PContext){.cdecl, importc: "cairo_push_group", dynlib: LIB_CAIRO.}
+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.}
+    importc: "cairo_rectangle", libcairo.}
-proc close_path*(cr: PContext){.cdecl, importc: "cairo_close_path", dynlib: LIB_CAIRO.}
+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.}
+    cdecl, importc: "cairo_mask_surface", libcairo.}
-proc stroke*(cr: PContext){.cdecl, importc: "cairo_stroke", dynlib: LIB_CAIRO.}
+proc stroke*(cr: PContext){.cdecl, importc: "cairo_stroke", libcairo.}
 proc stroke_preserve*(cr: PContext){.cdecl, importc: "cairo_stroke_preserve", 
-                              dynlib: LIB_CAIRO.}
+                              libcairo.}
-proc fill*(cr: PContext){.cdecl, importc: "cairo_fill", dynlib: LIB_CAIRO.}
+proc fill*(cr: PContext){.cdecl, importc: "cairo_fill", libcairo.}
 proc fill_preserve*(cr: PContext){.cdecl, importc: "cairo_fill_preserve", 
-                            dynlib: LIB_CAIRO.}
+                            libcairo.}
-proc copy_page*(cr: PContext){.cdecl, importc: "cairo_copy_page", dynlib: LIB_CAIRO.}
+proc copy_page*(cr: PContext){.cdecl, importc: "cairo_copy_page", libcairo.}
-proc show_page*(cr: PContext){.cdecl, importc: "cairo_show_page", dynlib: LIB_CAIRO.}
+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 reset_clip*(cr: PContext){.cdecl, importc: "cairo_reset_clip", libcairo.}
-proc clip*(cr: PContext){.cdecl, importc: "cairo_clip", dynlib: LIB_CAIRO.}
+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) = 

lib/wrappers/cairo/cairoxlib.nim

@@ -7,33 +7,46 @@
 import 
   cairo, x, xlib, xrender
 
+when defined(pkclibcairo):
+    {.passl: gorge("pkg-config cairo --libs").}
+    {.pragma: libcairo, cdecl.}
+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.}
+
+
 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

lib/wrappers/x11/xrender.nim

@@ -2,13 +2,19 @@
 import 
   x, xlib
 
-when defined(macosx):
+when defined(pkclibx):
+    {.passl: gorge("pkg-config xrender --libs").}
+    {.pragma: libxrender, cdecl, importc.}
+else:
+    when defined(macosx):
         const 
           libXrender* = "libXrender.dylib"
-else:
+    else:
         const 
           libXrender* = "libXrender.so"
 
+    
+    {.pragma: libxrender, dynlib: libXrender, cdecl, importc.}
 #const 
 #  libXrender* = "libXrender.so"
 
@@ -194,45 +200,39 @@ type
 
 
 proc XRenderQueryExtension*(dpy: PDisplay, event_basep: ptr int32, 
-                            error_basep: ptr int32): TBool{.cdecl, 
+                            error_basep: ptr int32): TBool{.libxrender.}
-    dynlib: libXrender, importc.}
 proc XRenderQueryVersion*(dpy: PDisplay, major_versionp: ptr int32, 
-                          minor_versionp: ptr int32): TStatus{.cdecl, 
+                          minor_versionp: ptr int32): TStatus{.libxrender.}
-    dynlib: libXrender, importc.}
+proc XRenderQueryFormats*(dpy: PDisplay): TStatus{.libxrender.}
-proc XRenderQueryFormats*(dpy: PDisplay): TStatus{.cdecl, dynlib: libXrender, 
-    importc.}
 proc XRenderFindVisualFormat*(dpy: PDisplay, visual: PVisual): PXRenderPictFormat{.
-    cdecl, dynlib: libXrender, importc.}
+    libxrender.}
 proc XRenderFindFormat*(dpy: PDisplay, mask: int32, 
                         `template`: PXRenderPictFormat, count: int32): PXRenderPictFormat{.
-    cdecl, dynlib: libXrender, importc.}
+    libxrender.}
 proc XRenderCreatePicture*(dpy: PDisplay, drawable: TDrawable, 
                            format: PXRenderPictFormat, valuemask: int32, 
                            attributes: PXRenderPictureAttributes): TPicture{.
-    cdecl, dynlib: libXrender, importc.}
+    libxrender.}
 proc XRenderChangePicture*(dpy: PDisplay, picture: TPicture, valuemask: int32, 
-                           attributes: PXRenderPictureAttributes){.cdecl, 
+                           attributes: PXRenderPictureAttributes){.libxrender.}
-    dynlib: libXrender, importc.}
+proc XRenderFreePicture*(dpy: PDisplay, picture: TPicture){.libxrender.}
-proc XRenderFreePicture*(dpy: PDisplay, picture: TPicture){.cdecl, 
-    dynlib: libXrender, importc.}
 proc XRenderComposite*(dpy: PDisplay, op: int32, src: TPicture, mask: TPicture, 
                        dst: TPicture, src_x: int32, src_y: int32, mask_x: int32, 
                        mask_y: int32, dst_x: int32, dst_y: int32, width: int32, 
-                       height: int32){.cdecl, dynlib: libXrender, importc.}
+                       height: int32){.libxrender.}
 proc XRenderCreateGlyphSet*(dpy: PDisplay, format: PXRenderPictFormat): TGlyphSet{.
-    cdecl, dynlib: libXrender, importc.}
+    libxrender.}
 proc XRenderReferenceGlyphSet*(dpy: PDisplay, existing: TGlyphSet): TGlyphSet{.
-    cdecl, dynlib: libXrender, importc.}
+    libxrender.}
-proc XRenderFreeGlyphSet*(dpy: PDisplay, glyphset: TGlyphSet){.cdecl, 
+proc XRenderFreeGlyphSet*(dpy: PDisplay, glyphset: TGlyphSet){.libxrender.}
-    dynlib: libXrender, importc.}
 proc XRenderAddGlyphs*(dpy: PDisplay, glyphset: TGlyphSet, gids: PGlyph, 
                        glyphs: PXGlyphInfo, nglyphs: int32, images: cstring, 
-                       nbyte_images: int32){.cdecl, dynlib: libXrender, importc.}
+                       nbyte_images: int32){.libxrender.}
 proc XRenderFreeGlyphs*(dpy: PDisplay, glyphset: TGlyphSet, gids: PGlyph, 
-                        nglyphs: int32){.cdecl, dynlib: libXrender, 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: libXrender, importc.}
+                              nchar: int32){.libxrender.}
 # implementation