Wrapping more and more functionality from A to Z.

README.md

@@ -1,5 +1,5 @@
 algo
 ====
 
-Go language binding to Allegro 5 (experimental, and has problems,
-full-screen windows do not work...)
+Go language binding to Allegro 5.1.5 (under construction).
+

src/algo/al/acodec.go

@@ -0,0 +1,23 @@
+// acodec
+package al
+
+/*
+#cgo pkg-config: allegro_acodec-5
+#cgo CFLAGS: -I/usr/local/include
+#cgo linux LDFLAGS: -lc_nonshared
+#include <stdlib.h>
+#include <allegro5/allegro.h>
+#include <allegro5/allegro_acodec.h>
+#include "helpers.h"
+*/
+import "C"
+
+// Initializes the audio codec addon of Allegro
+func InitAcodecAddon() bool {
+	return cb2b(C.al_init_acodec_addon())
+}
+
+// Gets the version of the allegro5 audio codec addon 
+func AcodecVersion() uint32 {
+	return uint32(C.al_get_allegro_acodec_version())
+}

src/algo/al/al.go

@@ -1,7 +1,7 @@
 package al
 
 /*
-#cgo pkg-config: allegro-5.0
+#cgo pkg-config: allegro-5
 #cgo CFLAGS: -I/usr/local/include
 #cgo linux LDFLAGS: -lc_nonshared
 #include <stdlib.h>
@@ -11,7 +11,7 @@ package al
 */
 import "C"
 
-// import "unsafe"
+import "unsafe"
 import "runtime"
 
 const PI = 3.14159265358979323846
@@ -31,6 +31,22 @@ const DATE = 20120624 /* yyyymmdd */
 const VERSION_INT = ((VERSION << 24) | (SUB_VERSION << 16) |
 	(WIP_VERSION << 8) | RELEASE_NUMBER)
 
+// Converts bool to Allegro's C.bool
+func b2cb(res bool) C.bool {
+	if res {
+		return C.bool(true)
+	}
+	return C.bool(false)
+}
+
+// Converts C.bool to Allegro's C.bool
+func cb2b(res C.bool) bool {
+	if res {
+		return true
+	}
+	return false
+}
+
 // Checks if the basic Allegro system is installed or not.
 func IsSystemInstalled() bool {
 	return bool(C.al_is_system_installed())
@@ -44,12 +60,12 @@ func GetAllegroVersion() uint32 {
 // Initializes the Allegro system.
 func Initialize() bool {
 	return bool(C.al_install_system(VERSION_INT, nil))
-//	return bool(C.algo_initialize())
+	//	return bool(C.algo_initialize())
 }
 
 // Cleans up the Allegro system. Needed after calling Initialize.
 func Cleanup() {
-	C.algo_atexit_cleanup()
+	C.al_uninstall_system()
 }
 
 // Installs the Allegro system. 
@@ -341,19 +357,71 @@ func (self *Event) toC() *C.ALLEGRO_EVENT {
 	return (*C.ALLEGRO_EVENT)(self)
 }
 
+// Returns an unsafe pointer to the event 
+func (self *Event) toPointer() unsafe.Pointer {
+	return unsafe.Pointer(self.toC())
+}
+
+// Converts wrapper Event pointer to C Allegro any event
+func (self *Event) ANY_EVENT() *C.ALLEGRO_ANY_EVENT {
+	return (*C.ALLEGRO_ANY_EVENT)(self.toPointer())
+}
+
+// Converts wrapper Event pointer to C Allegro display event
+func (self *Event) DISPLAY_EVENT() *C.ALLEGRO_DISPLAY_EVENT {
+	return (*C.ALLEGRO_DISPLAY_EVENT)(self.toPointer())
+}
+
+// Converts wrapper Event pointer to C Allegro joystick event
+func (self *Event) JOYSTICK_EVENT() *C.ALLEGRO_JOYSTICK_EVENT {
+	return (*C.ALLEGRO_JOYSTICK_EVENT)(self.toPointer())
+}
+
+// Converts wrapper Event pointer to C Allegro event
+func (self *Event) KEYBOARD_EVENT() *C.ALLEGRO_KEYBOARD_EVENT {
+	return (*C.ALLEGRO_KEYBOARD_EVENT)(self.toPointer())
+}
+
+// Converts wrapper Event pointer to C Allegro touch event
+func (self *Event) TOUCH_EVENT() *C.ALLEGRO_TOUCH_EVENT {
+	return (*C.ALLEGRO_TOUCH_EVENT)(self.toPointer())
+}
+
+// Converts wrapper Event pointer to C Allegro mouse event
+func (self *Event) MOUSE_EVENT() *C.ALLEGRO_MOUSE_EVENT {
+	return (*C.ALLEGRO_MOUSE_EVENT)(self.toPointer())
+}
+
+// Converts wrapper Event pointer to C Allegro timer event
+func (self *Event) TIMER_EVENT() *C.ALLEGRO_TIMER_EVENT {
+	return (*C.ALLEGRO_TIMER_EVENT)(self.toPointer())
+}
+
+// Converts wrapper Event pointer to C Allegro event
+func (self *Event) USER_EVENT() *C.ALLEGRO_USER_EVENT {
+	return (*C.ALLEGRO_USER_EVENT)(self.toPointer())
+}
+
+/*
+// Converts wrapper Event pointer to C Allegro event
+func (self *Event) _EVENT() *C.ALLEGRO__EVENT {
+	return (*C.ALLEGRO__EVENT)(self.toPointer())
+}
+*/
+
 // Returns the type of the event.
 func (self *Event) Type() int {
-	return int(C.algo_event_type(self.toC()))
+	return int(self.ANY_EVENT()._type)
 }
 
 // Returns the timestamp of the event.
 func (self *Event) Timestamp() float64 {
-	return float64(C.algo_event_any(self.toC()).timestamp)
+	return float64(self.ANY_EVENT().timestamp)
 }
 
 // Returns the event source of the event
 func (self *Event) EventSource() *EventSource {
-	return (*EventSource)(C.algo_event_any(self.toC()).source)
+	return (*EventSource)(self.ANY_EVENT().source)
 }
 
 // Returns true if this is a dispay event, false if not.
@@ -392,6 +460,15 @@ func (self *Event) IsUser() bool {
 	return EVENT_TYPE_IS_USER(t)
 }
 
+// Returns the event's source pointer
+func (self *Event) EVENT_SOURCE() *C.ALLEGRO_EVENT_SOURCE {
+	return self.ANY_EVENT().source
+}
+
+// Returns an unsafe pointer to the event's source pointer
+func (self *Event) EVENT_SOURCE_PTR() unsafe.Pointer {
+	return unsafe.Pointer(self.ANY_EVENT())
+}
 
 // Returns the display that has emitted the event. Will return nil if 
 // this is not a display event.
@@ -399,37 +476,37 @@ func (self *Event) DisplayDisplay() *Display {
 	if !(self.IsDisplay()) {
 		return nil
 	}
-	return wrapDisplayRaw(C.algo_event_display(self.toC()).source)
+	return wrapDisplayRaw((*C.ALLEGRO_DISPLAY)(self.EVENT_SOURCE_PTR()))
 }
 
 // Returns the X position of the display event. Will return garbage 
 // if this is not a display event.
 func (self *Event) DisplayX() int {
-	return int(C.algo_event_display(self.toC()).x)
+	return int((self.DISPLAY_EVENT()).x)
 }
 
 // Returns the Y position of the display event. Will return garbage 
 // if this is not a display event.
 func (self *Event) DisplayY() int {
-	return int(C.algo_event_display(self.toC()).y)
+	return int(self.DISPLAY_EVENT().y)
 }
 
 // Returns the width of the display event. Will return garbage 
 // if this is not a display event.
 func (self *Event) DisplayWidth() int {
-	return int(C.algo_event_display(self.toC()).width)
+	return int(self.DISPLAY_EVENT().width)
 }
 
 // Returns the height of the display event. Will return garbage 
 // if this is not a display event.
 func (self *Event) DisplayHeight() int {
-	return int(C.algo_event_display(self.toC()).height)
+	return int(self.DISPLAY_EVENT().height)
 }
 
 // Returns the orientation of the display event. Will return garbage 
 // if this is not a display event.
 func (self *Event) DisplayOrientation() int {
-	return int(C.algo_event_display(self.toC()).orientation)
+	return int(self.DISPLAY_EVENT().orientation)
 }
 
 // XXX: maybe also wrap the source in a Joystick type? 
@@ -437,25 +514,25 @@ func (self *Event) DisplayOrientation() int {
 // Returns the stick number of the joystick event. Will return garbage 
 // if this is not a joystick event.
 func (self *Event) JoystickStick() int {
-	return int(C.algo_event_joystick(self.toC()).stick)
+	return int(self.JOYSTICK_EVENT().stick)
 }
 
 // Returns the axis number of the joystick event. Will return garbage 
 // if this is not a joystick event.
 func (self *Event) JoystickAxis() int {
-	return int(C.algo_event_joystick(self.toC()).axis)
+	return int(self.JOYSTICK_EVENT().axis)
 }
 
 // Returns the button number of the joystick event. Will return garbage 
 // if this is not a joystick event.
 func (self *Event) JoystickButton() int {
-	return int(C.algo_event_joystick(self.toC()).button)
+	return int(self.JOYSTICK_EVENT().button)
 }
 
 // Returns the position of the joystick event. Will return garbage 
 // if this is not a joystick event.
 func (self *Event) JoystickPos() float32 {
-	return float32(C.algo_event_joystick(self.toC()).pos)
+	return float32(self.JOYSTICK_EVENT().pos)
 }
 
 /// XXX also wrap Keyboard event source?
@@ -466,91 +543,91 @@ func (self *Event) KeyboardDisplay() *Display {
 	if !(self.IsKeyboard()) {
 		return nil
 	}
-	return wrapDisplayRaw(C.algo_event_keyboard(self.toC()).display)
+	return wrapDisplayRaw(self.KEYBOARD_EVENT().display)
 }
 
 // Returns the keycode of the keyboard event. Returns garbage 
 // if this is not a keyboard event.
 func (self *Event) KeyboardKeycode() int {
-	return int(C.algo_event_keyboard(self.toC()).keycode)
+	return int(self.KEYBOARD_EVENT().keycode)
 }
 
 // Returns the unichar of the keyboard event. Returns garbage 
 // if this is not a keyboard event.
 func (self *Event) KeyboardUnichar() rune {
-	return rune(C.algo_event_keyboard(self.toC()).unichar)
+	return rune(self.KEYBOARD_EVENT().unichar)
 }
 
 // Returns the modifiers of the keyboard event. Returns garbage 
 // if this is not a keyboard event.
 func (self *Event) KeyboardModifiers() int {
-	return int(C.algo_event_keyboard(self.toC()).modifiers)
+	return int(self.KEYBOARD_EVENT().modifiers)
 }
 
 // Returns is the keyboard event was autorepeated or not. Returns garbage 
 // if this is not a keyboard event.
 func (self *Event) KeyboardRepeat() bool {
-	return bool(C.algo_event_keyboard(self.toC()).repeat)
+	return bool(self.KEYBOARD_EVENT().repeat)
 }
 
 // Returns the x postion of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MouseX() int {
-	return int(C.algo_event_mouse(self.toC()).x)
+	return int(self.MOUSE_EVENT().x)
 }
 
 // Returns the y postion of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MouseY() int {
-	return int(C.algo_event_mouse(self.toC()).y)
+	return int(self.MOUSE_EVENT().y)
 }
 
 // Returns the z postion of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MouseZ() int {
-	return int(C.algo_event_mouse(self.toC()).z)
+	return int(self.MOUSE_EVENT().z)
 }
 
 // Returns the w postion of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MouseW() int {
-	return int(C.algo_event_mouse(self.toC()).w)
+	return int(self.MOUSE_EVENT().w)
 }
 
 // Returns the dx of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MouseDX() int {
-	return int(C.algo_event_mouse(self.toC()).dx)
+	return int(self.MOUSE_EVENT().dx)
 }
 
 // Returns the dy of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MouseDY() int {
-	return int(C.algo_event_mouse(self.toC()).dy)
+	return int(self.MOUSE_EVENT().dy)
 }
 
 // Returns the dz of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MouseDZ() int {
-	return int(C.algo_event_mouse(self.toC()).dz)
+	return int(self.MOUSE_EVENT().dz)
 }
 
 // Returns the dw of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MouseDW() int {
-	return int(C.algo_event_mouse(self.toC()).dw)
+	return int(self.MOUSE_EVENT().dw)
 }
 
 // Returns the button of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MouseButton() int {
-	return int(C.algo_event_mouse(self.toC()).button)
+	return int(self.MOUSE_EVENT().button)
 }
 
 // Returns the pressure of the mouse event. Returns garbage 
 // if this is not a mouse event.
 func (self *Event) MousePressure() float32 {
-	return float32(C.algo_event_mouse(self.toC()).pressure)
+	return float32(self.MOUSE_EVENT().pressure)
 }
 
 // Returns the display that has emitted the mouse event. Will return nil if 
@@ -559,19 +636,19 @@ func (self *Event) MouseDisplay() *Display {
 	if !(self.IsMouse()) {
 		return nil
 	}
-	return wrapDisplayRaw(C.algo_event_mouse(self.toC()).display)
+	return wrapDisplayRaw(self.MOUSE_EVENT().display)
 }
 
 // Returns the error of the timer event. Returns garbage 
 // if this is not a timer event.
 func (self *Event) TimerError() float64 {
-	return float64(C.algo_event_timer(self.toC()).error)
+	return float64(self.TIMER_EVENT().error)
 }
 
 // Returns the ticks of the timer event. Returns garbage 
 // if this is not a timer event.
 func (self *Event) TimerCount() int64 {
-	return int64(C.algo_event_timer(self.toC()).count)
+	return int64(self.TIMER_EVENT().count)
 }
 
 // Wrapping of user event seems not really meaningful in Go so leave that out.
@@ -756,7 +833,5 @@ func (self *Timer) GetEventSource() *EventSource {
 }
 
 // Do nothing function for benchmarking only
