mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2026-01-04 20:17:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

further development of new wrappers

Browse Source
This commit is contained in:
Andreas Rumpf
2010-01-08 00:29:58 +01:00
parent a830367996
commit 868f8f8af7
20 changed files with 1381 additions and 1962 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
lib/newwrap/cairo/cairo.nim
View File

@@ -115,7 +115,7 @@ type
SVG_VERSION_1_1, SVG_VERSION_1_2
PSurface* = ptr TSurface
PPCairoSurface* = ptr PSurface
P* = ptr T
PCairo* = ptr TCario
PPattern* = ptr TPattern
PFontOptions* = ptr TFontOptions
PFontFace* = ptr TFontFace
@@ -135,7 +135,7 @@ type
TDestroyFunc* = proc (data: Pointer){.cdecl.}
TWriteFunc* = proc (closure: Pointer, data: PByte, len: int32): TStatus{.cdecl.}
TReadFunc* = proc (closure: Pointer, data: PByte, len: int32): TStatus{.cdecl.}
T*{.final.} = object #OPAQUE
TCario*{.final.} = object #OPAQUE
TSurface*{.final.} = object #OPAQUE
TPattern*{.final.} = object #OPAQUE
TScaledFont*{.final.} = object #OPAQUE
@@ -198,130 +198,130 @@ proc version_string*(): cstring{.cdecl, importc: "cairo_version_string",
#Helper function to retrieve decoded version
proc version*(major, minor, micro: var int32)
#* Functions for manipulating state objects
proc create*(target: PSurface): P{.cdecl, importc: "cairo_create",
proc create*(target: PSurface): PCairo{.cdecl, importc: "cairo_create",
dynlib: LIB_CAIRO.}
proc reference*(cr: P): P{.cdecl, importc: "cairo_reference", dynlib: LIB_CAIRO.}
proc destroy*(cr: P){.cdecl, importc: "cairo_destroy", dynlib: LIB_CAIRO.}
proc get_reference_count*(cr: P): int32{.cdecl,
proc reference*(cr: PCairo): PCairo{.cdecl, importc: "cairo_reference", dynlib: LIB_CAIRO.}
proc destroy*(cr: PCairo){.cdecl, importc: "cairo_destroy", dynlib: LIB_CAIRO.}
proc get_reference_count*(cr: PCairo): int32{.cdecl,
importc: "cairo_get_reference_count", dynlib: LIB_CAIRO.}
proc get_user_data*(cr: P, key: PUserDataKey): pointer{.cdecl,
proc get_user_data*(cr: PCairo, key: PUserDataKey): pointer{.cdecl,
importc: "cairo_get_user_data", dynlib: LIB_CAIRO.}
proc set_user_data*(cr: P, key: PUserDataKey, user_data: Pointer,
proc set_user_data*(cr: PCairo, key: PUserDataKey, user_data: Pointer,
destroy: TDestroyFunc): TStatus{.cdecl,
importc: "cairo_set_user_data", dynlib: LIB_CAIRO.}
proc save*(cr: P){.cdecl, importc: "cairo_save", dynlib: LIB_CAIRO.}
proc restore*(cr: P){.cdecl, importc: "cairo_restore", dynlib: LIB_CAIRO.}
proc push_group*(cr: P){.cdecl, importc: "cairo_push_group", dynlib: LIB_CAIRO.}
proc push_group_with_content*(cr: P, content: TContent){.cdecl,
proc save*(cr: PCairo){.cdecl, importc: "cairo_save", dynlib: LIB_CAIRO.}
proc restore*(cr: PCairo){.cdecl, importc: "cairo_restore", dynlib: LIB_CAIRO.}
proc push_group*(cr: PCairo){.cdecl, importc: "cairo_push_group", dynlib: LIB_CAIRO.}
proc push_group_with_content*(cr: PCairo, content: TContent){.cdecl,
importc: "cairo_push_group_with_content", dynlib: LIB_CAIRO.}
proc pop_group*(cr: P): PPattern{.cdecl, importc: "cairo_pop_group",
proc pop_group*(cr: PCairo): PPattern{.cdecl, importc: "cairo_pop_group",
dynlib: LIB_CAIRO.}
proc pop_group_to_source*(cr: P){.cdecl, importc: "cairo_pop_group_to_source",
proc pop_group_to_source*(cr: PCairo){.cdecl, importc: "cairo_pop_group_to_source",
dynlib: LIB_CAIRO.}
#* Modify state
proc set_operator*(cr: P, op: TOperator){.cdecl, importc: "cairo_set_operator",
proc set_operator*(cr: PCairo, op: TOperator){.cdecl, importc: "cairo_set_operator",
dynlib: LIB_CAIRO.}
proc set_source*(cr: P, source: PPattern){.cdecl, importc: "cairo_set_source",
proc set_source*(cr: PCairo, source: PPattern){.cdecl, importc: "cairo_set_source",
dynlib: LIB_CAIRO.}
proc set_source_rgb*(cr: P, red, green, blue: float64){.cdecl,
proc set_source_rgb*(cr: PCairo, red, green, blue: float64){.cdecl,
importc: "cairo_set_source_rgb", dynlib: LIB_CAIRO.}
proc set_source_rgba*(cr: P, red, green, blue, alpha: float64){.cdecl,
proc set_source_rgba*(cr: PCairo, red, green, blue, alpha: float64){.cdecl,
importc: "cairo_set_source_rgba", dynlib: LIB_CAIRO.}
proc set_source_surface*(cr: P, surface: PSurface, x, y: float64){.cdecl,
proc set_source_surface*(cr: PCairo, surface: PSurface, x, y: float64){.cdecl,
importc: "cairo_set_source_surface", dynlib: LIB_CAIRO.}
proc set_tolerance*(cr: P, tolerance: float64){.cdecl,
proc set_tolerance*(cr: PCairo, tolerance: float64){.cdecl,
importc: "cairo_set_tolerance", dynlib: LIB_CAIRO.}
proc set_antialias*(cr: P, antialias: TAntialias){.cdecl,
proc set_antialias*(cr: PCairo, antialias: TAntialias){.cdecl,
importc: "cairo_set_antialias", dynlib: LIB_CAIRO.}
proc set_fill_rule*(cr: P, fill_rule: TFillRule){.cdecl,
proc set_fill_rule*(cr: PCairo, fill_rule: TFillRule){.cdecl,
importc: "cairo_set_fill_rule", dynlib: LIB_CAIRO.}
proc set_line_width*(cr: P, width: float64){.cdecl,
proc set_line_width*(cr: PCairo, width: float64){.cdecl,
importc: "cairo_set_line_width", dynlib: LIB_CAIRO.}
proc set_line_cap*(cr: P, line_cap: TLineCap){.cdecl,
proc set_line_cap*(cr: PCairo, line_cap: TLineCap){.cdecl,
importc: "cairo_set_line_cap", dynlib: LIB_CAIRO.}
proc set_line_join*(cr: P, line_join: TLineJoin){.cdecl,
proc set_line_join*(cr: PCairo, line_join: TLineJoin){.cdecl,
importc: "cairo_set_line_join", dynlib: LIB_CAIRO.}
proc set_dash*(cr: P, dashes: openarray[float64], offset: float64){.cdecl,
proc set_dash*(cr: PCairo, dashes: openarray[float64], offset: float64){.cdecl,
importc: "cairo_set_dash", dynlib: LIB_CAIRO.}
proc set_miter_limit*(cr: P, limit: float64){.cdecl,
proc set_miter_limit*(cr: PCairo, limit: float64){.cdecl,
importc: "cairo_set_miter_limit", dynlib: LIB_CAIRO.}
proc translate*(cr: P, tx, ty: float64){.cdecl, importc: "cairo_translate",
proc translate*(cr: PCairo, tx, ty: float64){.cdecl, importc: "cairo_translate",
dynlib: LIB_CAIRO.}
proc scale*(cr: P, sx, sy: float64){.cdecl, importc: "cairo_scale",
proc scale*(cr: PCairo, sx, sy: float64){.cdecl, importc: "cairo_scale",
dynlib: LIB_CAIRO.}
proc rotate*(cr: P, angle: float64){.cdecl, importc: "cairo_rotate",
proc rotate*(cr: PCairo, angle: float64){.cdecl, importc: "cairo_rotate",
dynlib: LIB_CAIRO.}
proc transform*(cr: P, matrix: PMatrix){.cdecl, importc: "cairo_transform",
proc transform*(cr: PCairo, matrix: PMatrix){.cdecl, importc: "cairo_transform",
dynlib: LIB_CAIRO.}
proc set_matrix*(cr: P, matrix: PMatrix){.cdecl, importc: "cairo_set_matrix",
proc set_matrix*(cr: PCairo, matrix: PMatrix){.cdecl, importc: "cairo_set_matrix",
dynlib: LIB_CAIRO.}
proc identity_matrix*(cr: P){.cdecl, importc: "cairo_identity_matrix",
proc identity_matrix*(cr: PCairo){.cdecl, importc: "cairo_identity_matrix",
dynlib: LIB_CAIRO.}
proc user_to_device*(cr: P, x, y: var float64){.cdecl,
proc user_to_device*(cr: PCairo, x, y: var float64){.cdecl,
importc: "cairo_user_to_device", dynlib: LIB_CAIRO.}
proc user_to_device_distance*(cr: P, dx, dy: var float64){.cdecl,
proc user_to_device_distance*(cr: PCairo, dx, dy: var float64){.cdecl,
importc: "cairo_user_to_device_distance", dynlib: LIB_CAIRO.}
proc device_to_user*(cr: P, x, y: var float64){.cdecl,
proc device_to_user*(cr: PCairo, x, y: var float64){.cdecl,
importc: "cairo_device_to_user", dynlib: LIB_CAIRO.}
proc device_to_user_distance*(cr: P, dx, dy: var float64){.cdecl,
proc device_to_user_distance*(cr: PCairo, dx, dy: var float64){.cdecl,
importc: "cairo_device_to_user_distance", dynlib: LIB_CAIRO.}
#* Path creation functions
proc new_path*(cr: P){.cdecl, importc: "cairo_new_path", dynlib: LIB_CAIRO.}
proc move_to*(cr: P, x, y: float64){.cdecl, importc: "cairo_move_to",
proc new_path*(cr: PCairo){.cdecl, importc: "cairo_new_path", dynlib: LIB_CAIRO.}
proc move_to*(cr: PCairo, x, y: float64){.cdecl, importc: "cairo_move_to",
dynlib: LIB_CAIRO.}
proc new_sub_path*(cr: P){.cdecl, importc: "cairo_new_sub_path",
proc new_sub_path*(cr: PCairo){.cdecl, importc: "cairo_new_sub_path",
dynlib: LIB_CAIRO.}
proc line_to*(cr: P, x, y: float64){.cdecl, importc: "cairo_line_to",
proc line_to*(cr: PCairo, x, y: float64){.cdecl, importc: "cairo_line_to",
dynlib: LIB_CAIRO.}
proc curve_to*(cr: P, x1, y1, x2, y2, x3, y3: float64){.cdecl,
proc curve_to*(cr: PCairo, x1, y1, x2, y2, x3, y3: float64){.cdecl,
importc: "cairo_curve_to", dynlib: LIB_CAIRO.}
proc arc*(cr: P, xc, yc, radius, angle1, angle2: float64){.cdecl,
proc arc*(cr: PCairo, xc, yc, radius, angle1, angle2: float64){.cdecl,
importc: "cairo_arc", dynlib: LIB_CAIRO.}
proc arc_negative*(cr: P, xc, yc, radius, angle1, angle2: float64){.cdecl,
proc arc_negative*(cr: PCairo, xc, yc, radius, angle1, angle2: float64){.cdecl,
importc: "cairo_arc_negative", dynlib: LIB_CAIRO.}
proc rel_move_to*(cr: P, dx, dy: float64){.cdecl, importc: "cairo_rel_move_to",
proc rel_move_to*(cr: PCairo, dx, dy: float64){.cdecl, importc: "cairo_rel_move_to",
dynlib: LIB_CAIRO.}
proc rel_line_to*(cr: P, dx, dy: float64){.cdecl, importc: "cairo_rel_line_to",
proc rel_line_to*(cr: PCairo, dx, dy: float64){.cdecl, importc: "cairo_rel_line_to",
dynlib: LIB_CAIRO.}
proc rel_curve_to*(cr: P, dx1, dy1, dx2, dy2, dx3, dy3: float64){.cdecl,
proc rel_curve_to*(cr: PCairo, dx1, dy1, dx2, dy2, dx3, dy3: float64){.cdecl,
importc: "cairo_rel_curve_to", dynlib: LIB_CAIRO.}
proc rectangle*(cr: P, x, y, width, height: float64){.cdecl,
proc rectangle*(cr: PCairo, x, y, width, height: float64){.cdecl,
importc: "cairo_rectangle", dynlib: LIB_CAIRO.}
proc close_path*(cr: P){.cdecl, importc: "cairo_close_path", dynlib: LIB_CAIRO.}
proc close_path*(cr: PCairo){.cdecl, importc: "cairo_close_path", dynlib: LIB_CAIRO.}
#* Painting functions
proc paint*(cr: P){.cdecl, importc: "cairo_paint", dynlib: LIB_CAIRO.}
proc paint_with_alpha*(cr: P, alpha: float64){.cdecl,
proc paint*(cr: PCairo){.cdecl, importc: "cairo_paint", dynlib: LIB_CAIRO.}
proc paint_with_alpha*(cr: PCairo, alpha: float64){.cdecl,
importc: "cairo_paint_with_alpha", dynlib: LIB_CAIRO.}
proc mask*(cr: P, pattern: PPattern){.cdecl, importc: "cairo_mask",
proc mask*(cr: PCairo, pattern: PPattern){.cdecl, importc: "cairo_mask",
dynlib: LIB_CAIRO.}
proc mask_surface*(cr: P, surface: PSurface, surface_x, surface_y: float64){.
proc mask_surface*(cr: PCairo, surface: PSurface, surface_x, surface_y: float64){.
cdecl, importc: "cairo_mask_surface", dynlib: LIB_CAIRO.}
proc stroke*(cr: P){.cdecl, importc: "cairo_stroke", dynlib: LIB_CAIRO.}
proc stroke_preserve*(cr: P){.cdecl, importc: "cairo_stroke_preserve",
proc stroke*(cr: PCairo){.cdecl, importc: "cairo_stroke", dynlib: LIB_CAIRO.}
proc stroke_preserve*(cr: PCairo){.cdecl, importc: "cairo_stroke_preserve",
dynlib: LIB_CAIRO.}
proc fill*(cr: P){.cdecl, importc: "cairo_fill", dynlib: LIB_CAIRO.}
proc fill_preserve*(cr: P){.cdecl, importc: "cairo_fill_preserve",
proc fill*(cr: PCairo){.cdecl, importc: "cairo_fill", dynlib: LIB_CAIRO.}
proc fill_preserve*(cr: PCairo){.cdecl, importc: "cairo_fill_preserve",
dynlib: LIB_CAIRO.}
proc copy_page*(cr: P){.cdecl, importc: "cairo_copy_page", dynlib: LIB_CAIRO.}
proc show_page*(cr: P){.cdecl, importc: "cairo_show_page", dynlib: LIB_CAIRO.}
proc copy_page*(cr: PCairo){.cdecl, importc: "cairo_copy_page", dynlib: LIB_CAIRO.}
proc show_page*(cr: PCairo){.cdecl, importc: "cairo_show_page", dynlib: LIB_CAIRO.}
#* Insideness testing
proc in_stroke*(cr: P, x, y: float64): TBool{.cdecl, importc: "cairo_in_stroke",
proc in_stroke*(cr: PCairo, x, y: float64): TBool{.cdecl, importc: "cairo_in_stroke",
dynlib: LIB_CAIRO.}
proc in_fill*(cr: P, x, y: float64): TBool{.cdecl, importc: "cairo_in_fill",
proc in_fill*(cr: PCairo, x, y: float64): TBool{.cdecl, importc: "cairo_in_fill",
dynlib: LIB_CAIRO.}
#* Rectangular extents
proc stroke_extents*(cr: P, x1, y1, x2, y2: var float64){.cdecl,
proc stroke_extents*(cr: PCairo, x1, y1, x2, y2: var float64){.cdecl,
importc: "cairo_stroke_extents", dynlib: LIB_CAIRO.}
proc fill_extents*(cr: P, x1, y1, x2, y2: var float64){.cdecl,
proc fill_extents*(cr: PCairo, x1, y1, x2, y2: var float64){.cdecl,
importc: "cairo_fill_extents", dynlib: LIB_CAIRO.}
#* Clipping
proc reset_clip*(cr: P){.cdecl, importc: "cairo_reset_clip", dynlib: LIB_CAIRO.}
proc clip*(cr: P){.cdecl, importc: "cairo_clip", dynlib: LIB_CAIRO.}
proc clip_preserve*(cr: P){.cdecl, importc: "cairo_clip_preserve",
proc reset_clip*(cr: PCairo){.cdecl, importc: "cairo_reset_clip", dynlib: LIB_CAIRO.}
proc clip*(cr: PCairo){.cdecl, importc: "cairo_clip", dynlib: LIB_CAIRO.}
proc clip_preserve*(cr: PCairo){.cdecl, importc: "cairo_clip_preserve",
dynlib: LIB_CAIRO.}
proc clip_extents*(cr: P, x1, y1, x2, y2: var float64){.cdecl,
proc clip_extents*(cr: PCairo, x1, y1, x2, y2: var float64){.cdecl,
importc: "cairo_clip_extents", dynlib: LIB_CAIRO.}
proc copy_clip_rectangle_list*(cr: P): PRectangleList{.cdecl,
proc copy_clip_rectangle_list*(cr: PCairo): PRectangleList{.cdecl,
importc: "cairo_copy_clip_rectangle_list", dynlib: LIB_CAIRO.}
proc rectangle_list_destroy*(rectangle_list: PRectangleList){.cdecl,
importc: "cairo_rectangle_list_destroy", dynlib: LIB_CAIRO.}
@@ -360,41 +360,41 @@ proc font_options_get_hint_metrics*(options: PFontOptions): THintMetrics{.cdecl,
importc: "cairo_font_options_get_hint_metrics", dynlib: LIB_CAIRO.}
#* This interface is for dealing with text as text, not caring about the
# font object inside the the TCairo.
proc select_font_face*(cr: P, family: cstring, slant: TFontSlant,
proc select_font_face*(cr: PCairo, family: cstring, slant: TFontSlant,
weight: TFontWeight){.cdecl,
importc: "cairo_select_font_face", dynlib: LIB_CAIRO.}
proc set_font_size*(cr: P, size: float64){.cdecl,
proc set_font_size*(cr: PCairo, size: float64){.cdecl,
importc: "cairo_set_font_size", dynlib: LIB_CAIRO.}
proc set_font_matrix*(cr: P, matrix: PMatrix){.cdecl,
proc set_font_matrix*(cr: PCairo, matrix: PMatrix){.cdecl,
importc: "cairo_set_font_matrix", dynlib: LIB_CAIRO.}
proc get_font_matrix*(cr: P, matrix: PMatrix){.cdecl,
proc get_font_matrix*(cr: PCairo, matrix: PMatrix){.cdecl,
importc: "cairo_get_font_matrix", dynlib: LIB_CAIRO.}
proc set_font_options*(cr: P, options: PFontOptions){.cdecl,
proc set_font_options*(cr: PCairo, options: PFontOptions){.cdecl,
importc: "cairo_set_font_options", dynlib: LIB_CAIRO.}
proc get_font_options*(cr: P, options: PFontOptions){.cdecl,
proc get_font_options*(cr: PCairo, options: PFontOptions){.cdecl,
importc: "cairo_get_font_options", dynlib: LIB_CAIRO.}
proc set_font_face*(cr: P, font_face: PFontFace){.cdecl,
proc set_font_face*(cr: PCairo, font_face: PFontFace){.cdecl,
importc: "cairo_set_font_face", dynlib: LIB_CAIRO.}
proc get_font_face*(cr: P): PFontFace{.cdecl, importc: "cairo_get_font_face",
proc get_font_face*(cr: PCairo): PFontFace{.cdecl, importc: "cairo_get_font_face",
dynlib: LIB_CAIRO.}
proc set_scaled_font*(cr: P, scaled_font: PScaledFont){.cdecl,
proc set_scaled_font*(cr: PCairo, scaled_font: PScaledFont){.cdecl,
importc: "cairo_set_scaled_font", dynlib: LIB_CAIRO.}
proc get_scaled_font*(cr: P): PScaledFont{.cdecl,
proc get_scaled_font*(cr: PCairo): PScaledFont{.cdecl,
importc: "cairo_get_scaled_font", dynlib: LIB_CAIRO.}
proc show_text*(cr: P, utf8: cstring){.cdecl, importc: "cairo_show_text",
proc show_text*(cr: PCairo, utf8: cstring){.cdecl, importc: "cairo_show_text",
dynlib: LIB_CAIRO.}
proc show_glyphs*(cr: P, glyphs: PGlyph, num_glyphs: int32){.cdecl,
proc show_glyphs*(cr: PCairo, glyphs: PGlyph, num_glyphs: int32){.cdecl,
importc: "cairo_show_glyphs", dynlib: LIB_CAIRO.}
proc text_path*(cr: P, utf8: cstring){.cdecl, importc: "cairo_text_path",
proc text_path*(cr: PCairo, utf8: cstring){.cdecl, importc: "cairo_text_path",
dynlib: LIB_CAIRO.}
proc glyph_path*(cr: P, glyphs: PGlyph, num_glyphs: int32){.cdecl,
proc glyph_path*(cr: PCairo, glyphs: PGlyph, num_glyphs: int32){.cdecl,
importc: "cairo_glyph_path", dynlib: LIB_CAIRO.}
proc text_extents*(cr: P, utf8: cstring, extents: PTextExtents){.cdecl,
proc text_extents*(cr: PCairo, utf8: cstring, extents: PTextExtents){.cdecl,
importc: "cairo_text_extents", dynlib: LIB_CAIRO.}
proc glyph_extents*(cr: P, glyphs: PGlyph, num_glyphs: int32,
proc glyph_extents*(cr: PCairo, glyphs: PGlyph, num_glyphs: int32,
extents: PTextExtents){.cdecl,
importc: "cairo_glyph_extents", dynlib: LIB_CAIRO.}
proc font_extents*(cr: P, extents: PFontExtents){.cdecl,
proc font_extents*(cr: PCairo, extents: PFontExtents){.cdecl,
importc: "cairo_font_extents", dynlib: LIB_CAIRO.}
#* Generic identifier for a font style
proc font_face_reference*(font_face: PFontFace): PFontFace{.cdecl,
@@ -449,46 +449,46 @@ proc scaled_font_get_font_options*(scaled_font: PScaledFont,
options: PFontOptions){.cdecl,
importc: "cairo_scaled_font_get_font_options", dynlib: LIB_CAIRO.}
#* Query functions
proc get_operator*(cr: P): TOperator{.cdecl, importc: "cairo_get_operator",
proc get_operator*(cr: PCairo): TOperator{.cdecl, importc: "cairo_get_operator",
dynlib: LIB_CAIRO.}
proc get_source*(cr: P): PPattern{.cdecl, importc: "cairo_get_source",
proc get_source*(cr: PCairo): PPattern{.cdecl, importc: "cairo_get_source",
dynlib: LIB_CAIRO.}
proc get_tolerance*(cr: P): float64{.cdecl, importc: "cairo_get_tolerance",
proc get_tolerance*(cr: PCairo): float64{.cdecl, importc: "cairo_get_tolerance",
dynlib: LIB_CAIRO.}
proc get_antialias*(cr: P): TAntialias{.cdecl, importc: "cairo_get_antialias",
proc get_antialias*(cr: PCairo): TAntialias{.cdecl, importc: "cairo_get_antialias",
dynlib: LIB_CAIRO.}
proc get_current_point*(cr: P, x, y: var float64){.cdecl,
proc get_current_point*(cr: PCairo, x, y: var float64){.cdecl,
importc: "cairo_get_current_point", dynlib: LIB_CAIRO.}
proc get_fill_rule*(cr: P): TFillRule{.cdecl, importc: "cairo_get_fill_rule",
proc get_fill_rule*(cr: PCairo): TFillRule{.cdecl, importc: "cairo_get_fill_rule",
dynlib: LIB_CAIRO.}
proc get_line_width*(cr: P): float64{.cdecl, importc: "cairo_get_line_width",
proc get_line_width*(cr: PCairo): float64{.cdecl, importc: "cairo_get_line_width",
dynlib: LIB_CAIRO.}
proc get_line_cap*(cr: P): TLineCap{.cdecl, importc: "cairo_get_line_cap",
proc get_line_cap*(cr: PCairo): TLineCap{.cdecl, importc: "cairo_get_line_cap",
dynlib: LIB_CAIRO.}
proc get_line_join*(cr: P): TLineJoin{.cdecl, importc: "cairo_get_line_join",
proc get_line_join*(cr: PCairo): TLineJoin{.cdecl, importc: "cairo_get_line_join",
dynlib: LIB_CAIRO.}
proc get_miter_limit*(cr: P): float64{.cdecl, importc: "cairo_get_miter_limit",
proc get_miter_limit*(cr: PCairo): float64{.cdecl, importc: "cairo_get_miter_limit",
dynlib: LIB_CAIRO.}
proc get_dash_count*(cr: P): int32{.cdecl, importc: "cairo_get_dash_count",
proc get_dash_count*(cr: PCairo): int32{.cdecl, importc: "cairo_get_dash_count",
dynlib: LIB_CAIRO.}
proc get_dash*(cr: P, dashes, offset: var float64){.cdecl,
proc get_dash*(cr: PCairo, dashes, offset: var float64){.cdecl,
importc: "cairo_get_dash", dynlib: LIB_CAIRO.}
proc get_matrix*(cr: P, matrix: PMatrix){.cdecl, importc: "cairo_get_matrix",
proc get_matrix*(cr: PCairo, matrix: PMatrix){.cdecl, importc: "cairo_get_matrix",
dynlib: LIB_CAIRO.}
proc get_target*(cr: P): PSurface{.cdecl, importc: "cairo_get_target",
proc get_target*(cr: PCairo): PSurface{.cdecl, importc: "cairo_get_target",
dynlib: LIB_CAIRO.}
proc get_group_target*(cr: P): PSurface{.cdecl,
proc get_group_target*(cr: PCairo): PSurface{.cdecl,
importc: "cairo_get_group_target", dynlib: LIB_CAIRO.}
proc copy_path*(cr: P): PPath{.cdecl, importc: "cairo_copy_path",
proc copy_path*(cr: PCairo): PPath{.cdecl, importc: "cairo_copy_path",
dynlib: LIB_CAIRO.}
proc copy_path_flat*(cr: P): PPath{.cdecl, importc: "cairo_copy_path_flat",
proc copy_path_flat*(cr: PCairo): PPath{.cdecl, importc: "cairo_copy_path_flat",
dynlib: LIB_CAIRO.}
proc append_path*(cr: P, path: PPath){.cdecl, importc: "cairo_append_path",
proc append_path*(cr: PCairo, path: PPath){.cdecl, importc: "cairo_append_path",
dynlib: LIB_CAIRO.}
proc path_destroy*(path: PPath){.cdecl, importc: "cairo_path_destroy",
dynlib: LIB_CAIRO.}
#* Error status queries
proc status*(cr: P): TStatus{.cdecl, importc: "cairo_status", dynlib: LIB_CAIRO.}
proc status*(cr: PCairo): TStatus{.cdecl, importc: "cairo_status", dynlib: LIB_CAIRO.}
proc status_to_string*(status: TStatus): cstring{.cdecl,
importc: "cairo_status_to_string", dynlib: LIB_CAIRO.}
#* Surface manipulation

4
lib/newwrap/cairo/cairoft.nim
View File

@@ -5,7 +5,7 @@
#
import
, freetypeh
cairo, freetypeh
#todo: properly define FcPattern:
#It will require translate FontConfig header
@@ -32,4 +32,4 @@ proc ft_font_face_create_for_ft_face*(face: TFT_Face, load_flags: int32): PFontF
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.}
importc: "cairo_ft_scaled_font_unlock_face", dynlib: LIB_CAIRO.}

2
lib/newwrap/cairo/cairowin32.nim
View File

@@ -4,7 +4,7 @@
#
import
, windows
cairo, windows
proc win32_surface_create*(hdc: HDC): PSurface{.cdecl,
importc: "cairo_win32_surface_create", dynlib: LIB_CAIRO.}

2
lib/newwrap/cairo/cairoxlib.nim
View File

@@ -5,7 +5,7 @@
#
import
, x, xlib, xrender
cairo, x, xlib, xrender
proc xlib_surface_create*(dpy: PDisplay, drawable: TDrawable, visual: PVisual,
width, height: int32): PSurface{.cdecl,

4
lib/newwrap/gtk/atk.nim
View File

@@ -462,7 +462,7 @@ proc role_register*(name: cstring): TRole{.cdecl, dynlib: lib,
proc object_get_type*(): GType{.cdecl, dynlib: lib,
importc: "atk_object_get_type".}
proc TYPE_OBJECT*(): GType
proc OBJECT*(obj: pointer): PObject
proc `OBJECT`*(obj: pointer): PObject
proc OBJECT_CLASS*(klass: pointer): PObjectClass
proc IS_OBJECT*(obj: pointer): bool
proc IS_OBJECT_CLASS*(klass: pointer): bool
@@ -983,7 +983,7 @@ proc value_set_current_value*(obj: PValue, value: PGValue): gboolean{.cdecl,
proc TYPE_OBJECT*(): GType =
result = object_get_type()
proc OBJECT*(obj: pointer): PObject =
proc `OBJECT`*(obj: pointer): PObject =
result = cast[PObject](G_TYPE_CHECK_INSTANCE_CAST(obj, TYPE_OBJECT()))
proc OBJECT_CLASS*(klass: pointer): PObjectClass =

149
lib/newwrap/gtk/gdk2.nim
View File

@@ -1,6 +1,6 @@
{.deadCodeElim: on.}
import
glib2, 2pixbuf, pango
glib2, gdk2pixbuf, pango
when defined(win32):
const
@@ -56,8 +56,9 @@ type
PFunction* = ptr TFunction
TFunction* = enum
COPY, INVERT, XOR, CLEAR, AND, AND_REVERSE, AND_INVERT, NOOP, OR, EQUIV,
OR_REVERSE, COPY_INVERT, OR_INVERT, NAND, NOR, SET
funcCOPY, funcINVERT, funcXOR, funcCLEAR, funcAND,
funcAND_REVERSE, funcAND_INVERT, funcNOOP, funcOR, funcEQUIV,
funcOR_REVERSE, funcCOPY_INVERT, funcOR_INVERT, funcNAND, funcNOR, funcSET
PCapStyle* = ptr TCapStyle
TCapStyle* = enum
CAP_NOT_LAST, CAP_BUTT, CAP_ROUND, CAP_PROJECTING
@@ -109,7 +110,7 @@ type
PImage* = ptr TImage
PDevice* = ptr TDevice
PTimeCoord* = ptr TTimeCoord
PPGdkTimeCoord* = ptr PTimeCoord
PPTimeCoord* = ptr PTimeCoord
PRgbDither* = ptr TRgbDither
TRgbDither* = enum
RGB_DITHER_NONE, RGB_DITHER_NORMAL, RGB_DITHER_MAX
@@ -125,7 +126,7 @@ type
y*: gint
PPoint* = ptr TPoint
PPGdkPoint* = ptr PPoint
PPPoint* = ptr PPoint
PSpan* = ptr TSpan
PWChar* = ptr TWChar
TWChar* = guint32
@@ -247,8 +248,8 @@ type
nsegs: gint){.cdecl.}
draw_lines*: proc (drawable: PDrawable, gc: PGC, points: PPoint,
npoints: gint){.cdecl.}
draw_glyphs*: proc (drawable: PDrawable, gc: PGC, font: PPangoFont, x: gint,
y: gint, glyphs: PPangoGlyphString){.cdecl.}
draw_glyphs*: proc (drawable: PDrawable, gc: PGC, font: PFont, x: gint,
y: gint, glyphs: PGlyphString){.cdecl.}
draw_image*: proc (drawable: PDrawable, gc: PGC, image: PImage, xsrc: gint,
ysrc: gint, xdest: gint, ydest: gint, width: gint,
height: gint){.cdecl.}
@@ -509,25 +510,25 @@ type
TEvent*{.final, pure.} = object
data*: array[0..255, char] # union of
# `type`: TGdkEventType
# any: TGdkEventAny
# expose: TGdkEventExpose
# no_expose: TGdkEventNoExpose
# visibility: TGdkEventVisibility
# motion: TGdkEventMotion
# button: TGdkEventButton
# scroll: TGdkEventScroll
# key: TGdkEventKey
# crossing: TGdkEventCrossing
# focus_change: TGdkEventFocus
# configure: TGdkEventConfigure
# `property`: TGdkEventProperty
# selection: TGdkEventSelection
# proximity: TGdkEventProximity
# client: TGdkEventClient
# dnd: TGdkEventDND
# window_state: TGdkEventWindowState
# setting: TGdkEventSetting
# `type`: TEventType
# any: TEventAny
# expose: TEventExpose
# no_expose: TEventNoExpose
# visibility: TEventVisibility
# motion: TEventMotion
# button: TEventButton
# scroll: TEventScroll
# key: TEventKey
# crossing: TEventCrossing
# focus_change: TEventFocus
# configure: TEventConfigure
# `property`: TEventProperty
# selection: TEventSelection
# proximity: TEventProximity
# client: TEventClient
# dnd: TEventDND
# window_state: TEventWindowState
# setting: TEventSetting
PGCClass* = ptr TGCClass
TGCClass* = object of TGObjectClass
@@ -606,14 +607,14 @@ type
TKeymapClass* = object of TGObjectClass
direction_changed*: proc (keymap: PKeymap){.cdecl.}
PPangoAttrStipple* = ptr TPangoAttrStipple
TPangoAttrStipple*{.final, pure.} = object
attr*: TPangoAttribute
PAttrStipple* = ptr TAttrStipple
TAttrStipple*{.final, pure.} = object
attr*: TAttribute
stipple*: PBitmap
PPangoAttrEmbossed* = ptr TPangoAttrEmbossed
TPangoAttrEmbossed*{.final, pure.} = object
attr*: TPangoAttribute
PAttrEmbossed* = ptr TAttrEmbossed
TAttrEmbossed*{.final, pure.} = object
attr*: TAttribute
embossed*: gboolean
PPixmapObject* = ptr TPixmapObject
@@ -1004,21 +1005,21 @@ proc draw_segments*(drawable: PDrawable, gc: PGC, segs: PSegment, nsegs: gint){.
cdecl, dynlib: lib, importc: "gdk_draw_segments".}
proc draw_lines*(drawable: PDrawable, gc: PGC, points: PPoint, npoints: gint){.
cdecl, dynlib: lib, importc: "gdk_draw_lines".}
proc draw_glyphs*(drawable: PDrawable, gc: PGC, font: PPangoFont, x: gint,
y: gint, glyphs: PPangoGlyphString){.cdecl, dynlib: lib,
proc draw_glyphs*(drawable: PDrawable, gc: PGC, font: PFont, x: gint,
y: gint, glyphs: PGlyphString){.cdecl, dynlib: lib,
importc: "gdk_draw_glyphs".}
proc draw_layout_line*(drawable: PDrawable, gc: PGC, x: gint, y: gint,
line: PPangoLayoutLine){.cdecl, dynlib: lib,
line: PLayoutLine){.cdecl, dynlib: lib,
importc: "gdk_draw_layout_line".}
proc draw_layout*(drawable: PDrawable, gc: PGC, x: gint, y: gint,
layout: PPangoLayout){.cdecl, dynlib: lib,
layout: PLayout){.cdecl, dynlib: lib,
importc: "gdk_draw_layout".}
proc draw_layout_line_with_colors*(drawable: PDrawable, gc: PGC, x: gint,
y: gint, line: PPangoLayoutLine,
y: gint, line: PLayoutLine,
foreground: PColor, background: PColor){.
cdecl, dynlib: lib, importc: "gdk_draw_layout_line_with_colors".}
proc draw_layout_with_colors*(drawable: PDrawable, gc: PGC, x: gint, y: gint,
layout: PPangoLayout, foreground: PColor,
layout: PLayout, foreground: PColor,
background: PColor){.cdecl, dynlib: lib,
importc: "gdk_draw_layout_with_colors".}
proc drawable_get_image*(drawable: PDrawable, x: gint, y: gint, width: gint,
@@ -1035,8 +1036,8 @@ const
EXPOSE* = 2
MOTION_NOTIFY* = 3
BUTTON_PRESS* = 4
2BUTTON_PRESS* = 5
3BUTTON_PRESS* = 6
BUTTON2_PRESS* = 5
BUTTON3_PRESS* = 6
BUTTON_RELEASE* = 7
KEY_PRESS* = 8
KEY_RELEASE* = 9
@@ -1137,7 +1138,7 @@ proc font_load_for_display*(display: PDisplay, font_name: cstring): PFont{.
proc fontset_load_for_display*(display: PDisplay, fontset_name: cstring): PFont{.
cdecl, dynlib: lib, importc: "gdk_fontset_load_for_display".}
proc font_from_description_for_display*(display: PDisplay,
font_desc: PPangoFontDescription): PFont{.
font_desc: PFontDescription): PFont{.
cdecl, dynlib: lib, importc: "gdk_font_from_description_for_display".}
proc font_ref*(font: PFont): PFont{.cdecl, dynlib: lib, importc: "gdk_font_ref".}
proc font_unref*(font: PFont){.cdecl, dynlib: lib, importc: "gdk_font_unref".}
@@ -1311,9 +1312,9 @@ proc device_get_state*(device: PDevice, window: PWindow, axes: Pgdouble,
mask: PModifierType){.cdecl, dynlib: lib,
importc: "gdk_device_get_state".}
proc device_get_history*(device: PDevice, window: PWindow, start: guint32,
stop: guint32, s: var PPGdkTimeCoord, n_events: Pgint): gboolean{.
stop: guint32, s: var PPTimeCoord, n_events: Pgint): gboolean{.
cdecl, dynlib: lib, importc: "gdk_device_get_history".}
proc device_free_history*(events: PPGdkTimeCoord, n_events: gint){.cdecl,
proc device_free_history*(events: PPTimeCoord, n_events: gint){.cdecl,
dynlib: lib, importc: "gdk_device_free_history".}
proc device_get_axis*(device: PDevice, axes: Pgdouble, use: TAxisUse,
value: Pgdouble): gboolean{.cdecl, dynlib: lib,
@@ -1348,7 +1349,7 @@ proc keymap_get_entries_for_keycode*(keymap: PKeymap, hardware_keycode: guint,
s: var PKeymapKey, sasdf: var Pguint,
n_entries: Pgint): gboolean{.cdecl,
dynlib: lib, importc: "gdk_keymap_get_entries_for_keycode".}
proc keymap_get_direction*(keymap: PKeymap): TPangoDirection{.cdecl,
proc keymap_get_direction*(keymap: PKeymap): TDirection{.cdecl,
dynlib: lib, importc: "gdk_keymap_get_direction".}
proc keyval_name*(keyval: guint): cstring{.cdecl, dynlib: lib,
importc: "gdk_keyval_name".}
@@ -2703,21 +2704,21 @@ const
KEY_DongSign* = 0x000020AB
KEY_EuroSign* = 0x000020AC
proc pango_context_get_for_screen*(screen: PScreen): PPangoContext{.cdecl,
proc pango_context_get_for_screen*(screen: PScreen): PContext{.cdecl,
dynlib: lib, importc: "gdk_pango_context_get_for_screen".}
proc pango_context_set_colormap*(context: PPangoContext, colormap: PColormap){.
proc pango_context_set_colormap*(context: PContext, colormap: PColormap){.
cdecl, dynlib: lib, importc: "gdk_pango_context_set_colormap".}
proc pango_layout_line_get_clip_region*(line: PPangoLayoutLine, x_origin: gint,
proc pango_layout_line_get_clip_region*(line: PLayoutLine, x_origin: gint,
y_origin: gint, index_ranges: Pgint,
n_ranges: gint): PRegion{.cdecl,
dynlib: lib, importc: "gdk_pango_layout_line_get_clip_region".}
proc pango_layout_get_clip_region*(layout: PPangoLayout, x_origin: gint,
proc pango_layout_get_clip_region*(layout: PLayout, x_origin: gint,
y_origin: gint, index_ranges: Pgint,
n_ranges: gint): PRegion{.cdecl, dynlib: lib,
importc: "gdk_pango_layout_get_clip_region".}
proc pango_attr_stipple_new*(stipple: PBitmap): PPangoAttribute{.cdecl,
proc pango_attr_stipple_new*(stipple: PBitmap): PAttribute{.cdecl,
dynlib: lib, importc: "gdk_pango_attr_stipple_new".}
proc pango_attr_embossed_new*(embossed: gboolean): PPangoAttribute{.cdecl,
proc pango_attr_embossed_new*(embossed: gboolean): PAttribute{.cdecl,
dynlib: lib, importc: "gdk_pango_attr_embossed_new".}
proc pixbuf_render_threshold_alpha*(pixbuf: PPixbuf, bitmap: PBitmap,
src_x: int32, src_y: int32, dest_x: int32,
@@ -3125,14 +3126,14 @@ proc IS_WINDOW_CLASS*(klass: Pointer): bool
proc WINDOW_GET_CLASS*(obj: Pointer): PWindowObjectClass
proc WINDOW_OBJECT*(anObject: Pointer): PWindowObject
const
bm_TGdkWindowObject_guffaw_gravity* = 0x0001'i16
bp_TGdkWindowObject_guffaw_gravity* = 0'i16
bm_TGdkWindowObject_input_only* = 0x0002'i16
bp_TGdkWindowObject_input_only* = 1'i16
bm_TGdkWindowObject_modal_hint* = 0x0004'i16
bp_TGdkWindowObject_modal_hint* = 2'i16
bm_TGdkWindowObject_destroyed* = 0x0018'i16
bp_TGdkWindowObject_destroyed* = 3'i16
bm_TWindowObject_guffaw_gravity* = 0x0001'i16
bp_TWindowObject_guffaw_gravity* = 0'i16
bm_TWindowObject_input_only* = 0x0002'i16
bp_TWindowObject_input_only* = 1'i16
bm_TWindowObject_modal_hint* = 0x0004'i16
bp_TWindowObject_modal_hint* = 2'i16
bm_TWindowObject_destroyed* = 0x0018'i16
bp_TWindowObject_destroyed* = 3'i16
proc WindowObject_guffaw_gravity*(a: var TWindowObject): guint
proc WindowObject_set_guffaw_gravity*(a: var TWindowObject,
@@ -3802,41 +3803,41 @@ proc WINDOW_OBJECT*(anObject: Pointer): PWindowObject =
result = cast[PWindowObject](WINDOW(anObject))
proc WindowObject_guffaw_gravity*(a: var TWindowObject): guint =
result = (a.flag0 and bm_TGdkWindowObject_guffaw_gravity) shr
bp_TGdkWindowObject_guffaw_gravity
result = (a.flag0 and bm_TWindowObject_guffaw_gravity) shr
bp_TWindowObject_guffaw_gravity
proc WindowObject_set_guffaw_gravity*(a: var TWindowObject,
`guffaw_gravity`: guint) =
a.flag0 = a.flag0 or
(int16(`guffaw_gravity` shl bp_TGdkWindowObject_guffaw_gravity) and
bm_TGdkWindowObject_guffaw_gravity)
(int16(`guffaw_gravity` shl bp_TWindowObject_guffaw_gravity) and
bm_TWindowObject_guffaw_gravity)
proc WindowObject_input_only*(a: var TWindowObject): guint =
result = (a.flag0 and bm_TGdkWindowObject_input_only) shr
bp_TGdkWindowObject_input_only
result = (a.flag0 and bm_TWindowObject_input_only) shr
bp_TWindowObject_input_only
proc WindowObject_set_input_only*(a: var TWindowObject, `input_only`: guint) =
a.flag0 = a.flag0 or
(int16(`input_only` shl bp_TGdkWindowObject_input_only) and
bm_TGdkWindowObject_input_only)
(int16(`input_only` shl bp_TWindowObject_input_only) and
bm_TWindowObject_input_only)
proc WindowObject_modal_hint*(a: var TWindowObject): guint =
result = (a.flag0 and bm_TGdkWindowObject_modal_hint) shr
bp_TGdkWindowObject_modal_hint
result = (a.flag0 and bm_TWindowObject_modal_hint) shr
bp_TWindowObject_modal_hint
proc WindowObject_set_modal_hint*(a: var TWindowObject, `modal_hint`: guint) =
a.flag0 = a.flag0 or
(int16(`modal_hint` shl bp_TGdkWindowObject_modal_hint) and
bm_TGdkWindowObject_modal_hint)
(int16(`modal_hint` shl bp_TWindowObject_modal_hint) and
bm_TWindowObject_modal_hint)
proc WindowObject_destroyed*(a: var TWindowObject): guint =
result = (a.flag0 and bm_TGdkWindowObject_destroyed) shr
bp_TGdkWindowObject_destroyed
result = (a.flag0 and bm_TWindowObject_destroyed) shr
bp_TWindowObject_destroyed
proc WindowObject_set_destroyed*(a: var TWindowObject, `destroyed`: guint) =
a.flag0 = a.flag0 or
(int16(`destroyed` shl bp_TGdkWindowObject_destroyed) and
bm_TGdkWindowObject_destroyed)
(int16(`destroyed` shl bp_TWindowObject_destroyed) and
bm_TWindowObject_destroyed)
proc ROOT_PARENT*(): PWindow =
result = get_default_root_window()

1245
lib/newwrap/gtk/gtk2.nim
View File

File diff suppressed because it is too large Load Diff

49
lib/newwrap/libcurl.nim
View File

@@ -67,8 +67,8 @@ type
PSHoption* = ptr TSHoption
Pversion* = ptr Tversion
Pfd_set* = pointer
P* = ptr T
T* = pointer
PCurl* = ptr TCurl
TCurl* = pointer
Thttppost*{.final, pure.} = object
next*: Phttppost
name*: cstring
@@ -84,8 +84,8 @@ type
showfilename*: cstring
Tprogress_callback* = proc (clientp: pointer, dltotal: float64,
dlnow: float64, ultotal: float64, ulnow: float64): int32{.
cdecl.}
dlnow: float64, ultotal: float64,
ulnow: float64): int32 {.cdecl.}
Twrite_callback* = proc (buffer: cstring, size: int, nitems: int,
outstream: pointer): int{.cdecl.}
Tread_callback* = proc (buffer: cstring, size: int, nitems: int,
@@ -96,7 +96,7 @@ type
IOE_OK, IOE_UNKNOWNCMD, IOE_FAILRESTART, IOE_LAST
Tiocmd* = enum
IOCMD_NOP, IOCMD_RESTARTREAD, IOCMD_LAST
Tioctl_callback* = proc (handle: P, cmd: int32, clientp: pointer): Tioerr{.
Tioctl_callback* = proc (handle: PCurl, cmd: int32, clientp: pointer): Tioerr{.
cdecl.}
Tmalloc_callback* = proc (size: int): pointer{.cdecl.}
Tfree_callback* = proc (p: pointer){.cdecl.}
@@ -106,7 +106,7 @@ type
Tinfotype* = enum
INFO_TEXT = 0, INFO_HEADER_IN, INFO_HEADER_OUT, INFO_DATA_IN, INFO_DATA_OUT,
INFO_SSL_DATA_IN, INFO_SSL_DATA_OUT, INFO_END
Tdebug_callback* = proc (handle: P, theType: Tinfotype, data: cstring,
Tdebug_callback* = proc (handle: PCurl, theType: Tinfotype, data: cstring,
size: int, userptr: pointer): int32{.cdecl.}
Tcode* = enum
E_OK = 0, E_UNSUPPORTED_PROTOCOL, E_FAILED_INIT, E_URL_MALFORMAT,
@@ -134,7 +134,7 @@ type
E_TFTP_ILLEGAL, E_TFTP_UNKNOWNID, E_TFTP_EXISTS, E_TFTP_NOSUCHUSER,
E_CONV_FAILED, E_CONV_REQD, LAST
Tconv_callback* = proc (buffer: cstring, len: int): Tcode{.cdecl.}
Tssl_ctx_callback* = proc (: P, ssl_ctx, userptr: pointer): Tcode{.cdecl.}
Tssl_ctx_callback* = proc (curl: PCurl, ssl_ctx, userptr: pointer): Tcode{.cdecl.}
Tproxytype* = enum
PROXY_HTTP = 0, PROXY_SOCKS4 = 4, PROXY_SOCKS5 = 5
Tftpssl* = enum
@@ -269,9 +269,10 @@ type
Tlock_access* = enum
LOCK_ACCESS_NONE = 0, LOCK_ACCESS_SHARED = 1, LOCK_ACCESS_SINGLE = 2,
LOCK_ACCESS_LAST
Tlock_function* = proc (handle: P, data: Tlock_data, locktype: Tlock_access,
Tlock_function* = proc (handle: PCurl, data: Tlock_data,
locktype: Tlock_access,
userptr: pointer){.cdecl.}
Tunlock_function* = proc (handle: P, data: Tlock_data, userptr: pointer){.
Tunlock_function* = proc (handle: PCurl, data: Tlock_data, userptr: pointer){.
cdecl.}
TSH* = pointer
TSHcode* = enum
@@ -305,14 +306,14 @@ type
MSG_NONE, MSG_DONE, MSG_LAST
TMsg*{.pure, final.} = object
msg*: TMSGEnum
easy_handle*: P
easy_handle*: PCurl
whatever*: Pointer #data : record
# case longint of
# 0 : ( whatever : pointer );
# 1 : ( result : CURLcode );
# end;
Tsocket_callback* = proc (easy: P, s: Tsocket, what: int32,
Tsocket_callback* = proc (easy: PCurl, s: Tsocket, what: int32,
userp, socketp: pointer): int32{.cdecl.}
TMoption* = enum
MOPT_SOCKETDATA = 10000 + 2, MOPT_LASTENTRY = 10000 + 3,
@@ -419,11 +420,11 @@ proc formfree*(form: Phttppost){.cdecl, dynlib: libname,
proc getenv*(variable: cstring): cstring{.cdecl, dynlib: libname,
importc: "curl_getenv".}
proc version*(): cstring{.cdecl, dynlib: libname, importc: "curl_version".}
proc easy_escape*(handle: P, str: cstring, len: int32): cstring{.cdecl,
proc easy_escape*(handle: PCurl, str: cstring, len: int32): cstring{.cdecl,
dynlib: libname, importc: "curl_easy_escape".}
proc escape*(str: cstring, len: int32): cstring{.cdecl, dynlib: libname,
importc: "curl_escape".}
proc easy_unescape*(handle: P, str: cstring, len: int32, outlength: var int32): cstring{.
proc easy_unescape*(handle: PCurl, str: cstring, len: int32, outlength: var int32): cstring{.
cdecl, dynlib: libname, importc: "curl_easy_unescape".}
proc unescape*(str: cstring, len: int32): cstring{.cdecl, dynlib: libname,
importc: "curl_unescape".}
@@ -435,7 +436,7 @@ proc global_init_mem*(flags: int32, m: Tmalloc_callback, f: Tfree_callback,
c: Tcalloc_callback): Tcode{.cdecl, dynlib: libname,
importc: "curl_global_init_mem".}
proc global_cleanup*(){.cdecl, dynlib: libname, importc: "curl_global_cleanup".}
proc slist_append*(slist: Pslist, P: cstring): Pslist{.cdecl, dynlib: libname,
proc slist_append*(slist: Pslist, p: cstring): Pslist{.cdecl, dynlib: libname,
importc: "curl_slist_append".}
proc slist_free_all*(para1: Pslist){.cdecl, dynlib: libname,
importc: "curl_slist_free_all".}
@@ -452,21 +453,21 @@ proc easy_strerror*(para1: Tcode): cstring{.cdecl, dynlib: libname,
importc: "curl_easy_strerror".}
proc share_strerror*(para1: TSHcode): cstring{.cdecl, dynlib: libname,
importc: "curl_share_strerror".}
proc easy_init*(): P{.cdecl, dynlib: libname, importc: "curl_easy_init".}
proc easy_setopt*(: P, option: Toption): Tcode{.cdecl, varargs, dynlib: libname,
proc easy_init*(): PCurl{.cdecl, dynlib: libname, importc: "curl_easy_init".}
proc easy_setopt*(curl: PCurl, option: Toption): Tcode{.cdecl, varargs, dynlib: libname,
importc: "curl_easy_setopt".}
proc easy_perform*(: P): Tcode{.cdecl, dynlib: libname,
proc easy_perform*(curl: PCurl): Tcode{.cdecl, dynlib: libname,
importc: "curl_easy_perform".}
proc easy_cleanup*(: P){.cdecl, dynlib: libname, importc: "curl_easy_cleanup".}
proc easy_getinfo*(: P, info: TINFO): Tcode{.cdecl, varargs, dynlib: libname,
proc easy_cleanup*(curl: PCurl){.cdecl, dynlib: libname, importc: "curl_easy_cleanup".}
proc easy_getinfo*(curl: PCurl, info: TINFO): Tcode{.cdecl, varargs, dynlib: libname,
importc: "curl_easy_getinfo".}
proc easy_duphandle*(: P): P{.cdecl, dynlib: libname,
proc easy_duphandle*(curl: PCurl): PCurl{.cdecl, dynlib: libname,
importc: "curl_easy_duphandle".}
proc easy_reset*(: P){.cdecl, dynlib: libname, importc: "curl_easy_reset".}
proc easy_reset*(curl: PCurl){.cdecl, dynlib: libname, importc: "curl_easy_reset".}
proc multi_init*(): PM{.cdecl, dynlib: libname, importc: "curl_multi_init".}
proc multi_add_handle*(multi_handle: PM, handle: P): TMcode{.cdecl,
proc multi_add_handle*(multi_handle: PM, handle: PCurl): TMcode{.cdecl,
dynlib: libname, importc: "curl_multi_add_handle".}
proc multi_remove_handle*(multi_handle: PM, handle: P): TMcode{.cdecl,
proc multi_remove_handle*(multi_handle: PM, handle: PCurl): TMcode{.cdecl,
dynlib: libname, importc: "curl_multi_remove_handle".}
proc multi_fdset*(multi_handle: PM, read_fd_set: Pfd_set, write_fd_set: Pfd_set,
exc_fd_set: Pfd_set, max_fd: var int32): TMcode{.cdecl,
@@ -488,4 +489,4 @@ proc multi_timeout*(multi_handle: PM, milliseconds: var int32): TMcode{.cdecl,
proc multi_setopt*(multi_handle: PM, option: TMoption): TMcode{.cdecl, varargs,
dynlib: libname, importc: "curl_multi_setopt".}
proc multi_assign*(multi_handle: PM, sockfd: Tsocket, sockp: pointer): TMcode{.
cdecl, dynlib: libname, importc: "curl_multi_assign".}
cdecl, dynlib: libname, importc: "curl_multi_assign".}

182
lib/newwrap/lua/lauxlib.nim
View File

@@ -24,89 +24,89 @@
import
lua
proc lua_pushstring*(L: Plua_State, s: string)
proc pushstring*(L: PState, s: string)
# compatibilty macros
proc getn*(L: Plua_State, n: int): int
proc getn*(L: PState, n: int): int
# calls lua_objlen
proc setn*(L: Plua_State, t, n: int)
proc setn*(L: PState, t, n: int)
# does nothing!
type
Treg*{.final.} = object
name*: cstring
func*: lua_CFunction
func*: CFunction
Preg* = ptr Treg
proc openlib*(L: Plua_State, libname: cstring, lr: Preg, nup: int){.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_openlib".}
proc register*(L: Plua_State, libname: cstring, lr: Preg){.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_register".}
proc getmetafield*(L: Plua_State, obj: int, e: cstring): int{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_getmetafield".}
proc callmeta*(L: Plua_State, obj: int, e: cstring): int{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_callmeta".}
proc typerror*(L: Plua_State, narg: int, tname: cstring): int{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_typerror".}
proc argerror*(L: Plua_State, numarg: int, extramsg: cstring): int{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_argerror".}
proc checklstring*(L: Plua_State, numArg: int, l_: Psize_t): cstring{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_checklstring".}
proc optlstring*(L: Plua_State, numArg: int, def: cstring, l_: Psize_t): cstring{.
cdecl, dynlib: LUA_LIB_NAME, importc: "luaL_optlstring".}
proc checknumber*(L: Plua_State, numArg: int): lua_Number{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_checknumber".}
proc optnumber*(L: Plua_State, nArg: int, def: lua_Number): lua_Number{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_optnumber".}
proc checkinteger*(L: Plua_State, numArg: int): lua_Integer{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_checkinteger".}
proc optinteger*(L: Plua_State, nArg: int, def: lua_Integer): lua_Integer{.
cdecl, dynlib: LUA_LIB_NAME, importc: "luaL_optinteger".}
proc checkstack*(L: Plua_State, sz: int, msg: cstring){.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_checkstack".}
proc checktype*(L: Plua_State, narg, t: int){.cdecl, dynlib: LUA_LIB_NAME,
proc openlib*(L: PState, libname: cstring, lr: Preg, nup: int){.cdecl,
dynlib: LIB_NAME, importc: "luaL_openlib".}
proc register*(L: PState, libname: cstring, lr: Preg){.cdecl,
dynlib: LIB_NAME, importc: "luaL_register".}
proc getmetafield*(L: PState, obj: int, e: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_getmetafield".}
proc callmeta*(L: PState, obj: int, e: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_callmeta".}
proc typerror*(L: PState, narg: int, tname: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_typerror".}
proc argerror*(L: PState, numarg: int, extramsg: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_argerror".}
proc checklstring*(L: PState, numArg: int, l_: Psize_t): cstring{.cdecl,
dynlib: LIB_NAME, importc: "luaL_checklstring".}
proc optlstring*(L: PState, numArg: int, def: cstring, l_: Psize_t): cstring{.
cdecl, dynlib: LIB_NAME, importc: "luaL_optlstring".}
proc checknumber*(L: PState, numArg: int): lua_Number{.cdecl,
dynlib: LIB_NAME, importc: "luaL_checknumber".}
proc optnumber*(L: PState, nArg: int, def: lua_Number): lua_Number{.cdecl,
dynlib: LIB_NAME, importc: "luaL_optnumber".}
proc checkinteger*(L: PState, numArg: int): lua_Integer{.cdecl,
dynlib: LIB_NAME, importc: "luaL_checkinteger".}
proc optinteger*(L: PState, nArg: int, def: lua_Integer): lua_Integer{.
cdecl, dynlib: LIB_NAME, importc: "luaL_optinteger".}
proc checkstack*(L: PState, sz: int, msg: cstring){.cdecl,
dynlib: LIB_NAME, importc: "luaL_checkstack".}
proc checktype*(L: PState, narg, t: int){.cdecl, dynlib: LIB_NAME,
importc: "luaL_checktype".}
proc checkany*(L: Plua_State, narg: int){.cdecl, dynlib: LUA_LIB_NAME,
proc checkany*(L: PState, narg: int){.cdecl, dynlib: LIB_NAME,
importc: "luaL_checkany".}
proc newmetatable*(L: Plua_State, tname: cstring): int{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_newmetatable".}
proc checkudata*(L: Plua_State, ud: int, tname: cstring): Pointer{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_checkudata".}
proc where*(L: Plua_State, lvl: int){.cdecl, dynlib: LUA_LIB_NAME,
proc newmetatable*(L: PState, tname: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_newmetatable".}
proc checkudata*(L: PState, ud: int, tname: cstring): Pointer{.cdecl,
dynlib: LIB_NAME, importc: "luaL_checkudata".}
proc where*(L: PState, lvl: int){.cdecl, dynlib: LIB_NAME,
importc: "luaL_where".}
proc error*(L: Plua_State, fmt: cstring): int{.cdecl, varargs,
dynlib: LUA_LIB_NAME, importc: "luaL_error".}
proc checkoption*(L: Plua_State, narg: int, def: cstring, lst: cstringArray): int{.
cdecl, dynlib: LUA_LIB_NAME, importc: "luaL_checkoption".}
proc ref*(L: Plua_State, t: int): int{.cdecl, dynlib: LUA_LIB_NAME,
proc error*(L: PState, fmt: cstring): int{.cdecl, varargs,
dynlib: LIB_NAME, importc: "luaL_error".}
proc checkoption*(L: PState, narg: int, def: cstring, lst: cstringArray): int{.
cdecl, dynlib: LIB_NAME, importc: "luaL_checkoption".}
proc ref*(L: PState, t: int): int{.cdecl, dynlib: LIB_NAME,
importc: "luaL_ref".}
proc unref*(L: Plua_State, t, theref: int){.cdecl, dynlib: LUA_LIB_NAME,
proc unref*(L: PState, t, theref: int){.cdecl, dynlib: LIB_NAME,
importc: "luaL_unref".}
proc loadfile*(L: Plua_State, filename: cstring): int{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_loadfile".}
proc loadbuffer*(L: Plua_State, buff: cstring, size: size_t, name: cstring): int{.
cdecl, dynlib: LUA_LIB_NAME, importc: "luaL_loadbuffer".}
proc loadstring*(L: Plua_State, s: cstring): int{.cdecl, dynlib: LUA_LIB_NAME,
proc loadfile*(L: PState, filename: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_loadfile".}
proc loadbuffer*(L: PState, buff: cstring, size: size_t, name: cstring): int{.
cdecl, dynlib: LIB_NAME, importc: "luaL_loadbuffer".}
proc loadstring*(L: PState, s: cstring): int{.cdecl, dynlib: LIB_NAME,
importc: "luaL_loadstring".}
proc newstate*(): Plua_State{.cdecl, dynlib: LUA_LIB_NAME,
proc newstate*(): PState{.cdecl, dynlib: LIB_NAME,
importc: "luaL_newstate".}
proc lua_open*(): Plua_State
proc lua_open*(): PState
# compatibility; moved from unit lua to lauxlib because it needs luaL_newstate
#
#** ===============================================================
#** some useful macros
#** ===============================================================
#
proc argcheck*(L: Plua_State, cond: bool, numarg: int, extramsg: cstring)
proc checkstring*(L: Plua_State, n: int): cstring
proc optstring*(L: Plua_State, n: int, d: cstring): cstring
proc checkint*(L: Plua_State, n: int): int
proc checklong*(L: Plua_State, n: int): int32
proc optint*(L: Plua_State, n: int, d: float64): int
proc optlong*(L: Plua_State, n: int, d: float64): int32
proc typename*(L: Plua_State, i: int): cstring
proc lua_dofile*(L: Plua_State, filename: cstring): int
proc lua_dostring*(L: Plua_State, str: cstring): int
proc lua_Lgetmetatable*(L: Plua_State, tname: cstring)
proc argcheck*(L: PState, cond: bool, numarg: int, extramsg: cstring)
proc checkstring*(L: PState, n: int): cstring
proc optstring*(L: PState, n: int, d: cstring): cstring
proc checkint*(L: PState, n: int): int
proc checklong*(L: PState, n: int): int32
proc optint*(L: PState, n: int, d: float64): int
proc optlong*(L: PState, n: int, d: float64): int32
proc typename*(L: PState, i: int): cstring
proc lua_dofile*(L: PState, filename: cstring): int
proc lua_dostring*(L: PState, str: cstring): int
proc lua_Lgetmetatable*(L: PState, tname: cstring)
# not translated:
# #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
#
@@ -121,7 +121,7 @@ type
Buffer*{.final.} = object
p*: cstring # current position in buffer
lvl*: int # number of strings in the stack (level)
L*: Plua_State
L*: PState
buffer*: array[0..BUFFERSIZE - 1, Char] # warning: see note above about LUAL_BUFFERSIZE
PBuffer* = ptr Buffer
@@ -132,82 +132,82 @@ proc addchar*(B: PBuffer, c: Char)
proc putchar*(B: PBuffer, c: Char)
# warning: see note above about LUAL_BUFFERSIZE
proc addsize*(B: PBuffer, n: int)
proc buffinit*(L: Plua_State, B: PBuffer){.cdecl, dynlib: LUA_LIB_NAME,
proc buffinit*(L: PState, B: PBuffer){.cdecl, dynlib: LIB_NAME,
importc: "luaL_buffinit".}
proc prepbuffer*(B: PBuffer): cstring{.cdecl, dynlib: LUA_LIB_NAME,
proc prepbuffer*(B: PBuffer): cstring{.cdecl, dynlib: LIB_NAME,
importc: "luaL_prepbuffer".}
proc addlstring*(B: PBuffer, s: cstring, L: size_t){.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_addlstring".}
proc addstring*(B: PBuffer, s: cstring){.cdecl, dynlib: LUA_LIB_NAME,
dynlib: LIB_NAME, importc: "luaL_addlstring".}
proc addstring*(B: PBuffer, s: cstring){.cdecl, dynlib: LIB_NAME,
importc: "luaL_addstring".}
proc addvalue*(B: PBuffer){.cdecl, dynlib: LUA_LIB_NAME,
proc addvalue*(B: PBuffer){.cdecl, dynlib: LIB_NAME,
importc: "luaL_addvalue".}
proc pushresult*(B: PBuffer){.cdecl, dynlib: LUA_LIB_NAME,
proc pushresult*(B: PBuffer){.cdecl, dynlib: LIB_NAME,
importc: "luaL_pushresult".}
proc gsub*(L: Plua_State, s, p, r: cstring): cstring{.cdecl,
dynlib: LUA_LIB_NAME, importc: "luaL_gsub".}
proc findtable*(L: Plua_State, idx: int, fname: cstring, szhint: int): cstring{.
cdecl, dynlib: LUA_LIB_NAME, importc: "luaL_findtable".}
proc gsub*(L: PState, s, p, r: cstring): cstring{.cdecl,
dynlib: LIB_NAME, importc: "luaL_gsub".}
proc findtable*(L: PState, idx: int, fname: cstring, szhint: int): cstring{.
cdecl, dynlib: LIB_NAME, importc: "luaL_findtable".}
# compatibility with ref system
# pre-defined references
const
LUA_NOREF* = - 2
LUA_REFNIL* = - 1
proc lua_unref*(L: Plua_State, theref: int)
proc lua_getref*(L: Plua_State, theref: int)
proc lua_unref*(L: PState, theref: int)
proc lua_getref*(L: PState, theref: int)
#
#** Compatibility macros and functions
#
# implementation
proc lua_pushstring(L: Plua_State, s: string) =
proc lua_pushstring(L: PState, s: string) =
lua_pushlstring(L, cstring(s), len(s))
proc getn(L: Plua_State, n: int): int =
proc getn(L: PState, n: int): int =
Result = lua_objlen(L, n)
proc setn(L: Plua_State, t, n: int) =
proc setn(L: PState, t, n: int) =
# does nothing as this operation is deprecated
nil
proc lua_open(): Plua_State =
proc lua_open(): PState =
Result = newstate()
proc typename(L: Plua_State, i: int): cstring =
proc typename(L: PState, i: int): cstring =
Result = lua_typename(L, lua_type(L, i))
proc lua_dofile(L: Plua_State, filename: cstring): int =
proc lua_dofile(L: PState, filename: cstring): int =
Result = loadfile(L, filename)
if Result == 0: Result = lua_pcall(L, 0, LUA_MULTRET, 0)
proc lua_dostring(L: Plua_State, str: cstring): int =
proc lua_dostring(L: PState, str: cstring): int =
Result = loadstring(L, str)
if Result == 0: Result = lua_pcall(L, 0, LUA_MULTRET, 0)
proc lua_Lgetmetatable(L: Plua_State, tname: cstring) =
proc lua_Lgetmetatable(L: PState, tname: cstring) =
lua_getfield(L, LUA_REGISTRYINDEX, tname)
proc argcheck(L: Plua_State, cond: bool, numarg: int, extramsg: cstring) =
proc argcheck(L: PState, cond: bool, numarg: int, extramsg: cstring) =
if not cond:
discard argerror(L, numarg, extramsg)
proc checkstring(L: Plua_State, n: int): cstring =
proc checkstring(L: PState, n: int): cstring =
Result = checklstring(L, n, nil)
proc optstring(L: Plua_State, n: int, d: cstring): cstring =
proc optstring(L: PState, n: int, d: cstring): cstring =
Result = optlstring(L, n, d, nil)
proc checkint(L: Plua_State, n: int): int =
proc checkint(L: PState, n: int): int =
Result = toInt(checknumber(L, n))
proc checklong(L: Plua_State, n: int): int32 =
proc checklong(L: PState, n: int): int32 =
Result = int32(ToInt(checknumber(L, n)))
proc optint(L: Plua_State, n: int, d: float64): int =
proc optint(L: PState, n: int, d: float64): int =
Result = int(ToInt(optnumber(L, n, d)))
proc optlong(L: Plua_State, n: int, d: float64): int32 =
proc optlong(L: PState, n: int, d: float64): int32 =
Result = int32(ToInt(optnumber(L, n, d)))
proc addchar(B: PBuffer, c: Char) =
@@ -222,8 +222,8 @@ proc putchar(B: PBuffer, c: Char) =
proc addsize(B: PBuffer, n: int) =
B.p = cast[cstring](cast[int](B.p) + n)
proc lua_unref(L: Plua_State, theref: int) =
proc lua_unref(L: PState, theref: int) =
unref(L, LUA_REGISTRYINDEX, theref)
proc lua_getref(L: Plua_State, theref: int) =
proc lua_getref(L: PState, theref: int) =
lua_rawgeti(L, LUA_REGISTRYINDEX, theref)

48
lib/newwrap/lua/lua.nim
View File

@@ -47,9 +47,7 @@ else:
const
NAME* = "lua(|5.2|5.1|5.0).dll"
LIB_NAME* = "lua(|5.2|5.1|5.0).dll"
type
size_t* = int
Psize_t* = ptr size_t
const
VERSION* = "Lua 5.1"
@@ -67,7 +65,7 @@ const
proc upvalueindex*(I: int): int
const # thread status; 0 is OK
YIELD_* = 1
constYIELD* = 1
ERRRUN* = 2
ERRSYNTAX* = 3
ERRMEM* = 4
@@ -82,9 +80,9 @@ type
#
type
Reader* = proc (L: PState, ud: Pointer, sz: Psize_t): cstring{.cdecl.}
Writer* = proc (L: PState, p: Pointer, sz: size_t, ud: Pointer): int{.cdecl.}
Alloc* = proc (ud, theptr: Pointer, osize, nsize: size_t){.cdecl.}
Reader* = proc (L: PState, ud: Pointer, sz: ptr int): cstring{.cdecl.}
Writer* = proc (L: PState, p: Pointer, sz: int, ud: Pointer): int{.cdecl.}
Alloc* = proc (ud, theptr: Pointer, osize, nsize: int){.cdecl.}
const
TNONE* = - 1
@@ -129,7 +127,7 @@ proc iscfunction*(L: PState, idx: int): cint{.cdecl, dynlib: NAME,
importc: "lua_iscfunction".}
proc isuserdata*(L: PState, idx: int): cint{.cdecl, dynlib: NAME,
importc: "lua_isuserdata".}
proc type*(L: PState, idx: int): int{.cdecl, dynlib: NAME, importc: "lua_type".}
proc luatype*(L: PState, idx: int): int{.cdecl, dynlib: NAME, importc: "lua_type".}
proc typename*(L: PState, tp: int): cstring{.cdecl, dynlib: NAME,
importc: "lua_typename".}
proc equal*(L: PState, idx1, idx2: int): cint{.cdecl, dynlib: NAME,
@@ -144,9 +142,9 @@ proc tointeger*(L: PState, idx: int): Integer{.cdecl, dynlib: NAME,
importc: "lua_tointeger".}
proc toboolean*(L: PState, idx: int): cint{.cdecl, dynlib: NAME,
importc: "lua_toboolean".}
proc tolstring*(L: PState, idx: int, length: Psize_t): cstring{.cdecl,
proc tolstring*(L: PState, idx: int, length: ptr int): cstring{.cdecl,
dynlib: NAME, importc: "lua_tolstring".}
proc objlen*(L: PState, idx: int): size_t{.cdecl, dynlib: NAME,
proc objlen*(L: PState, idx: int): int{.cdecl, dynlib: NAME,
importc: "lua_objlen".}
proc tocfunction*(L: PState, idx: int): CFunction{.cdecl, dynlib: NAME,
importc: "lua_tocfunction".}
@@ -161,7 +159,7 @@ proc pushnumber*(L: PState, n: Number){.cdecl, dynlib: NAME,
importc: "lua_pushnumber".}
proc pushinteger*(L: PState, n: Integer){.cdecl, dynlib: NAME,
importc: "lua_pushinteger".}
proc pushlstring*(L: PState, s: cstring, l_: size_t){.cdecl, dynlib: NAME,
proc pushlstring*(L: PState, s: cstring, l_: int){.cdecl, dynlib: NAME,
importc: "lua_pushlstring".}
proc pushstring*(L: PState, s: cstring){.cdecl, dynlib: NAME,
importc: "lua_pushstring".}
@@ -185,7 +183,7 @@ proc rawgeti*(L: PState, idx, n: int){.cdecl, dynlib: NAME,
importc: "lua_rawgeti".}
proc createtable*(L: PState, narr, nrec: int){.cdecl, dynlib: NAME,
importc: "lua_createtable".}
proc newuserdata*(L: PState, sz: size_t): Pointer{.cdecl, dynlib: NAME,
proc newuserdata*(L: PState, sz: int): Pointer{.cdecl, dynlib: NAME,
importc: "lua_newuserdata".}
proc getmetatable*(L: PState, objindex: int): int{.cdecl, dynlib: NAME,
importc: "lua_getmetatable".}
@@ -211,7 +209,7 @@ proc load*(L: PState, reader: Reader, dt: Pointer, chunkname: cstring): int{.
cdecl, dynlib: NAME, importc: "lua_load".}
proc dump*(L: PState, writer: Writer, data: Pointer): int{.cdecl, dynlib: NAME,
importc: "lua_dump".}
proc yield*(L: PState, nresults: int): int{.cdecl, dynlib: NAME,
proc luayield*(L: PState, nresults: int): int{.cdecl, dynlib: NAME,
importc: "lua_yield".}
proc resume*(L: PState, narg: int): int{.cdecl, dynlib: NAME,
importc: "lua_resume".}
@@ -249,7 +247,7 @@ proc pop*(L: PState, n: int)
proc newtable*(L: Pstate)
proc register*(L: PState, n: cstring, f: CFunction)
proc pushcfunction*(L: PState, f: CFunction)
proc strlen*(L: Pstate, i: int): size_t
proc strlen*(L: Pstate, i: int): int
proc isfunction*(L: PState, n: int): bool
proc istable*(L: PState, n: int): bool
proc islightuserdata*(L: PState, n: int): bool
@@ -295,7 +293,7 @@ const
IDSIZE* = 60
type
Debug*{.final.} = object # activation record
TDebug*{.final.} = object # activation record
event*: int
name*: cstring # (n)
namewhat*: cstring # (n) `global', `local', `field', `method'
@@ -309,7 +307,7 @@ type
# private part
i_ci*: int # active function
PDebug* = ptr Debug
PDebug* = ptr TDebug
Hook* = proc (L: PState, ar: PDebug){.cdecl.}
#
@@ -355,32 +353,32 @@ proc register(L: PState, n: cstring, f: CFunction) =
proc pushcfunction(L: PState, f: CFunction) =
pushcclosure(L, f, 0)
proc strlen(L: PState, i: int): size_t =
proc strlen(L: PState, i: int): int =
Result = objlen(L, i)
proc isfunction(L: PState, n: int): bool =
Result = type(L, n) == TFUNCTION
Result = luatype(L, n) == TFUNCTION
proc istable(L: PState, n: int): bool =
Result = type(L, n) == TTABLE
Result = luatype(L, n) == TTABLE
proc islightuserdata(L: PState, n: int): bool =
Result = type(L, n) == TLIGHTUSERDATA
Result = luatype(L, n) == TLIGHTUSERDATA
proc isnil(L: PState, n: int): bool =
Result = type(L, n) == TNIL
Result = luatype(L, n) == TNIL
proc isboolean(L: PState, n: int): bool =
Result = type(L, n) == TBOOLEAN
Result = luatype(L, n) == TBOOLEAN
proc isthread(L: PState, n: int): bool =
Result = type(L, n) == TTHREAD
Result = luatype(L, n) == TTHREAD
proc isnone(L: PState, n: int): bool =
Result = type(L, n) == TNONE
Result = luatype(L, n) == TNONE
proc isnoneornil(L: PState, n: int): bool =
Result = type(L, n) <= 0
Result = luatype(L, n) <= 0
proc pushliteral(L: PState, s: cstring) =
pushlstring(L, s, len(s))

24
lib/newwrap/lua/lualib.nim
View File

@@ -20,7 +20,7 @@
#
import
lua
const
COLIBNAME* = "coroutine"
@@ -45,30 +45,22 @@ proc open_debug*(L: PState): cint{.cdecl, dynlib: LIB_NAME,
importc: "luaopen_debug".}
proc open_package*(L: PState): cint{.cdecl, dynlib: LIB_NAME,
importc: "luaopen_package".}
proc L_openlibs*(L: PState){.cdecl, dynlib: LIB_NAME, importc: "luaL_openlibs".}
# compatibility code
proc baselibopen*(L: PState): Bool
proc tablibopen*(L: PState): Bool
proc iolibopen*(L: PState): Bool
proc strlibopen*(L: PState): Bool
proc mathlibopen*(L: PState): Bool
proc dblibopen*(L: PState): Bool
# implementation
proc openlibs*(L: PState){.cdecl, dynlib: LIB_NAME, importc: "luaL_openlibs".}
proc baselibopen(L: PState): Bool =
proc baselibopen*(L: PState): Bool =
Result = open_base(L) != 0'i32
proc tablibopen(L: PState): Bool =
proc tablibopen*(L: PState): Bool =
Result = open_table(L) != 0'i32
proc iolibopen(L: PState): Bool =
proc iolibopen*(L: PState): Bool =
Result = open_io(L) != 0'i32
proc strlibopen(L: PState): Bool =
proc strlibopen*(L: PState): Bool =
Result = open_string(L) != 0'i32
proc mathlibopen(L: PState): Bool =
proc mathlibopen*(L: PState): Bool =
Result = open_math(L) != 0'i32
proc dblibopen(L: PState): Bool =
proc dblibopen*(L: PState): Bool =
Result = open_debug(L) != 0'i32

2
lib/newwrap/sdl/sdl.nim
View File

@@ -752,7 +752,7 @@ type
THandle* = int #SDL_types.h types
# Basic data types
TBool* = enum
FALSE, TRUE
sdlFALSE, sdlTRUE
PUInt8Array* = ptr TUInt8Array
PUInt8* = ptr UInt8
PPUInt8* = ptr PUInt8

2
lib/newwrap/sdl/sdl_gfx.nim
View File

@@ -18,7 +18,7 @@
#
import
sdl
when defined(windows):
const

12
lib/newwrap/sdl/sdl_image.nim
View File

@@ -129,7 +129,7 @@
#******************************************************************************
import
sdl
when defined(windows):
const
@@ -224,19 +224,9 @@ proc IMG_LoadXV_RW*(src: PRWops): PSurface{.cdecl, importc: "IMG_LoadXV_RW",
dynlib: ImageLibName.}
proc IMG_ReadXPMFromArray*(xpm: cstringArray): PSurface{.cdecl,
importc: "IMG_ReadXPMFromArray", dynlib: ImageLibName.}
# Error Macros
# We'll use SDL for reporting errors
proc IMG_SetError*(fmt: cstring)
proc IMG_GetError*(): cstring
# implementation
proc IMAGE_VERSION(X: var TVersion) =
X.major = IMAGE_MAJOR_VERSION
X.minor = IMAGE_MINOR_VERSION
X.patch = IMAGE_PATCHLEVEL
proc IMG_SetError(fmt: cstring) =
SetError(fmt)
proc IMG_GetError(): cstring =
result = GetError()

506
lib/newwrap/sdl/sdl_mixer.nim
View File

@@ -149,7 +149,7 @@
#******************************************************************************
import
, smpeg
sdl, smpeg
when defined(windows):
const
@@ -161,25 +161,22 @@ else:
const
MixerLibName = "libSDL_mixer.so"
const
MIXER_MAJOR_VERSION* = 1'i8
MIXER_MINOR_VERSION* = 2'i8
MIXER_PATCHLEVEL* = 7'i8 # Backwards compatibility
MIX_MAJOR_VERSION* = MIXER_MAJOR_VERSION
MIX_MINOR_VERSION* = MIXER_MINOR_VERSION
MIX_PATCHLEVEL* = MIXER_PATCHLEVEL # SDL_Mixer.h constants
# The default mixer has 8 simultaneous mixing channels
MIX_CHANNELS* = 8 # Good default values for a PC soundcard
MIX_DEFAULT_FREQUENCY* = 22050
MAJOR_VERSION* = 1'i8
MINOR_VERSION* = 2'i8
PATCHLEVEL* = 7'i8 # Backwards compatibility
CHANNELS* = 8 # Good default values for a PC soundcard
DEFAULT_FREQUENCY* = 22050
when defined(IA32):
const
MIX_DEFAULT_FORMAT* = AUDIO_S16LSB
DEFAULT_FORMAT* = AUDIO_S16LSB
else:
const
MIX_DEFAULT_FORMAT* = AUDIO_S16MSB
DEFAULT_FORMAT* = AUDIO_S16MSB
const
MIX_DEFAULT_CHANNELS* = 2
MIX_MAX_VOLUME* = 128 # Volume of a chunk
DEFAULT_CHANNELS* = 2
MAX_VOLUME* = 128 # Volume of a chunk
PATH_MAX* = 255 # mikmod.h constants
#*
# * Library version
@@ -254,34 +251,20 @@ type #music_cmd.h types
PUNIMOD* = ptr TUNIMOD
TUNIMOD* = TMODULE #SDL_mixer.h types
# The internal format for an audio chunk
PMix_Chunk* = ptr TMix_Chunk
TMix_Chunk*{.final.} = object
PChunk* = ptr TChunk
TChunk*{.final.} = object
allocated*: int
abuf*: PUint8
alen*: Uint32
volume*: Uint8 # Per-sample volume, 0-128
Mix_Chunk* = TMix_Chunk # The different fading types supported
TMix_Fading* = enum
TFading* = enum
MIX_NO_FADING, MIX_FADING_OUT, MIX_FADING_IN
Mix_Fading* = TMix_Fading
TMix_MusicType* = enum
TMusicType* = enum
MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG, MUS_MP3
Mix_MusicType* = TMix_MusicType #
# TMusicUnion = record
# case XXX: Byte of
# 0 : ( cmd : PMusicCMD );
# 1 : ( wave : PWAVStream );
# 2 : ( module : PUNIMOD );
# 3 : ( midi : TMidiSong );
# 4 : ( ogg : POGG_music );
# {$IFNDEF DARWIN}
# 5 : ( mp3 : PSMPEG );
# {$ENDIF}
# end;
PMix_Music* = ptr TMix_Music
TMix_Music*{.final.} = object # The internal format for a music chunk interpreted via mikmod
type_*: TMix_MusicType # other fields are not aviable
PMusic* = ptr TMusic
TMusic*{.final.} = object # The internal format for a music chunk interpreted via mikmod
mixtype*: TMusicType # other fields are not aviable
# data : TMusicUnion;
# fading : TMix_Fading;
# fade_volume : integer;
@@ -293,14 +276,14 @@ type #music_cmd.h types
cdecl.} # This macro can be used to fill a version structure with the compile-time
# version of the SDL_mixer library.
proc MIXER_VERSION*(X: var TVersion)
proc VERSION*(X: var sdl.TVersion)
# This function gets the version of the dynamically linked SDL_mixer library.
# It should NOT be used to fill a version structure, instead you should use the
# SDL_MIXER_VERSION() macro.
proc Mix_Linked_Version*(): Pversion{.cdecl, importc: "Mix_Linked_Version",
proc Linked_Version*(): sdl.Pversion{.cdecl, importc: "Mix_Linked_Version",
dynlib: MixerLibName.}
# Open the mixer with a certain audio format
proc Mix_OpenAudio*(frequency: int, format: Uint16, channels: int,
proc OpenAudio*(frequency: int, format: Uint16, channels: int,
chunksize: int): int{.cdecl, importc: "Mix_OpenAudio",
dynlib: MixerLibName.}
# Dynamically change the number of channels managed by the mixer.
@@ -308,456 +291,193 @@ proc Mix_OpenAudio*(frequency: int, format: Uint16, channels: int,
# stopped.
# This function returns the new number of allocated channels.
#
proc Mix_AllocateChannels*(numchannels: int): int{.cdecl,
proc AllocateChannels*(numchannels: int): int{.cdecl,
importc: "Mix_AllocateChannels", dynlib: MixerLibName.}
# Find out what the actual audio device parameters are.
# This function returns 1 if the audio has been opened, 0 otherwise.
#
proc Mix_QuerySpec*(frequency: var int, format: var Uint16, channels: var int): int{.
proc QuerySpec*(frequency: var int, format: var Uint16, channels: var int): int{.
cdecl, importc: "Mix_QuerySpec", dynlib: MixerLibName.}
# Load a wave file or a music (.mod .s3m .it .xm) file
proc Mix_LoadWAV_RW*(src: PRWops, freesrc: int): PMix_Chunk{.cdecl,
proc LoadWAV_RW*(src: PRWops, freesrc: int): PChunk{.cdecl,
importc: "Mix_LoadWAV_RW", dynlib: MixerLibName.}
proc Mix_LoadWAV*(filename: cstring): PMix_Chunk
proc Mix_LoadMUS*(filename: cstring): PMix_Music{.cdecl, importc: "Mix_LoadMUS",
proc LoadWAV*(filename: cstring): PChunk
proc LoadMUS*(filename: cstring): PMusic{.cdecl, importc: "Mix_LoadMUS",
dynlib: MixerLibName.}
# Load a wave file of the mixer format from a memory buffer
proc Mix_QuickLoad_WAV*(mem: PUint8): PMix_Chunk{.cdecl,
proc QuickLoad_WAV*(mem: PUint8): PChunk{.cdecl,
importc: "Mix_QuickLoad_WAV", dynlib: MixerLibName.}
# Free an audio chunk previously loaded
proc Mix_FreeChunk*(chunk: PMix_Chunk){.cdecl, importc: "Mix_FreeChunk",
proc FreeChunk*(chunk: PChunk){.cdecl, importc: "Mix_FreeChunk",
dynlib: MixerLibName.}
proc Mix_FreeMusic*(music: PMix_Music){.cdecl, importc: "Mix_FreeMusic",
proc FreeMusic*(music: PMusic){.cdecl, importc: "Mix_FreeMusic",
dynlib: MixerLibName.}
# Find out the music format of a mixer music, or the currently playing
# music, if 'music' is NULL.
proc Mix_GetMusicType*(music: PMix_Music): TMix_MusicType{.cdecl,
proc GetMusicType*(music: PMusic): TMusicType{.cdecl,
importc: "Mix_GetMusicType", dynlib: MixerLibName.}
# Set a function that is called after all mixing is performed.
# This can be used to provide real-time visual display of the audio stream
# or add a custom mixer filter for the stream data.
#
proc Mix_SetPostMix*(mix_func: TMixFunction, arg: Pointer){.cdecl,
proc SetPostMix*(mix_func: TMixFunction, arg: Pointer){.cdecl,
importc: "Mix_SetPostMix", dynlib: MixerLibName.}
# Add your own music player or additional mixer function.
# If 'mix_func' is NULL, the default music player is re-enabled.
#
proc Mix_HookMusic*(mix_func: TMixFunction, arg: Pointer){.cdecl,
proc HookMusic*(mix_func: TMixFunction, arg: Pointer){.cdecl,
importc: "Mix_HookMusic", dynlib: MixerLibName.}
# Add your own callback when the music has finished playing.
#
proc Mix_HookMusicFinished*(music_finished: Pointer){.cdecl,
proc HookMusicFinished*(music_finished: Pointer){.cdecl,
importc: "Mix_HookMusicFinished", dynlib: MixerLibName.}
# Get a pointer to the user data for the current music hook
proc Mix_GetMusicHookData*(): Pointer{.cdecl, importc: "Mix_GetMusicHookData",
proc GetMusicHookData*(): Pointer{.cdecl, importc: "Mix_GetMusicHookData",
dynlib: MixerLibName.}
#* Add your own callback when a channel has finished playing. NULL
# * to disable callback.*
type
TChannel_finished* = proc (channel: int){.cdecl.}
proc Mix_ChannelFinished*(channel_finished: TChannel_finished){.cdecl,
proc ChannelFinished*(channel_finished: TChannel_finished){.cdecl,
importc: "Mix_ChannelFinished", dynlib: MixerLibName.}
const
MIX_CHANNEL_POST* = - 2 # This is the format of a special effect callback:
# myeffect(int chan, void *stream, int len, void *udata);
#
# (chan) is the channel number that your effect is affecting. (stream) is
# the buffer of data to work upon. (len) is the size of (stream), and
# (udata) is a user-defined bit of data, which you pass as the last arg of
# Mix_RegisterEffect(), and is passed back unmolested to your callback.
# Your effect changes the contents of (stream) based on whatever parameters
# are significant, or just leaves it be, if you prefer. You can do whatever
# you like to the buffer, though, and it will continue in its changed state
# down the mixing pipeline, through any other effect functions, then finally
# to be mixed with the rest of the channels and music for the final output
# stream.
#
CHANNEL_POST* = - 2
type
TMix_EffectFunc* = proc (chan: int, stream: Pointer, length: int,
udata: Pointer): Pointer{.cdecl.} # * This is a callback that signifies that a channel has finished all its
# * loops and has completed playback. This gets called if the buffer
# * plays out normally, or if you call Mix_HaltChannel(), implicitly stop
# * a channel via
# Mix_AllocateChannels(), or unregister a callback while
# * it's still playing.
TMix_EffectDone* = proc (chan: int, udata: Pointer): Pointer{.cdecl.} #* Register a special effect function. At mixing time, the channel data is
# * copied into a buffer and passed through each registered effect function.
# * After it passes through all the functions, it is mixed into the final
# * output stream. The copy to buffer is performed once, then each effect
# * function performs on the output of the previous effect. Understand that
# * this extra copy to a buffer is not performed if there are no effects
# * registered for a given chunk, which saves CPU cycles, and any given
# * effect will be extra cycles, too, so it is crucial that your code run
# * fast. Also note that the data that your function is given is in the
# * format of the sound device, and not the format you gave to Mix_OpenAudio(),
# * although they may in reality be the same. This is an unfortunate but
# * necessary speed concern. Use Mix_QuerySpec() to determine if you can
# * handle the data before you register your effect, and take appropriate
# * actions.
# * You may also specify a callback (Mix_EffectDone_t) that is called when
# * the channel finishes playing. This gives you a more fine-grained control
# * than Mix_ChannelFinished(), in case you need to free effect-specific
# * resources, etc. If you don't need this, you can specify NULL.
# * You may set the callbacks before or after calling Mix_PlayChannel().
# * Things like Mix_SetPanning() are just internal special effect functions,
# * so if you are using that, you've already incurred the overhead of a copy
# * to a separate buffer, and that these effects will be in the queue with
# * any functions you've registered. The list of registered effects for a
# * channel is reset when a chunk finishes playing, so you need to explicitly
# * set them with each call to Mix_PlayChannel*().
# * You may also register a special effect function that is to be run after
# * final mixing occurs. The rules for these callbacks are identical to those
# * in Mix_RegisterEffect, but they are run after all the channels and the
# * music have been mixed into a single stream, whereas channel-specific
# * effects run on a given channel before any other mixing occurs. These
# * global effect callbacks are call "posteffects". Posteffects only have
# * their Mix_EffectDone_t function called when they are unregistered (since
# * the main output stream is never "done" in the same sense as a channel).
# * You must unregister them manually when you've had enough. Your callback
# * will be told that the channel being mixed is (MIX_CHANNEL_POST) if the
# * processing is considered a posteffect.
# *
# * After all these effects have finished processing, the callback registered
# * through Mix_SetPostMix() runs, and then the stream goes to the audio
# * device.
# *
# * returns zero if error (no such channel), nonzero if added.
# * Error messages can be retrieved from Mix_GetError().
# *
proc Mix_RegisterEffect*(chan: int, f: TMix_EffectFunc, d: TMix_EffectDone,
TEffectFunc* = proc (chan: int, stream: Pointer, length: int,
udata: Pointer): Pointer{.cdecl.}
TEffectDone* = proc (chan: int, udata: Pointer): Pointer{.cdecl.}
proc RegisterEffect*(chan: int, f: TEffectFunc, d: TEffectDone,
arg: Pointer): int{.cdecl,
importc: "Mix_RegisterEffect", dynlib: MixerLibName.}
#* You may not need to call this explicitly, unless you need to stop an
# * effect from processing in the middle of a chunk's playback.
# * Posteffects are never implicitly unregistered as they are for channels,
# * but they may be explicitly unregistered through this function by
# * specifying MIX_CHANNEL_POST for a channel.
# * returns zero if error (no such channel or effect), nonzero if removed.
# * Error messages can be retrieved from Mix_GetError().
# *
proc Mix_UnregisterEffect*(channel: int, f: TMix_EffectFunc): int{.cdecl,
proc UnregisterEffect*(channel: int, f: TEffectFunc): int{.cdecl,
importc: "Mix_UnregisterEffect", dynlib: MixerLibName.}
#* You may not need to call this explicitly, unless you need to stop all
# * effects from processing in the middle of a chunk's playback. Note that
# * this will also shut off some internal effect processing, since
# * Mix_SetPanning( ) and others may use this API under the hood.This is
# * called internally when a channel completes playback.
# * Posteffects are never implicitly unregistered as they are for channels,
# * but they may be explicitly unregistered through this function by
# * specifying MIX_CHANNEL_POST for a channel.
# * returns zero if error( no such channel ), nonzero if all effects removed.
# * Error messages can be retrieved from Mix_GetError( ).
# *
proc Mix_UnregisterAllEffects*(channel: int): int{.cdecl,
proc UnregisterAllEffects*(channel: int): int{.cdecl,
importc: "Mix_UnregisterAllEffects", dynlib: MixerLibName.}
const
MIX_EFFECTSMAXSPEED* = "MIX_EFFECTSMAXSPEED" # * These are the internally - defined mixing effects.They use the same API that
# * effects defined in the application use, but are provided here as a
# * convenience.Some effects can reduce their quality or use more memory in
# * the name of speed; to enable this, make sure the environment variable
# * MIX_EFFECTSMAXSPEED( see above ) is defined before you call
# * Mix_OpenAudio( ).
# *
#* set the panning of a channel.The left and right channels are specified
# * as integers between 0 and 255, quietest to loudest, respectively.
# *
# * Technically, this is just individual volume control for a sample with
# * two( stereo )channels, so it can be used for more than just panning.
# * if you want real panning, call it like this :
# *
# * Mix_SetPanning( channel, left, 255 - left );
# *
# * ...which isn't so hard.
# *
# * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
# * the panning will be done to the final mixed stream before passing it on
# * to the audio device.
# *
# * This uses the Mix_RegisterEffect( )API internally, and returns without
# * registering the effect function if the audio device is not configured
# * for stereo output.Setting both( left ) and ( right ) to 255 causes this
# * effect to be unregistered, since that is the data's normal state.
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if panning effect enabled.Note that an audio device in mono
# * mode is a no - op, but this call will return successful in that case .
# * Error messages can be retrieved from Mix_GetError( ).
# *
proc Mix_SetPanning*(channel: int, left: Uint8, right: Uint8): int{.cdecl,
EFFECTSMAXSPEED* = "MIX_EFFECTSMAXSPEED"
proc SetPanning*(channel: int, left: Uint8, right: Uint8): int{.cdecl,
importc: "Mix_SetPanning", dynlib: MixerLibName.}
# * set the position ofa channel.( angle ) is an integer from 0 to 360, that
# * specifies the location of the sound in relation to the listener.( angle )
# * will be reduced as neccesary( 540 becomes 180 degrees, -100 becomes 260 ).
# * Angle 0 is due north, and rotates clockwise as the value increases.
# * for efficiency, the precision of this effect may be limited( angles 1
# * through 7 might all produce the same effect, 8 through 15 are equal, etc ).
# * ( distance ) is an integer between 0 and 255 that specifies the space
# * between the sound and the listener.The larger the number, the further
# * away the sound is .Using 255 does not guarantee that the channel will be
# * culled from the mixing process or be completely silent.For efficiency,
# * the precision of this effect may be limited( distance 0 through 5 might
# * all produce the same effect, 6 through 10 are equal, etc ).Setting( angle )
# * and ( distance ) to 0 unregisters this effect, since the data would be
# * unchanged.
# *
# * if you need more precise positional audio, consider using OpenAL for
# * spatialized effects instead of SDL_mixer.This is only meant to be a
# * basic effect for simple "3D" games.
# *
# * if the audio device is configured for mono output, then you won't get
# * any effectiveness from the angle; however, distance attenuation on the
# * channel will still occur.While this effect will function with stereo
# * voices, it makes more sense to use voices with only one channel of sound,
# * so when they are mixed through this effect, the positioning will sound
# * correct.You can convert them to mono through SDL before giving them to
# * the mixer in the first place if you like.
# *
# * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
# * the positioning will be done to the final mixed stream before passing it
# * on to the audio device.
# *
# * This is a convenience wrapper over Mix_SetDistance( ) and Mix_SetPanning( ).
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if position effect is enabled.
# * Error messages can be retrieved from Mix_GetError( ).
# *
proc Mix_SetPosition*(channel: int, angle: Sint16, distance: Uint8): int{.cdecl,
proc SetPosition*(channel: int, angle: Sint16, distance: Uint8): int{.cdecl,
importc: "Mix_SetPosition", dynlib: MixerLibName.}
#* set the "distance" of a channel.( distance ) is an integer from 0 to 255
# * that specifies the location of the sound in relation to the listener.
# * Distance 0 is overlapping the listener, and 255 is as far away as possible
# * A distance of 255 does not guarantee silence; in such a case , you might
# * want to try changing the chunk's volume, or just cull the sample from the
# * mixing process with Mix_HaltChannel( ).
# * for efficiency, the precision of this effect may be limited( distances 1
# * through 7 might all produce the same effect, 8 through 15 are equal, etc ).
# * ( distance ) is an integer between 0 and 255 that specifies the space
# * between the sound and the listener.The larger the number, the further
# * away the sound is .
# * Setting( distance ) to 0 unregisters this effect, since the data would be
# * unchanged.
# * if you need more precise positional audio, consider using OpenAL for
# * spatialized effects instead of SDL_mixer.This is only meant to be a
# * basic effect for simple "3D" games.
# *
# * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
# * the distance attenuation will be done to the final mixed stream before
# * passing it on to the audio device.
# *
# * This uses the Mix_RegisterEffect( )API internally.
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if position effect is enabled.
# * Error messages can be retrieved from Mix_GetError( ).
# *
proc Mix_SetDistance*(channel: int, distance: Uint8): int{.cdecl,
proc SetDistance*(channel: int, distance: Uint8): int{.cdecl,
importc: "Mix_SetDistance", dynlib: MixerLibName.}
# *
# * !!! FIXME : Haven't implemented, since the effect goes past the
# * end of the sound buffer.Will have to think about this.
# * - -ryan.
# * /
# { if 0
# { * Causes an echo effect to be mixed into a sound.( echo ) is the amount
# * of echo to mix.0 is no echo, 255 is infinite( and probably not
# * what you want ).
# *
# * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
# * the reverbing will be done to the final mixed stream before passing it on
# * to the audio device.
# *
# * This uses the Mix_RegisterEffect( )API internally.If you specify an echo
# * of zero, the effect is unregistered, as the data is already in that state.
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if reversing effect is enabled.
# * Error messages can be retrieved from Mix_GetError( ).
# *
# extern no_parse_DECLSPEC int Mix_SetReverb( int channel, Uint8 echo );
# #E ndif
# * Causes a channel to reverse its stereo.This is handy if the user has his
# * speakers hooked up backwards, or you would like to have a minor bit of
# * psychedelia in your sound code. : )Calling this function with ( flip )
# * set to non - zero reverses the chunks's usual channels. If (flip) is zero,
# * the effect is unregistered.
# *
# * This uses the Mix_RegisterEffect( )API internally, and thus is probably
# * more CPU intensive than having the user just plug in his speakers
# * correctly.Mix_SetReverseStereo( )returns without registering the effect
# * function if the audio device is not configured for stereo output.
# *
# * if you specify MIX_CHANNEL_POST for ( channel ), then this the effect is used
# * on the final mixed stream before sending it on to the audio device( a
# * posteffect ).
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if reversing effect is enabled.Note that an audio device in mono
# * mode is a no - op, but this call will return successful in that case .
# * Error messages can be retrieved from Mix_GetError( ).
# *
proc Mix_SetReverseStereo*(channel: int, flip: int): int{.cdecl,
proc SetReverseStereo*(channel: int, flip: int): int{.cdecl,
importc: "Mix_SetReverseStereo", dynlib: MixerLibName.}
# end of effects API. - -ryan. *
# Reserve the first channels (0 -> n-1) for the application, i.e. don't allocate
# them dynamically to the next sample if requested with a -1 value below.
# Returns the number of reserved channels.
#
proc Mix_ReserveChannels*(num: int): int{.cdecl, importc: "Mix_ReserveChannels",
proc ReserveChannels*(num: int): int{.cdecl, importc: "Mix_ReserveChannels",
dynlib: MixerLibName.}
# Channel grouping functions
# Attach a tag to a channel. A tag can be assigned to several mixer
# channels, to form groups of channels.
# If 'tag' is -1, the tag is removed (actually -1 is the tag used to
# represent the group of all the channels).
# Returns true if everything was OK.
#
proc Mix_GroupChannel*(which: int, tag: int): int{.cdecl,
proc GroupChannel*(which: int, tag: int): int{.cdecl,
importc: "Mix_GroupChannel", dynlib: MixerLibName.}
# Assign several consecutive channels to a group
proc Mix_GroupChannels*(`from`: int, `to`: int, tag: int): int{.cdecl,
proc GroupChannels*(`from`: int, `to`: int, tag: int): int{.cdecl,
importc: "Mix_GroupChannels", dynlib: MixerLibName.}
# Finds the first available channel in a group of channels
proc Mix_GroupAvailable*(tag: int): int{.cdecl, importc: "Mix_GroupAvailable",
proc GroupAvailable*(tag: int): int{.cdecl, importc: "Mix_GroupAvailable",
dynlib: MixerLibName.}
# Returns the number of channels in a group. This is also a subtle
# way to get the total number of channels when 'tag' is -1
#
proc Mix_GroupCount*(tag: int): int{.cdecl, importc: "Mix_GroupCount",
proc GroupCount*(tag: int): int{.cdecl, importc: "Mix_GroupCount",
dynlib: MixerLibName.}
# Finds the "oldest" sample playing in a group of channels
proc Mix_GroupOldest*(tag: int): int{.cdecl, importc: "Mix_GroupOldest",
proc GroupOldest*(tag: int): int{.cdecl, importc: "Mix_GroupOldest",
dynlib: MixerLibName.}
# Finds the "most recent" (i.e. last) sample playing in a group of channels
proc Mix_GroupNewer*(tag: int): int{.cdecl, importc: "Mix_GroupNewer",
proc GroupNewer*(tag: int): int{.cdecl, importc: "Mix_GroupNewer",
dynlib: MixerLibName.}
# The same as above, but the sound is played at most 'ticks' milliseconds
proc Mix_PlayChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int,
proc PlayChannelTimed*(channel: int, chunk: PChunk, loops: int,
ticks: int): int{.cdecl,
importc: "Mix_PlayChannelTimed", dynlib: MixerLibName.}
# Play an audio chunk on a specific channel.
# If the specified channel is -1, play on the first free channel.
# If 'loops' is greater than zero, loop the sound that many times.
# If 'loops' is -1, loop inifinitely (~65000 times).
# Returns which channel was used to play the sound.
#
proc Mix_PlayChannel*(channel: int, chunk: PMix_Chunk, loops: int): int
proc Mix_PlayMusic*(music: PMix_Music, loops: int): int{.cdecl,
proc PlayChannel*(channel: int, chunk: PChunk, loops: int): int
proc PlayMusic*(music: PMusic, loops: int): int{.cdecl,
importc: "Mix_PlayMusic", dynlib: MixerLibName.}
# Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions
proc Mix_FadeInMusic*(music: PMix_Music, loops: int, ms: int): int{.cdecl,
proc FadeInMusic*(music: PMusic, loops: int, ms: int): int{.cdecl,
importc: "Mix_FadeInMusic", dynlib: MixerLibName.}
proc Mix_FadeInChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int,
proc FadeInChannelTimed*(channel: int, chunk: PChunk, loops: int,
ms: int, ticks: int): int{.cdecl,
importc: "Mix_FadeInChannelTimed", dynlib: MixerLibName.}
proc Mix_FadeInChannel*(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int
# Set the volume in the range of 0-128 of a specific channel or chunk.
# If the specified channel is -1, set volume for all channels.
# Returns the original volume.
# If the specified volume is -1, just return the current volume.
#
proc Mix_Volume*(channel: int, volume: int): int{.cdecl, importc: "Mix_Volume",
proc FadeInChannel*(channel: int, chunk: PChunk, loops: int, ms: int): int
proc Volume*(channel: int, volume: int): int{.cdecl, importc: "Mix_Volume",
dynlib: MixerLibName.}
proc Mix_VolumeChunk*(chunk: PMix_Chunk, volume: int): int{.cdecl,
proc VolumeChunk*(chunk: PChunk, volume: int): int{.cdecl,
importc: "Mix_VolumeChunk", dynlib: MixerLibName.}
proc Mix_VolumeMusic*(volume: int): int{.cdecl, importc: "Mix_VolumeMusic",
proc VolumeMusic*(volume: int): int{.cdecl, importc: "Mix_VolumeMusic",
dynlib: MixerLibName.}
# Halt playing of a particular channel
proc Mix_HaltChannel*(channel: int): int{.cdecl, importc: "Mix_HaltChannel",
proc HaltChannel*(channel: int): int{.cdecl, importc: "Mix_HaltChannel",
dynlib: MixerLibName.}
proc Mix_HaltGroup*(tag: int): int{.cdecl, importc: "Mix_HaltGroup",
proc HaltGroup*(tag: int): int{.cdecl, importc: "Mix_HaltGroup",
dynlib: MixerLibName.}
proc Mix_HaltMusic*(): int{.cdecl, importc: "Mix_HaltMusic",
proc HaltMusic*(): int{.cdecl, importc: "Mix_HaltMusic",
dynlib: MixerLibName.}
# Change the expiration delay for a particular channel.
# The sample will stop playing after the 'ticks' milliseconds have elapsed,
# or remove the expiration if 'ticks' is -1
#
proc Mix_ExpireChannel*(channel: int, ticks: int): int{.cdecl,
proc ExpireChannel*(channel: int, ticks: int): int{.cdecl,
importc: "Mix_ExpireChannel", dynlib: MixerLibName.}
# Halt a channel, fading it out progressively till it's silent
# The ms parameter indicates the number of milliseconds the fading
# will take.
#
proc Mix_FadeOutChannel*(which: int, ms: int): int{.cdecl,
proc FadeOutChannel*(which: int, ms: int): int{.cdecl,
importc: "Mix_FadeOutChannel", dynlib: MixerLibName.}
proc Mix_FadeOutGroup*(tag: int, ms: int): int{.cdecl,
proc FadeOutGroup*(tag: int, ms: int): int{.cdecl,
importc: "Mix_FadeOutGroup", dynlib: MixerLibName.}
proc Mix_FadeOutMusic*(ms: int): int{.cdecl, importc: "Mix_FadeOutMusic",
proc FadeOutMusic*(ms: int): int{.cdecl, importc: "Mix_FadeOutMusic",
dynlib: MixerLibName.}
# Query the fading status of a channel
proc Mix_FadingMusic*(): TMix_Fading{.cdecl, importc: "Mix_FadingMusic",
proc FadingMusic*(): TFading{.cdecl, importc: "Mix_FadingMusic",
dynlib: MixerLibName.}
proc Mix_FadingChannel*(which: int): TMix_Fading{.cdecl,
proc FadingChannel*(which: int): TFading{.cdecl,
importc: "Mix_FadingChannel", dynlib: MixerLibName.}
# Pause/Resume a particular channel
proc Mix_Pause*(channel: int){.cdecl, importc: "Mix_Pause", dynlib: MixerLibName.}
proc Mix_Resume*(channel: int){.cdecl, importc: "Mix_Resume",
proc Pause*(channel: int){.cdecl, importc: "Mix_Pause", dynlib: MixerLibName.}
proc Resume*(channel: int){.cdecl, importc: "Mix_Resume",
dynlib: MixerLibName.}
proc Mix_Paused*(channel: int): int{.cdecl, importc: "Mix_Paused",
proc Paused*(channel: int): int{.cdecl, importc: "Mix_Paused",
dynlib: MixerLibName.}
# Pause/Resume the music stream
proc Mix_PauseMusic*(){.cdecl, importc: "Mix_PauseMusic", dynlib: MixerLibName.}
proc Mix_ResumeMusic*(){.cdecl, importc: "Mix_ResumeMusic", dynlib: MixerLibName.}
proc Mix_RewindMusic*(){.cdecl, importc: "Mix_RewindMusic", dynlib: MixerLibName.}
proc Mix_PausedMusic*(): int{.cdecl, importc: "Mix_PausedMusic",
proc PauseMusic*(){.cdecl, importc: "Mix_PauseMusic", dynlib: MixerLibName.}
proc ResumeMusic*(){.cdecl, importc: "Mix_ResumeMusic", dynlib: MixerLibName.}
proc RewindMusic*(){.cdecl, importc: "Mix_RewindMusic", dynlib: MixerLibName.}
proc PausedMusic*(): int{.cdecl, importc: "Mix_PausedMusic",
dynlib: MixerLibName.}
# Set the current position in the music stream.
# This returns 0 if successful, or -1 if it failed or isn't implemented.
# This function is only implemented for MOD music formats (set pattern
# order number) and for OGG music (set position in seconds), at the
# moment.
#
proc Mix_SetMusicPosition*(position: float64): int{.cdecl,
proc SetMusicPosition*(position: float64): int{.cdecl,
importc: "Mix_SetMusicPosition", dynlib: MixerLibName.}
# Check the status of a specific channel.
# If the specified channel is -1, check all channels.
#
proc Mix_Playing*(channel: int): int{.cdecl, importc: "Mix_Playing",
proc Playing*(channel: int): int{.cdecl, importc: "Mix_Playing",
dynlib: MixerLibName.}
proc Mix_PlayingMusic*(): int{.cdecl, importc: "Mix_PlayingMusic",
proc PlayingMusic*(): int{.cdecl, importc: "Mix_PlayingMusic",
dynlib: MixerLibName.}
# Stop music and set external music playback command
proc Mix_SetMusicCMD*(command: cstring): int{.cdecl, importc: "Mix_SetMusicCMD",
proc SetMusicCMD*(command: cstring): int{.cdecl, importc: "Mix_SetMusicCMD",
dynlib: MixerLibName.}
# Synchro value is set by MikMod from modules while playing
proc Mix_SetSynchroValue*(value: int): int{.cdecl,
proc SetSynchroValue*(value: int): int{.cdecl,
importc: "Mix_SetSynchroValue", dynlib: MixerLibName.}
proc Mix_GetSynchroValue*(): int{.cdecl, importc: "Mix_GetSynchroValue",
proc GetSynchroValue*(): int{.cdecl, importc: "Mix_GetSynchroValue",
dynlib: MixerLibName.}
#
# Get the Mix_Chunk currently associated with a mixer channel
# Returns nil if it's an invalid channel, or there's no chunk associated.
#
proc Mix_GetChunk*(channel: int): PMix_Chunk{.cdecl, importc: "Mix_GetChunk",
proc GetChunk*(channel: int): PChunk{.cdecl, importc: "Mix_GetChunk",
dynlib: MixerLibName.}
# Close the mixer, halting all playing audio
proc Mix_CloseAudio*(){.cdecl, importc: "Mix_CloseAudio", dynlib: MixerLibName.}
# We'll use SDL for reporting errors
proc Mix_SetError*(fmt: cstring)
proc Mix_GetError*(): cstring
# implementation
proc MIXER_VERSION(X: var Tversion) =
X.major = MIXER_MAJOR_VERSION
X.minor = MIXER_MINOR_VERSION
X.patch = MIXER_PATCHLEVEL
proc CloseAudio*(){.cdecl, importc: "Mix_CloseAudio", dynlib: MixerLibName.}
proc Mix_LoadWAV(filename: cstring): PMix_Chunk =
result = Mix_LoadWAV_RW(RWFromFile(filename, "rb"), 1)
proc VERSION(X: var sdl.Tversion) =
X.major = MAJOR_VERSION
X.minor = MINOR_VERSION
X.patch = PATCHLEVEL
proc Mix_PlayChannel(channel: int, chunk: PMix_Chunk, loops: int): int =
result = Mix_PlayChannelTimed(channel, chunk, loops, - 1)
proc LoadWAV(filename: cstring): PChunk =
result = LoadWAV_RW(RWFromFile(filename, "rb"), 1)
proc Mix_FadeInChannel(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int =
result = Mix_FadeInChannelTimed(channel, chunk, loops, ms, - 1)
proc PlayChannel(channel: int, chunk: PChunk, loops: int): int =
result = PlayChannelTimed(channel, chunk, loops, - 1)
proc Mix_SetError(fmt: cstring) =
SetError(fmt)
proc FadeInChannel(channel: int, chunk: PChunk, loops: int, ms: int): int =
result = FadeInChannelTimed(channel, chunk, loops, ms, - 1)
proc Mix_GetError(): cstring =
result = GetError()

475
lib/newwrap/sdl/sdl_mixer_nosmpeg.nim
View File

@@ -3,7 +3,7 @@
#******************************************************************************
import
sdl
when defined(windows):
const
@@ -15,29 +15,24 @@ else:
const
MixerLibName = "libSDL_mixer.so"
const
MIXER_MAJOR_VERSION* = 1'i8
MIXER_MINOR_VERSION* = 2'i8
MIXER_PATCHLEVEL* = 7'i8 # Backwards compatibility
MIX_MAJOR_VERSION* = MIXER_MAJOR_VERSION
MIX_MINOR_VERSION* = MIXER_MINOR_VERSION
MIX_PATCHLEVEL* = MIXER_PATCHLEVEL # SDL_Mixer.h constants
# The default mixer has 8 simultaneous mixing channels
MIX_CHANNELS* = 8 # Good default values for a PC soundcard
MIX_DEFAULT_FREQUENCY* = 22050
MAJOR_VERSION* = 1'i8
MINOR_VERSION* = 2'i8
PATCHLEVEL* = 7'i8 # Backwards compatibility
CHANNELS* = 8 # Good default values for a PC soundcard
DEFAULT_FREQUENCY* = 22050
when defined(IA32):
const
MIX_DEFAULT_FORMAT* = AUDIO_S16LSB
DEFAULT_FORMAT* = AUDIO_S16LSB
else:
const
MIX_DEFAULT_FORMAT* = AUDIO_S16MSB
DEFAULT_FORMAT* = AUDIO_S16MSB
const
MIX_DEFAULT_CHANNELS* = 2
MIX_MAX_VOLUME* = 128 # Volume of a chunk
PATH_MAX* = 255 # mikmod.h constants
#*
# * Library version
# *
DEFAULT_CHANNELS* = 2
MAX_VOLUME* = 128 # Volume of a chunk
PATH_MAX* = 255
LIBMIKMOD_VERSION_MAJOR* = 3
LIBMIKMOD_VERSION_MINOR* = 1
LIBMIKMOD_REVISION* = 8
@@ -108,35 +103,33 @@ type #music_cmd.h types
PUNIMOD* = ptr TUNIMOD
TUNIMOD* = TMODULE #SDL_mixer.h types
# The internal format for an audio chunk
PMix_Chunk* = ptr TMix_Chunk
TMix_Chunk*{.final.} = object
PChunk* = ptr TChunk
TChunk*{.final.} = object
allocated*: int
abuf*: PUint8
alen*: Uint32
volume*: Uint8 # Per-sample volume, 0-128
Mix_Chunk* = TMix_Chunk # The different fading types supported
TMix_Fading* = enum
TFading* = enum
MIX_NO_FADING, MIX_FADING_OUT, MIX_FADING_IN
Mix_Fading* = TMix_Fading
TMix_MusicType* = enum
TMusicType* = enum
MUS_NONE, MUS_CMD, MUS_WAV, MUS_MOD, MUS_MID, MUS_OGG
PMix_Music* = ptr TMix_Music
TMix_Music*{.final.} = object
type_*: TMix_MusicType
PMusic* = ptr TMusic
TMusic*{.final.} = object
type_*: TMusicType
TMixFunction* = proc (udata: Pointer, stream: PUint8, length: int): Pointer{.
cdecl.} # This macro can be used to fill a version structure with the compile-time
# version of the SDL_mixer library.
proc MIXER_VERSION*(X: var TVersion)
proc VERSION*(X: var sdl.TVersion)
# This function gets the version of the dynamically linked SDL_mixer library.
# It should NOT be used to fill a version structure, instead you should use the
# SDL_MIXER_VERSION() macro.
proc Mix_Linked_Version*(): Pversion{.cdecl, importc: "Mix_Linked_Version",
proc Linked_Version*(): sdl.Pversion{.cdecl, importc: "Mix_Linked_Version",
dynlib: MixerLibName.}
# Open the mixer with a certain audio format
proc Mix_OpenAudio*(frequency: int, format: Uint16, channels: int,
proc OpenAudio*(frequency: int, format: Uint16, channels: int,
chunksize: int): int{.cdecl, importc: "Mix_OpenAudio",
dynlib: MixerLibName.}
# Dynamically change the number of channels managed by the mixer.
@@ -144,402 +137,170 @@ proc Mix_OpenAudio*(frequency: int, format: Uint16, channels: int,
# stopped.
# This function returns the new number of allocated channels.
#
proc Mix_AllocateChannels*(numchannels: int): int{.cdecl,
proc AllocateChannels*(numchannels: int): int{.cdecl,
importc: "Mix_AllocateChannels", dynlib: MixerLibName.}
# Find out what the actual audio device parameters are.
# This function returns 1 if the audio has been opened, 0 otherwise.
#
proc Mix_QuerySpec*(frequency: var int, format: var Uint16, channels: var int): int{.
proc QuerySpec*(frequency: var int, format: var Uint16, channels: var int): int{.
cdecl, importc: "Mix_QuerySpec", dynlib: MixerLibName.}
# Load a wave file or a music (.mod .s3m .it .xm) file
proc Mix_LoadWAV_RW*(src: PRWops, freesrc: int): PMix_Chunk{.cdecl,
proc LoadWAV_RW*(src: PRWops, freesrc: int): PChunk{.cdecl,
importc: "Mix_LoadWAV_RW", dynlib: MixerLibName.}
proc Mix_LoadWAV*(filename: cstring): PMix_Chunk
proc Mix_LoadMUS*(filename: cstring): PMix_Music{.cdecl, importc: "Mix_LoadMUS",
proc LoadWAV*(filename: cstring): PChunk
proc LoadMUS*(filename: cstring): PMusic{.cdecl, importc: "Mix_LoadMUS",
dynlib: MixerLibName.}
# Load a wave file of the mixer format from a memory buffer
proc Mix_QuickLoad_WAV*(mem: PUint8): PMix_Chunk{.cdecl,
proc QuickLoad_WAV*(mem: PUint8): PChunk{.cdecl,
importc: "Mix_QuickLoad_WAV", dynlib: MixerLibName.}
# Free an audio chunk previously loaded
proc Mix_FreeChunk*(chunk: PMix_Chunk){.cdecl, importc: "Mix_FreeChunk",
proc FreeChunk*(chunk: PChunk){.cdecl, importc: "Mix_FreeChunk",
dynlib: MixerLibName.}
proc Mix_FreeMusic*(music: PMix_Music){.cdecl, importc: "Mix_FreeMusic",
proc FreeMusic*(music: PMusic){.cdecl, importc: "Mix_FreeMusic",
dynlib: MixerLibName.}
# Find out the music format of a mixer music, or the currently playing
# music, if 'music' is NULL.
proc Mix_GetMusicType*(music: PMix_Music): TMix_MusicType{.cdecl,
proc GetMusicType*(music: PMusic): TMusicType{.cdecl,
importc: "Mix_GetMusicType", dynlib: MixerLibName.}
# Set a function that is called after all mixing is performed.
# This can be used to provide real-time visual display of the audio stream
# or add a custom mixer filter for the stream data.
#
proc Mix_SetPostMix*(mix_func: TMixFunction, arg: Pointer){.cdecl,
proc SetPostMix*(mixfunc: TMixFunction, arg: Pointer){.cdecl,
importc: "Mix_SetPostMix", dynlib: MixerLibName.}
# Add your own music player or additional mixer function.
# If 'mix_func' is NULL, the default music player is re-enabled.
#
proc Mix_HookMusic*(mix_func: TMixFunction, arg: Pointer){.cdecl,
proc HookMusic*(mix_func: TMixFunction, arg: Pointer){.cdecl,
importc: "Mix_HookMusic", dynlib: MixerLibName.}
# Add your own callback when the music has finished playing.
#
proc Mix_HookMusicFinished*(music_finished: Pointer){.cdecl,
proc HookMusicFinished*(music_finished: Pointer){.cdecl,
importc: "Mix_HookMusicFinished", dynlib: MixerLibName.}
# Get a pointer to the user data for the current music hook
proc Mix_GetMusicHookData*(): Pointer{.cdecl, importc: "Mix_GetMusicHookData",
proc GetMusicHookData*(): Pointer{.cdecl, importc: "Mix_GetMusicHookData",
dynlib: MixerLibName.}
#* Add your own callback when a channel has finished playing. NULL
# * to disable callback.*
type
TChannel_finished* = proc (channel: int){.cdecl.}
proc Mix_ChannelFinished*(channel_finished: TChannel_finished){.cdecl,
proc ChannelFinished*(channel_finished: TChannel_finished){.cdecl,
importc: "Mix_ChannelFinished", dynlib: MixerLibName.}
const
MIX_CHANNEL_POST* = - 2 #* This is the format of a special effect callback:
# *
# * myeffect(int chan, void *stream, int len, void *udata);
# *
# * (chan) is the channel number that your effect is affecting. (stream) is
# * the buffer of data to work upon. (len) is the size of (stream), and
# * (udata) is a user-defined bit of data, which you pass as the last arg of
# * Mix_RegisterEffect(), and is passed back unmolested to your callback.
# * Your effect changes the contents of (stream) based on whatever parameters
# * are significant, or just leaves it be, if you prefer. You can do whatever
# * you like to the buffer, though, and it will continue in its changed state
# * down the mixing pipeline, through any other effect functions, then finally
# * to be mixed with the rest of the channels and music for the final output
# * stream.
# *
CHANNEL_POST* = - 2
type
TMix_EffectFunc* = proc (chan: int, stream: Pointer, length: int,
udata: Pointer): Pointer{.cdecl.} # * This is a callback that signifies that a channel has finished all its
# * loops and has completed playback. This gets called if the buffer
# * plays out normally, or if you call Mix_HaltChannel(), implicitly stop
# * a channel via
# Mix_AllocateChannels(), or unregister a callback while
# * it's still playing.
TMix_EffectDone* = proc (chan: int, udata: Pointer): Pointer{.cdecl.} #* Register a special effect function. At mixing time, the channel data is
# * copied into a buffer and passed through each registered effect function.
# * After it passes through all the functions, it is mixed into the final
# * output stream. The copy to buffer is performed once, then each effect
# * function performs on the output of the previous effect. Understand that
# * this extra copy to a buffer is not performed if there are no effects
# * registered for a given chunk, which saves CPU cycles, and any given
# * effect will be extra cycles, too, so it is crucial that your code run
# * fast. Also note that the data that your function is given is in the
# * format of the sound device, and not the format you gave to Mix_OpenAudio(),
# * although they may in reality be the same. This is an unfortunate but
# * necessary speed concern. Use Mix_QuerySpec() to determine if you can
# * handle the data before you register your effect, and take appropriate
# * actions.
# * You may also specify a callback (Mix_EffectDone_t) that is called when
# * the channel finishes playing. This gives you a more fine-grained control
# * than Mix_ChannelFinished(), in case you need to free effect-specific
# * resources, etc. If you don't need this, you can specify NULL.
# * You may set the callbacks before or after calling Mix_PlayChannel().
# * Things like Mix_SetPanning() are just internal special effect functions,
# * so if you are using that, you've already incurred the overhead of a copy
# * to a separate buffer, and that these effects will be in the queue with
# * any functions you've registered. The list of registered effects for a
# * channel is reset when a chunk finishes playing, so you need to explicitly
# * set them with each call to Mix_PlayChannel*().
# * You may also register a special effect function that is to be run after
# * final mixing occurs. The rules for these callbacks are identical to those
# * in Mix_RegisterEffect, but they are run after all the channels and the
# * music have been mixed into a single stream, whereas channel-specific
# * effects run on a given channel before any other mixing occurs. These
# * global effect callbacks are call "posteffects". Posteffects only have
# * their Mix_EffectDone_t function called when they are unregistered (since
# * the main output stream is never "done" in the same sense as a channel).
# * You must unregister them manually when you've had enough. Your callback
# * will be told that the channel being mixed is (MIX_CHANNEL_POST) if the
# * processing is considered a posteffect.
# *
# * After all these effects have finished processing, the callback registered
# * through Mix_SetPostMix() runs, and then the stream goes to the audio
# * device.
# *
# * returns zero if error (no such channel), nonzero if added.
# * Error messages can be retrieved from Mix_GetError().
TEffectFunc* = proc (chan: int, stream: Pointer, length: int,
udata: Pointer): Pointer{.cdecl.}
TEffectDone* = proc (chan: int, udata: Pointer): Pointer{.cdecl.}
proc Mix_RegisterEffect*(chan: int, f: TMix_EffectFunc, d: TMix_EffectDone,
proc RegisterEffect*(chan: int, f: TEffectFunc, d: TEffectDone,
arg: Pointer): int{.cdecl,
importc: "Mix_RegisterEffect", dynlib: MixerLibName.}
#* You may not need to call this explicitly, unless you need to stop an
# * effect from processing in the middle of a chunk's playback.
# * Posteffects are never implicitly unregistered as they are for channels,
# * but they may be explicitly unregistered through this function by
# * specifying MIX_CHANNEL_POST for a channel.
# * returns zero if error (no such channel or effect), nonzero if removed.
# * Error messages can be retrieved from Mix_GetError().
# *
proc Mix_UnregisterEffect*(channel: int, f: TMix_EffectFunc): int{.cdecl,
importc: "Mix_UnregisterEffect", dynlib: MixerLibName.}
#* You may not need to call this explicitly, unless you need to stop all
# * effects from processing in the middle of a chunk's playback. Note that
# * this will also shut off some internal effect processing, since
# * Mix_SetPanning( ) and others may use this API under the hood.This is
# * called internally when a channel completes playback.
# * Posteffects are never implicitly unregistered as they are for channels,
# * but they may be explicitly unregistered through this function by
# * specifying MIX_CHANNEL_POST for a channel.
# * returns zero if error( no such channel ), nonzero if all effects removed.
# * Error messages can be retrieved from Mix_GetError( ).
# *
proc Mix_UnregisterAllEffects*(channel: int): int{.cdecl,
importc: "Mix_UnregisterAllEffects", dynlib: MixerLibName.}
const
MIX_EFFECTSMAXSPEED* = "MIX_EFFECTSMAXSPEED" # * These are the internally - defined mixing effects.They use the same API that
# * effects defined in the application use, but are provided here as a
# * convenience.Some effects can reduce their quality or use more memory in
# * the name of speed; to enable this, make sure the environment variable
# * MIX_EFFECTSMAXSPEED( see above ) is defined before you call
# * Mix_OpenAudio( ).
# *
#* set the panning of a channel.The left and right channels are specified
# * as integers between 0 and 255, quietest to loudest, respectively.
# *
# * Technically, this is just individual volume control for a sample with
# * two( stereo )channels, so it can be used for more than just panning.
# * if you want real panning, call it like this :
# *
# * Mix_SetPanning( channel, left, 255 - left );
# *
# * ...which isn't so hard.
# *
# * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
# * the panning will be done to the final mixed stream before passing it on
# * to the audio device.
# *
# * This uses the Mix_RegisterEffect( )API internally, and returns without
# * registering the effect function if the audio device is not configured
# * for stereo output.Setting both( left ) and ( right ) to 255 causes this
# * effect to be unregistered, since that is the data's normal state.
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if panning effect enabled.Note that an audio device in mono
# * mode is a no - op, but this call will return successful in that case .
# * Error messages can be retrieved from Mix_GetError( ).
proc Mix_SetPanning*(channel: int, left: Uint8, right: Uint8): int{.cdecl,
proc UnregisterEffect*(channel: int, f: TEffectFunc): int{.cdecl,
importc: "Mix_UnregisterEffect", dynlib: MixerLibName.}
proc UnregisterAllEffects*(channel: int): int{.cdecl,
importc: "Mix_UnregisterAllEffects", dynlib: MixerLibName.}
const
EFFECTSMAXSPEED* = "MIX_EFFECTSMAXSPEED"
proc SetPanning*(channel: int, left: Uint8, right: Uint8): int{.cdecl,
importc: "Mix_SetPanning", dynlib: MixerLibName.}
# * set the position ofa channel.( angle ) is an integer from 0 to 360, that
# * specifies the location of the sound in relation to the listener.( angle )
# * will be reduced as neccesary( 540 becomes 180 degrees, -100 becomes 260 ).
# * Angle 0 is due north, and rotates clockwise as the value increases.
# * for efficiency, the precision of this effect may be limited( angles 1
# * through 7 might all produce the same effect, 8 through 15 are equal, etc ).
# * ( distance ) is an integer between 0 and 255 that specifies the space
# * between the sound and the listener.The larger the number, the further
# * away the sound is .Using 255 does not guarantee that the channel will be
# * culled from the mixing process or be completely silent.For efficiency,
# * the precision of this effect may be limited( distance 0 through 5 might
# * all produce the same effect, 6 through 10 are equal, etc ).Setting( angle )
# * and ( distance ) to 0 unregisters this effect, since the data would be
# * unchanged.
# *
# * if you need more precise positional audio, consider using OpenAL for
# * spatialized effects instead of SDL_mixer.This is only meant to be a
# * basic effect for simple "3D" games.
# *
# * if the audio device is configured for mono output, then you won't get
# * any effectiveness from the angle; however, distance attenuation on the
# * channel will still occur.While this effect will function with stereo
# * voices, it makes more sense to use voices with only one channel of sound,
# * so when they are mixed through this effect, the positioning will sound
# * correct.You can convert them to mono through SDL before giving them to
# * the mixer in the first place if you like.
# *
# * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
# * the positioning will be done to the final mixed stream before passing it
# * on to the audio device.
# *
# * This is a convenience wrapper over Mix_SetDistance( ) and Mix_SetPanning( ).
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if position effect is enabled.
# * Error messages can be retrieved from Mix_GetError( ).
# *
proc Mix_SetPosition*(channel: int, angle: Sint16, distance: Uint8): int{.cdecl,
proc SetPosition*(channel: int, angle: Sint16, distance: Uint8): int{.cdecl,
importc: "Mix_SetPosition", dynlib: MixerLibName.}
#* set the "distance" of a channel.( distance ) is an integer from 0 to 255
# * that specifies the location of the sound in relation to the listener.
# * Distance 0 is overlapping the listener, and 255 is as far away as possible
# * A distance of 255 does not guarantee silence; in such a case , you might
# * want to try changing the chunk's volume, or just cull the sample from the
# * mixing process with Mix_HaltChannel( ).
# * for efficiency, the precision of this effect may be limited( distances 1
# * through 7 might all produce the same effect, 8 through 15 are equal, etc ).
# * ( distance ) is an integer between 0 and 255 that specifies the space
# * between the sound and the listener.The larger the number, the further
# * away the sound is .
# * Setting( distance ) to 0 unregisters this effect, since the data would be
# * unchanged.
# * if you need more precise positional audio, consider using OpenAL for
# * spatialized effects instead of SDL_mixer.This is only meant to be a
# * basic effect for simple "3D" games.
# *
# * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
# * the distance attenuation will be done to the final mixed stream before
# * passing it on to the audio device.
# *
# * This uses the Mix_RegisterEffect( )API internally.
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if position effect is enabled.
# * Error messages can be retrieved from Mix_GetError( ).
# *
proc Mix_SetDistance*(channel: int, distance: Uint8): int{.cdecl,
proc SetDistance*(channel: int, distance: Uint8): int{.cdecl,
importc: "Mix_SetDistance", dynlib: MixerLibName.}
# *
# * !!! FIXME : Haven't implemented, since the effect goes past the
# * end of the sound buffer.Will have to think about this.
# * - -ryan.
# * /
# { if 0
# { * Causes an echo effect to be mixed into a sound.( echo ) is the amount
# * of echo to mix.0 is no echo, 255 is infinite( and probably not
# * what you want ).
# *
# * Setting( channel ) to MIX_CHANNEL_POST registers this as a posteffect, and
# * the reverbing will be done to the final mixed stream before passing it on
# * to the audio device.
# *
# * This uses the Mix_RegisterEffect( )API internally.If you specify an echo
# * of zero, the effect is unregistered, as the data is already in that state.
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if reversing effect is enabled.
# * Error messages can be retrieved from Mix_GetError( ).
# *
# extern no_parse_DECLSPEC int Mix_SetReverb( int channel, Uint8 echo );
# #E ndif
# * Causes a channel to reverse its stereo.This is handy if the user has his
# * speakers hooked up backwards, or you would like to have a minor bit of
# * psychedelia in your sound code. : )Calling this function with ( flip )
# * set to non - zero reverses the chunks's usual channels. If (flip) is zero,
# * the effect is unregistered.
# *
# * This uses the Mix_RegisterEffect( )API internally, and thus is probably
# * more CPU intensive than having the user just plug in his speakers
# * correctly.Mix_SetReverseStereo( )returns without registering the effect
# * function if the audio device is not configured for stereo output.
# *
# * if you specify MIX_CHANNEL_POST for ( channel ), then this the effect is used
# * on the final mixed stream before sending it on to the audio device( a
# * posteffect ).
# *
# * returns zero if error( no such channel or Mix_RegisterEffect( )fails ),
# * nonzero if reversing effect is enabled.Note that an audio device in mono
# * mode is a no - op, but this call will return successful in that case .
# * Error messages can be retrieved from Mix_GetError( ).
# *
proc Mix_SetReverseStereo*(channel: int, flip: int): int{.cdecl,
proc SetReverseStereo*(channel: int, flip: int): int{.cdecl,
importc: "Mix_SetReverseStereo", dynlib: MixerLibName.}
# end of effects API. - -ryan. *
# Reserve the first channels (0 -> n-1) for the application, i.e. don't allocate
# them dynamically to the next sample if requested with a -1 value below.
# Returns the number of reserved channels.
#
proc Mix_ReserveChannels*(num: int): int{.cdecl, importc: "Mix_ReserveChannels",
proc ReserveChannels*(num: int): int{.cdecl, importc: "Mix_ReserveChannels",
dynlib: MixerLibName.}
# Channel grouping functions
# Attach a tag to a channel. A tag can be assigned to several mixer
# channels, to form groups of channels.
# If 'tag' is -1, the tag is removed (actually -1 is the tag used to
# represent the group of all the channels).
# Returns true if everything was OK.
#
proc Mix_GroupChannel*(which: int, tag: int): int{.cdecl,
proc GroupChannel*(which: int, tag: int): int{.cdecl,
importc: "Mix_GroupChannel", dynlib: MixerLibName.}
# Assign several consecutive channels to a group
proc Mix_GroupChannels*(`from`: int, `to`: int, tag: int): int{.cdecl,
proc GroupChannels*(`from`: int, `to`: int, tag: int): int{.cdecl,
importc: "Mix_GroupChannels", dynlib: MixerLibName.}
# Finds the first available channel in a group of channels
proc Mix_GroupAvailable*(tag: int): int{.cdecl, importc: "Mix_GroupAvailable",
proc GroupAvailable*(tag: int): int{.cdecl, importc: "Mix_GroupAvailable",
dynlib: MixerLibName.}
# Returns the number of channels in a group. This is also a subtle
# way to get the total number of channels when 'tag' is -1
#
proc Mix_GroupCount*(tag: int): int{.cdecl, importc: "Mix_GroupCount",
proc GroupCount*(tag: int): int{.cdecl, importc: "Mix_GroupCount",
dynlib: MixerLibName.}
# Finds the "oldest" sample playing in a group of channels
proc Mix_GroupOldest*(tag: int): int{.cdecl, importc: "Mix_GroupOldest",
proc GroupOldest*(tag: int): int{.cdecl, importc: "Mix_GroupOldest",
dynlib: MixerLibName.}
# Finds the "most recent" (i.e. last) sample playing in a group of channels
proc Mix_GroupNewer*(tag: int): int{.cdecl, importc: "Mix_GroupNewer",
proc GroupNewer*(tag: int): int{.cdecl, importc: "Mix_GroupNewer",
dynlib: MixerLibName.}
# The same as above, but the sound is played at most 'ticks' milliseconds
proc Mix_PlayChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int,
proc PlayChannelTimed*(channel: int, chunk: PChunk, loops: int,
ticks: int): int{.cdecl,
importc: "Mix_PlayChannelTimed", dynlib: MixerLibName.}
# Play an audio chunk on a specific channel.
# If the specified channel is -1, play on the first free channel.
# If 'loops' is greater than zero, loop the sound that many times.
# If 'loops' is -1, loop inifinitely (~65000 times).
# Returns which channel was used to play the sound.
#
proc Mix_PlayChannel*(channel: int, chunk: PMix_Chunk, loops: int): int
proc Mix_PlayMusic*(music: PMix_Music, loops: int): int{.cdecl,
proc PlayChannel*(channel: int, chunk: PChunk, loops: int): int
proc PlayMusic*(music: PMusic, loops: int): int{.cdecl,
importc: "Mix_PlayMusic", dynlib: MixerLibName.}
# Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions
proc Mix_FadeInMusic*(music: PMix_Music, loops: int, ms: int): int{.cdecl,
proc FadeInMusic*(music: PMusic, loops: int, ms: int): int{.cdecl,
importc: "Mix_FadeInMusic", dynlib: MixerLibName.}
proc Mix_FadeInChannelTimed*(channel: int, chunk: PMix_Chunk, loops: int,
proc FadeInChannelTimed*(channel: int, chunk: PChunk, loops: int,
ms: int, ticks: int): int{.cdecl,
importc: "Mix_FadeInChannelTimed", dynlib: MixerLibName.}
proc Mix_FadeInChannel*(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int
proc FadeInChannel*(channel: int, chunk: PChunk, loops: int, ms: int): int
# Set the volume in the range of 0-128 of a specific channel or chunk.
# If the specified channel is -1, set volume for all channels.
# Returns the original volume.
# If the specified volume is -1, just return the current volume.
#
proc Mix_Volume*(channel: int, volume: int): int{.cdecl, importc: "Mix_Volume",
proc Volume*(channel: int, volume: int): int{.cdecl, importc: "Mix_Volume",
dynlib: MixerLibName.}
proc Mix_VolumeChunk*(chunk: PMix_Chunk, volume: int): int{.cdecl,
proc VolumeChunk*(chunk: PChunk, volume: int): int{.cdecl,
importc: "Mix_VolumeChunk", dynlib: MixerLibName.}
proc Mix_VolumeMusic*(volume: int): int{.cdecl, importc: "Mix_VolumeMusic",
proc VolumeMusic*(volume: int): int{.cdecl, importc: "Mix_VolumeMusic",
dynlib: MixerLibName.}
# Halt playing of a particular channel
proc Mix_HaltChannel*(channel: int): int{.cdecl, importc: "Mix_HaltChannel",
proc HaltChannel*(channel: int): int{.cdecl, importc: "Mix_HaltChannel",
dynlib: MixerLibName.}
proc Mix_HaltGroup*(tag: int): int{.cdecl, importc: "Mix_HaltGroup",
proc HaltGroup*(tag: int): int{.cdecl, importc: "Mix_HaltGroup",
dynlib: MixerLibName.}
proc Mix_HaltMusic*(): int{.cdecl, importc: "Mix_HaltMusic",
proc HaltMusic*(): int{.cdecl, importc: "Mix_HaltMusic",
dynlib: MixerLibName.}
# Change the expiration delay for a particular channel.
# The sample will stop playing after the 'ticks' milliseconds have elapsed,
# or remove the expiration if 'ticks' is -1
#
proc Mix_ExpireChannel*(channel: int, ticks: int): int{.cdecl,
proc ExpireChannel*(channel: int, ticks: int): int{.cdecl,
importc: "Mix_ExpireChannel", dynlib: MixerLibName.}
# Halt a channel, fading it out progressively till it's silent
# The ms parameter indicates the number of milliseconds the fading
# will take.
#
proc Mix_FadeOutChannel*(which: int, ms: int): int{.cdecl,
proc FadeOutChannel*(which: int, ms: int): int{.cdecl,
importc: "Mix_FadeOutChannel", dynlib: MixerLibName.}
proc Mix_FadeOutGroup*(tag: int, ms: int): int{.cdecl,
proc FadeOutGroup*(tag: int, ms: int): int{.cdecl,
importc: "Mix_FadeOutGroup", dynlib: MixerLibName.}
proc Mix_FadeOutMusic*(ms: int): int{.cdecl, importc: "Mix_FadeOutMusic",
proc FadeOutMusic*(ms: int): int{.cdecl, importc: "Mix_FadeOutMusic",
dynlib: MixerLibName.}
# Query the fading status of a channel
proc Mix_FadingMusic*(): TMix_Fading{.cdecl, importc: "Mix_FadingMusic",
proc FadingMusic*(): TFading{.cdecl, importc: "Mix_FadingMusic",
dynlib: MixerLibName.}
proc Mix_FadingChannel*(which: int): TMix_Fading{.cdecl,
proc FadingChannel*(which: int): TFading{.cdecl,
importc: "Mix_FadingChannel", dynlib: MixerLibName.}
# Pause/Resume a particular channel
proc Mix_Pause*(channel: int){.cdecl, importc: "Mix_Pause", dynlib: MixerLibName.}
proc Mix_Resume*(channel: int){.cdecl, importc: "Mix_Resume",
proc Pause*(channel: int){.cdecl, importc: "Mix_Pause", dynlib: MixerLibName.}
proc Resume*(channel: int){.cdecl, importc: "Mix_Resume",
dynlib: MixerLibName.}
proc Mix_Paused*(channel: int): int{.cdecl, importc: "Mix_Paused",
proc Paused*(channel: int): int{.cdecl, importc: "Mix_Paused",
dynlib: MixerLibName.}
# Pause/Resume the music stream
proc Mix_PauseMusic*(){.cdecl, importc: "Mix_PauseMusic", dynlib: MixerLibName.}
proc Mix_ResumeMusic*(){.cdecl, importc: "Mix_ResumeMusic", dynlib: MixerLibName.}
proc Mix_RewindMusic*(){.cdecl, importc: "Mix_RewindMusic", dynlib: MixerLibName.}
proc Mix_PausedMusic*(): int{.cdecl, importc: "Mix_PausedMusic",
proc PauseMusic*(){.cdecl, importc: "Mix_PauseMusic", dynlib: MixerLibName.}
proc ResumeMusic*(){.cdecl, importc: "Mix_ResumeMusic", dynlib: MixerLibName.}
proc RewindMusic*(){.cdecl, importc: "Mix_RewindMusic", dynlib: MixerLibName.}
proc PausedMusic*(): int{.cdecl, importc: "Mix_PausedMusic",
dynlib: MixerLibName.}
# Set the current position in the music stream.
# This returns 0 if successful, or -1 if it failed or isn't implemented.
@@ -547,52 +308,44 @@ proc Mix_PausedMusic*(): int{.cdecl, importc: "Mix_PausedMusic",
# order number) and for OGG music (set position in seconds), at the
# moment.
#
proc Mix_SetMusicPosition*(position: float64): int{.cdecl,
proc SetMusicPosition*(position: float64): int{.cdecl,
importc: "Mix_SetMusicPosition", dynlib: MixerLibName.}
# Check the status of a specific channel.
# If the specified channel is -1, check all channels.
#
proc Mix_Playing*(channel: int): int{.cdecl, importc: "Mix_Playing",
proc Playing*(channel: int): int{.cdecl, importc: "Mix_Playing",
dynlib: MixerLibName.}
proc Mix_PlayingMusic*(): int{.cdecl, importc: "Mix_PlayingMusic",
proc PlayingMusic*(): int{.cdecl, importc: "Mix_PlayingMusic",
dynlib: MixerLibName.}
# Stop music and set external music playback command
proc Mix_SetMusicCMD*(command: cstring): int{.cdecl, importc: "Mix_SetMusicCMD",
proc SetMusicCMD*(command: cstring): int{.cdecl, importc: "Mix_SetMusicCMD",
dynlib: MixerLibName.}
# Synchro value is set by MikMod from modules while playing
proc Mix_SetSynchroValue*(value: int): int{.cdecl,
proc SetSynchroValue*(value: int): int{.cdecl,
importc: "Mix_SetSynchroValue", dynlib: MixerLibName.}
proc Mix_GetSynchroValue*(): int{.cdecl, importc: "Mix_GetSynchroValue",
proc GetSynchroValue*(): int{.cdecl, importc: "Mix_GetSynchroValue",
dynlib: MixerLibName.}
#
# Get the Mix_Chunk currently associated with a mixer channel
# Returns nil if it's an invalid channel, or there's no chunk associated.
#
proc Mix_GetChunk*(channel: int): PMix_Chunk{.cdecl, importc: "Mix_GetChunk",
proc GetChunk*(channel: int): PChunk{.cdecl, importc: "Mix_GetChunk",
dynlib: MixerLibName.}
# Close the mixer, halting all playing audio
proc Mix_CloseAudio*(){.cdecl, importc: "Mix_CloseAudio", dynlib: MixerLibName.}
proc CloseAudio*(){.cdecl, importc: "Mix_CloseAudio", dynlib: MixerLibName.}
# We'll use SDL for reporting errors
proc Mix_SetError*(fmt: cstring)
proc Mix_GetError*(): cstring
# implementation
proc MIXER_VERSION(X: var Tversion) =
X.major = MIXER_MAJOR_VERSION
X.minor = MIXER_MINOR_VERSION
X.patch = MIXER_PATCHLEVEL
proc VERSION(X: var Tversion) =
X.major = MAJOR_VERSION
X.minor = MINOR_VERSION
X.patch = PATCHLEVEL
proc Mix_LoadWAV(filename: cstring): PMix_Chunk =
result = Mix_LoadWAV_RW(RWFromFile(filename, "rb"), 1)
proc LoadWAV(filename: cstring): PChunk =
result = LoadWAV_RW(RWFromFile(filename, "rb"), 1)
proc Mix_PlayChannel(channel: int, chunk: PMix_Chunk, loops: int): int =
result = Mix_PlayChannelTimed(channel, chunk, loops, - 1)
proc PlayChannel(channel: int, chunk: PChunk, loops: int): int =
result = PlayChannelTimed(channel, chunk, loops, - 1)
proc Mix_FadeInChannel(channel: int, chunk: PMix_Chunk, loops: int, ms: int): int =
result = Mix_FadeInChannelTimed(channel, chunk, loops, ms, - 1)
proc FadeInChannel(channel: int, chunk: PChunk, loops: int, ms: int): int =
result = FadeInChannelTimed(channel, chunk, loops, ms, - 1)
proc Mix_SetError(fmt: cstring) =
SetError(fmt)
proc Mix_GetError(): cstring =
result = GetError()

151
lib/newwrap/sdl/sdl_net.nim
View File

@@ -110,7 +110,7 @@
#******************************************************************************
import
sdl
when defined(windows):
const
@@ -122,9 +122,9 @@ else:
const
NetLibName = "libSDL_net.so"
const #* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *
NET_MAJOR_VERSION* = 1'i8
NET_MINOR_VERSION* = 2'i8
NET_PATCHLEVEL* = 5'i8 # SDL_Net.h constants
MAJOR_VERSION* = 1'i8
MINOR_VERSION* = 2'i8
PATCHLEVEL* = 5'i8 # SDL_Net.h constants
#* Resolve a host name and port to an IP address in network form.
# If the function succeeds, it will return 0.
# If the host couldn't be resolved, the host portion of the returned
@@ -136,8 +136,8 @@ const #* Printable format: "%d.%d.%d", MAJOR, MINOR, PAT
#* UDP network API *
#***********************************************************************
#* The maximum channels on a a UDP socket *
NET_MAX_UDPCHANNELS* = 32 #* The maximum addresses bound to a single UDP socket channel *
NET_MAX_UDPADDRESSES* = 4
MAX_UDPCHANNELS* = 32 #* The maximum addresses bound to a single UDP socket channel *
MAX_UDPADDRESSES* = 4
type # SDL_net.h types
#***********************************************************************
@@ -149,9 +149,7 @@ type # SDL_net.h types
port*: Uint16 # 16-bit protocol port */
PTCPSocket* = ptr TTCPSocket
TTCPSocket*{.final.} = object #***********************************************************************
#* UDP network API *
#***********************************************************************
TTCPSocket*{.final.} = object # UDP network API
ready*: int
channel*: int
remoteAddress*: TIPaddress
@@ -161,14 +159,14 @@ type # SDL_net.h types
PUDP_Channel* = ptr TUDP_Channel
TUDP_Channel*{.final.} = object
numbound*: int
address*: array[0..NET_MAX_UDPADDRESSES - 1, TIPAddress]
address*: array[0..MAX_UDPADDRESSES - 1, TIPAddress]
PUDPSocket* = ptr TUDPSocket
TUDPSocket*{.final.} = object
ready*: int
channel*: int
address*: TIPAddress
binding*: array[0..NET_MAX_UDPCHANNELS - 1, TUDP_Channel]
binding*: array[0..MAX_UDPCHANNELS - 1, TUDP_Channel]
PUDPpacket* = ptr TUDPpacket
PPUDPpacket* = ptr PUDPpacket
@@ -182,44 +180,43 @@ type # SDL_net.h types
status*: int #* packet status after sending *
address*: TIPAddress #* The source/dest address of an incoming/outgoing packet *
PNet_Socket* = ptr TNet_Socket
TNet_Socket*{.final.} = object
PSocket* = ptr TSocket
TSocket*{.final.} = object
ready*: int
channel*: int
PNet_SocketSet* = ptr TNet_SocketSet
TNet_SocketSet*{.final.} = object #* Any network socket can be safely cast to this socket type *
PSocketSet* = ptr TSocketSet
TSocketSet*{.final.} = object # Any network socket can be safely cast to this socket type *
numsockets*: int
maxsockets*: int
sockets*: PNet_Socket
sockets*: PSocket
PNet_GenericSocket* = ptr TNet_GenericSocket
TNet_GenericSocket*{.final.} = object # This macro can be used to fill a version structure with the compile-time
# version of the SDL_net library.
PGenericSocket* = ptr TGenericSocket
TGenericSocket*{.final.} = object
ready*: int
proc NET_VERSION*(X: var Tversion)
proc VERSION*(X: var Tversion)
#* Initialize/Cleanup the network API
# SDL must be initialized before calls to functions in this library,
# because this library uses utility functions from the SDL library.
#*
proc Net_Init*(): int{.cdecl, importc: "SDLNet_Init", dynlib: NetLibName.}
proc Net_Quit*(){.cdecl, importc: "SDLNet_Quit", dynlib: NetLibName.}
proc Init*(): int{.cdecl, importc: "SDLNet_Init", dynlib: NetLibName.}
proc Quit*(){.cdecl, importc: "SDLNet_Quit", dynlib: NetLibName.}
#* Resolve a host name and port to an IP address in network form.
# If the function succeeds, it will return 0.
# If the host couldn't be resolved, the host portion of the returned
# address will be INADDR_NONE, and the function will return -1.
# If 'host' is NULL, the resolved host will be set to INADDR_ANY.
# *
proc Net_ResolveHost*(address: var TIPaddress, host: cstring, port: Uint16): int{.
proc ResolveHost*(address: var TIPaddress, host: cstring, port: Uint16): int{.
cdecl, importc: "SDLNet_ResolveHost", dynlib: NetLibName.}
#* Resolve an ip address to a host name in canonical form.
# If the ip couldn't be resolved, this function returns NULL,
# otherwise a pointer to a static buffer containing the hostname
# is returned. Note that this function is not thread-safe.
#*
proc Net_ResolveIP*(ip: var TIPaddress): cstring{.cdecl,
proc ResolveIP*(ip: var TIPaddress): cstring{.cdecl,
importc: "SDLNet_ResolveIP", dynlib: NetLibName.}
#***********************************************************************
#* TCP network API *
@@ -232,24 +229,24 @@ proc Net_ResolveIP*(ip: var TIPaddress): cstring{.cdecl,
# in the correct form).
# The newly created socket is returned, or NULL if there was an error.
#*
proc Net_TCP_Open*(ip: var TIPaddress): PTCPSocket{.cdecl,
proc TCP_Open*(ip: var TIPaddress): PTCPSocket{.cdecl,
importc: "SDLNet_TCP_Open", dynlib: NetLibName.}
#* Accept an incoming connection on the given server socket.
# The newly created socket is returned, or NULL if there was an error.
#*
proc Net_TCP_Accept*(server: PTCPsocket): PTCPSocket{.cdecl,
proc TCP_Accept*(server: PTCPsocket): PTCPSocket{.cdecl,
importc: "SDLNet_TCP_Accept", dynlib: NetLibName.}
#* Get the IP address of the remote system associated with the socket.
# If the socket is a server socket, this function returns NULL.
#*
proc Net_TCP_GetPeerAddress*(sock: PTCPsocket): PIPAddress{.cdecl,
proc TCP_GetPeerAddress*(sock: PTCPsocket): PIPAddress{.cdecl,
importc: "SDLNet_TCP_GetPeerAddress", dynlib: NetLibName.}
#* Send 'len' bytes of 'data' over the non-server socket 'sock'
# This function returns the actual amount of data sent. If the return value
# is less than the amount of data sent, then either the remote connection was
# closed, or an unknown socket error occurred.
#*
proc Net_TCP_Send*(sock: PTCPsocket, data: Pointer, length: int): int{.cdecl,
proc TCP_Send*(sock: PTCPsocket, data: Pointer, length: int): int{.cdecl,
importc: "SDLNet_TCP_Send", dynlib: NetLibName.}
#* Receive up to 'maxlen' bytes of data over the non-server socket 'sock',
# and store them in the buffer pointed to by 'data'.
@@ -257,10 +254,10 @@ proc Net_TCP_Send*(sock: PTCPsocket, data: Pointer, length: int): int{.cdecl,
# value is less than or equal to zero, then either the remote connection was
# closed, or an unknown socket error occurred.
#*
proc Net_TCP_Recv*(sock: PTCPsocket, data: Pointer, maxlen: int): int{.cdecl,
proc TCP_Recv*(sock: PTCPsocket, data: Pointer, maxlen: int): int{.cdecl,
importc: "SDLNet_TCP_Recv", dynlib: NetLibName.}
#* Close a TCP network socket *
proc Net_TCP_Close*(sock: PTCPsocket){.cdecl, importc: "SDLNet_TCP_Close",
proc TCP_Close*(sock: PTCPsocket){.cdecl, importc: "SDLNet_TCP_Close",
dynlib: NetLibName.}
#***********************************************************************
#* UDP network API *
@@ -268,26 +265,26 @@ proc Net_TCP_Close*(sock: PTCPsocket){.cdecl, importc: "SDLNet_TCP_Close",
#* Allocate/resize/free a single UDP packet 'size' bytes long.
# The new packet is returned, or NULL if the function ran out of memory.
# *
proc Net_AllocPacket*(size: int): PUDPpacket{.cdecl,
proc AllocPacket*(size: int): PUDPpacket{.cdecl,
importc: "SDLNet_AllocPacket", dynlib: NetLibName.}
proc Net_ResizePacket*(packet: PUDPpacket, newsize: int): int{.cdecl,
proc ResizePacket*(packet: PUDPpacket, newsize: int): int{.cdecl,
importc: "SDLNet_ResizePacket", dynlib: NetLibName.}
proc Net_FreePacket*(packet: PUDPpacket){.cdecl, importc: "SDLNet_FreePacket",
proc FreePacket*(packet: PUDPpacket){.cdecl, importc: "SDLNet_FreePacket",
dynlib: NetLibName.}
#* Allocate/Free a UDP packet vector (array of packets) of 'howmany' packets,
# each 'size' bytes long.
# A pointer to the first packet in the array is returned, or NULL if the
# function ran out of memory.
# *
proc Net_AllocPacketV*(howmany: int, size: int): PUDPpacket{.cdecl,
proc AllocPacketV*(howmany: int, size: int): PUDPpacket{.cdecl,
importc: "SDLNet_AllocPacketV", dynlib: NetLibName.}
proc Net_FreePacketV*(packetV: PUDPpacket){.cdecl,
proc FreePacketV*(packetV: PUDPpacket){.cdecl,
importc: "SDLNet_FreePacketV", dynlib: NetLibName.}
#* Open a UDP network socket
# If 'port' is non-zero, the UDP socket is bound to a local port.
# This allows other systems to send to this socket via a known port.
#*
proc Net_UDP_Open*(port: Uint16): PUDPsocket{.cdecl, importc: "SDLNet_UDP_Open",
proc UDP_Open*(port: Uint16): PUDPsocket{.cdecl, importc: "SDLNet_UDP_Open",
dynlib: NetLibName.}
#* Bind the address 'address' to the requested channel on the UDP socket.
# If the channel is -1, then the first unbound channel will be bound with
@@ -298,10 +295,10 @@ proc Net_UDP_Open*(port: Uint16): PUDPsocket{.cdecl, importc: "SDLNet_UDP_Open",
# address, to which all outbound packets on the channel are sent.
# This function returns the channel which was bound, or -1 on error.
#*
proc Net_UDP_Bind*(sock: PUDPsocket, channel: int, address: var TIPaddress): int{.
proc UDP_Bind*(sock: PUDPsocket, channel: int, address: var TIPaddress): int{.
cdecl, importc: "SDLNet_UDP_Bind", dynlib: NetLibName.}
#* Unbind all addresses from the given channel *
proc Net_UDP_Unbind*(sock: PUDPsocket, channel: int){.cdecl,
proc UDP_Unbind*(sock: PUDPsocket, channel: int){.cdecl,
importc: "SDLNet_UDP_Unbind", dynlib: NetLibName.}
#* Get the primary IP address of the remote system associated with the
# socket and channel. If the channel is -1, then the primary IP port
@@ -309,7 +306,7 @@ proc Net_UDP_Unbind*(sock: PUDPsocket, channel: int){.cdecl,
# opened with a specific port.
# If the channel is not bound and not -1, this function returns NULL.
# *
proc Net_UDP_GetPeerAddress*(sock: PUDPsocket, channel: int): PIPAddress{.cdecl,
proc UDP_GetPeerAddress*(sock: PUDPsocket, channel: int): PIPAddress{.cdecl,
importc: "SDLNet_UDP_GetPeerAddress", dynlib: NetLibName.}
#* Send a vector of packets to the the channels specified within the packet.
# If the channel specified in the packet is -1, the packet will be sent to
@@ -318,7 +315,7 @@ proc Net_UDP_GetPeerAddress*(sock: PUDPsocket, channel: int): PIPAddress{.cdecl,
# been sent, -1 if the packet send failed.
# This function returns the number of packets sent.
#*
proc Net_UDP_SendV*(sock: PUDPsocket, packets: PPUDPpacket, npackets: int): int{.
proc UDP_SendV*(sock: PUDPsocket, packets: PPUDPpacket, npackets: int): int{.
cdecl, importc: "SDLNet_UDP_SendV", dynlib: NetLibName.}
#* Send a single packet to the specified channel.
# If the channel specified in the packet is -1, the packet will be sent to
@@ -327,7 +324,7 @@ proc Net_UDP_SendV*(sock: PUDPsocket, packets: PPUDPpacket, npackets: int): int{
# been sent.
# This function returns 1 if the packet was sent, or 0 on error.
#*
proc Net_UDP_Send*(sock: PUDPsocket, channel: int, packet: PUDPpacket): int{.
proc UDP_Send*(sock: PUDPsocket, channel: int, packet: PUDPpacket): int{.
cdecl, importc: "SDLNet_UDP_Send", dynlib: NetLibName.}
#* Receive a vector of pending packets from the UDP socket.
# The returned packets contain the source address and the channel they arrived
@@ -339,7 +336,7 @@ proc Net_UDP_Send*(sock: PUDPsocket, channel: int, packet: PUDPpacket): int{.
# This function returns the number of packets read from the network, or -1
# on error. This function does not block, so can return 0 packets pending.
#*
proc Net_UDP_RecvV*(sock: PUDPsocket, packets: PPUDPpacket): int{.cdecl,
proc UDP_RecvV*(sock: PUDPsocket, packets: PPUDPpacket): int{.cdecl,
importc: "SDLNet_UDP_RecvV", dynlib: NetLibName.}
#* Receive a single packet from the UDP socket.
# The returned packet contains the source address and the channel it arrived
@@ -351,10 +348,10 @@ proc Net_UDP_RecvV*(sock: PUDPsocket, packets: PPUDPpacket): int{.cdecl,
# This function returns the number of packets read from the network, or -1
# on error. This function does not block, so can return 0 packets pending.
#*
proc Net_UDP_Recv*(sock: PUDPsocket, packet: PUDPpacket): int{.cdecl,
proc UDP_Recv*(sock: PUDPsocket, packet: PUDPpacket): int{.cdecl,
importc: "SDLNet_UDP_Recv", dynlib: NetLibName.}
#* Close a UDP network socket *
proc Net_UDP_Close*(sock: PUDPsocket){.cdecl, importc: "SDLNet_UDP_Close",
proc UDP_Close*(sock: PUDPsocket){.cdecl, importc: "SDLNet_UDP_Close",
dynlib: NetLibName.}
#***********************************************************************
#* Hooks for checking sockets for available data *
@@ -363,19 +360,19 @@ proc Net_UDP_Close*(sock: PUDPsocket){.cdecl, importc: "SDLNet_UDP_Close",
# This returns a socket set for up to 'maxsockets' sockets, or NULL if
# the function ran out of memory.
# *
proc Net_AllocSocketSet*(maxsockets: int): PNet_SocketSet{.cdecl,
proc AllocSocketSet*(maxsockets: int): PSocketSet{.cdecl,
importc: "SDLNet_AllocSocketSet", dynlib: NetLibName.}
#* Add a socket to a set of sockets to be checked for available data *
proc Net_AddSocket*(theSet: PNet_SocketSet, sock: PNet_GenericSocket): int{.
proc AddSocket*(theSet: PSocketSet, sock: PGenericSocket): int{.
cdecl, importc: "SDLNet_AddSocket", dynlib: NetLibName.}
proc Net_TCP_AddSocket*(theSet: PNet_SocketSet, sock: PTCPSocket): int
proc Net_UDP_AddSocket*(theSet: PNet_SocketSet, sock: PUDPSocket): int
proc TCP_AddSocket*(theSet: PSocketSet, sock: PTCPSocket): int
proc UDP_AddSocket*(theSet: PSocketSet, sock: PUDPSocket): int
#* Remove a socket from a set of sockets to be checked for available data *
proc Net_DelSocket*(theSet: PNet_SocketSet, sock: PNet_GenericSocket): int{.
proc DelSocket*(theSet: PSocketSet, sock: PGenericSocket): int{.
cdecl, importc: "SDLNet_DelSocket", dynlib: NetLibName.}
proc Net_TCP_DelSocket*(theSet: PNet_SocketSet, sock: PTCPSocket): int
proc TCP_DelSocket*(theSet: PSocketSet, sock: PTCPSocket): int
# SDLNet_DelSocket(set, (SDLNet_GenericSocket)sock)
proc Net_UDP_DelSocket*(theSet: PNet_SocketSet, sock: PUDPSocket): int
proc UDP_DelSocket*(theSet: PSocketSet, sock: PUDPSocket): int
#SDLNet_DelSocket(set, (SDLNet_GenericSocket)sock)
#* This function checks to see if data is available for reading on the
# given set of sockets. If 'timeout' is 0, it performs a quick poll,
@@ -384,59 +381,47 @@ proc Net_UDP_DelSocket*(theSet: PNet_SocketSet, sock: PUDPSocket): int
# first. This function returns the number of sockets ready for reading,
# or -1 if there was an error with the select() system call.
#*
proc Net_CheckSockets*(theSet: PNet_SocketSet, timeout: Sint32): int{.cdecl,
proc CheckSockets*(theSet: PSocketSet, timeout: Sint32): int{.cdecl,
importc: "SDLNet_CheckSockets", dynlib: NetLibName.}
#* After calling SDLNet_CheckSockets(), you can use this function on a
# socket that was in the socket set, to find out if data is available
# for reading.
#*
proc Net_SocketReady*(sock: PNet_GenericSocket): bool
proc SocketReady*(sock: PGenericSocket): bool
#* Free a set of sockets allocated by SDL_NetAllocSocketSet() *
proc Net_FreeSocketSet*(theSet: PNet_SocketSet){.cdecl,
proc FreeSocketSet*(theSet: PSocketSet){.cdecl,
importc: "SDLNet_FreeSocketSet", dynlib: NetLibName.}
#***********************************************************************
#* Platform-independent data conversion functions *
#***********************************************************************
#* Write a 16/32 bit value to network packet buffer *
proc Net_Write16*(value: Uint16, area: Pointer){.cdecl,
proc Write16*(value: Uint16, area: Pointer){.cdecl,
importc: "SDLNet_Write16", dynlib: NetLibName.}
proc Net_Write32*(value: Uint32, area: Pointer){.cdecl,
proc Write32*(value: Uint32, area: Pointer){.cdecl,
importc: "SDLNet_Write32", dynlib: NetLibName.}
#* Read a 16/32 bit value from network packet buffer *
proc Net_Read16*(area: Pointer): Uint16{.cdecl, importc: "SDLNet_Read16",
proc Read16*(area: Pointer): Uint16{.cdecl, importc: "SDLNet_Read16",
dynlib: NetLibName.}
proc Net_Read32*(area: Pointer): Uint32{.cdecl, importc: "SDLNet_Read32",
proc Read32*(area: Pointer): Uint32{.cdecl, importc: "SDLNet_Read32",
dynlib: NetLibName.}
#***********************************************************************
#* Error reporting functions *
#***********************************************************************
#* We'll use SDL's functions for error reporting *
proc Net_SetError*(fmt: cstring)
proc Net_GetError*(): cstring
# implementation
proc NET_VERSION(X: var Tversion) =
X.major = NET_MAJOR_VERSION
X.minor = NET_MINOR_VERSION
X.patch = NET_PATCHLEVEL
proc VERSION(X: var Tversion) =
X.major = MAJOR_VERSION
X.minor = MINOR_VERSION
X.patch = PATCHLEVEL
proc Net_TCP_AddSocket(theSet: PNet_SocketSet, sock: PTCPSocket): int =
result = Net_AddSocket(theSet, cast[PNet_GenericSocket](sock))
proc TCP_AddSocket(theSet: PSocketSet, sock: PTCPSocket): int =
result = AddSocket(theSet, cast[PGenericSocket](sock))
proc Net_UDP_AddSocket(theSet: PNet_SocketSet, sock: PUDPSocket): int =
result = Net_AddSocket(theSet, cast[PNet_GenericSocket](sock))
proc UDP_AddSocket(theSet: PSocketSet, sock: PUDPSocket): int =
result = AddSocket(theSet, cast[PGenericSocket](sock))
proc Net_TCP_DelSocket(theSet: PNet_SocketSet, sock: PTCPSocket): int =
result = Net_DelSocket(theSet, cast[PNet_GenericSocket](sock))
proc TCP_DelSocket(theSet: PSocketSet, sock: PTCPSocket): int =
result = DelSocket(theSet, cast[PGenericSocket](sock))
proc Net_UDP_DelSocket(theSet: PNet_SocketSet, sock: PUDPSocket): int =
result = Net_DelSocket(theSet, cast[PNet_GenericSocket](sock))
proc UDP_DelSocket(theSet: PSocketSet, sock: PUDPSocket): int =
result = DelSocket(theSet, cast[PGenericSocket](sock))
proc Net_SocketReady(sock: PNet_GenericSocket): bool =
proc SocketReady(sock: PGenericSocket): bool =
result = ((sock != nil) and (sock.ready == 1))
proc Net_SetError(fmt: cstring) =
SetError(fmt)
proc Net_GetError(): cstring =
result = GetError()

128
lib/newwrap/sdl/sdl_ttf.nim
View File

@@ -153,7 +153,7 @@
#
import
sdl
when defined(windows):
const
@@ -165,97 +165,88 @@ else:
const
ttfLibName = "libSDL_ttf.so"
const
TTF_MAJOR_VERSION* = 2'i8
TTF_MINOR_VERSION* = 0'i8
TTF_PATCHLEVEL* = 8'i8 # Backwards compatibility
TTF_MAJOR_VERSION* = TTF_MAJOR_VERSION
TTF_MINOR_VERSION* = TTF_MINOR_VERSION
TTF_PATCHLEVEL* = TTF_PATCHLEVEL #*
# Set and retrieve the font style
# This font style is implemented by modifying the font glyphs, and
# doesn't reflect any inherent properties of the truetype font file.
#*
TTF_STYLE_NORMAL* = 0x00000000
TTF_STYLE_BOLD* = 0x00000001
TTF_STYLE_ITALIC* = 0x00000002
TTF_STYLE_UNDERLINE* = 0x00000004 # ZERO WIDTH NO-BREAKSPACE (Unicode byte order mark)
MAJOR_VERSION* = 2'i8
MINOR_VERSION* = 0'i8
PATCHLEVEL* = 8'i8 # Backwards compatibility
STYLE_NORMAL* = 0x00000000
STYLE_BOLD* = 0x00000001
STYLE_ITALIC* = 0x00000002
STYLE_UNDERLINE* = 0x00000004 # ZERO WIDTH NO-BREAKSPACE (Unicode byte order mark)
UNICODE_BOM_NATIVE* = 0x0000FEFF
UNICODE_BOM_SWAPPED* = 0x0000FFFE
type
PTTF_Font* = ptr TTTF_font
TTTF_Font*{.final.} = object # This macro can be used to fill a version structure with the compile-time
PFont* = ptr Tfont
TFont*{.final.} = object # This macro can be used to fill a version structure with the compile-time
# version of the SDL_ttf library.
proc TTF_VERSION*(X: var Tversion)
# This function gets the version of the dynamically linked SDL_ttf library.
# It should NOT be used to fill a version structure, instead you should use the
# SDL_TTF_VERSION() macro.
proc TTF_Linked_Version*(): Pversion{.cdecl, importc: "TTF_Linked_Version",
proc Linked_Version*(): sdl.Pversion{.cdecl, importc: "TTF_Linked_Version",
dynlib: ttfLibName.}
# This function tells the library whether UNICODE text is generally
# byteswapped. A UNICODE BOM character in a string will override
# this setting for the remainder of that string.
#
proc TTF_ByteSwappedUNICODE*(swapped: int){.cdecl,
proc ByteSwappedUNICODE*(swapped: int){.cdecl,
importc: "TTF_ByteSwappedUNICODE", dynlib: ttfLibName.}
#returns 0 on succes, -1 if error occurs
proc TTF_Init*(): int{.cdecl, importc: "TTF_Init", dynlib: ttfLibName.}
proc Init*(): int{.cdecl, importc: "TTF_Init", dynlib: ttfLibName.}
#
# Open a font file and create a font of the specified point size.
# Some .fon fonts will have several sizes embedded in the file, so the
# point size becomes the index of choosing which size. If the value
# is too high, the last indexed size will be the default.
#
proc TTF_OpenFont*(filename: cstring, ptsize: int): PTTF_Font{.cdecl,
proc OpenFont*(filename: cstring, ptsize: int): PFont{.cdecl,
importc: "TTF_OpenFont", dynlib: ttfLibName.}
proc TTF_OpenFontIndex*(filename: cstring, ptsize: int, index: int32): PTTF_Font{.
proc OpenFontIndex*(filename: cstring, ptsize: int, index: int32): PFont{.
cdecl, importc: "TTF_OpenFontIndex", dynlib: ttfLibName.}
proc TTF_OpenFontRW*(src: PRWops, freesrc: int, ptsize: int): PTTF_Font{.cdecl,
proc OpenFontRW*(src: PRWops, freesrc: int, ptsize: int): PFont{.cdecl,
importc: "TTF_OpenFontRW", dynlib: ttfLibName.}
proc TTF_OpenFontIndexRW*(src: PRWops, freesrc: int, ptsize: int, index: int32): PTTF_Font{.
proc OpenFontIndexRW*(src: PRWops, freesrc: int, ptsize: int, index: int32): PFont{.
cdecl, importc: "TTF_OpenFontIndexRW", dynlib: ttfLibName.}
proc TTF_GetFontStyle*(font: PTTF_Font): int{.cdecl,
proc GetFontStyle*(font: PFont): int{.cdecl,
importc: "TTF_GetFontStyle", dynlib: ttfLibName.}
proc TTF_SetFontStyle*(font: PTTF_Font, style: int){.cdecl,
proc SetFontStyle*(font: PFont, style: int){.cdecl,
importc: "TTF_SetFontStyle", dynlib: ttfLibName.}
# Get the total height of the font - usually equal to point size
proc TTF_FontHeight*(font: PTTF_Font): int{.cdecl, importc: "TTF_FontHeight",
proc FontHeight*(font: PFont): int{.cdecl, importc: "TTF_FontHeight",
dynlib: ttfLibName.}
# Get the offset from the baseline to the top of the font
# This is a positive value, relative to the baseline.
#
proc TTF_FontAscent*(font: PTTF_Font): int{.cdecl, importc: "TTF_FontAscent",
proc FontAscent*(font: PFont): int{.cdecl, importc: "TTF_FontAscent",
dynlib: ttfLibName.}
# Get the offset from the baseline to the bottom of the font
# This is a negative value, relative to the baseline.
#
proc TTF_FontDescent*(font: PTTF_Font): int{.cdecl, importc: "TTF_FontDescent",
proc FontDescent*(font: PFont): int{.cdecl, importc: "TTF_FontDescent",
dynlib: ttfLibName.}
# Get the recommended spacing between lines of text for this font
proc TTF_FontLineSkip*(font: PTTF_Font): int{.cdecl,
proc FontLineSkip*(font: PFont): int{.cdecl,
importc: "TTF_FontLineSkip", dynlib: ttfLibName.}
# Get the number of faces of the font
proc TTF_FontFaces*(font: PTTF_Font): int32{.cdecl, importc: "TTF_FontFaces",
proc FontFaces*(font: PFont): int32{.cdecl, importc: "TTF_FontFaces",
dynlib: ttfLibName.}
# Get the font face attributes, if any
proc TTF_FontFaceIsFixedWidth*(font: PTTF_Font): int{.cdecl,
proc FontFaceIsFixedWidth*(font: PFont): int{.cdecl,
importc: "TTF_FontFaceIsFixedWidth", dynlib: ttfLibName.}
proc TTF_FontFaceFamilyName*(font: PTTF_Font): cstring{.cdecl,
proc FontFaceFamilyName*(font: PFont): cstring{.cdecl,
importc: "TTF_FontFaceFamilyName", dynlib: ttfLibName.}
proc TTF_FontFaceStyleName*(font: PTTF_Font): cstring{.cdecl,
proc FontFaceStyleName*(font: PFont): cstring{.cdecl,
importc: "TTF_FontFaceStyleName", dynlib: ttfLibName.}
# Get the metrics (dimensions) of a glyph
proc TTF_GlyphMetrics*(font: PTTF_Font, ch: Uint16, minx: var int,
proc GlyphMetrics*(font: PFont, ch: Uint16, minx: var int,
maxx: var int, miny: var int, maxy: var int,
advance: var int): int{.cdecl,
importc: "TTF_GlyphMetrics", dynlib: ttfLibName.}
# Get the dimensions of a rendered string of text
proc TTF_SizeText*(font: PTTF_Font, text: cstring, w: var int, y: var int): int{.
proc SizeText*(font: PFont, text: cstring, w: var int, y: var int): int{.
cdecl, importc: "TTF_SizeText", dynlib: ttfLibName.}
proc TTF_SizeUTF8*(font: PTTF_Font, text: cstring, w: var int, y: var int): int{.
proc SizeUTF8*(font: PFont, text: cstring, w: var int, y: var int): int{.
cdecl, importc: "TTF_SizeUTF8", dynlib: ttfLibName.}
proc TTF_SizeUNICODE*(font: PTTF_Font, text: PUint16, w: var int, y: var int): int{.
proc SizeUNICODE*(font: PFont, text: PUint16, w: var int, y: var int): int{.
cdecl, importc: "TTF_SizeUNICODE", dynlib: ttfLibName.}
# Create an 8-bit palettized surface and render the given text at
# fast quality with the given font and color. The 0 pixel is the
@@ -263,9 +254,9 @@ proc TTF_SizeUNICODE*(font: PTTF_Font, text: PUint16, w: var int, y: var int): i
# to the text color.
# This function returns the new surface, or NULL if there was an error.
#
proc TTF_RenderUTF8_Solid*(font: PTTF_Font, text: cstring, fg: TColor): PSurface{.
proc RenderUTF8_Solid*(font: PFont, text: cstring, fg: TColor): PSurface{.
cdecl, importc: "TTF_RenderUTF8_Solid", dynlib: ttfLibName.}
proc TTF_RenderUNICODE_Solid*(font: PTTF_Font, text: PUint16, fg: TColor): PSurface{.
proc RenderUNICODE_Solid*(font: PFont, text: PUint16, fg: TColor): PSurface{.
cdecl, importc: "TTF_RenderUNICODE_Solid", dynlib: ttfLibName.}
#
#Create an 8-bit palettized surface and render the given glyph at
@@ -275,20 +266,20 @@ proc TTF_RenderUNICODE_Solid*(font: PTTF_Font, text: PUint16, fg: TColor): PSurf
# centering in the X direction, and aligned normally in the Y direction.
# This function returns the new surface, or NULL if there was an error.
#
proc TTF_RenderGlyph_Solid*(font: PTTF_Font, ch: Uint16, fg: TColor): PSurface{.
proc RenderGlyph_Solid*(font: PFont, ch: Uint16, fg: TColor): PSurface{.
cdecl, importc: "TTF_RenderGlyph_Solid", dynlib: ttfLibName.}
# Create an 8-bit palettized surface and render the given text at
# high quality with the given font and colors. The 0 pixel is background,
# while other pixels have varying degrees of the foreground color.
# This function returns the new surface, or NULL if there was an error.
#
proc TTF_RenderText_Shaded*(font: PTTF_Font, text: cstring, fg: TColor,
proc RenderText_Shaded*(font: PFont, text: cstring, fg: TColor,
bg: TColor): PSurface{.cdecl,
importc: "TTF_RenderText_Shaded", dynlib: ttfLibName.}
proc TTF_RenderUTF8_Shaded*(font: PTTF_Font, text: cstring, fg: TColor,
proc RenderUTF8_Shaded*(font: PFont, text: cstring, fg: TColor,
bg: TColor): PSurface{.cdecl,
importc: "TTF_RenderUTF8_Shaded", dynlib: ttfLibName.}
proc TTF_RenderUNICODE_Shaded*(font: PTTF_Font, text: PUint16, fg: TColor,
proc RenderUNICODE_Shaded*(font: PFont, text: PUint16, fg: TColor,
bg: TColor): PSurface{.cdecl,
importc: "TTF_RenderUNICODE_Shaded", dynlib: ttfLibName.}
# Create an 8-bit palettized surface and render the given glyph at
@@ -298,17 +289,17 @@ proc TTF_RenderUNICODE_Shaded*(font: PTTF_Font, text: PUint16, fg: TColor,
# direction, and aligned normally in the Y direction.
# This function returns the new surface, or NULL if there was an error.
#
proc TTF_RenderGlyph_Shaded*(font: PTTF_Font, ch: Uint16, fg: TColor, bg: TColor): PSurface{.
proc RenderGlyph_Shaded*(font: PFont, ch: Uint16, fg: TColor, bg: TColor): PSurface{.
cdecl, importc: "TTF_RenderGlyph_Shaded", dynlib: ttfLibName.}
# Create a 32-bit ARGB surface and render the given text at high quality,
# using alpha blending to dither the font with the given color.
# This function returns the new surface, or NULL if there was an error.
#
proc TTF_RenderText_Blended*(font: PTTF_Font, text: cstring, fg: TColor): PSurface{.
proc RenderText_Blended*(font: PFont, text: cstring, fg: TColor): PSurface{.
cdecl, importc: "TTF_RenderText_Blended", dynlib: ttfLibName.}
proc TTF_RenderUTF8_Blended*(font: PTTF_Font, text: cstring, fg: TColor): PSurface{.
proc RenderUTF8_Blended*(font: PFont, text: cstring, fg: TColor): PSurface{.
cdecl, importc: "TTF_RenderUTF8_Blended", dynlib: ttfLibName.}
proc TTF_RenderUNICODE_Blended*(font: PTTF_Font, text: PUint16, fg: TColor): PSurface{.
proc RenderUNICODE_Blended*(font: PFont, text: PUint16, fg: TColor): PSurface{.
cdecl, importc: "TTF_RenderUNICODE_Blended", dynlib: ttfLibName.}
# Create a 32-bit ARGB surface and render the given glyph at high quality,
# using alpha blending to dither the font with the given color.
@@ -316,7 +307,7 @@ proc TTF_RenderUNICODE_Blended*(font: PTTF_Font, text: PUint16, fg: TColor): PSu
# direction, and aligned normally in the Y direction.
# This function returns the new surface, or NULL if there was an error.
#
proc TTF_RenderGlyph_Blended*(font: PTTF_Font, ch: Uint16, fg: TColor): PSurface{.
proc RenderGlyph_Blended*(font: PFont, ch: Uint16, fg: TColor): PSurface{.
cdecl, importc: "TTF_RenderGlyph_Blended", dynlib: ttfLibName.}
# For compatibility with previous versions, here are the old functions
##define TTF_RenderText(font, text, fg, bg)
@@ -326,32 +317,25 @@ proc TTF_RenderGlyph_Blended*(font: PTTF_Font, ch: Uint16, fg: TColor): PSurface
##define TTF_RenderUNICODE(font, text, fg, bg)
# TTF_RenderUNICODE_Shaded(font, text, fg, bg)
# Close an opened font file
proc TTF_CloseFont*(font: PTTF_Font){.cdecl, importc: "TTF_CloseFont",
proc CloseFont*(font: PFont){.cdecl, importc: "TTF_CloseFont",
dynlib: ttfLibName.}
#De-initialize TTF engine
proc TTF_Quit*(){.cdecl, importc: "TTF_Quit", dynlib: ttfLibName.}
proc Quit*(){.cdecl, importc: "TTF_Quit", dynlib: ttfLibName.}
# Check if the TTF engine is initialized
proc TTF_WasInit*(): int{.cdecl, importc: "TTF_WasInit", dynlib: ttfLibName.}
# We'll use SDL for reporting errors
proc TTF_SetError*(fmt: cstring)
proc TTF_GetError*(): cstring
# implementation
proc WasInit*(): int{.cdecl, importc: "TTF_WasInit", dynlib: ttfLibName.}
proc TTF_VERSION(X: var Tversion) =
X.major = TTF_MAJOR_VERSION
X.minor = TTF_MINOR_VERSION
X.patch = TTF_PATCHLEVEL
proc TTF_SetError(fmt: cstring) =
SetError(fmt)
proc VERSION*(X: var sdl.Tversion) =
X.major = MAJOR_VERSION
X.minor = MINOR_VERSION
X.patch = PATCHLEVEL
proc TTF_GetError(): cstring =
result = GetError()
when not (defined(Workaround_TTF_RenderText_Solid)):
proc TTF_RenderText_Solid*(font: PTTF_Font, text: cstring, fg: TColor): PSurface{.
when not (defined(Workaround_RenderText_Solid)):
proc RenderText_Solid*(font: PFont, text: cstring, fg: TColor): PSurface{.
cdecl, importc: "TTF_RenderText_Solid", dynlib: ttfLibName.}
else:
proc TTF_RenderText_Solid(font: PTTF_Font, text: cstring, fg: TColor): PSurface =
proc RenderText_Solid(font: PFont, text: cstring, fg: TColor): PSurface =
var Black: TColor # initialized to zero
Result = TTF_RenderText_Shaded(font, text, fg, Black)
result = RenderText_Shaded(font, text, fg, Black)

148
lib/newwrap/sdl/smpeg.nim
View File

@@ -126,7 +126,7 @@
#******************************************************************************
import
sdl
when defined(windows):
const
@@ -138,57 +138,53 @@ else:
const
SmpegLibName = "libsmpeg.so"
const
SMPEG_FILTER_INFO_MB_ERROR* = 1
SMPEG_FILTER_INFO_PIXEL_ERROR* = 2 # Filter info from SMPEG
FILTER_INFO_MB_ERROR* = 1
FILTER_INFO_PIXEL_ERROR* = 2 # Filter info from SMPEG
type
SMPEG_FilterInfo*{.final.} = object
TFilterInfo*{.final.} = object
yuv_mb_square_error*: PUint16
yuv_pixel_square_error*: PUint16
TSMPEG_FilterInfo* = SMPEG_FilterInfo
PSMPEG_FilterInfo* = ptr SMPEG_FilterInfo # MPEG filter definition
PSMPEG_Filter* = ptr TSMPEG_Filter # Callback functions for the filter
TSMPEG_FilterCallback* = proc (dest, source: POverlay, region: PRect,
filter_info: PSMPEG_FilterInfo, data: Pointer): Pointer{.
PFilterInfo* = ptr TFilterInfo # MPEG filter definition
PFilter* = ptr TFilter # Callback functions for the filter
TFilterCallback* = proc (dest, source: POverlay, region: PRect,
filter_info: PFilterInfo, data: Pointer): Pointer{.
cdecl.}
TSMPEG_FilterDestroy* = proc (Filter: PSMPEG_Filter): Pointer{.cdecl.} # The filter
#
# definition itself
TSMPEG_Filter*{.final.} = object # The null filter (default). It simply copies the source rectangle to the video overlay.
TFilterDestroy* = proc (Filter: PFilter): Pointer{.cdecl.} # The filter definition itself
TFilter*{.final.} = object # The null filter (default). It simply copies the source rectangle to the video overlay.
flags*: Uint32
data*: Pointer
callback*: TSMPEG_FilterCallback
destroy*: TSMPEG_FilterDestroy
callback*: TFilterCallback
destroy*: TFilterDestroy
proc SMPEGfilter_null*(): PSMPEG_Filter{.cdecl, importc: "SMPEGfilter_null",
proc filter_null*(): PFilter{.cdecl, importc: "SMPEGfilter_null",
dynlib: SmpegLibName.}
# The bilinear filter. A basic low-pass filter that will produce a smoother image.
proc SMPEGfilter_bilinear*(): PSMPEG_Filter{.cdecl,
proc filter_bilinear*(): PFilter{.cdecl,
importc: "SMPEGfilter_bilinear", dynlib: SmpegLibName.}
# The deblocking filter. It filters block borders and non-intra coded blocks to reduce blockiness
proc SMPEGfilter_deblocking*(): PSMPEG_Filter{.cdecl,
proc filter_deblocking*(): PFilter{.cdecl,
importc: "SMPEGfilter_deblocking", dynlib: SmpegLibName.}
#------------------------------------------------------------------------------
# SMPEG.h
#------------------------------------------------------------------------------
const
SMPEG_MAJOR_VERSION* = 0'i8
SMPEG_MINOR_VERSION* = 4'i8
SMPEG_PATCHLEVEL* = 2'i8
MAJOR_VERSION* = 0'i8
MINOR_VERSION* = 4'i8
PATCHLEVEL* = 2'i8
type
SMPEG_version*{.final.} = object
TVersion*{.final.} = object
major*: UInt8
minor*: UInt8
patch*: UInt8
TSMPEG_version* = SMPEG_version
PSMPEG_version* = ptr TSMPEG_version # This is the actual SMPEG object
Pversion* = ptr Tversion # This is the actual SMPEG object
TSMPEG*{.final.} = object
PSMPEG* = ptr TSMPEG # Used to get information about the SMPEG object
TSMPEG_Info*{.final.} = object
TInfo*{.final.} = object
has_audio*: int
has_video*: int
width*: int
@@ -202,138 +198,138 @@ type
current_time*: float64
total_time*: float64
PSMPEG_Info* = ptr TSMPEG_Info # Possible MPEG status codes
PInfo* = ptr TInfo # Possible MPEG status codes
const
STATUS_SMPEG_ERROR* = - 1
STATUS_SMPEG_STOPPED* = 0
STATUS_SMPEG_PLAYING* = 1
STATUS_ERROR* = - 1
STATUS_STOPPED* = 0
STATUS_PLAYING* = 1
type
TSMPEGstatus* = int
PSMPEGstatus* = ptr int # Matches the declaration of SDL_UpdateRect()
TSMPEG_DisplayCallback* = proc (dst: PSurface, x, y: int, w, h: int): Pointer{.
Tstatus* = int
Pstatus* = ptr int # Matches the declaration of SDL_UpdateRect()
TDisplayCallback* = proc (dst: PSurface, x, y: int, w, h: int): Pointer{.
cdecl.} # Create a new SMPEG object from an MPEG file.
# On return, if 'info' is not NULL, it will be filled with information
# about the MPEG object.
# This function returns a new SMPEG object. Use SMPEG_error() to find out
# This function returns a new SMPEG object. Use error() to find out
# whether or not there was a problem building the MPEG stream.
# The sdl_audio parameter indicates if SMPEG should initialize the SDL audio
# subsystem. If not, you will have to use the SMPEG_playaudio() function below
# subsystem. If not, you will have to use the playaudio() function below
# to extract the decoded data.
proc SMPEG_new*(theFile: cstring, info: PSMPEG_Info, audio: int): PSMPEG{.cdecl,
proc SMPEG_new*(theFile: cstring, info: PInfo, audio: int): PSMPEG{.cdecl,
importc: "SMPEG_new", dynlib: SmpegLibName.}
# The same as above for a file descriptor
proc SMPEG_new_descr*(theFile: int, info: PSMPEG_Info, audio: int): PSMPEG{.
proc new_descr*(theFile: int, info: PInfo, audio: int): PSMPEG{.
cdecl, importc: "SMPEG_new_descr", dynlib: SmpegLibName.}
# The same as above but for a raw chunk of data. SMPEG makes a copy of the
# data, so the application is free to delete after a successful call to this
# function.
proc SMPEG_new_data*(data: Pointer, size: int, info: PSMPEG_Info, audio: int): PSMPEG{.
proc new_data*(data: Pointer, size: int, info: PInfo, audio: int): PSMPEG{.
cdecl, importc: "SMPEG_new_data", dynlib: SmpegLibName.}
# Get current information about an SMPEG object
proc SMPEG_getinfo*(mpeg: PSMPEG, info: PSMPEG_Info){.cdecl,
proc getinfo*(mpeg: PSMPEG, info: PInfo){.cdecl,
importc: "SMPEG_getinfo", dynlib: SmpegLibName.}
#procedure SMPEG_getinfo(mpeg: PSMPEG; info: Pointer);
#procedure getinfo(mpeg: PSMPEG; info: Pointer);
#cdecl; external SmpegLibName;
# Enable or disable audio playback in MPEG stream
proc SMPEG_enableaudio*(mpeg: PSMPEG, enable: int){.cdecl,
proc enableaudio*(mpeg: PSMPEG, enable: int){.cdecl,
importc: "SMPEG_enableaudio", dynlib: SmpegLibName.}
# Enable or disable video playback in MPEG stream
proc SMPEG_enablevideo*(mpeg: PSMPEG, enable: int){.cdecl,
proc enablevideo*(mpeg: PSMPEG, enable: int){.cdecl,
importc: "SMPEG_enablevideo", dynlib: SmpegLibName.}
# Delete an SMPEG object
proc SMPEG_delete*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_delete",
proc delete*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_delete",
dynlib: SmpegLibName.}
# Get the current status of an SMPEG object
proc SMPEG_status*(mpeg: PSMPEG): TSMPEGstatus{.cdecl, importc: "SMPEG_status",
proc status*(mpeg: PSMPEG): Tstatus{.cdecl, importc: "SMPEG_status",
dynlib: SmpegLibName.}
# status
# Set the audio volume of an MPEG stream, in the range 0-100
proc SMPEG_setvolume*(mpeg: PSMPEG, volume: int){.cdecl,
proc setvolume*(mpeg: PSMPEG, volume: int){.cdecl,
importc: "SMPEG_setvolume", dynlib: SmpegLibName.}
# Set the destination surface for MPEG video playback
# 'surfLock' is a mutex used to synchronize access to 'dst', and can be NULL.
# 'callback' is a function called when an area of 'dst' needs to be updated.
# If 'callback' is NULL, the default function (SDL_UpdateRect) will be used.
proc SMPEG_setdisplay*(mpeg: PSMPEG, dst: PSurface, surfLock: Pmutex,
callback: TSMPEG_DisplayCallback){.cdecl,
proc setdisplay*(mpeg: PSMPEG, dst: PSurface, surfLock: Pmutex,
callback: TDisplayCallback){.cdecl,
importc: "SMPEG_setdisplay", dynlib: SmpegLibName.}
# Set or clear looping play on an SMPEG object
proc SMPEG_loop*(mpeg: PSMPEG, repeat_: int){.cdecl, importc: "SMPEG_loop",
proc loop*(mpeg: PSMPEG, repeat_: int){.cdecl, importc: "SMPEG_loop",
dynlib: SmpegLibName.}
# Scale pixel display on an SMPEG object
proc SMPEG_scaleXY*(mpeg: PSMPEG, width, height: int){.cdecl,
proc scaleXY*(mpeg: PSMPEG, width, height: int){.cdecl,
importc: "SMPEG_scaleXY", dynlib: SmpegLibName.}
proc SMPEG_scale*(mpeg: PSMPEG, scale: int){.cdecl, importc: "SMPEG_scale",
proc scale*(mpeg: PSMPEG, scale: int){.cdecl, importc: "SMPEG_scale",
dynlib: SmpegLibName.}
proc SMPEG_Double*(mpeg: PSMPEG, doubleit: bool)
proc Double*(mpeg: PSMPEG, doubleit: bool)
# Move the video display area within the destination surface
proc SMPEG_move*(mpeg: PSMPEG, x, y: int){.cdecl, importc: "SMPEG_move",
proc move*(mpeg: PSMPEG, x, y: int){.cdecl, importc: "SMPEG_move",
dynlib: SmpegLibName.}
# Set the region of the video to be shown
proc SMPEG_setdisplayregion*(mpeg: PSMPEG, x, y, w, h: int){.cdecl,
proc setdisplayregion*(mpeg: PSMPEG, x, y, w, h: int){.cdecl,
importc: "SMPEG_setdisplayregion", dynlib: SmpegLibName.}
# Play an SMPEG object
proc SMPEG_play*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_play",
proc play*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_play",
dynlib: SmpegLibName.}
# Pause/Resume playback of an SMPEG object
proc SMPEG_pause*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_pause",
proc pause*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_pause",
dynlib: SmpegLibName.}
# Stop playback of an SMPEG object
proc SMPEG_stop*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_stop",
proc stop*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_stop",
dynlib: SmpegLibName.}
# Rewind the play position of an SMPEG object to the beginning of the MPEG
proc SMPEG_rewind*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_rewind",
proc rewind*(mpeg: PSMPEG){.cdecl, importc: "SMPEG_rewind",
dynlib: SmpegLibName.}
# Seek 'bytes' bytes in the MPEG stream
proc SMPEG_seek*(mpeg: PSMPEG, bytes: int){.cdecl, importc: "SMPEG_seek",
proc seek*(mpeg: PSMPEG, bytes: int){.cdecl, importc: "SMPEG_seek",
dynlib: SmpegLibName.}
# Skip 'seconds' seconds in the MPEG stream
proc SMPEG_skip*(mpeg: PSMPEG, seconds: float32){.cdecl, importc: "SMPEG_skip",
proc skip*(mpeg: PSMPEG, seconds: float32){.cdecl, importc: "SMPEG_skip",
dynlib: SmpegLibName.}
# Render a particular frame in the MPEG video
# API CHANGE: This function no longer takes a target surface and position.
# Use SMPEG_setdisplay() and SMPEG_move() to set this information.
proc SMPEG_renderFrame*(mpeg: PSMPEG, framenum: int){.cdecl,
# Use setdisplay() and move() to set this information.
proc renderFrame*(mpeg: PSMPEG, framenum: int){.cdecl,
importc: "SMPEG_renderFrame", dynlib: SmpegLibName.}
# Render the last frame of an MPEG video
proc SMPEG_renderFinal*(mpeg: PSMPEG, dst: PSurface, x, y: int){.cdecl,
proc renderFinal*(mpeg: PSMPEG, dst: PSurface, x, y: int){.cdecl,
importc: "SMPEG_renderFinal", dynlib: SmpegLibName.}
# Set video filter
proc SMPEG_filter*(mpeg: PSMPEG, filter: PSMPEG_Filter): PSMPEG_Filter{.cdecl,
proc filter*(mpeg: PSMPEG, filter: PFilter): PFilter{.cdecl,
importc: "SMPEG_filter", dynlib: SmpegLibName.}
# Return NULL if there is no error in the MPEG stream, or an error message
# if there was a fatal error in the MPEG stream for the SMPEG object.
proc SMPEG_error*(mpeg: PSMPEG): cstring{.cdecl, importc: "SMPEG_error",
proc error*(mpeg: PSMPEG): cstring{.cdecl, importc: "SMPEG_error",
dynlib: SmpegLibName.}
# Exported callback function for audio playback.
# The function takes a buffer and the amount of data to fill, and returns
# the amount of data in bytes that was actually written. This will be the
# amount requested unless the MPEG audio has finished.
#
proc SMPEG_playAudio*(mpeg: PSMPEG, stream: PUInt8, length: int): int{.cdecl,
proc playAudio*(mpeg: PSMPEG, stream: PUInt8, length: int): int{.cdecl,
importc: "SMPEG_playAudio", dynlib: SmpegLibName.}
# Wrapper for SMPEG_playAudio() that can be passed to SDL and SDL_mixer
proc SMPEG_playAudioSDL*(mpeg: Pointer, stream: PUInt8, length: int){.cdecl,
# Wrapper for playAudio() that can be passed to SDL and SDL_mixer
proc playAudioSDL*(mpeg: Pointer, stream: PUInt8, length: int){.cdecl,
importc: "SMPEG_playAudioSDL", dynlib: SmpegLibName.}
# Get the best SDL audio spec for the audio stream
proc SMPEG_wantedSpec*(mpeg: PSMPEG, wanted: PAudioSpec): int{.cdecl,
proc wantedSpec*(mpeg: PSMPEG, wanted: PAudioSpec): int{.cdecl,
importc: "SMPEG_wantedSpec", dynlib: SmpegLibName.}
# Inform SMPEG of the actual SDL audio spec used for sound playback
proc SMPEG_actualSpec*(mpeg: PSMPEG, spec: PAudioSpec){.cdecl,
proc actualSpec*(mpeg: PSMPEG, spec: PAudioSpec){.cdecl,
importc: "SMPEG_actualSpec", dynlib: SmpegLibName.}
# This macro can be used to fill a version structure with the compile-time
# version of the SDL library.
proc SMPEG_GETVERSION*(X: var TSMPEG_version)
proc GETVERSION*(X: var Tversion)
# implementation
proc SMPEG_double(mpeg: PSMPEG, doubleit: bool) =
if doubleit: SMPEG_scale(mpeg, 2)
else: SMPEG_scale(mpeg, 1)
proc double(mpeg: PSMPEG, doubleit: bool) =
if doubleit: scale(mpeg, 2)
else: scale(mpeg, 1)
proc SMPEG_GETVERSION(X: var TSMPEG_version) =
X.major = SMPEG_MAJOR_VERSION
X.minor = SMPEG_MINOR_VERSION
X.patch = SMPEG_PATCHLEVEL
proc GETVERSION(X: var Tversion) =
X.major = MAJOR_VERSION
X.minor = MINOR_VERSION
X.patch = PATCHLEVEL

2
rod/expandimportc.nim
View File

@@ -1,7 +1,7 @@
#
#
# The Nimrod Compiler
# (c) Copyright 2009 Andreas Rumpf
# (c) Copyright 2010 Andreas Rumpf
#
# See the file "copying.txt", included in this
# distribution, for details about the copyright.