diff --git a/allegro5/event.go b/allegro5/event.go
index 577f9c6..8aaf11f 100644
--- a/allegro5/event.go
+++ b/allegro5/event.go
@@ -4,137 +4,143 @@ package allegro5
 import "C"
 
 import (
-  "fmt"
-  "unsafe"
+	"fmt"
+	"unsafe"
 )
 
 type EventQueue struct {
-  queue *C.ALLEGRO_EVENT_QUEUE
+	queue *C.ALLEGRO_EVENT_QUEUE
 }
 
 type Event interface {
-  Stamp() float64
+	Stamp() float64
 }
 
 type EventBase struct {
-  stamp float64
+	stamp float64
 }
 
 func (eb EventBase) Stamp() float64 {
-  return eb.stamp
+	return eb.stamp
 }
 
 type DisplayCloseEvent struct {
-  EventBase
+	EventBase
 }
 
 type KeyEvent struct {
-  EventBase
-  KeyCode int
-  Display *Display
+	EventBase
+	KeyCode int
+	Display *Display
 }
 
 type KeyCharEvent struct {
-  KeyEvent
-  UnicodeCharacter rune
-  Modifiers uint
-  Repeat bool
+	KeyEvent
+	UnicodeCharacter rune
+	Modifiers        uint
+	Repeat           bool
 }
 
 type KeyDownEvent struct {
-  KeyEvent
+	KeyEvent
 }
 
 type KeyUpEvent struct {
-  KeyEvent
+	KeyEvent
 }
 
 type MouseButtonDownEvent struct {
-  MouseEvent
-  Button uint
-  Pressure float32
+	MouseEvent
+	Button   uint
+	Pressure float32
 }
 
 type MouseButtonUpEvent struct {
-  MouseEvent
-  Button uint
-  Pressure float32
+	MouseEvent
+	Button   uint
+	Pressure float32
 }
 
 type MouseEvent struct {
-  EventBase
-  X, Y    int
-  Z, W    int
-  Display *Display
+	EventBase
+	X, Y    int
+	Z, W    int
+	Display *Display
 }
 
 type MouseMoveEvent struct {
-  MouseEvent
-  DeltaX, DeltaY int
-  DeltaZ, DeltaW int
-  Pressure float32
+	MouseEvent
+	DeltaX, DeltaY int
+	DeltaZ, DeltaW int
+	Pressure       float32
 }
 
 func NewEventQueue() (*EventQueue, error) {
-  q := C.al_create_event_queue()
-  if nil == q {
-    return nil, fmt.Errorf("Unable to create event queue")
-  }
-  return &EventQueue{q}, nil
+	q := C.al_create_event_queue()
+	if nil == q {
+		return nil, fmt.Errorf("Unable to create event queue")
+	}
+	return &EventQueue{q}, nil
 }
 
 func (eq *EventQueue) register(source *C.ALLEGRO_EVENT_SOURCE) {
-  C.al_register_event_source(eq.queue, source)
+	C.al_register_event_source(eq.queue, source)
 }
 
 func (eq *EventQueue) RegisterDisplay(d *Display) {
-  eq.register(C.al_get_display_event_source(d.display))
+	eq.register(C.al_get_display_event_source(d.display))
 }
 
 func (eq *EventQueue) RegisterMouse() {
-  eq.register(C.al_get_mouse_event_source())  
+	eq.register(C.al_get_mouse_event_source())
 }
 
 func (eq *EventQueue) RegisterKeyboard() {
-  eq.register(C.al_get_keyboard_event_source())
+	eq.register(C.al_get_keyboard_event_source())
 }
 
 func (eq *EventQueue) mapEvent(e *C.ALLEGRO_EVENT) Event {
-  any := (*C.ALLEGRO_ANY_EVENT)(unsafe.Pointer(e))
-  eb := EventBase{float64(any.timestamp)}
-  switch any._type {
-    case C.ALLEGRO_EVENT_DISPLAY_CLOSE:
-      return &DisplayCloseEvent{EventBase{float64(any.timestamp)}}
-    case C.ALLEGRO_EVENT_MOUSE_AXES:
-      mouse := (*C.ALLEGRO_MOUSE_EVENT)(unsafe.Pointer(e))
-      return &MouseMoveEvent{MouseEvent{eb, int(mouse.x), int(mouse.y), int(mouse.z), int(mouse.w), nil}, int(mouse.dx), int(mouse.dy), int(mouse.dz), int(mouse.dw), float32(mouse.pressure)}
-    case C.ALLEGRO_EVENT_MOUSE_BUTTON_DOWN:
-      mouse := (*C.ALLEGRO_MOUSE_EVENT)(unsafe.Pointer(e))
-      return &MouseButtonDownEvent{MouseEvent{eb, int(mouse.x), int(mouse.y), int(mouse.z), int(mouse.w), nil}, uint(mouse.button), float32(mouse.pressure)}
-    case C.ALLEGRO_EVENT_MOUSE_BUTTON_UP:
-      mouse := (*C.ALLEGRO_MOUSE_EVENT)(unsafe.Pointer(e))
-      return &MouseButtonUpEvent{MouseEvent{eb, int(mouse.x), int(mouse.y), int(mouse.z), int(mouse.w), nil}, uint(mouse.button), float32(mouse.pressure)}
-    case C.ALLEGRO_EVENT_KEY_DOWN:
-      key := (*C.ALLEGRO_KEYBOARD_EVENT)(unsafe.Pointer(e))
-      return &KeyDownEvent{KeyEvent{eb, int(key.keycode), nil}}
-    case C.ALLEGRO_EVENT_KEY_UP:
-      key := (*C.ALLEGRO_KEYBOARD_EVENT)(unsafe.Pointer(e))
-      return &KeyUpEvent{KeyEvent{eb, int(key.keycode), nil}}
-    case C.ALLEGRO_EVENT_KEY_CHAR:
-      key := (*C.ALLEGRO_KEYBOARD_EVENT)(unsafe.Pointer(e))
-      return &KeyCharEvent{KeyEvent{eb, int(key.keycode), nil}, rune(key.unichar), uint(key.modifiers), bool(key.repeat)}
-  }
-  return nil
+	any := (*C.ALLEGRO_ANY_EVENT)(unsafe.Pointer(e))
+	eb := EventBase{float64(any.timestamp)}
+	switch any._type {
+	case C.ALLEGRO_EVENT_DISPLAY_CLOSE:
+		return &DisplayCloseEvent{EventBase{float64(any.timestamp)}}
+	case C.ALLEGRO_EVENT_MOUSE_AXES:
+		mouse := (*C.ALLEGRO_MOUSE_EVENT)(unsafe.Pointer(e))
+		return &MouseMoveEvent{MouseEvent{eb, int(mouse.x), int(mouse.y), int(mouse.z), int(mouse.w), nil}, int(mouse.dx), int(mouse.dy), int(mouse.dz), int(mouse.dw), float32(mouse.pressure)}
+	case C.ALLEGRO_EVENT_MOUSE_BUTTON_DOWN:
+		mouse := (*C.ALLEGRO_MOUSE_EVENT)(unsafe.Pointer(e))
+		return &MouseButtonDownEvent{MouseEvent{eb, int(mouse.x), int(mouse.y), int(mouse.z), int(mouse.w), nil}, uint(mouse.button), float32(mouse.pressure)}
+	case C.ALLEGRO_EVENT_MOUSE_BUTTON_UP:
+		mouse := (*C.ALLEGRO_MOUSE_EVENT)(unsafe.Pointer(e))
+		return &MouseButtonUpEvent{MouseEvent{eb, int(mouse.x), int(mouse.y), int(mouse.z), int(mouse.w), nil}, uint(mouse.button), float32(mouse.pressure)}
+	case C.ALLEGRO_EVENT_KEY_DOWN:
+		key := (*C.ALLEGRO_KEYBOARD_EVENT)(unsafe.Pointer(e))
+		return &KeyDownEvent{KeyEvent{eb, int(key.keycode), nil}}
+	case C.ALLEGRO_EVENT_KEY_UP:
+		key := (*C.ALLEGRO_KEYBOARD_EVENT)(unsafe.Pointer(e))
+		return &KeyUpEvent{KeyEvent{eb, int(key.keycode), nil}}
+	case C.ALLEGRO_EVENT_KEY_CHAR:
+		key := (*C.ALLEGRO_KEYBOARD_EVENT)(unsafe.Pointer(e))
+		return &KeyCharEvent{KeyEvent{eb, int(key.keycode), nil}, rune(key.unichar), uint(key.modifiers), bool(key.repeat)}
+	}
+	return nil
 }
 
 func (eq *EventQueue) Get() Event {
-  var event C.ALLEGRO_EVENT
-  if !bool(C.al_get_next_event(eq.queue, &event)) {
-    return nil
-  }
-  return eq.mapEvent(&event)
+	var event C.ALLEGRO_EVENT
+	if !bool(C.al_get_next_event(eq.queue, &event)) {
+		return nil
+	}
+	return eq.mapEvent(&event)
+}
+
+func (eq *EventQueue) GetWait() Event {
+	var event C.ALLEGRO_EVENT
+	C.al_wait_for_event(eq.queue, &event)
+	return eq.mapEvent(&event)
 }
 
 func (eq *EventQueue) Destroy() {
-  C.al_destroy_event_queue(eq.queue)
-}
\ No newline at end of file
+	C.al_destroy_event_queue(eq.queue)
+}