-func DoNothing() { 
-  C.algo_do_nothing()
+func DoNothing() {
 }
-

src/algo/al/al_test.go

@@ -2,14 +2,17 @@ package al
 
 import "testing"
 import "runtime"
+import "flag"
 
 // import "fmt"
 
 // some parameters
-const expected_version = 83887873
-const SCREEN_W         = 640 
-const SCREEN_H         = 480
-const TEST_FULLSCREEN  = false
+const expected_version = 83952897
+const SCREEN_W = 640
+const SCREEN_H = 480
+const TEST_FULLSCREEN = true
+
+var fullscreen = flag.Bool("fullscreen", false, "Run fullscreen or not")
 
 func TestGetAllegroVersion(t *testing.T) {
 	version := GetAllegroVersion()
@@ -25,7 +28,10 @@ func TestSystemInstall(t *testing.T) {
 		t.Errorf("System should not be installed before install\n")
 		return
 	}
-	InstallSystem()
+	if !InstallSystem() {
+		t.Errorf("System should be installed now\n")
+		return
+	}
 	if !IsSystemInstalled() {
 		t.Errorf("System should be installed after install\n")
 		return
@@ -90,6 +96,25 @@ func TestPath(t *testing.T) {
 	}
 }
 
+// Test display info 
+func TestGetInfo(t *testing.T) {
+	InstallSystem()
+	defer UninstallSystem()
+	nv := NumVideoAdapters()
+	if nv < 1 {
+		t.Error("No video adapters found!")
+	}
+	for index := 0; index < nv; index++ {
+		info := GetMonitorInfo(index)
+		if info == nil {
+			t.Errorf("Video adapter %d not found!", index)
+			continue
+		}
+		t.Logf("MonitorInfo for %d: %d %d %d %d\n", index,
+			info.X1(), info.Y1(), info.X2(), info.Y2())
+	}
+}
+
 // Test screen saver inhibition.
 func TestInhibitScreensaver(t *testing.T) {
 	InstallSystem()
@@ -100,122 +125,132 @@ func TestInhibitScreensaver(t *testing.T) {
 	}
 }
 
-
-
 // Test joystick functions, works better with a joystick plugged in ;)
 func TestJoystick(t *testing.T) {
-  InstallSystem()
-  defer UninstallSystem()
-  InstallJoystick()
-  defer UninstallJoystick()
-  num := GetNumJoysticks()
-  t.Logf("Found %d joysticks\n", num)
-  for index :=0 ; index < num ; index ++ {
-    js      := GetJoystick(index)
-    jsname  := js.GetName()
-    sticks  := js.GetNumSticks()
-    buttons := js.GetNumButtons()
-    t.Logf("Joystick %s (nr %d) has %d sticks and %d buttons:\n", 
-            jsname, index, sticks, buttons)
-    for sdex  := 0 ; sdex < sticks ; sdex++ {
-      axes    := js.GetNumAxes(sdex)
-      sname   := js.GetStickName(sdex)
-      sfname  := js.GetStickFlagsName(sdex)
-      t.Logf("Stick %s (nr %d, %s) has %d axes: ", sname, sdex, sfname, axes)
-      for adex :=0 ; adex < axes ; adex++ {
-        aname  := js.GetAxisName(sdex, adex)
-        t.Logf("%s (nr %d) ",aname, adex)
-      }
-    }
-    t.Logf("\nButtons :")
-    for bdex := 0 ; bdex < buttons; bdex++ {
-      bname := js.GetButtonName(bdex);
-        t.Logf("%s (nr %d) ",bname, bdex)
-    }
-    t.Logf("\n")
-  }
+	InstallSystem()
+	defer UninstallSystem()
+	InstallJoystick()
+	defer UninstallJoystick()
+	num := GetNumJoysticks()
+	t.Logf("Found %d joysticks\n", num)
+	for index := 0; index < num; index++ {
+		js := GetJoystick(index)
+		jsname := js.GetName()
+		sticks := js.GetNumSticks()
+		buttons := js.GetNumButtons()
+		t.Logf("Joystick %s (nr %d) has %d sticks and %d buttons:\n",
+			jsname, index, sticks, buttons)
+		for sdex := 0; sdex < sticks; sdex++ {
+			axes := js.GetNumAxes(sdex)
+			sname := js.GetStickName(sdex)
+			sfname := js.GetStickFlagsName(sdex)
+			t.Logf("Stick %s (nr %d, %s) has %d axes: ", sname, sdex, sfname, axes)
+			for adex := 0; adex < axes; adex++ {
+				aname := js.GetAxisName(sdex, adex)
+				t.Logf("%s (nr %d) ", aname, adex)
+			}
+		}
+		t.Logf("\nButtons :")
+		for bdex := 0; bdex < buttons; bdex++ {
+			bname := js.GetButtonName(bdex)
+			t.Logf("%s (nr %d) ", bname, bdex)
+		}
+		t.Logf("\n")
+	}
 }
 
 // Makesa display for testing, using the test's setting above 
-func makeDisplay() (*Display) {
-  flags := 0
-  // Use full screen mode if needed.
-  if TEST_FULLSCREEN  { 
-    flags = FULLSCREEN // | GENERATE_EXPOSE_EVENTS
-  } 
-  SetNewDisplayFlags(flags)
-  // Create a window to display things on: 640x480 pixels.
-  display := CreateDisplay(SCREEN_W, SCREEN_H)
-  display.Resize(SCREEN_W, SCREEN_H)
-  return display
+func makeDisplay() *Display {
+	flags := 0
+	// Use full screen mode if needed.
+	if *fullscreen {
+		flags = FULLSCREEN // | GENERATE_EXPOSE_EVENTS
+	} else {
+		SetNewDisplayFlags(flags)
+	}
+	// Create a window to display things on: 640x480 pixels.
+	display := CreateDisplay(SCREEN_W, SCREEN_H)
+	display.Resize(SCREEN_W, SCREEN_H)
+	if !(*fullscreen) {
+		display.SetTitle("Algo test window")
+	}
+	return display
 }
 
 // Test basic display functions 
 func TestBasicDisplay(t *testing.T) {
-  InstallSystem()
-  defer UninstallSystem()  
-  display := makeDisplay()
-  if display == nil {
-    t.Error("Error creating display.")
-  }
-  /*
-  if ! {
-    t.Error("Resize of display failed.")
-  }
-  */
-  blue   := CreateColor(0.0, 0.0, 1.0, 1.0)
-  yellow := CreateColor(1.0, 1.0, 0.0, 1.0)
-  ClearToColor(blue)
-  DrawPixel(20.0, 10.0, yellow)  
-  FlipDisplay()
-  Rest(1.0)
-  ClearToColor(yellow)
-  DrawPixel(20.0, 10.0, blue)
-  FlipDisplay()
-  display.Destroy() 
-  Rest(1.0)
+	InstallSystem()
+	defer UninstallSystem()
+	display := makeDisplay()
+	if display == nil {
+		t.Error("Error creating display.")
+	}
+	HoldBitmapDrawing(true)
+	if !IsBitmapDrawingHeld() {
+		t.Error("Bitmap drawing hold failed")
+	}
+	HoldBitmapDrawing(false)
+	if IsBitmapDrawingHeld() {
+		t.Error("Bitmap drawing hold release failed")
+	}
+
+	/*
+	   if ! {
+	     t.Error("Resize of display failed.")
+	   }
+	*/
+	blue := CreateColor(0.0, 0.0, 1.0, 1.0)
+	yellow := CreateColor(1.0, 1.0, 0.0, 1.0)
+	ClearToColor(blue)
+	DrawPixel(20.0, 10.0, yellow)
+	FlipDisplay()
+	Rest(1.0)
+	display.SetWindowPosition(50, 100)
+	ClearToColor(yellow)
+	DrawPixel(20.0, 10.0, blue)
+	FlipDisplay()
+	display.Destroy()
+	Rest(1.0)
 }
 
 // Benchmark basic display function ClearToColor
 func BenchmarkClearToColor(b *testing.B) {
-    b.StopTimer()
-    InstallSystem()
-    defer UninstallSystem()  
-    display := makeDisplay()
-    blue    := CreateColor(0.0, 0.0, 1.0, 1.0)
-    if display == nil {
-      b.Fatal("Error creating display. Cannot benchmark it.")
-    }
-    b.StartTimer()
-    for i := 0; i < b.N; i++ {
-        ClearToColor(blue)
-        FlipDisplay()
-    }    
-    display.Destroy()
+	b.StopTimer()
+	InstallSystem()
+	defer UninstallSystem()
+	display := makeDisplay()
+	blue := CreateColor(0.0, 0.0, 1.0, 1.0)
+	if display == nil {
+		b.Fatal("Error creating display. Cannot benchmark it.")
+	}
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		ClearToColor(blue)
+	}
+	// FlipDisplay()
+	display.Destroy()
 }
 
 // Benchmark basic display function FlipDisplay
 func BenchmarkFlipDisplay(b *testing.B) {
-    b.StopTimer()
-    InstallSystem()
-    defer UninstallSystem()  
-    display := makeDisplay()
-    if display == nil {
-      b.Fatal("Error creating display. Cannot benchmark it.")
-    }
-    b.StartTimer()
-    for i := 0; i < b.N; i++ {
-        FlipDisplay()
-    }
-    display.Destroy()
+	b.StopTimer()
+	InstallSystem()
+	defer UninstallSystem()
+	display := makeDisplay()
+	if display == nil {
+		b.Fatal("Error creating display. Cannot benchmark it.")
+	}
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		FlipDisplay()
+	}
+	display.Destroy()
 }
 
 // Benchmarking of C call overhead
 // Benchmark basic display function FlipDisplay
 func BenchmarkDoNothing(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        DoNothing()
-    }
+	for i := 0; i < b.N; i++ {
+		DoNothing()
+	}
 }
-
-

src/algo/al/al_windows.go

@@ -1,5 +1,4 @@
 package al
 
-
-const NATIVE_PATH_SEP  = '\\'
+const NATIVE_PATH_SEP = '\\'
 const NATIVE_DRIVE_SEP = ':'

src/algo/al/albitmap.go

@@ -0,0 +1,202 @@
+// albitmap
+package al
+
+/*
+#include <stdlib.h>
+#include <allegro5/allegro.h>
+#include "helpers.h"
+*/
+import "C"
+
+import "runtime"
+
+// Type that wraps a Bitmap
+type Bitmap struct {
+	handle *C.ALLEGRO_BITMAP
+}
+
+// Destroys a bitmap. Use this only when really needed!
+func (self *Bitmap) Destroy() {
+	if self.handle != nil {
+		C.al_destroy_bitmap(self.handle)
+	}
+	self.handle = nil
+}
+
+// Wraps a C Allegro bitmap in a Bitmap. Sets no finalizer.
+func wrapBitmapRaw(handle *C.ALLEGRO_BITMAP) *Bitmap {
+	if handle == nil {
+		return nil
+	}
+	return &Bitmap{handle}
+}
+
+// Wraps a C Allegro Bitmap in a Bitmap. Sets a finalizer that calls Destroy.
+func wrapBitmap(handle *C.ALLEGRO_BITMAP) *Bitmap {
+	self := wrapBitmapRaw(handle)
+	if self != nil {
+		runtime.SetFinalizer(self, func(me *Bitmap) { me.Destroy() })
+	}
+	return self
+}
+
+const (
+	MEMORY_BITMAP       = C.ALLEGRO_MEMORY_BITMAP
+	FORCE_LOCKING       = C.ALLEGRO_FORCE_LOCKING
+	NO_PRESERVE_TEXTURE = C.ALLEGRO_NO_PRESERVE_TEXTURE
+	MIN_LINEAR          = C.ALLEGRO_MIN_LINEAR
+	MAG_LINEAR          = C.ALLEGRO_MAG_LINEAR
+	MIPMAP              = C.ALLEGRO_MIPMAP
+	VIDEO_BITMAP        = C.ALLEGRO_VIDEO_BITMAP
+	CONVERT_BITMAP      = C.ALLEGRO_CONVERT_BITMAP
+)
+
+// Sets the format for new bitmaps that are created using CreateBitmap
+func SetNewBitmapFormat(format int) {
+	C.al_set_new_bitmap_format(C.int(format))
+}
+
+// Sets the flags for new bitmaps that are created using CreateBitmap
+func SetNewBitmapFlags(flags int) {
+	C.al_set_new_bitmap_flags(C.int(flags))
+}
+
+// Adds a flags to the flags that will be used for new bitmaps that are created 
+// using CreateBitmap
+func AddNewBitmapFlag(flags int) {
+	C.al_add_new_bitmap_flag(C.int(flags))
+}
+
+// Gets the format for new bitmaps that are created using CreateBitmap
+func NewBitmapFormat(format int) int {
+	return int(C.al_get_new_bitmap_format())
+}
+
+// Gets the flags for new bitmaps that are created using CreateBitmap
+func NewBitmapFlags(flags int) int {
+	return int(C.al_get_new_bitmap_flags())
+}
+
+// Gets the width of the bitmap.
+func (self *Bitmap) Width() int {
+	return int(C.al_get_bitmap_width(self.handle))
+}
+
+// Gets the height of the bitmap.
+func (self *Bitmap) Height() int {
+	return int(C.al_get_bitmap_height(self.handle))
+}
+
+// Gets the format of the bitmap.
+func (self *Bitmap) Format() int {
+	return int(C.al_get_bitmap_format(self.handle))
+}
+
+// Gets the flags of the bitmap.
+func (self *Bitmap) Flags() int {
+	return int(C.al_get_bitmap_flags(self.handle))
+}
+
+// Creates a new RAW bitmap. It will not be automatically destroyed!
+func CreateBitmapRaw(w, h int) *Bitmap {
+	return wrapBitmapRaw(C.al_create_bitmap(C.int(w), C.int(h)))
+}
+
+// Creates a new bitmap. It has a finalizer in place that will let it be automatically 
+// destroyed.
+func CreateBitmap(w, h int) *Bitmap {
+	return wrapBitmap(C.al_create_bitmap(C.int(w), C.int(h)))
+}
+
+/* TODO:
+AL_FUNC(ALLEGRO_BITMAP*, al_create_custom_bitmap, (int w, int h, bool (*upload)(ALLEGRO_BITMAP *bitmap, void *data), void *data));
+*/
+
+// Puts a pixel to the currently active bitmap
+func PutPixel(x, y int, color Color) {
+	C.al_put_pixel(C.int(x), C.int(y), color.toC())
+}
+
+// Blends a pixel to the currently active bitmap
+func PutBlendedPixel(x, y int, color Color) {
+	C.al_put_blended_pixel(C.int(x), C.int(y), color.toC())
+}
+
+// Gets a pixel from the bitmap
+func (self *Bitmap) GetPixel(x, y int) (color Color) {
+	return wrapColor(C.al_get_pixel(self.handle, C.int(x), C.int(y)))
+}
+
+// Converts pixels of the mask color to transparent pixels (with an alpha channel) 
+// for the given bitmap. Useful for, say "magic pink" backgrounds.
+func (self *Bitmap) ConvertMaskToAlpha(mask_color Color) {
+	C.al_convert_mask_to_alpha(self.handle, mask_color.toC())
+}
+
+// Sets the clipping rectangle for the currently active bitmap. Anything drawn outside
+// this rectangle will be cut off or "clipped".
+func SetClippingRectangle(x, y, w, h int) {
+	C.al_set_clipping_rectangle(C.int(x), C.int(y), C.int(w), C.int(h))
+}
+
+// Resets the clipping rectangle for the currently active bitmap to the full size. 
+func ResetClippingRectangle() {
+	C.al_reset_clipping_rectangle()
+}
+
+// Gets the clipping rectangle for the currently active bitmap. 
+func ClippingRectangle() (x, y, w, h int) {
+	var cx, cy, cw, ch C.int
+	C.al_get_clipping_rectangle(&cx, &cy, &cw, &ch)
+	return int(cx), int(cy), int(cw), int(ch)
+}
+
+// Creates a RAW sub bitmap of the given bitmap that must be manually destoyed with 
+// Destroy() 
+func (self *Bitmap) CreateSubBitmapRaw(x, y, w, h int) *Bitmap {
+	return wrapBitmapRaw(C.al_create_sub_bitmap(self.handle,
+		C.int(x), C.int(y), C.int(w), C.int(h)))
+}
+
+// Creates a sub bitmap of the given bitmap that will automatically be destoyed
+// through a finalizer. However, you must ensure that this destroy happens before the 
+// parent bitmap is disposed of. You may need to call Destroy manyally anyway. 
+func (self *Bitmap) CreateSubBitmap(x, y, w, h int) *Bitmap {
+	return wrapBitmap(C.al_create_sub_bitmap(self.handle,
+		C.int(x), C.int(y), C.int(w), C.int(h)))
+}
+
+// Returns whether or not the bitmap is a sub bitmap 
+func (self *Bitmap) IsSubBitmap() bool {
+	return cb2b(C.al_is_sub_bitmap(self.handle))
+}
+
+// Returns the parent bitmap of this sub bitmap, or nil if there is no parent. 
+// This is a raw bitmap that has no finaliser set on it since likely 
+/// this function will only be used for inspection.
+func (self *Bitmap) Parent() *Bitmap {
+	return wrapBitmapRaw(C.al_get_parent_bitmap(self.handle))
+}
+
+// Returns a raw clone of the bitmap, that will not be automatically 
+// destroyed.
+func (self *Bitmap) CloneRaw() *Bitmap {
+	return wrapBitmapRaw(C.al_clone_bitmap(self.handle))
+}
+
+// Returns a clone of the bitmap, that will automatically be
+// destroyed.
+func (self *Bitmap) Clone() *Bitmap {
+	return wrapBitmap(C.al_clone_bitmap(self.handle))
+}
+
+// Converts the bitmap to the current screen format, to ensure the blitting goes fast
+func (self *Bitmap) Convert() {
+	C.al_convert_bitmap(self.handle)
+}
+
+// Converts all known unconverted bitmaps to the current screen format, 
+// to ensure the blitting goes fast. 
+func ConvertBitmaps() {
+	C.al_convert_bitmaps()
+}

src/algo/al/aldisplay.go

@@ -15,290 +15,446 @@ import "runtime"
 
 // Possible bit combinations for the flags parameter of CreateDisplay.
 const (
-   WINDOWED = C.ALLEGRO_WINDOWED
-   FULLSCREEN = C.ALLEGRO_FULLSCREEN
-   OPENGL = C.ALLEGRO_OPENGL
-   DIRECT3D_INTERNAL = C.ALLEGRO_DIRECT3D_INTERNAL
-   RESIZABLE = C.ALLEGRO_RESIZABLE
-   FRAMELESS = C.ALLEGRO_FRAMELESS
-   NOFRAME = C.ALLEGRO_NOFRAME
-   GENERATE_EXPOSE_EVENTS = C.ALLEGRO_GENERATE_EXPOSE_EVENTS
-   OPENGL_3_0 = C.ALLEGRO_OPENGL_3_0
-   OPENGL_FORWARD_COMPATIBLE = C.ALLEGRO_OPENGL_FORWARD_COMPATIBLE
-   FULLSCREEN_WINDOW = C.ALLEGRO_FULLSCREEN_WINDOW
-   MINIMIZED = C.ALLEGRO_MINIMIZED
+	WINDOWED                  = C.ALLEGRO_WINDOWED
+	FULLSCREEN                = C.ALLEGRO_FULLSCREEN
+	OPENGL                    = C.ALLEGRO_OPENGL
+	DIRECT3D_INTERNAL         = C.ALLEGRO_DIRECT3D_INTERNAL
+	RESIZABLE                 = C.ALLEGRO_RESIZABLE
+	FRAMELESS                 = C.ALLEGRO_FRAMELESS
+	NOFRAME                   = C.ALLEGRO_NOFRAME
+	GENERATE_EXPOSE_EVENTS    = C.ALLEGRO_GENERATE_EXPOSE_EVENTS
+	OPENGL_3_0                = C.ALLEGRO_OPENGL_3_0
+	OPENGL_FORWARD_COMPATIBLE = C.ALLEGRO_OPENGL_FORWARD_COMPATIBLE
+	FULLSCREEN_WINDOW         = C.ALLEGRO_FULLSCREEN_WINDOW
+	MINIMIZED                 = C.ALLEGRO_MINIMIZED
 )
 
 /* Possible parameters for SetDisplayOption. */
 const (
-   RED_SIZE = C.ALLEGRO_RED_SIZE
-   GREEN_SIZE = C.ALLEGRO_GREEN_SIZE
-   BLUE_SIZE = C.ALLEGRO_BLUE_SIZE
-   ALPHA_SIZE = C.ALLEGRO_ALPHA_SIZE
-   RED_SHIFT = C.ALLEGRO_RED_SHIFT
-   GREEN_SHIFT = C.ALLEGRO_GREEN_SHIFT
-   BLUE_SHIFT = C.ALLEGRO_BLUE_SHIFT
-   ALPHA_SHIFT = C.ALLEGRO_ALPHA_SHIFT
-   ACC_RED_SIZE = C.ALLEGRO_ACC_RED_SIZE
-   ACC_GREEN_SIZE = C.ALLEGRO_ACC_GREEN_SIZE
-   ACC_BLUE_SIZE = C.ALLEGRO_ACC_BLUE_SIZE
-   ACC_ALPHA_SIZE = C.ALLEGRO_ACC_ALPHA_SIZE
-   STEREO = C.ALLEGRO_STEREO
-   AUX_BUFFERS = C.ALLEGRO_AUX_BUFFERS
-   COLOR_SIZE = C.ALLEGRO_COLOR_SIZE
-   DEPTH_SIZE = C.ALLEGRO_DEPTH_SIZE
-   STENCIL_SIZE = C.ALLEGRO_STENCIL_SIZE
-   SAMPLE_BUFFERS = C.ALLEGRO_SAMPLE_BUFFERS
-   SAMPLES = C.ALLEGRO_SAMPLES
-   RENDER_METHOD = C.ALLEGRO_RENDER_METHOD
-   FLOAT_COLOR = C.ALLEGRO_FLOAT_COLOR
-   FLOAT_DEPTH = C.ALLEGRO_FLOAT_DEPTH
-   SINGLE_BUFFER = C.ALLEGRO_SINGLE_BUFFER
-   SWAP_METHOD = C.ALLEGRO_SWAP_METHOD
-   COMPATIBLE_DISPLAY = C.ALLEGRO_COMPATIBLE_DISPLAY
-   UPDATE_DISPLAY_REGION = C.ALLEGRO_UPDATE_DISPLAY_REGION
-   VSYNC = C.ALLEGRO_VSYNC
-   MAX_BITMAP_SIZE = C.ALLEGRO_MAX_BITMAP_SIZE
-   SUPPORT_NPOT_BITMAP = C.ALLEGRO_SUPPORT_NPOT_BITMAP
-   CAN_DRAW_INTO_BITMAP = C.ALLEGRO_CAN_DRAW_INTO_BITMAP
-   SUPPORT_SEPARATE_ALPHA = C.ALLEGRO_SUPPORT_SEPARATE_ALPHA
-   DISPLAY_OPTIONS_COUNT = C.ALLEGRO_DISPLAY_OPTIONS_COUNT
+	RED_SIZE               = C.ALLEGRO_RED_SIZE
+	GREEN_SIZE             = C.ALLEGRO_GREEN_SIZE
+	BLUE_SIZE              = C.ALLEGRO_BLUE_SIZE
+	ALPHA_SIZE             = C.ALLEGRO_ALPHA_SIZE
+	RED_SHIFT              = C.ALLEGRO_RED_SHIFT
+	GREEN_SHIFT            = C.ALLEGRO_GREEN_SHIFT
+	BLUE_SHIFT             = C.ALLEGRO_BLUE_SHIFT
+	ALPHA_SHIFT            = C.ALLEGRO_ALPHA_SHIFT
+	ACC_RED_SIZE           = C.ALLEGRO_ACC_RED_SIZE
+	ACC_GREEN_SIZE         = C.ALLEGRO_ACC_GREEN_SIZE
+	ACC_BLUE_SIZE          = C.ALLEGRO_ACC_BLUE_SIZE
+	ACC_ALPHA_SIZE         = C.ALLEGRO_ACC_ALPHA_SIZE
+	STEREO                 = C.ALLEGRO_STEREO
+	AUX_BUFFERS            = C.ALLEGRO_AUX_BUFFERS
+	COLOR_SIZE             = C.ALLEGRO_COLOR_SIZE
+	DEPTH_SIZE             = C.ALLEGRO_DEPTH_SIZE
+	STENCIL_SIZE           = C.ALLEGRO_STENCIL_SIZE
+	SAMPLE_BUFFERS         = C.ALLEGRO_SAMPLE_BUFFERS
+	SAMPLES                = C.ALLEGRO_SAMPLES
+	RENDER_METHOD          = C.ALLEGRO_RENDER_METHOD
+	FLOAT_COLOR            = C.ALLEGRO_FLOAT_COLOR
+	FLOAT_DEPTH            = C.ALLEGRO_FLOAT_DEPTH
+	SINGLE_BUFFER          = C.ALLEGRO_SINGLE_BUFFER
+	SWAP_METHOD            = C.ALLEGRO_SWAP_METHOD
+	COMPATIBLE_DISPLAY     = C.ALLEGRO_COMPATIBLE_DISPLAY
+	UPDATE_DISPLAY_REGION  = C.ALLEGRO_UPDATE_DISPLAY_REGION
+	VSYNC                  = C.ALLEGRO_VSYNC
+	MAX_BITMAP_SIZE        = C.ALLEGRO_MAX_BITMAP_SIZE
+	SUPPORT_NPOT_BITMAP    = C.ALLEGRO_SUPPORT_NPOT_BITMAP
+	CAN_DRAW_INTO_BITMAP   = C.ALLEGRO_CAN_DRAW_INTO_BITMAP
+	SUPPORT_SEPARATE_ALPHA = C.ALLEGRO_SUPPORT_SEPARATE_ALPHA
+	DISPLAY_OPTIONS_COUNT  = C.ALLEGRO_DISPLAY_OPTIONS_COUNT
 )
 
-// Constants thatdetermine if a setting is required or not.
+// Constants that determine if a setting is required or not.
 const (
-   DONTCARE = C.ALLEGRO_DONTCARE
-   REQUIRE = C.ALLEGRO_REQUIRE
-   SUGGEST = C.ALLEGRO_SUGGEST
+	DONTCARE = C.ALLEGRO_DONTCARE
+	REQUIRE  = C.ALLEGRO_REQUIRE
+	SUGGEST  = C.ALLEGRO_SUGGEST
 )
 
 // Display orientations
 const (
-   DISPLAY_ORIENTATION_0_DEGREES = C.ALLEGRO_DISPLAY_ORIENTATION_0_DEGREES
-   DISPLAY_ORIENTATION_90_DEGREES = C.ALLEGRO_DISPLAY_ORIENTATION_90_DEGREES
-   DISPLAY_ORIENTATION_180_DEGREES = C.ALLEGRO_DISPLAY_ORIENTATION_180_DEGREES
-   DISPLAY_ORIENTATION_270_DEGREES = C.ALLEGRO_DISPLAY_ORIENTATION_270_DEGREES
-   DISPLAY_ORIENTATION_FACE_UP = C.ALLEGRO_DISPLAY_ORIENTATION_FACE_UP
-   DISPLAY_ORIENTATION_FACE_DOWN = C.ALLEGRO_DISPLAY_ORIENTATION_FACE_DOWN
+	DISPLAY_ORIENTATION_0_DEGREES   = C.ALLEGRO_DISPLAY_ORIENTATION_0_DEGREES
+	DISPLAY_ORIENTATION_90_DEGREES  = C.ALLEGRO_DISPLAY_ORIENTATION_90_DEGREES
+	DISPLAY_ORIENTATION_180_DEGREES = C.ALLEGRO_DISPLAY_ORIENTATION_180_DEGREES
+	DISPLAY_ORIENTATION_270_DEGREES = C.ALLEGRO_DISPLAY_ORIENTATION_270_DEGREES
+	DISPLAY_ORIENTATION_FACE_UP     = C.ALLEGRO_DISPLAY_ORIENTATION_FACE_UP
+	DISPLAY_ORIENTATION_FACE_DOWN   = C.ALLEGRO_DISPLAY_ORIENTATION_FACE_DOWN
 )
 
 // Type that wraps a Display (a main window)
 type Display struct {
-  handle * C.ALLEGRO_DISPLAY
+	handle *C.ALLEGRO_DISPLAY
 }
 
 // Destroys a display. Use this only when really needed!
-func (self * Display) Destroy() {
-  if(self.handle != nil) {
-    C.al_destroy_display(self.handle)
-  }
-  self.handle = nil
+func (self *Display) Destroy() {
+	if self.handle != nil {
+		C.al_destroy_display(self.handle)
+	}
+	self.handle = nil
 }
 
 // Wraps a C Allegro display in a Display. Sets no finalizer.
-func wrapDisplayRaw(handle * C.ALLEGRO_DISPLAY) * Display {
-  if handle == nil { return nil } 
-  return &Display{handle}
+func wrapDisplayRaw(handle *C.ALLEGRO_DISPLAY) *Display {
+	if handle == nil {
+		return nil
+	}
+	return &Display{handle}
 }
 
 // Wraps a C Allegro display in a Display. Sets a finalizer that calls Destroy
-func wrapDisplay(handle * C.ALLEGRO_DISPLAY) * Display {
-  self := wrapDisplayRaw(handle)
-  if self != nil {
-    runtime.SetFinalizer(self, func (me * Display) { me.Destroy() })
-  }
-  return self
+func wrapDisplay(handle *C.ALLEGRO_DISPLAY) *Display {
+	self := wrapDisplayRaw(handle)
+	if self != nil {
+		runtime.SetFinalizer(self, func(me *Display) { me.Destroy() })
+	}
+	return self
 }
 
-
 // Display mode info.
-type DisplayMode C.ALLEGRO_DISPLAY_MODE 
+type DisplayMode C.ALLEGRO_DISPLAY_MODE
+
+// Converts display mode to C display mode 
+func (self *DisplayMode) toC() *C.ALLEGRO_DISPLAY_MODE {
+	return (*C.ALLEGRO_DISPLAY_MODE)(self)
+}
 
 // Returns the width of the display mode self.
-func (self * DisplayMode) Width() int {
-  return int(self.width)
+func (self *DisplayMode) Width() int {
+	return int(self.width)
 }
 
 // Returns the height of the display mode self.
-func (self * DisplayMode) Height() int {
-  return int(self.height)
+func (self *DisplayMode) Height() int {
+	return int(self.height)
 }
 
 // Returns the format of the display mode self.
-func (self * DisplayMode) Format() int {
-  return int(self.format)
+func (self *DisplayMode) Format() int {
+	return int(self.format)
 }
 
 // Returns the refresh rate of the display mode self.
-func (self * DisplayMode) RefreshRate() int {
-  return int(self.refresh_rate)
+func (self *DisplayMode) RefreshRate() int {
+	return int(self.refresh_rate)
 }
 
 // Monitor info
 type MonitorInfo C.ALLEGRO_MONITOR_INFO
 
 // Returns the X1 of the monitor info self.
-func (self * MonitorInfo) X1() int {
-  return int(self.x1)
+func (self *MonitorInfo) X1() int {
+	return int(self.x1)
 }
 
 // Returns the Y1 of the monitor info self.
-func (self * MonitorInfo) Y1() int {
-  return int(self.y1)
+func (self *MonitorInfo) Y1() int {
+	return int(self.y1)
 }
 
 // Returns the X2 of the monitor info self.
-func (self * MonitorInfo) X2() int {
-  return int(self.x2)
+func (self *MonitorInfo) X2() int {
+	return int(self.x2)
 }
 
 // Returns the Y2 of the monitor info self.
-func (self * MonitorInfo) Y2() int {
-  return int(self.y2)
+func (self *MonitorInfo) Y2() int {
+	return int(self.y2)
 }
 
-
 const (
-   DEFAULT_DISPLAY_ADAPTER = C.ALLEGRO_DEFAULT_DISPLAY_ADAPTER
+	DEFAULT_DISPLAY_ADAPTER = C.ALLEGRO_DEFAULT_DISPLAY_ADAPTER
 )
 
 // Sets the flags that a display created by CreateDisplay will get after
 // this function was called.
 func SetNewDisplayFlags(flags int) {
-  C.al_set_new_display_flags(C.int(flags))
+	C.al_set_new_display_flags(C.int(flags))
 }
 
 // Creates a new dosplay with the given size. Influenced by SetNewDisplayFlags.
-func CreateDisplay(width, height int) (*Display) {
-  return wrapDisplay(C.al_create_display(C.int(width), C.int(height)))
+func CreateDisplay(width, height int) *Display {
+	return wrapDisplay(C.al_create_display(C.int(width), C.int(height)))
 }
 
 // Resizes the display.
-func (self * Display) Resize(width, height int) bool {
-  return bool(C.al_resize_display(self.handle, C.int(width), C.int(height)))
+func (self *Display) Resize(width, height int) bool {
+	return bool(C.al_resize_display(self.handle, C.int(width), C.int(height)))
 }
 
 // Updates the display to the physical scree no any changes become visible
 func FlipDisplay() {
-  C.al_flip_display()
+	C.al_flip_display()
 }
 
 // Same as FlipDisplay, for mere consistency
-func (self * Display) Flip() {
-  C.al_flip_display()
+func (self *Display) Flip() {
+	C.al_flip_display()
 }
 
-
 // Color type
 type Color C.ALLEGRO_COLOR
 
+// Convert from
+func wrapColor(color C.ALLEGRO_COLOR) Color {
+	return Color(color)
+}
+
 // Convert to C
 func (self Color) toC() C.ALLEGRO_COLOR {
-  return C.ALLEGRO_COLOR(self)
+	return C.ALLEGRO_COLOR(self)
 }
 
-
 // Creates a new color 
 func CreateColor(r, g, b, a float32) Color {
-  return Color{C.float(r),C.float(g),C.float(b),C.float(a)}
+	return Color{C.float(r), C.float(g), C.float(b), C.float(a)}
 }
 
 // Returns the R component of the color self.
 func (self Color) R() float32 {
-  return float32(self.r)
+	return float32(self.r)
 }
 
 // Returns the G component of the color self.
 func (self Color) G() float32 {
-  return float32(self.g)
+	return float32(self.g)
 }
 
 // Returns the B component of the color self.
 func (self Color) B() float32 {
-  return float32(self.b)
+	return float32(self.b)
 }
 
 // Returns the A component of the color self.
 func (self Color) A() float32 {
-  return float32(self.a)
+	return float32(self.a)
 }
 
 // Fills the current active display with a color
 func ClearToColor(color Color) {
-  C.al_clear_to_color(color.toC());
+	C.al_clear_to_color(color.toC())
 }
 
 // Draws a pixel on the active display at the given location 
 // with the given color
 func DrawPixel(x, y float32, color Color) {
-  C.al_draw_pixel(C.float(x), C.float(y), C.ALLEGRO_COLOR(color))
+	C.al_draw_pixel(C.float(x), C.float(y), C.ALLEGRO_COLOR(color))
 }
 
+// Sets the refresh rate that the display should have after CreateDisplay().
+func SetNewDisplayRefreshRate(refresh_rate int) {
+	C.al_set_new_display_refresh_rate(C.int(refresh_rate))
+}
 
-/*
-AL_FUNC(void, al_set_new_display_refresh_rate, (int refresh_rate));
-AL_FUNC(void, al_set_new_display_flags, (int flags));
-AL_FUNC(int,  al_get_new_display_refresh_rate, (void));
-AL_FUNC(int,  al_get_new_display_flags, (void));
+// Gets the refresh rate that the display should have after CreateDisplay().
+func NewDisplayRefreshRate() int {
+	return int(C.al_get_new_display_refresh_rate())
+}
 
-AL_FUNC(int, al_get_display_width,  (ALLEGRO_DISPLAY *display));
-AL_FUNC(int, al_get_display_height, (ALLEGRO_DISPLAY *display));
-AL_FUNC(int, al_get_display_format, (ALLEGRO_DISPLAY *display));
-AL_FUNC(int, al_get_display_refresh_rate, (ALLEGRO_DISPLAY *display));
-AL_FUNC(int, al_get_display_flags,  (ALLEGRO_DISPLAY *display));
-AL_FUNC(bool, al_set_display_flag, (ALLEGRO_DISPLAY *display, int flag, bool onoff));
-AL_FUNC(bool, al_toggle_display_flag, (ALLEGRO_DISPLAY *display, int flag, bool onoff));
+// Gets the display flags that the display should have after CreateDisplay().
+func NewDisplayFlags() int {
+	return int(C.al_get_new_display_flags())
+}
 
-AL_FUNC(ALLEGRO_DISPLAY*, al_create_display, (int w, int h));
-AL_FUNC(void,             al_destroy_display, (ALLEGRO_DISPLAY *display));
-AL_FUNC(ALLEGRO_DISPLAY*, al_get_current_display, (void));
-AL_FUNC(void,            al_set_target_bitmap, (ALLEGRO_BITMAP *bitmap));
-AL_FUNC(void,            al_set_target_backbuffer, (ALLEGRO_DISPLAY *display));
-AL_FUNC(ALLEGRO_BITMAP*, al_get_backbuffer,    (ALLEGRO_DISPLAY *display));
-AL_FUNC(ALLEGRO_BITMAP*, al_get_target_bitmap, (void));
+// Gets the width of the display  in pixels
+func (self *Display) Width() int {
+	return int(C.al_get_display_width(self.handle))
+}
 
-AL_FUNC(bool, al_acknowledge_resize, (ALLEGRO_DISPLAY *display));
-AL_FUNC(bool, al_resize_display,     (ALLEGRO_DISPLAY *display, int width, int height));
-AL_FUNC(void, al_flip_display,       (void));
-AL_FUNC(void, al_update_display_region, (int x, int y, int width, int height));
-AL_FUNC(bool, al_is_compatible_bitmap, (ALLEGRO_BITMAP *bitmap));
+// Gets the height of the display in pixels
+func (self *Display) Height() int {
+	return int(C.al_get_display_height(self.handle))
+}
 
-AL_FUNC(int, al_get_num_display_modes, (void));
-AL_FUNC(ALLEGRO_DISPLAY_MODE*, al_get_display_mode, (int index,
-        ALLEGRO_DISPLAY_MODE *mode));
+// Gets the refresh rate of the display
+func (self *Display) RefreshRate() int {
+	return int(C.al_get_display_refresh_rate(self.handle))
+}
 
-AL_FUNC(bool, al_wait_for_vsync, (void));
+// Gets the display flags of the display
+func (self *Display) DisplayFlags() int {
+	return int(C.al_get_display_flags(self.handle))
+}
 
-AL_FUNC(ALLEGRO_EVENT_SOURCE *, al_get_display_event_source, (ALLEGRO_DISPLAY *display));
+// Sets a dispay flag on the display
+func (self *Display) SetDisplayFlag(flag int, onoff bool) bool {
+	return cb2b(C.al_set_display_flag(self.handle, C.int(flag), b2cb(onoff)))
+}
 
+// Returns the current display 
+func CurrentDisplay() *Display {
+	return wrapDisplayRaw(C.al_get_current_display())
+}
 
-AL_FUNC(void, al_clear_to_color, (ALLEGRO_COLOR color));
-AL_FUNC(void, al_draw_pixel, (float x, float y, ALLEGRO_COLOR color));
+// Sets the target C bitmap of allegro drawing 
+func setTargetCBitmap(bmp *C.ALLEGRO_BITMAP) {
+	C.al_set_target_bitmap(bmp)
+}
 
-AL_FUNC(void, al_set_display_icon, (ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *icon));
+// Sets the target bitmap of the allegro drawing
+func SetTargetBitmap(bmp Bitmap) {
+	setTargetCBitmap(bmp.handle)
+}
 
+// Sets the target C backbuffer of allegro drawing 
+func setTargetCBackbuffer(display *C.ALLEGRO_DISPLAY) {
+	C.al_set_target_backbuffer(display)
+}
 
-AL_FUNC(int, al_get_num_video_adapters, (void));
-AL_FUNC(bool, al_get_monitor_info, (int adapter, ALLEGRO_MONITOR_INFO *info));
-AL_FUNC(int, al_get_new_display_adapter, (void));
-AL_FUNC(void, al_set_new_display_adapter, (int adapter));
-AL_FUNC(void, al_set_new_window_position, (int x, int y));
-AL_FUNC(void, al_get_new_window_position, (int *x, int *y));
-AL_FUNC(void, al_set_window_position, (ALLEGRO_DISPLAY *display, int x, int y));
-AL_FUNC(void, al_get_window_position, (ALLEGRO_DISPLAY *display, int *x, int *y));
+// Sets the target backbuffer of allegro drawing 
+func SetTargetBackbuffer(display *Display) {
+	setTargetCBackbuffer(display.handle)
+}
 
-AL_FUNC(void, al_set_window_title, (ALLEGRO_DISPLAY *display, const char *title));
+// Gets the backbuffer bitmap of the display 
+func (self *Display) Backbuffer() *Bitmap {
+	return wrapBitmapRaw(C.al_get_backbuffer(self.handle))
+}
 
+// Gets the target bitmap of allegro drawing
+func TargetBitmap() *Bitmap {
+	return wrapBitmapRaw(C.al_get_target_bitmap())
+}
 
-AL_FUNC(void, al_set_new_display_option, (int option, int value, int importance));
-AL_FUNC(int, al_get_new_display_option, (int option, int *importance));
-AL_FUNC(void, al_reset_new_display_options, (void));
-AL_FUNC(int, al_get_display_option, (ALLEGRO_DISPLAY *display, int option));
+// Must be called to aknowledge a RESIZE event
+func (self *Display) AcknowledgeResize() bool {
+	return cb2b(C.al_acknowledge_resize(self.handle))
+}
 
+// Updates a region of the display (not the whole display like flip does)
+func UpdateDisplayRegion(x, y, width, height int) {
+	C.al_update_display_region(C.int(x), C.int(y), C.int(width), C.int(height))
+}
 
-AL_FUNC(void, al_hold_bitmap_drawing, (bool hold));
-AL_FUNC(bool, al_is_bitmap_drawing_held, (void));
+// Returns true of the bitmap is compatible with the currebt display, false if not. 
+func (bitmap *Bitmap) IsCompatibleBitmap() bool {
+	return cb2b(C.al_is_compatible_bitmap(bitmap.handle))
+}
 
-*/
+// Returns the number of display modes available to Allegro
+func NumDisplayModes() int {
+	return int(C.al_get_num_display_modes())
+}
+
+// Returns the index'th display mode. Pass in a DisplayMode struct to store the display
+// mode info in. 
+func (self *DisplayMode) Get(index int) *DisplayMode {
+	return (*DisplayMode)(C.al_get_display_mode(C.int(index), self.toC()))
+}
 
+// Gets display mode info for the index'th display mode
+func GetDisplayMode(index int) *DisplayMode {
+	var mode DisplayMode
+	if (&mode).Get(index) != nil {
+		return &mode
+	}
+	return nil
+}
+
+// Waits for the vertical retrace of the monitor to lessen tearing.
+func WaitForVsync() {
+	C.al_wait_for_vsync()
+}
 
+// Gets the event source of the display to registeron an event queue 
+// with RegisterEventSource.
+func (self *Display) GetEventSource() *EventSource {
+	return (*EventSource)(C.al_get_display_event_source(self.handle))
+}
+
+// Sets the display icon the window manager should use for the display window
+func (self *Display) SetDisplayIcon(bitmap *Bitmap) {
+	C.al_set_display_icon(self.handle, bitmap.handle)
+}
+
+// Gets the number of available video adapters (I.E. grapic cards)
+func NumVideoAdapters() int {
+	return int(C.al_get_num_video_adapters())
+}
+
+// Converts a monitor info pointer to a C  * ALLEGRO_MONITOR_INFO
+func (self *MonitorInfo) toC() *C.ALLEGRO_MONITOR_INFO {
+	return (*C.ALLEGRO_MONITOR_INFO)(self)
+}
+
+// Gets the monitor info for the index'th video adapter
+func (self *MonitorInfo) Get(index int) bool {
+	return cb2b(C.al_get_monitor_info(C.int(index), self.toC()))
+}
+
+// Gets the monitor info for the index'th video adapter
+func GetMonitorInfo(index int) *MonitorInfo {
+	var info MonitorInfo
+	if (&info).Get(index) {
+		return &info
+	}
+	return nil
+}
+
+// Returns the number of the display adapter where new dsplays will be created
+func NewDisplayAdapter() int {
+	return int(C.al_get_new_display_adapter())
+}
+
+// Sets the number of the display adapter where new dsplays will be created
+func SetNewDisplayAdapter(adapter int) {
+	C.al_set_new_display_adapter(C.int(adapter))
+}
+
+// Returns the position where new windowed displays will be created
+func NewWindowPosition() (x, y int) {
+	var cx, cy C.int
+	C.al_get_new_window_position(&cx, &cy)
+	return int(cx), int(cy)
+}
+
+// Sets the position where new windowed displays will be created
+func SetNewWindowPosition(x, y int) {
+	C.al_set_new_window_position(C.int(x), C.int(y))
+}
+
+// Returns the current position of the windowed display
+func (self *Display) WindowPosition() (x, y int) {
+	var cx, cy C.int
+	C.al_get_window_position(self.handle, &cx, &cy)
+	return int(cx), int(cy)
+}
+
+// Sets the position where new windowed displays will be created
+func (self *Display) SetWindowPosition(x, y int) {
+	C.al_set_window_position(self.handle, C.int(x), C.int(y))
+}
+
+// Sets the title of the windowed display
+func (self *Display) SetTitle(str string) {
+	cstr := cstr(str)
+	defer cstrFree(cstr)
+	C.al_set_window_title(self.handle, cstr)
+}
+
+// Sets a display option to be used when a new display is created
+func SetNewDisplayOption(option, value, importance int) {
+	C.al_set_new_display_option(C.int(option), C.int(value), C.int(importance))
+}
+
+// Resets all display oprions for new displays to their default values.
+func ResetNewDisplayOptions() {
+	C.al_reset_new_display_options()
+}
+
+// Gets the display option of this display
+func (self *Display) DisplayOption(option int) int {
+	return int(C.al_get_display_option(self.handle, C.int(option)))
+}
+
+// Allows to speed up drawing by holding the display . Only bitmap functions and font 
+// drawing, as well as tranformations shouldbe done until the hold is released
+func HoldBitmapDrawing(hold bool) {
+	C.al_hold_bitmap_drawing(b2cb(hold))
+}
+
+// Returns whether or not the bitmap drawing was held
+func IsBitmapDrawingHeld() bool {
+	return cb2b(C.al_is_bitmap_drawing_held())
+}

src/algo/al/aljoystick.go

@@ -13,181 +13,189 @@ import "runtime"
 
 // Joystick functionality.
 
-type Joystick struct { 
-  handle * C.ALLEGRO_JOYSTICK
+type Joystick struct {
+    handle *C.ALLEGRO_JOYSTICK
 }
 
 // Destroyst he joystick. According to the Allegro documentation, this 
 // does nothing.
-func (self * Joystick) Destroy() {
-  // Some problems is this is enabled so make sure this does nothing...
-  // C.al_release_joystick(self.handle)
+func (self *Joystick) Destroy() {
+    // Some problems is this is enabled so make sure this does nothing...
+    // C.al_release_joystick(self.handle)
 }
 
 // Wraps a C joystick handler into the Go Joystick wrapper.
-func wrapJoystickRaw(handle * C.ALLEGRO_JOYSTICK) (*Joystick) {
-  if handle == nil { return nil }
-  return &Joystick{handle}
+func wrapJoystickRaw(handle *C.ALLEGRO_JOYSTICK) *Joystick {
+    if handle == nil {
+        return nil
+    }
+    return &Joystick{handle}
 }
 
 // Wraps a C joystick handler into the Go Joystick wrapper.
 // Also sets a finalizer that calls joystick.Destroy().
-func wrapJoystick(handle * C.ALLEGRO_JOYSTICK) (*Joystick) {
-  self := wrapJoystickRaw(handle)
-  if self != nil {
-    runtime.SetFinalizer(self, func(me * Joystick) { me.Destroy() } )
-  }
-  return self
+func wrapJoystick(handle *C.ALLEGRO_JOYSTICK) *Joystick {
+    self := wrapJoystickRaw(handle)
+    if self != nil {
+        runtime.SetFinalizer(self, func(me *Joystick) { me.Destroy() })
+    }
+    return self
 }
 
 // Struct that holds the state of the joystick.
 type JoystickState C.ALLEGRO_JOYSTICK_STATE
 
 // Converts a wrapped joystick state to a C joystick state.
-func (self * JoystickState) toC()  *C.ALLEGRO_JOYSTICK_STATE {
-  return (*C.ALLEGRO_JOYSTICK_STATE)(self)
+func (self *JoystickState) toC() *C.ALLEGRO_JOYSTICK_STATE {
+    return (*C.ALLEGRO_JOYSTICK_STATE)(self)
 }
 
 // Gets the state of the axis for the given stick on the joystick.
 // returns 0.0 if the stick or axis are out of range. May return
 // garbage for nonexisting sticks and axes.
-func (self * JoystickState) GetStickAxis(stick, axis int) float32 {
-  if (stick >= int(C._AL_MAX_JOYSTICK_STICKS)) { return 0.0 }
-  if (axis >= int(C._AL_MAX_JOYSTICK_AXES))    { return 0.0 }
-  if (axis  < 0) { return 0.0 }
-  if (stick < 0) { return 0.0 }
-  return float32(self.stick[C.int(stick)].axis[C.int(axis)])
+func (self *JoystickState) GetStickAxis(stick, axis int) float32 {
+    if stick >= int(C._AL_MAX_JOYSTICK_STICKS) {
+        return 0.0
+    }
+    if axis >= int(C._AL_MAX_JOYSTICK_AXES) {
+        return 0.0
+    }
+    if axis < 0 {
+        return 0.0
+    }
+    if stick < 0 {
+        return 0.0
+    }
+    return float32(self.stick[C.int(stick)].axis[C.int(axis)])
 }
 
 // Gerts the state of the button with the given index on the joystick.
 // Will return -1 if the button is out of range.
-func (self * JoystickState) GetButton(button int) int {
-  if (button >= int(C._AL_MAX_JOYSTICK_BUTTONS)) { return -1 }
-  if (button < 0) { return -1 }
-  return int(self.button[C.int(button)])
+func (self *JoystickState) GetButton(button int) int {
+    if button >= int(C._AL_MAX_JOYSTICK_BUTTONS) {
+        return -1
+    }
+    if button < 0 {
+        return -1
+    }
+    return int(self.button[C.int(button)])
 }
 
-
 // Joystick flags that determine the type of the joystick.
 const (
-  JOYFLAG_DIGITAL  = C.ALLEGRO_JOYFLAG_DIGITAL
-  JOYFLAG_ANALOGUE = C.ALLEGRO_JOYFLAG_ANALOGUE 
+    JOYFLAG_DIGITAL  = C.ALLEGRO_JOYFLAG_DIGITAL
+    JOYFLAG_ANALOGUE = C.ALLEGRO_JOYFLAG_ANALOGUE
 )
 
-
 // Installs the Allegro Joystick module.
 func InstallJoystick() bool {
-  return bool(C.al_install_joystick())
+    return bool(C.al_install_joystick())
 }
 
 // Uninstalls the Allegro Joystick module.
 func UninstallJoystick() {
-  C.al_uninstall_joystick()
+    C.al_uninstall_joystick()
 }
 
 // Returns true if the Allegro joystick module ws instaled, false if not.
 func IsJoystickInstalled() bool {
-  return bool(C.al_is_joystick_installed())
+    return bool(C.al_is_joystick_installed())
 }
 
 // Returns the amount of joysticks detected.
 func GetNumJoysticks() int {
-  return int(C.al_get_num_joysticks())
+    return int(C.al_get_num_joysticks())
 }
 
 // Returns the joyn'th joystick, or nil if no such stick exists. 
-func GetJoystick(joyn int) (*Joystick) {
-  return wrapJoystick(C.al_get_joystick(C.int(joyn)))
+func GetJoystick(joyn int) *Joystick {
+    return wrapJoystick(C.al_get_joystick(C.int(joyn)))
 }
 
-
 // Joystick properties.
 
 // Returns true if the joystick self is active, false if not.
-func (self * Joystick) IsActive() bool {
-  return bool(C.al_get_joystick_active(self.handle))
+func (self *Joystick) IsActive() bool {
+    return bool(C.al_get_joystick_active(self.handle))
 }
 
 // Returns the name of the joystick self.
-func (self * Joystick) GetName() string {
-  return gostr(C.al_get_joystick_name(self.handle))
+func (self *Joystick) GetName() string {
+    return gostr(C.al_get_joystick_name(self.handle))
 }
 
 // Returns the amount of sticks the joystick self has.
-func (self * Joystick) GetNumSticks() int {
-  return int(C.al_get_joystick_num_sticks(self.handle))
+func (self *Joystick) GetNumSticks() int {
+    return int(C.al_get_joystick_num_sticks(self.handle))
 }
 
 // Returns the joystick flags for the numbered stick on the joystick self.
-func (self * Joystick) GetStickFlags(stick int) int {
-  return int(C.al_get_joystick_stick_flags(self.handle, C.int(stick)))
+func (self *Joystick) GetStickFlags(stick int) int {
+    return int(C.al_get_joystick_stick_flags(self.handle, C.int(stick)))
 }
 
 // Returns true if the numbered stick on joystick self is digital, false if not.
 // Note that theoretically, a stick could be both digital and analog...
-func (self * Joystick) IsStickDigital(stick int) bool {
-  return (JOYFLAG_DIGITAL &  self.GetStickFlags(stick)) == JOYFLAG_DIGITAL
+func (self *Joystick) IsStickDigital(stick int) bool {
+    return (JOYFLAG_DIGITAL & self.GetStickFlags(stick)) == JOYFLAG_DIGITAL
 }
 
 // Returns true if the numbered stick on joystick self is analog, false if not
 // Note that theoretically, a stick could be both digital and analog...
-func (self * Joystick) IsStickAnalog(stick int) bool {
-  return (JOYFLAG_ANALOGUE &  self.GetStickFlags(stick)) == JOYFLAG_ANALOGUE
+func (self *Joystick) IsStickAnalog(stick int) bool {
+    return (JOYFLAG_ANALOGUE & self.GetStickFlags(stick)) == JOYFLAG_ANALOGUE
 }
 
 // Returns a string that describes the joystick flags for the numbered stick 
 // on the joystick self. Will return "Analog" for an analog joystick, 
 // "Digital" for a digital joystick, "Hybrid" fo one that's both and 
 // "None" for one that's neither
-func (self * Joystick) GetStickFlagsName(stick int) string {
-  if self.IsStickAnalog(stick) {
-    if self.IsStickDigital(stick) { 
-      return "Hybrid"
-    } else { 
-      return "Analog"
+func (self *Joystick) GetStickFlagsName(stick int) string {
+    if self.IsStickAnalog(stick) {
+        if self.IsStickDigital(stick) {
+            return "Hybrid"
+        } else {
+            return "Analog"
+        }
+    }
+    if self.IsStickDigital(stick) {
+        return "Digital"
     }
-  } 
-  if self.IsStickDigital(stick) {
-    return "Digital"
-  } 
-  return "None"
+    return "None"
 }
 
-
 // Returns the name of the stick on the joystick self.
-func (self * Joystick) GetStickName(stick int) string {
-  return gostr(C.al_get_joystick_stick_name(self.handle, C.int(stick)))
+func (self *Joystick) GetStickName(stick int) string {
+    return gostr(C.al_get_joystick_stick_name(self.handle, C.int(stick)))
 }
 
-
 // Returns the amount of axes for the stick on the joystick self.
-func (self * Joystick) GetNumAxes(stick int) int {
-  return int(C.al_get_joystick_num_axes(self.handle, C.int(stick)))
+func (self *Joystick) GetNumAxes(stick int) int {
+    return int(C.al_get_joystick_num_axes(self.handle, C.int(stick)))
 }
 
 // Returns the name of the axis for the stick on the joystick self.
-func (self * Joystick) GetAxisName(stick, axis int) string {
-  return gostr(C.al_get_joystick_axis_name(self.handle, C.int(stick), C.int(axis)))
+func (self *Joystick) GetAxisName(stick, axis int) string {
+    return gostr(C.al_get_joystick_axis_name(self.handle, C.int(stick), C.int(axis)))
 }
 
 // Returns the amount of buttons on the joystick self.
-func (self * Joystick) GetNumButtons() int {
-  return int(C.al_get_joystick_num_buttons(self.handle))
+func (self *Joystick) GetNumButtons() int {
+    return int(C.al_get_joystick_num_buttons(self.handle))
 }
 
 // Returns the name of the button on the joystick self.
-func (self * Joystick) GetButtonName(button int) string {
-  return gostr(C.al_get_joystick_button_name(self.handle, C.int(button)))
+func (self *Joystick) GetButtonName(button int) string {
+    return gostr(C.al_get_joystick_button_name(self.handle, C.int(button)))
 }
 
 // Gets the state of the joystick
-func (self * Joystick) GetState() (* JoystickState) {
-  state := &JoystickState{}
-  C.al_get_joystick_state(self.handle, state.toC())
-  return state
+func (self *Joystick) GetState() *JoystickState {
+    state := &JoystickState{}
+    C.al_get_joystick_state(self.handle, state.toC())
+    return state
 }
 
-
 /*
 AL_FUNC(bool,           al_install_joystick,    (void));
 AL_FUNC(void,           al_uninstall_joystick,  (void));

src/algo/al/alkeyboard.go

@@ -9,27 +9,26 @@ import "C"
 
 // Usful regexp for KATE:  ALLEGRO_([A-Z0-9_]+)(.*) -> \1 = C.ALLEGRO_\1
 
-
 // Keyboard functionality.
 
 // Checks if the Allegro keyboard module is installed or not.
 func IsKeyboardInstalled() bool {
-  return bool(C.al_is_keyboard_installed())
+    return bool(C.al_is_keyboard_installed())
 }
 
 // Installs the Allegro keyboard module.
 func InstallKeyboard() bool {
-  return bool(C.al_install_keyboard())
+    return bool(C.al_install_keyboard())
 }
 
 // Uninstalls the Allegro keyboard module.
 func UninstallKeyboard() {
-  C.al_uninstall_keyboard()
+    C.al_uninstall_keyboard()
 }
 
 // Gets the name of te given keucode as a string.
 func KeycodeToName(keycode int) string {
-  return gostr(C.al_keycode_to_name(C.int(keycode)))
+    return gostr(C.al_keycode_to_name(C.int(keycode)))
 }
 
 // KeyboardState isn't very interesting for now, so don't wrap it
@@ -37,193 +36,180 @@ func KeycodeToName(keycode int) string {
 
 // Gets the state of a given keyboard key by keycode. True is down, false is up.
 func KeyDown(keycode int) bool {
-  state := &C.ALLEGRO_KEYBOARD_STATE{}
-  C.al_get_keyboard_state(state)
-  return bool(C.al_key_down(state, C.int(keycode)))
+    state := &C.ALLEGRO_KEYBOARD_STATE{}
+    C.al_get_keyboard_state(state)
+    return bool(C.al_key_down(state, C.int(keycode)))
 }
 
 // Sets the state of the leds on the keyboard.
 func SetKeyboardLeds(leds int) bool {
-  return bool(C.al_set_keyboard_leds(C.int(leds)))
+    return bool(C.al_set_keyboard_leds(C.int(leds)))
 }
 
 // Returns the Keyboard event source that can be registered to an EventQueue
 // with RegisterEventSource.
-func GetKeyboardEventSource() * EventSource {
-  return (*EventSource)(C.al_get_keyboard_event_source())
+func GetKeyboardEventSource() *EventSource {
+    return (*EventSource)(C.al_get_keyboard_event_source())
 }
 
-
 // Keyboard constants
 const (
-	KEY_A = C.ALLEGRO_KEY_A
-	KEY_B = C.ALLEGRO_KEY_B
-	KEY_C = C.ALLEGRO_KEY_C
-	KEY_D = C.ALLEGRO_KEY_D
-	KEY_E = C.ALLEGRO_KEY_E
-	KEY_F = C.ALLEGRO_KEY_F
-	KEY_G = C.ALLEGRO_KEY_G
-	KEY_H = C.ALLEGRO_KEY_H
-	KEY_I = C.ALLEGRO_KEY_I
-	KEY_J = C.ALLEGRO_KEY_J
-	KEY_K = C.ALLEGRO_KEY_K
-	KEY_L = C.ALLEGRO_KEY_L
-	KEY_M = C.ALLEGRO_KEY_M
-	KEY_N = C.ALLEGRO_KEY_N
-	KEY_O = C.ALLEGRO_KEY_O
-	KEY_P = C.ALLEGRO_KEY_P
-	KEY_Q = C.ALLEGRO_KEY_Q
-	KEY_R = C.ALLEGRO_KEY_R
-	KEY_S = C.ALLEGRO_KEY_S
-	KEY_T = C.ALLEGRO_KEY_T
-	KEY_U = C.ALLEGRO_KEY_U
-	KEY_V = C.ALLEGRO_KEY_V
-	KEY_W = C.ALLEGRO_KEY_W
-	KEY_X = C.ALLEGRO_KEY_X
-	KEY_Y = C.ALLEGRO_KEY_Y
-	KEY_Z = C.ALLEGRO_KEY_Z
-
-	KEY_0 = C.ALLEGRO_KEY_0
-	KEY_1 = C.ALLEGRO_KEY_1
-	KEY_2 = C.ALLEGRO_KEY_2
-	KEY_3 = C.ALLEGRO_KEY_3
-	KEY_4 = C.ALLEGRO_KEY_4
-	KEY_5 = C.ALLEGRO_KEY_5
-	KEY_6 = C.ALLEGRO_KEY_6
-	KEY_7 = C.ALLEGRO_KEY_7
-	KEY_8 = C.ALLEGRO_KEY_8
-	KEY_9 = C.ALLEGRO_KEY_9
-
-	KEY_PAD_0 = C.ALLEGRO_KEY_PAD_0
-	KEY_PAD_1 = C.ALLEGRO_KEY_PAD_1
-	KEY_PAD_2 = C.ALLEGRO_KEY_PAD_2
-	KEY_PAD_3 = C.ALLEGRO_KEY_PAD_3
-	KEY_PAD_4 = C.ALLEGRO_KEY_PAD_4
-	KEY_PAD_5 = C.ALLEGRO_KEY_PAD_5
-	KEY_PAD_6 = C.ALLEGRO_KEY_PAD_6
-	KEY_PAD_7 = C.ALLEGRO_KEY_PAD_7
-	KEY_PAD_8 = C.ALLEGRO_KEY_PAD_8
-	KEY_PAD_9 = C.ALLEGRO_KEY_PAD_9
-
-	KEY_F1  = C.ALLEGRO_KEY_F1
-	KEY_F2  = C.ALLEGRO_KEY_F2
-	KEY_F3  = C.ALLEGRO_KEY_F3
-	KEY_F4  = C.ALLEGRO_KEY_F4
-	KEY_F5  = C.ALLEGRO_KEY_F5
-	KEY_F6  = C.ALLEGRO_KEY_F6
-	KEY_F7  = C.ALLEGRO_KEY_F7
-	KEY_F8  = C.ALLEGRO_KEY_F8
-	KEY_F9  = C.ALLEGRO_KEY_F9
-	KEY_F10 = C.ALLEGRO_KEY_F10
-	KEY_F11 = C.ALLEGRO_KEY_F11
-	KEY_F12 = C.ALLEGRO_KEY_F12
-
-	KEY_ESCAPE     = C.ALLEGRO_KEY_ESCAPE
-	KEY_TILDE      = C.ALLEGRO_KEY_TILDE
-	KEY_MINUS      = C.ALLEGRO_KEY_MINUS
-	KEY_EQUALS     = C.ALLEGRO_KEY_EQUALS
-	KEY_BACKSPACE  = C.ALLEGRO_KEY_BACKSPACE
-	KEY_TAB        = C.ALLEGRO_KEY_TAB
-	KEY_OPENBRACE  = C.ALLEGRO_KEY_OPENBRACE
-	KEY_CLOSEBRACE = C.ALLEGRO_KEY_CLOSEBRACE
-	KEY_ENTER      = C.ALLEGRO_KEY_ENTER
-	KEY_SEMICOLON  = C.ALLEGRO_KEY_SEMICOLON
-	KEY_QUOTE      = C.ALLEGRO_KEY_QUOTE
-	KEY_BACKSLASH  = C.ALLEGRO_KEY_BACKSLASH
-	KEY_BACKSLASH2 = C.ALLEGRO_KEY_BACKSLASH2
-	KEY_COMMA      = C.ALLEGRO_KEY_COMMA
-	KEY_FULLSTOP   = C.ALLEGRO_KEY_FULLSTOP
-	KEY_SLASH      = C.ALLEGRO_KEY_SLASH
-	KEY_SPACE      = C.ALLEGRO_KEY_SPACE
-
-	KEY_INSERT = C.ALLEGRO_KEY_INSERT
-	KEY_DELETE = C.ALLEGRO_KEY_DELETE
-	KEY_HOME   = C.ALLEGRO_KEY_HOME
-	KEY_END    = C.ALLEGRO_KEY_END
-	KEY_PGUP   = C.ALLEGRO_KEY_PGUP
-	KEY_PGDN   = C.ALLEGRO_KEY_PGDN
-	KEY_LEFT   = C.ALLEGRO_KEY_LEFT
-	KEY_RIGHT  = C.ALLEGRO_KEY_RIGHT
-	KEY_UP     = C.ALLEGRO_KEY_UP
-	KEY_DOWN   = C.ALLEGRO_KEY_DOWN
-
-	KEY_PAD_SLASH    = C.ALLEGRO_KEY_PAD_SLASH
-	KEY_PAD_ASTERISK = C.ALLEGRO_KEY_PAD_ASTERISK
-	KEY_PAD_MINUS    = C.ALLEGRO_KEY_PAD_MINUS
-	KEY_PAD_PLUS     = C.ALLEGRO_KEY_PAD_PLUS
-	KEY_PAD_DELETE   = C.ALLEGRO_KEY_PAD_DELETE
-	KEY_PAD_ENTER    = C.ALLEGRO_KEY_PAD_ENTER
-
-	KEY_PRINTSCREEN = C.ALLEGRO_KEY_PRINTSCREEN
-	KEY_PAUSE       = C.ALLEGRO_KEY_PAUSE
-
-	KEY_ABNT_C1    = C.ALLEGRO_KEY_ABNT_C1
-	KEY_YEN        = C.ALLEGRO_KEY_YEN
-	KEY_KANA       = C.ALLEGRO_KEY_KANA
-	KEY_CONVERT    = C.ALLEGRO_KEY_CONVERT
-	KEY_NOCONVERT  = C.ALLEGRO_KEY_NOCONVERT
-	KEY_AT         = C.ALLEGRO_KEY_AT
-	KEY_CIRCUMFLEX = C.ALLEGRO_KEY_CIRCUMFLEX
-	KEY_COLON2     = C.ALLEGRO_KEY_COLON2
-	KEY_KANJI      = C.ALLEGRO_KEY_KANJI
-
-	KEY_PAD_EQUALS = C.ALLEGRO_KEY_PAD_EQUALS
-	KEY_BACKQUOTE  = C.ALLEGRO_KEY_BACKQUOTE
-	KEY_SEMICOLON2 = C.ALLEGRO_KEY_SEMICOLON2
-	KEY_COMMAND    = C.ALLEGRO_KEY_COMMAND
-	KEY_UNKNOWN    = C.ALLEGRO_KEY_UNKNOWN
-
-	/* All codes up to before KEY_MODIFIERS = C.ALLEGRO_KEY_MODIFIERS
-	 * assignedas additional unknown keys, like various multimedia
-	 * and application keys keyboards may have.
-	 */
-
-	KEY_MODIFIERS = C.ALLEGRO_KEY_MODIFIERS
-
-	KEY_LSHIFT     = C.ALLEGRO_KEY_LSHIFT
-	KEY_RSHIFT     = C.ALLEGRO_KEY_RSHIFT
-	KEY_LCTRL      = C.ALLEGRO_KEY_LCTRL
-	KEY_RCTRL      = C.ALLEGRO_KEY_RCTRL
-	KEY_ALT        = C.ALLEGRO_KEY_ALT
-	KEY_ALTGR      = C.ALLEGRO_KEY_ALTGR
-	KEY_LWIN       = C.ALLEGRO_KEY_LWIN
-	KEY_RWIN       = C.ALLEGRO_KEY_RWIN
-	KEY_MENU       = C.ALLEGRO_KEY_MENU
-	KEY_SCROLLLOCK = C.ALLEGRO_KEY_SCROLLLOCK
-	KEY_NUMLOCK    = C.ALLEGRO_KEY_NUMLOCK
-	KEY_CAPSLOCK   = C.ALLEGRO_KEY_CAPSLOCK
-
-	KEY_MAX = C.ALLEGRO_KEY_MAX
+    KEY_A = C.ALLEGRO_KEY_A
+    KEY_B = C.ALLEGRO_KEY_B
+    KEY_C = C.ALLEGRO_KEY_C
+    KEY_D = C.ALLEGRO_KEY_D
+    KEY_E = C.ALLEGRO_KEY_E
+    KEY_F = C.ALLEGRO_KEY_F
+    KEY_G = C.ALLEGRO_KEY_G
+    KEY_H = C.ALLEGRO_KEY_H
+    KEY_I = C.ALLEGRO_KEY_I
+    KEY_J = C.ALLEGRO_KEY_J
+    KEY_K = C.ALLEGRO_KEY_K
+    KEY_L = C.ALLEGRO_KEY_L
+    KEY_M = C.ALLEGRO_KEY_M
+    KEY_N = C.ALLEGRO_KEY_N
+    KEY_O = C.ALLEGRO_KEY_O
+    KEY_P = C.ALLEGRO_KEY_P
+    KEY_Q = C.ALLEGRO_KEY_Q
+    KEY_R = C.ALLEGRO_KEY_R
+    KEY_S = C.ALLEGRO_KEY_S
+    KEY_T = C.ALLEGRO_KEY_T
+    KEY_U = C.ALLEGRO_KEY_U
+    KEY_V = C.ALLEGRO_KEY_V
+    KEY_W = C.ALLEGRO_KEY_W
+    KEY_X = C.ALLEGRO_KEY_X
+    KEY_Y = C.ALLEGRO_KEY_Y
+    KEY_Z = C.ALLEGRO_KEY_Z
+
+    KEY_0 = C.ALLEGRO_KEY_0
+    KEY_1 = C.ALLEGRO_KEY_1
+    KEY_2 = C.ALLEGRO_KEY_2
+    KEY_3 = C.ALLEGRO_KEY_3
+    KEY_4 = C.ALLEGRO_KEY_4
+    KEY_5 = C.ALLEGRO_KEY_5
+    KEY_6 = C.ALLEGRO_KEY_6
+    KEY_7 = C.ALLEGRO_KEY_7
+    KEY_8 = C.ALLEGRO_KEY_8
+    KEY_9 = C.ALLEGRO_KEY_9
+
+    KEY_PAD_0 = C.ALLEGRO_KEY_PAD_0
+    KEY_PAD_1 = C.ALLEGRO_KEY_PAD_1
+    KEY_PAD_2 = C.ALLEGRO_KEY_PAD_2
+    KEY_PAD_3 = C.ALLEGRO_KEY_PAD_3
+    KEY_PAD_4 = C.ALLEGRO_KEY_PAD_4
+    KEY_PAD_5 = C.ALLEGRO_KEY_PAD_5
+    KEY_PAD_6 = C.ALLEGRO_KEY_PAD_6
+    KEY_PAD_7 = C.ALLEGRO_KEY_PAD_7
+    KEY_PAD_8 = C.ALLEGRO_KEY_PAD_8
+    KEY_PAD_9 = C.ALLEGRO_KEY_PAD_9
+
+    KEY_F1  = C.ALLEGRO_KEY_F1
+    KEY_F2  = C.ALLEGRO_KEY_F2
+    KEY_F3  = C.ALLEGRO_KEY_F3
+    KEY_F4  = C.ALLEGRO_KEY_F4
+    KEY_F5  = C.ALLEGRO_KEY_F5
+    KEY_F6  = C.ALLEGRO_KEY_F6
+    KEY_F7  = C.ALLEGRO_KEY_F7
+    KEY_F8  = C.ALLEGRO_KEY_F8
+    KEY_F9  = C.ALLEGRO_KEY_F9
+    KEY_F10 = C.ALLEGRO_KEY_F10
+    KEY_F11 = C.ALLEGRO_KEY_F11
+    KEY_F12 = C.ALLEGRO_KEY_F12
+
+    KEY_ESCAPE     = C.ALLEGRO_KEY_ESCAPE
+    KEY_TILDE      = C.ALLEGRO_KEY_TILDE
+    KEY_MINUS      = C.ALLEGRO_KEY_MINUS
+    KEY_EQUALS     = C.ALLEGRO_KEY_EQUALS
+    KEY_BACKSPACE  = C.ALLEGRO_KEY_BACKSPACE
+    KEY_TAB        = C.ALLEGRO_KEY_TAB
+    KEY_OPENBRACE  = C.ALLEGRO_KEY_OPENBRACE
+    KEY_CLOSEBRACE = C.ALLEGRO_KEY_CLOSEBRACE
+    KEY_ENTER      = C.ALLEGRO_KEY_ENTER
+    KEY_SEMICOLON  = C.ALLEGRO_KEY_SEMICOLON
+    KEY_QUOTE      = C.ALLEGRO_KEY_QUOTE
+    KEY_BACKSLASH  = C.ALLEGRO_KEY_BACKSLASH
+    KEY_BACKSLASH2 = C.ALLEGRO_KEY_BACKSLASH2
+    KEY_COMMA      = C.ALLEGRO_KEY_COMMA
+    KEY_FULLSTOP   = C.ALLEGRO_KEY_FULLSTOP
+    KEY_SLASH      = C.ALLEGRO_KEY_SLASH
+    KEY_SPACE      = C.ALLEGRO_KEY_SPACE
+
+    KEY_INSERT = C.ALLEGRO_KEY_INSERT
+    KEY_DELETE = C.ALLEGRO_KEY_DELETE
+    KEY_HOME   = C.ALLEGRO_KEY_HOME
+    KEY_END    = C.ALLEGRO_KEY_END
+    KEY_PGUP   = C.ALLEGRO_KEY_PGUP
+    KEY_PGDN   = C.ALLEGRO_KEY_PGDN
+    KEY_LEFT   = C.ALLEGRO_KEY_LEFT
+    KEY_RIGHT  = C.ALLEGRO_KEY_RIGHT
+    KEY_UP     = C.ALLEGRO_KEY_UP
+    KEY_DOWN   = C.ALLEGRO_KEY_DOWN
+
+    KEY_PAD_SLASH    = C.ALLEGRO_KEY_PAD_SLASH
+    KEY_PAD_ASTERISK = C.ALLEGRO_KEY_PAD_ASTERISK
+    KEY_PAD_MINUS    = C.ALLEGRO_KEY_PAD_MINUS
+    KEY_PAD_PLUS     = C.ALLEGRO_KEY_PAD_PLUS
+    KEY_PAD_DELETE   = C.ALLEGRO_KEY_PAD_DELETE
+    KEY_PAD_ENTER    = C.ALLEGRO_KEY_PAD_ENTER
+
+    KEY_PRINTSCREEN = C.ALLEGRO_KEY_PRINTSCREEN
+    KEY_PAUSE       = C.ALLEGRO_KEY_PAUSE
+
+    KEY_ABNT_C1    = C.ALLEGRO_KEY_ABNT_C1
+    KEY_YEN        = C.ALLEGRO_KEY_YEN
+    KEY_KANA       = C.ALLEGRO_KEY_KANA
+    KEY_CONVERT    = C.ALLEGRO_KEY_CONVERT
+    KEY_NOCONVERT  = C.ALLEGRO_KEY_NOCONVERT
+    KEY_AT         = C.ALLEGRO_KEY_AT
+    KEY_CIRCUMFLEX = C.ALLEGRO_KEY_CIRCUMFLEX
+    KEY_COLON2     = C.ALLEGRO_KEY_COLON2
+    KEY_KANJI      = C.ALLEGRO_KEY_KANJI
+
+    KEY_PAD_EQUALS = C.ALLEGRO_KEY_PAD_EQUALS
+    KEY_BACKQUOTE  = C.ALLEGRO_KEY_BACKQUOTE
+    KEY_SEMICOLON2 = C.ALLEGRO_KEY_SEMICOLON2
+    KEY_COMMAND    = C.ALLEGRO_KEY_COMMAND
+    KEY_UNKNOWN    = C.ALLEGRO_KEY_UNKNOWN
+
+    /* All codes up to before KEY_MODIFIERS = C.ALLEGRO_KEY_MODIFIERS
+     * assignedas additional unknown keys, like various multimedia
+     * and application keys keyboards may have.
+     */
+
+    KEY_MODIFIERS = C.ALLEGRO_KEY_MODIFIERS
+
+    KEY_LSHIFT     = C.ALLEGRO_KEY_LSHIFT
+    KEY_RSHIFT     = C.ALLEGRO_KEY_RSHIFT
+    KEY_LCTRL      = C.ALLEGRO_KEY_LCTRL
+    KEY_RCTRL      = C.ALLEGRO_KEY_RCTRL
+    KEY_ALT        = C.ALLEGRO_KEY_ALT
+    KEY_ALTGR      = C.ALLEGRO_KEY_ALTGR
+    KEY_LWIN       = C.ALLEGRO_KEY_LWIN
+    KEY_RWIN       = C.ALLEGRO_KEY_RWIN
+    KEY_MENU       = C.ALLEGRO_KEY_MENU
+    KEY_SCROLLLOCK = C.ALLEGRO_KEY_SCROLLLOCK
+    KEY_NUMLOCK    = C.ALLEGRO_KEY_NUMLOCK
+    KEY_CAPSLOCK   = C.ALLEGRO_KEY_CAPSLOCK
+
+    KEY_MAX = C.ALLEGRO_KEY_MAX
 )
 
 // Keyboard modifier constants
 const (
-	KEYMOD_SHIFT      = C.ALLEGRO_KEYMOD_SHIFT
-	KEYMOD_CTRL       = C.ALLEGRO_KEYMOD_CTRL
-	KEYMOD_ALT        = C.ALLEGRO_KEYMOD_ALT
-	KEYMOD_LWIN       = C.ALLEGRO_KEYMOD_LWIN
-	KEYMOD_RWIN       = C.ALLEGRO_KEYMOD_RWIN
-	KEYMOD_MENU       = C.ALLEGRO_KEYMOD_MENU
-	KEYMOD_ALTGR      = C.ALLEGRO_KEYMOD_ALTGR
-	KEYMOD_COMMAND    = C.ALLEGRO_KEYMOD_COMMAND
-	KEYMOD_SCROLLLOCK = C.ALLEGRO_KEYMOD_SCROLLLOCK
-	KEYMOD_NUMLOCK    = C.ALLEGRO_KEYMOD_NUMLOCK
-	KEYMOD_CAPSLOCK   = C.ALLEGRO_KEYMOD_CAPSLOCK
-	KEYMOD_INALTSEQ   = C.ALLEGRO_KEYMOD_INALTSEQ
-	KEYMOD_ACCENT1    = C.ALLEGRO_KEYMOD_ACCENT1
-	KEYMOD_ACCENT2    = C.ALLEGRO_KEYMOD_ACCENT2
-	KEYMOD_ACCENT3    = C.ALLEGRO_KEYMOD_ACCENT3
-	KEYMOD_ACCENT4    = C.ALLEGRO_KEYMOD_ACCENT4
+    KEYMOD_SHIFT      = C.ALLEGRO_KEYMOD_SHIFT
+    KEYMOD_CTRL       = C.ALLEGRO_KEYMOD_CTRL
+    KEYMOD_ALT        = C.ALLEGRO_KEYMOD_ALT
+    KEYMOD_LWIN       = C.ALLEGRO_KEYMOD_LWIN
+    KEYMOD_RWIN       = C.ALLEGRO_KEYMOD_RWIN
+    KEYMOD_MENU       = C.ALLEGRO_KEYMOD_MENU
+    KEYMOD_ALTGR      = C.ALLEGRO_KEYMOD_ALTGR
+    KEYMOD_COMMAND    = C.ALLEGRO_KEYMOD_COMMAND
+    KEYMOD_SCROLLLOCK = C.ALLEGRO_KEYMOD_SCROLLLOCK
+    KEYMOD_NUMLOCK    = C.ALLEGRO_KEYMOD_NUMLOCK
+    KEYMOD_CAPSLOCK   = C.ALLEGRO_KEYMOD_CAPSLOCK
+    KEYMOD_INALTSEQ   = C.ALLEGRO_KEYMOD_INALTSEQ
+    KEYMOD_ACCENT1    = C.ALLEGRO_KEYMOD_ACCENT1
+    KEYMOD_ACCENT2    = C.ALLEGRO_KEYMOD_ACCENT2
+    KEYMOD_ACCENT3    = C.ALLEGRO_KEYMOD_ACCENT3
+    KEYMOD_ACCENT4    = C.ALLEGRO_KEYMOD_ACCENT4
 )
-
-
-
-
-
-
-
-
-
-
-
-

src/algo/al/audio.go

@@ -0,0 +1,345 @@
+// audio
+package al
+
+/*
+#cgo pkg-config: allegro_audio-5
+#cgo CFLAGS: -I/usr/local/include
+#cgo linux LDFLAGS: -lc_nonshared
+#include <stdlib.h>
+#include <allegro5/allegro.h>
+#include <allegro5/allegro_audio.h>
+#include "helpers.h"
+*/
+import "C"
+import "runtime"
+
+// User event type emitted when a stream fragment is ready to be
+// refilled with more audio data.
+const (
+	EVENT_AUDIO_STREAM_FRAGMENT   = C.ALLEGRO_EVENT_AUDIO_STREAM_FRAGMENT
+	EVENT_AUDIO_STREAM_FINISHED   = C.ALLEGRO_EVENT_AUDIO_STREAM_FINISHED
+	EVENT_AUDIO_RECORDER_FRAGMENT = C.ALLEGRO_EVENT_AUDIO_RECORDER_FRAGMENT
+)
+
+// Converts wrapper Event pointer to C Allegro audio recorder event
+func (self *Event) AUDIO_RECORDER_EVENT() *C.ALLEGRO_AUDIO_RECORDER_EVENT {
+	return (*C.ALLEGRO_AUDIO_RECORDER_EVENT)(self.toPointer())
+}
+
+/*
+TODO?
+struct ALLEGRO_AUDIO_RECORDER_EVENT
+{
+   _AL_EVENT_HEADER(struct ALLEGRO_AUDIO_RECORDER)
+   struct ALLEGRO_USER_EVENT_DESCRIPTOR *__internal__descr;
+   void *buffer;
+   unsigned int samples;
+};
+*/
+
+type AudioDepth int
+
+const (
+	AUDIO_DEPTH_INT8     AudioDepth = C.ALLEGRO_AUDIO_DEPTH_INT8
+	AUDIO_DEPTH_INT16    AudioDepth = C.ALLEGRO_AUDIO_DEPTH_INT16
+	AUDIO_DEPTH_INT24    AudioDepth = C.ALLEGRO_AUDIO_DEPTH_INT24
+	AUDIO_DEPTH_UINT8    AudioDepth = C.ALLEGRO_AUDIO_DEPTH_UINT8
+	AUDIO_DEPTH_UINT16   AudioDepth = C.ALLEGRO_AUDIO_DEPTH_UINT16
+	AUDIO_DEPTH_UINT24   AudioDepth = C.ALLEGRO_AUDIO_DEPTH_UINT24
+	AUDIO_DEPTH_FLOAT32  AudioDepth = C.ALLEGRO_AUDIO_DEPTH_FLOAT32
+	AUDIO_DEPTH_UNSIGNED AudioDepth = C.ALLEGRO_AUDIO_DEPTH_UNSIGNED
+)
+
+/*
+   Speaker configuration (mono, stereo, 2.1, 3, etc). With regards to
+   * behavior, most of this code makes no distinction between, say, 4.1 and
+   * 5 speaker setups.. they both have 5 "channels". However, users would
+   * like the distinction, and later when the higher-level stuff is added,
+   * the differences will become more important. (v>>4)+(v&0xF) should yield
+   * the total channel count.
+*/
+
+type ChannelConf int
+
+const (
+	CHANNEL_CONF_1   ChannelConf = C.ALLEGRO_CHANNEL_CONF_1
+	CHANNEL_CONF_2   ChannelConf = C.ALLEGRO_CHANNEL_CONF_2
+	CHANNEL_CONF_3   ChannelConf = C.ALLEGRO_CHANNEL_CONF_3
+	CHANNEL_CONF_4   ChannelConf = C.ALLEGRO_CHANNEL_CONF_4
+	CHANNEL_CONF_5_1 ChannelConf = C.ALLEGRO_CHANNEL_CONF_5_1
+	CHANNEL_CONF_6_1 ChannelConf = C.ALLEGRO_CHANNEL_CONF_6_1
+	CHANNEL_CONF_7_1 ChannelConf = C.ALLEGRO_CHANNEL_CONF_7_1
+	MAX_CHANNELS     ChannelConf = C.ALLEGRO_MAX_CHANNELS
+)
+
+type PlayMode int
+
+const (
+	PLAYMODE_ONCE  PlayMode = C.ALLEGRO_PLAYMODE_ONCE
+	PLAYMODE_LOOP  PlayMode = C.ALLEGRO_PLAYMODE_LOOP
+	PLAYMODE_BIDIR PlayMode = C.ALLEGRO_PLAYMODE_BIDIR
+)
+
+type MixerQuality int
+
+const (
+	MIXER_QUALITY_POINT  MixerQuality = C.ALLEGRO_MIXER_QUALITY_POINT
+	MIXER_QUALITY_LINEAR MixerQuality = C.ALLEGRO_MIXER_QUALITY_LINEAR
+	MIXER_QUALITY_CUBIC  MixerQuality = C.ALLEGRO_MIXER_QUALITY_CUBIC
+)
+
+const AUDIO_PAN_NONE = -1000.0
+
+type AudioEventType int
+
+const (
+	ALLEGRO_EVENT_AUDIO_ROUTE_CHANGE = C.ALLEGRO_EVENT_AUDIO_ROUTE_CHANGE
+	EVENT_AUDIO_INTERRUPTION         = C.ALLEGRO_EVENT_AUDIO_INTERRUPTION
+	EVENT_AUDIO_END_INTERRUPTION     = C.ALLEGRO_EVENT_AUDIO_END_INTERRUPTION
+)
+
+type Sample struct {
+	handle *C.ALLEGRO_SAMPLE
+}
+
+type SampleId C.ALLEGRO_SAMPLE_ID
+
+type SampleInstance struct {
+	handle *C.ALLEGRO_SAMPLE_INSTANCE
+}
+
+type AudioStream C.ALLEGRO_AUDIO_STREAM
+type Mixer C.ALLEGRO_MIXER
+type Voice C.ALLEGRO_VOICE
+type AudioRecorder C.ALLEGRO_AUDIO_RECORDER
+
+func (self *Sample) toC() *C.ALLEGRO_SAMPLE {
+	return (*C.ALLEGRO_SAMPLE)(self.handle)
+}
+
+func (self *Sample) Destroy() {
+	C.al_destroy_sample(self.toC())
+}
+
+func wrapSampleRaw(sample *C.ALLEGRO_SAMPLE) *Sample {
+	if sample == nil {
+		return nil
+	}
+	return &Sample{sample}
+}
+
+func wrapSample(sample *C.ALLEGRO_SAMPLE) *Sample {
+	self := wrapSampleRaw(sample)
+	if self != nil {
+		runtime.SetFinalizer(self, func(me *Sample) { me.Destroy() })
+	}
+	return self
+}
+
+/*
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE *, al_create_sample, (void *buf,
+      unsigned int samples, unsigned int freq, AudioDepth depth,
+      ALLEGRO_CHANNEL_CONF chan_conf, bool free_buf));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_sample, (ALLEGRO_SAMPLE *spl));
+
+
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE_INSTANCE*, al_create_sample_instance, (
+      ALLEGRO_SAMPLE *data));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_sample_instance, (
+      ALLEGRO_SAMPLE_INSTANCE *spl));
+
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_frequency, (const ALLEGRO_SAMPLE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_length, (const ALLEGRO_SAMPLE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_sample_depth, (const ALLEGRO_SAMPLE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_sample_channels, (const ALLEGRO_SAMPLE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(void *, al_get_sample_data, (const ALLEGRO_SAMPLE *spl));
+
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_instance_frequency, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_instance_length, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_instance_position, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+
+ALLEGRO_KCM_AUDIO_FUNC(float, al_get_sample_instance_speed, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(float, al_get_sample_instance_gain, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(float, al_get_sample_instance_pan, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(float, al_get_sample_instance_time, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_sample_instance_depth, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_sample_instance_channels, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_PLAYMODE, al_get_sample_instance_playmode, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_sample_instance_playing, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_sample_instance_attached, (const ALLEGRO_SAMPLE_INSTANCE *spl));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_position, (ALLEGRO_SAMPLE_INSTANCE *spl, unsigned int val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_length, (ALLEGRO_SAMPLE_INSTANCE *spl, unsigned int val));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_speed, (ALLEGRO_SAMPLE_INSTANCE *spl, float val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_gain, (ALLEGRO_SAMPLE_INSTANCE *spl, float val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_pan, (ALLEGRO_SAMPLE_INSTANCE *spl, float val));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_playmode, (ALLEGRO_SAMPLE_INSTANCE *spl, ALLEGRO_PLAYMODE val));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_playing, (ALLEGRO_SAMPLE_INSTANCE *spl, bool val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_detach_sample_instance, (ALLEGRO_SAMPLE_INSTANCE *spl));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample, (ALLEGRO_SAMPLE_INSTANCE *spl, ALLEGRO_SAMPLE *data));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE *, al_get_sample, (ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_play_sample_instance, (ALLEGRO_SAMPLE_INSTANCE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_stop_sample_instance, (ALLEGRO_SAMPLE_INSTANCE *spl));
+
+
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_STREAM*, al_create_audio_stream, (size_t buffer_count,
+      unsigned int samples, unsigned int freq,
+      AudioDepth depth, ALLEGRO_CHANNEL_CONF chan_conf));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_audio_stream, (ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_drain_audio_stream, (ALLEGRO_AUDIO_STREAM *stream));
+
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_audio_stream_frequency, (const ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_audio_stream_length, (const ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_audio_stream_fragments, (const ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_available_audio_stream_fragments, (const ALLEGRO_AUDIO_STREAM *stream));
+
+ALLEGRO_KCM_AUDIO_FUNC(float, al_get_audio_stream_speed, (const ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(float, al_get_audio_stream_gain, (const ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(float, al_get_audio_stream_pan, (const ALLEGRO_AUDIO_STREAM *stream));
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_audio_stream_channels, (const ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_audio_stream_depth, (const ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_PLAYMODE, al_get_audio_stream_playmode, (const ALLEGRO_AUDIO_STREAM *stream));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_audio_stream_playing, (const ALLEGRO_AUDIO_STREAM *spl));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_audio_stream_attached, (const ALLEGRO_AUDIO_STREAM *spl));
+
+ALLEGRO_KCM_AUDIO_FUNC(void *, al_get_audio_stream_fragment, (const ALLEGRO_AUDIO_STREAM *stream));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_speed, (ALLEGRO_AUDIO_STREAM *stream, float val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_gain, (ALLEGRO_AUDIO_STREAM *stream, float val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_pan, (ALLEGRO_AUDIO_STREAM *stream, float val));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_playmode, (ALLEGRO_AUDIO_STREAM *stream, ALLEGRO_PLAYMODE val));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_playing, (ALLEGRO_AUDIO_STREAM *stream, bool val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_detach_audio_stream, (ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_fragment, (ALLEGRO_AUDIO_STREAM *stream, void *val));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_rewind_audio_stream, (ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_seek_audio_stream_secs, (ALLEGRO_AUDIO_STREAM *stream, double time));
+ALLEGRO_KCM_AUDIO_FUNC(double, al_get_audio_stream_position_secs, (ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(double, al_get_audio_stream_length_secs, (ALLEGRO_AUDIO_STREAM *stream));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_loop_secs, (ALLEGRO_AUDIO_STREAM *stream, double start, double end));
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_EVENT_SOURCE *, al_get_audio_stream_event_source, (ALLEGRO_AUDIO_STREAM *stream));
+
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_MIXER*, al_create_mixer, (unsigned int freq,
+      AudioDepth depth, ALLEGRO_CHANNEL_CONF chan_conf));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_mixer, (ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_sample_instance_to_mixer, (
+   ALLEGRO_SAMPLE_INSTANCE *stream, ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_audio_stream_to_mixer, (ALLEGRO_AUDIO_STREAM *stream,
+   ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_mixer_to_mixer, (ALLEGRO_MIXER *stream,
+   ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_postprocess_callback, (
+      ALLEGRO_MIXER *mixer,
+      void (*cb)(void *buf, unsigned int samples, void *data),
+      void *data));
+
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_mixer_frequency, (const ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_mixer_channels, (const ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_mixer_depth, (const ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_MIXER_QUALITY, al_get_mixer_quality, (const ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(float, al_get_mixer_gain, (const ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_mixer_playing, (const ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_mixer_attached, (const ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_frequency, (ALLEGRO_MIXER *mixer, unsigned int val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_quality, (ALLEGRO_MIXER *mixer, ALLEGRO_MIXER_QUALITY val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_gain, (ALLEGRO_MIXER *mixer, float gain));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_playing, (ALLEGRO_MIXER *mixer, bool val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_detach_mixer, (ALLEGRO_MIXER *mixer));
+
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_VOICE*, al_create_voice, (unsigned int freq,
+      AudioDepth depth,
+      ALLEGRO_CHANNEL_CONF chan_conf));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_voice, (ALLEGRO_VOICE *voice));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_sample_instance_to_voice, (
+   ALLEGRO_SAMPLE_INSTANCE *stream, ALLEGRO_VOICE *voice));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_audio_stream_to_voice, (
+   ALLEGRO_AUDIO_STREAM *stream, ALLEGRO_VOICE *voice ));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_mixer_to_voice, (ALLEGRO_MIXER *mixer,
+   ALLEGRO_VOICE *voice));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_detach_voice, (ALLEGRO_VOICE *voice));
+
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_voice_frequency, (const ALLEGRO_VOICE *voice));
+ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_voice_position, (const ALLEGRO_VOICE *voice));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_voice_channels, (const ALLEGRO_VOICE *voice));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_voice_depth, (const ALLEGRO_VOICE *voice));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_voice_playing, (const ALLEGRO_VOICE *voice));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_voice_position, (ALLEGRO_VOICE *voice, unsigned int val));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_voice_playing, (ALLEGRO_VOICE *voice, bool val));
+
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_install_audio, (void));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_uninstall_audio, (void));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_is_audio_installed, (void));
+ALLEGRO_KCM_AUDIO_FUNC(uint32_t, al_get_allegro_audio_version, (void));
+
+ALLEGRO_KCM_AUDIO_FUNC(size_t, al_get_channel_count, (ALLEGRO_CHANNEL_CONF conf));
+ALLEGRO_KCM_AUDIO_FUNC(size_t, al_get_audio_depth_size, (ALLEGRO_AUDIO_DEPTH conf));
+
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_reserve_samples, (int reserve_samples));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_MIXER *, al_get_default_mixer, (void));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_default_mixer, (ALLEGRO_MIXER *mixer));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_restore_default_mixer, (void));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_play_sample, (ALLEGRO_SAMPLE *data,
+      float gain, float pan, float speed, ALLEGRO_PLAYMODE loop, ALLEGRO_SAMPLE_ID *ret_id));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_stop_sample, (ALLEGRO_SAMPLE_ID *spl_id));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_stop_samples, (void));
+
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_sample_loader, (const char *ext,
+	ALLEGRO_SAMPLE *(*loader)(const char *filename)));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_sample_saver, (const char *ext,
+	bool (*saver)(const char *filename, ALLEGRO_SAMPLE *spl)));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_audio_stream_loader, (const char *ext,
+	ALLEGRO_AUDIO_STREAM *(*stream_loader)(const char *filename,
+	    size_t buffer_count, unsigned int samples)));
+
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_sample_loader_f, (const char *ext,
+	ALLEGRO_SAMPLE *(*loader)(ALLEGRO_FILE *fp)));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_sample_saver_f, (const char *ext,
+	bool (*saver)(ALLEGRO_FILE *fp, ALLEGRO_SAMPLE *spl)));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_audio_stream_loader_f, (const char *ext,
+	ALLEGRO_AUDIO_STREAM *(*stream_loader)(ALLEGRO_FILE *fp,
+	    size_t buffer_count, unsigned int samples)));
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE *, al_load_sample, (const char *filename));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_save_sample, (const char *filename,
+	ALLEGRO_SAMPLE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_STREAM *, al_load_audio_stream, (const char *filename,
+	size_t buffer_count, unsigned int samples));
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE *, al_load_sample_f, (ALLEGRO_FILE* fp, const char *ident));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_save_sample_f, (ALLEGRO_FILE* fp, const char *ident,
+	ALLEGRO_SAMPLE *spl));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_STREAM *, al_load_audio_stream_f, (ALLEGRO_FILE* fp, const char *ident,
+	size_t buffer_count, unsigned int samples));
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_EVENT_SOURCE *, al_get_audio_event_source, (void));
+
+
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_RECORDER *, al_create_audio_recorder, (size_t fragment_count,
+   unsigned int samples, unsigned int freq, AudioDepth depth, ALLEGRO_CHANNEL_CONF chan_conf));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_start_audio_recorder, (ALLEGRO_AUDIO_RECORDER *r));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_stop_audio_recorder, (ALLEGRO_AUDIO_RECORDER *r));
+ALLEGRO_KCM_AUDIO_FUNC(bool, al_is_audio_recorder_recording, (ALLEGRO_AUDIO_RECORDER *r));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_EVENT_SOURCE *, al_get_audio_recorder_event_source,
+   (ALLEGRO_AUDIO_RECORDER *r));
+ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_RECORDER_EVENT *, al_get_audio_recorder_event, (ALLEGRO_EVENT *event));
+ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_audio_recorder, (ALLEGRO_AUDIO_RECORDER *r));
+*/

src/algo/al/helpers.c

@@ -0,0 +1 @@
+