sdl2_ffi 0.0.3 → 0.0.4

data/lib/enumerable_constants.rb

@@ -0,0 +1,82 @@
+require 'ffi'
+# This module adds a couple static-scope routines to
+# any module that includes it, allowing them to enumerate
+# the constants they define.  Please help me make it better
+#
+# An example:
+#     module MyEnumeration
+#       include EnumerableConstants
+#       MY_FIRST_CONSTANT = next_const_value # defaults to 0
+#       MY_NEXT_CONSTANT = next_const_value # will be 1
+#       MY_THIRD_CONSTANT = next_const_value # will be 2, and the next would be 3 unless
+#       MY_FOURTH_CONSTANT = 100 # you assign a value.
+#       MY_FIFTH_CONSTANT = next_const_value # will be 101
+#       MY_SIXTH_CONSTANT = MY_THIRD_CONSTANT # There are no rules against duplicate values.
+#       MY_SEVENTH_CONSTANT = next_const_value # will be 3, be careful you don't unintentionally reuse values.
+#     end
+#
+# With this module, you can:
+#
+#     MyEnumeration.by_name #=> {:MY_FIRST_CONSTANT=>0,:MY_NEXT_CONSTANT=>1,:MY_...}
+#
+# This is actually a standard function, nothing I added:
+#
+#     MyEnumeration.constants #=> [:MY_FIRST_CONSTANT,:MY_SECOND_CONSTANT]
+#
+# Get the last value defined:
+#
+#     MyEnumeration.last_const_value #=> 3, based on the example above.
+#
+# Get the next logical value, assuming the last value responds to .next,
+# Otherwise, there will likely be an error.
+# Note: This routine has no effect without assignment to a constant
+# within this EnumerableConstants module/class. i.e.
+#
+#     MyEnumeration::MY_EIGTH_CONSTANT = MyEnumeration.next_const_value # 4
+#
+# However, successive calls to just `#next_const_value` will just result in
+# the same value.
+#     MyEnumeration.next_const_value # 5
+#     MyEnumeration.next_const_value # 5
+module EnumerableConstants
+
+  # This is the method that injects the new static-scope routines.
+  def self.included(base)
+    base.module_eval do
+
+      ##
+      # Return the defined constants in a hash keyed by name.
+      def self.by_name
+        result = {}
+        self.constants.each do |constant|
+          result[constant] = self.const_get(constant)
+        end
+        return result
+      end
+      
+      # This routine returns a flattened array of alternating symbols and values.
+      # The symbols are the CONSTANT names and values are the values defined by that constant.
+      def self.flatten_consts
+        by_name.to_a.flatten
+      end
+
+      ##
+      # Get the last defined value.
+      def self.last_const_value
+        if self.constants.empty?
+          return 0
+        else
+          return self.const_get(self.constants.last)
+        end
+      end
+
+      ##
+      # Get the next value in order.
+      def self.next_const_value
+        last_const_value.next
+      end
+
+    end
+  end
+
+end

data/lib/sdl2.rb

@@ -1,101 +1,13 @@
-require 'ffi'
 require 'sdl2/sdl_module'
 require 'active_support/inflector'
-
-# libSDL2's interface
+require 'enumerable_constants'
+require 'sdl2/stdinc'
+# libSDL2's prototypes are attached directly to this module.
+#
 module SDL2
   extend FFI::Library
-  ffi_lib SDL_MODULE
-
-  [:int, :uint8, :int8, :uint16, :int16, :uint32, :int32, :uint64, :int64, :float, :double].each do |type|
-    typedef :pointer, "p_#{type}".to_sym
-  end
-
-  #Filter Proc, True when arg equals zero
-  TRUE_WHEN_ZERO = Proc.new do |result|
-    result == 0
-  end
-
-  # Filter Proc, True when arg not null?
-  TRUE_WHEN_NOT_NULL = Proc.new do |result|
-    (!result.null?)
-  end
-
-  # This converts the SDL Function Prototype name "SDL_XxxYyyyyZzz" to ruby's
-  # "xxx_yyyy_zzz" convetion
-  def self.api(func_name, args, type, options = {})
-
-    options = {
-      :error => false,
-      :filter => TRUE_WHEN_ZERO
-    }.merge(options)
-
-    camelCaseName = func_name.to_s.gsub('SDL_','')
-    methodName = ActiveSupport::Inflector.underscore(camelCaseName).to_sym
-
-    self.attach_function methodName, func_name, args, type
-
-    if options[:error]
-      returns_error(methodName, options[:filter])
-    end
-
-    if type == :bool
-      boolean?(methodName)
-    end
-
-    return methodName
-  end
-
-  # Returns the 'singleton class' so we can define class-level methods on the
-  # fly.
-  # There may be a better place to put this.
-  def self.metaclass
-
-    class << self; self; end
-  end
-
-  # Generates an alternative version of methodName that will raise a SDL Error
-  # when the return value fails the filter test.  The alternative version has
-  # the same name, but with an exclamation mark ("!") at the end, indicating the
-  # danger.
-  def self.returns_error(methodName, filter)
-    metaclass.instance_eval do
-      define_method "#{methodName}!".to_sym do |*args|
-        result = self.send(methodName, *args)
-        raise_error_unless filter.call(result)
-        result
-      end
-    end
-  end
-
-  # Generates an alternative version of methodName that will return Ruby's `true`
-  # if the method named returns SDL_true/:true enum value.  The alternative
-  # method has the same name with a question mark ("?") appended, to indicate its
-  # boolean nature.
-  def self.boolean?(methodName)
-    metaclass.instance_eval do
-      define_method("#{methodName}?".to_sym) do |*args|
-        self.send(methodName, *args) == :true
-      end
-    end
-  end
-
-  # Define a four character code as a Uint32
-  #MACRO: SDL_FOURCC(A, B, C, D) \
-  #    ((SDL_static_cast(Uint32, SDL_static_cast(Uint8, (A))) << 0) | \
-  #     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (B))) << 8) | \
-  #     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (C))) << 16) | \
-  #     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (D))) << 24))
-  def self.fourcc(*args)
-    bit_cnt = 0
-    result = 0
-    args.each do |arg|
-      arg = arg.codepoints[0] if arg.kind_of? String
-      result = result | (arg << bit_cnt)
-      bit_cnt += 8
-    end
-    return result
-  end
+  extend Library
+  ffi_lib SDL_MODULE  
 
   # FFI::Struct class with some useful additions.
   class Struct < FFI::Struct
@@ -115,8 +27,37 @@ module SDL2
       pointer.free
     end
 
+    # Define a set of member readers
+    # Ex1: `member_readers [:one, :two, :three]`
+    # Ex2: `member_readers *members`
+    def self.member_readers(*members_to_define)
+      #self.class_eval do
+      members_to_define.each do |member|
+        define_method member do
+          [member]
+        end
+      end
+      #end
+    end
+
+    # Define a set of member writers
+  	# Ex1: `member_writers [:one, :two, :three]`
+	  # Ex2: `member_writers *members`
+    def self.member_writers(*members_to_define)
+      members_to_define.each do |member|
+        define_method "#{member}=".to_sym do |value|
+          self[member]= value
+        end
+      end
+    end
+
     # A human-readable representation of the struct and it's values.
     def inspect
+      return 'nil' if self.null?
+
+      #binding.pry
+      #return self.to_s
+
       report = "struct #{self.class.to_s}{"
       report += self.class.members.collect do |field|
         "#{field}->#{self[field].inspect}"
@@ -147,34 +88,18 @@ module SDL2
 
   end
 
-  # SDL_Bool: SDL's TRUE/FALSE enumeration.
-  # Ruby does not automatically evaluate 0 as false.
-  enum :bool, [:false, 0, :true, 1]
-
-  # Raise the current error value as a RuntimeException
-  def self.raise_error
-    raise "SDL Error: #{SDL2.get_error()}"
-  end
-
-  # Conditionally raise an error, unless true
-  def self.raise_error_unless(condition)
-    raise_error unless condition
-  end
-
-  # Conditionally raise an error, unless false
-  def self.raise_error_if(condition)
-    raise_error if condition
-  end
   
+
   class TypedPointer < Struct
+
     def self.type(kind)
       layout :value, kind
     end
-    
+
     def value
       self[value]
     end
-    
+
     alias_method :deref, :value
   end
 
@@ -189,19 +114,19 @@ module SDL2
     type :int
   end
 
-  # 
+  #
   class UInt16Struct < TypedPointer
     type :uint16
   end
 
-  class UInt32Struct < TypedPointer 
+  class UInt32Struct < TypedPointer
     type :uint32
   end
 
   class UInt8Struct < TypedPointer
     type :uint8
   end
-
+  
   # TODO: Review if this is the best place to put it.
   # BlendMode is defined in a header file that is always included, so I'm
   # defineing again here.
@@ -222,3 +147,35 @@ module SDL2
   typedef :int, :count
 
 end
+
+
+require 'sdl2/init'
+
+#TODO: require 'sdl2/assert'
+#TODO: require 'sdl2/atomic'
+require 'sdl2/audio'
+require 'sdl2/clipboard'
+require 'sdl2/cpuinfo'
+
+#TODO: require 'sdl2/endian'
+require 'sdl2/error'
+require 'sdl2/events'
+require 'sdl2/joystick'
+require 'sdl2/gamecontroller'
+require 'sdl2/haptic'
+require 'sdl2/hints'
+
+#TODO?: require 'sdl2/loadso'
+require 'sdl2/log'
+
+#TODO: require 'sdl2/messagebox'
+#TODO: require 'sdl2/mutex'
+require 'sdl2/power'
+require 'sdl2/render'
+require 'sdl2/rwops'
+
+#TODO: require 'sdl2/system'
+#TODO: require 'sdl2/thread'
+require 'sdl2/timer'
+require 'sdl2/version'
+require 'sdl2/video'

data/lib/sdl2/audio.rb

@@ -1,17 +1,20 @@
 require 'sdl2'
-require 'yinum'
+require 'sdl2/rwops'
+
 
 module SDL2
 
   typedef :uint16, :audio_format
 
   module Audio
-    Mask = Enum.new(:AudioMask, {
-      BITSIZE: (0xFF),
-      DATATYPE: (1<<8),
-      ENDIAN: (1<<12),
-      SIGNED: (1<<15)
-    })
+    module MASK
+      include EnumerableConstants
+      
+      BITSIZE= (0xFF)
+      DATATYPE= (1<<8)
+      ENDIAN= (1<<12)
+      SIGNED= (1<<15)
+    end
 
     def self.bitsize(x)
       x & Mask.BITSIZE

data/lib/sdl2/clipboard.rb

@@ -5,15 +5,15 @@ module SDL2
   module Clipboard
 
     def self.has
-      SDL2.has_clipboard_text()
+      SDL2.has_clipboard_text
     end
 
     def self.has?
-      SDL2.has_clipboard_text == :true
+      SDL2.has_clipboard_text?
     end
 
     def self.get
-      SDL2.get_clipboard_text()
+      SDL2.get_clipboard_text
     end
 
     def self.set(text)

data/lib/sdl2/events.rb

@@ -7,78 +7,84 @@ require 'sdl2/joystick'
 require 'sdl2/gamecontroller'
 require 'sdl2/gesture'
 require 'sdl2/touch'
+require 'sdl2/syswm/msg'
 
 module SDL2
-  
+
   RELEASED = 0
   PRESSED = 1
-  
-  enum :event_type, [
-    :firstEvent, 0,
-      
-    :quit, 0x100,
-    :app_terminating,
-    :app_lowMemory,
-    :app_willEnterBackground,
-    :app_didEnterBackground,
-    :app_willEnterForeground,
-    :app_didEnterForeground,
-    
-    :windowEvent, 0x200,
-    :syswmEvent,
-    
-    :keyDown, 0x300,
-    :keyUp,
-    :textEditing,
-    :textInput,
-    
-    :mouseMotion, 0x400,
-    :mouseButtonDown,
-    :mouseButtonUp, 
-    :mouseWheel,
-    
-    :joyAxisMotion, 0x600,
-    :joyBallMotion,
-    :joyHatMotion,
-    :joyButtonDown,
-    :joyButtonUp,
-    :joyDeviceAdded,
-    :joyDeviceRemoved,
-    
-    :controllerAxisMotion, 0x650,
-    :controllerButtonDown, 
-    :controllerButtonUp,
-    :controllerDeviceAdded,
-    :controllerDeviceRemoved,
-    :controllerDeviceRemapped,
-    
-    :fingerDown, 0x700,
-    :fingerUp, 
-    :fingerMotion,
-    
-    :dollarGesture, 0x800,
-    :dollarRecord, 
-    :dollarMultigesture,
-    
-    :clipboardUpdate, 0x900,
-      
-    :dropFile, 0x1000,
-      
-    :userEvent, 0x8000,
-      
-    :lastEvent, 0xFFFF
-    
-    ]
-  
-  COMMON_EVENT_LAYOUT = [:type, :uint32, :timestamp, :uint32]
-  
+
+  # The types of events that can be delivered
+  module EVENTTYPE
+    include EnumerableConstants
+    FIRSTEVENT     = 0
+
+    QUIT           = 0x100
+
+    APP_TERMINATING = next_const_value
+    APP_LOWMEMORY = next_const_value
+    APP_WILLENTERBACKGROUND = next_const_value
+    APP_DIDENTERBACKGROUND = next_const_value
+    APP_WILLENTERFOREGROUND = next_const_value
+    APP_DIDENTERFOREGROUND = next_const_value
+
+    WINDOWEVENT    = 0x200
+    SYSWMEVENT = next_const_value
+
+    KEYDOWN        = 0x300
+    KEYUP = next_const_value
+    TEXTEDITING = next_const_value
+    TEXTINPUT = next_const_value
+
+    MOUSEMOTION    = 0x400
+    MOUSEBUTTONDOWN = next_const_value
+    MOUSEBUTTONUP = next_const_value
+    MOUSEWHEEL = next_const_value
+
+    JOYAXISMOTION  = 0x600
+    JOYBALLMOTION = next_const_value
+    JOYHATMOTION = next_const_value
+    JOYBUTTONDOWN = next_const_value
+    JOYBUTTONUP = next_const_value
+    JOYDEVICEADDED = next_const_value
+    JOYDEVICEREMOVED = next_const_value
+
+    CONTROLLERAXISMOTION  = 0x650
+    CONTROLLERBUTTONDOWN = next_const_value
+    CONTROLLERBUTTONUP = next_const_value
+    CONTROLLERDEVICEADDED = next_const_value
+    CONTROLLERDEVICEREMOVED = next_const_value
+    CONTROLLERDEVICEREMAPPED = next_const_value
+
+    FINGERDOWN      = 0x700
+    FINGERUP = next_const_value
+    FINGERMOTION = next_const_value
+
+    DOLLARGESTURE   = 0x800
+    DOLLARRECORD = next_const_value
+    MULTIGESTURE = next_const_value
+
+    CLIPBOARDUPDATE = 0x900
+
+    DROPFILE        = 0x1000
+
+    USEREVENT    = 0x8000
+
+    LASTEVENT    = 0xFFFF
+  end
+
+  enum :event_type, EVENTTYPE.flatten_consts
+
+  # Fields shared by every event
   class CommonEvent < Struct
-    layout *COMMON_EVENT_LAYOUT
-    
+    LAYOUT = [:type, :uint32, :timestamp, :uint32]
+    layout *LAYOUT
+
   end
-  
+
+  # Window state change event data (event.window.*)
   class WindowEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :windowID, :uint32,
       :event, :uint8,
       :padding1, :uint8,
@@ -88,9 +94,10 @@ module SDL2
       :data2, :int32
     ]
   end
-  
+
+  # Keyboard button event structure (event.key.*)
   class KeyboardEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :windowID, :uint32,
       :state, :uint8,
       :repeat, :uint8,
@@ -99,27 +106,30 @@ module SDL2
       :keysym, Keysym
     ]
   end
-  
+
+  # Keyboard text editing event structure (event.edit.*)
   class TextEditingEvent < Struct
     TEXT_SIZE = 32 # Line 188
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :windowID, :uint32,
       :char, [:char, TEXT_SIZE],
       :start, :int32,
       :length, :int32
     ]
   end
-  
+
+  # Keyboard text input event structure (event.text.*)
   class TextInputEvent < Struct
     TEXT_SIZE = 32 # Line 203
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :windowID, :uint32,
-      :char, [:char, TEXT_SIZE]      
+      :char, [:char, TEXT_SIZE]
     ]
   end
-  
+
+  # Mouse motion event structure (event.motion.*)
   class MouseMotionEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :windowID, :uint32,
       :which, :uint32,
       :state, :uint32,
@@ -129,9 +139,10 @@ module SDL2
       :yrel, :int32
     ]
   end
-  
+
+  # Mouse button event structure (event.button.*)
   class MouseButtonEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :windowID, :uint32,
       :which, :uint32,
       :button, :uint8,
@@ -142,18 +153,20 @@ module SDL2
       :y, :int32
     ]
   end
-   
+
+  # Mouse wheel event structure (event.wheel.*)
   class MouseWheelEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :windowID, :uint32,
       :which, :uint32,
       :x, :int32,
       :y, :int32
-    ]  
+    ]
   end
-  
+
+  # Joystick axis motion event structure (event.jaxis.*)
   class JoyAxisEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :which, :joystick_id,
       :axis, :uint8,
       :padding1, :uint8,
@@ -163,9 +176,10 @@ module SDL2
       :padding4, :uint16
     ]
   end
-  
+
+  # Joystick trackball motion event structure (event.jball.*)
   class JoyBallEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :which, :joystick_id,
       :ball, :uint8,
       :padding1, :uint8,
@@ -175,19 +189,21 @@ module SDL2
       :yrel, :int16
     ]
   end
-  
+
+  # Joystick hat position change event structure (event.jhat.*)
   class JoyHatEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :which, :joystick_id,
       :hat, :uint8,
       :value, :uint8,
       :padding1, :uint8,
       :padding2, :uint8
-    ]    
+    ]
   end
-  
+
+  # Joystick button event structure (event.jbutton.*)
   class JoyButtonEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :which, :joystick_id,
       :button, :uint8,
       :state, :uint8,
@@ -195,15 +211,17 @@ module SDL2
       :padding2, :uint8
     ]
   end
-  
+
+  # Joystick device event structure (event.jdevice.*)
   class JoyDeviceEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :which, :joystick_id
-    ]    
+    ]
   end
-  
+
+  # Game controller axis motion event structure (event.caxis.*)
   class ControllerAxisEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :which, :joystick_id,
       :axis, :uint8,
       :padding1, :uint8,
@@ -213,25 +231,28 @@ module SDL2
       :padding4, :uint16
     ]
   end
-  
+
+  # Game controller button event structure (event.cbutton.*)
   class ControllerButtonEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :which, :joystick_id,
       :button, :uint8,
       :state, :uint8,
       :padding1, :uint8,
       :padding2, :uint8
-    ]    
+    ]
   end
-  
+
+  # Controller device event structure (event.cdevice.*)
   class ControllerDeviceEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :which, :joystick_id
     ]
   end
-  
+
+  # Touch finger event structure (event.tfinger.*)
   class TouchFingerEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :touchId, :touch_id,
       :fingerId, :finger_id,
       :x, :float,
@@ -241,9 +262,10 @@ module SDL2
       :pressure, :float
     ]
   end
-  
+
+  # Multiple Finger Gesture Event (event.mgesture.*)
   class MultiGestureEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :touchId, :touch_id,
       :dTheta, :float,
       :dDist, :float,
@@ -253,35 +275,43 @@ module SDL2
       :padding, :uint16
     ]
   end
-  
+
+  # Dollar Gesture Event (event.dgesture.*)
   class DollarGestureEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :touchId, :touch_id,
       :gestureId, :gesture_id,
       :numFingers, :uint32,
       :error, :float,
       :x, :float,
       :y, :float
-    ]    
+    ]
   end
-  
+
+  # @brief An event used to request a file open by the system (event.drop.*)
+  #        This event is disabled by default, you can enable it with
+  # SDL_EventState()
+  # @note If you enable this event, you must free the filename in the event.
+  #
   class DropEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :file, :string
-    ]    
+    ]
   end
-  
+
+  # The "quit requested" event
   class QuitEvent < Struct
-    layout *COMMON_EVENT_LAYOUT
+    layout *CommonEvent::LAYOUT
   end
-  
+
+  # OS Specific event
   class OSEvent < Struct
-    layout *COMMON_EVENT_LAYOUT
+    layout *CommonEvent::LAYOUT
   end
-  
-  
+
+  # A user-defined event type (event.user.*)
   class UserEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :windowID, :uint32,
       :code, :int32,
       :data1, :pointer,
@@ -289,70 +319,100 @@ module SDL2
     ]
   end
 
+  #  @brief A video driver dependent system event (event.syswm.*)
+  #         This event is disabled by default, you can enable it with
+  # SDL_EventState()
+  #
+  #  @note If you want to use this event, you should include SDL_syswm.h.
   class SysWMEvent < Struct
-    layout *COMMON_EVENT_LAYOUT + [
+    layout *CommonEvent::LAYOUT + [
       :msg, SDL2::SysWM::Msg.by_ref
     ]
-  end  
-  
+  end
+
+  # General event UNION (structure)
+  # Remember that this is a union, all other structures not related to #type are
+  # garbage
   class Event < FFI::Union
     layout :type, :uint32,
-      :common, CommonEvent,
-      :window, WindowEvent,
-      :key, KeyboardEvent,
-      :edit, TextEditingEvent,
-      :text, TextInputEvent,
-      :motion, MouseMotionEvent,
-      :button, MouseButtonEvent,
-      :wheel, MouseWheelEvent,
-      :jaxis, JoyAxisEvent,
-      :jball, JoyBallEvent,
-      :jbutton, JoyButtonEvent,
-      :jdevice, JoyDeviceEvent,
-      :caxis, ControllerAxisEvent,
-      :cbutton, ControllerButtonEvent,
-      :cdevice, ControllerDeviceEvent,
-      :quit, QuitEvent,
-      :user, UserEvent,
-      :syswm, SysWMEvent,
-      :tfinger, TouchFingerEvent,
-      :mgesture, MultiGestureEvent,
-      :drop, DropEvent,
-      :padding, [:uint8, 56] # From SDL_events.h:529
+    :common, CommonEvent,
+    :window, WindowEvent,
+    :key, KeyboardEvent,
+    :edit, TextEditingEvent,
+    :text, TextInputEvent,
+    :motion, MouseMotionEvent,
+    :button, MouseButtonEvent,
+    :wheel, MouseWheelEvent,
+    :jaxis, JoyAxisEvent,
+    :jball, JoyBallEvent,
+    :jbutton, JoyButtonEvent,
+    :jdevice, JoyDeviceEvent,
+    :caxis, ControllerAxisEvent,
+    :cbutton, ControllerButtonEvent,
+    :cdevice, ControllerDeviceEvent,
+    :quit, QuitEvent,
+    :user, UserEvent,
+    :syswm, SysWMEvent,
+    :tfinger, TouchFingerEvent,
+    :mgesture, MultiGestureEvent,
+    :drop, DropEvent,
+    :padding, [:uint8, 56] # From SDL_events.h:529
   end
-  
-  enum :eventaction, [:add, :peek, :get]
-    
-  attach_function :peep_events, :SDL_PeepEvents, [Event.by_ref, :count, :eventaction, :uint32, :uint32], :int
-  attach_function :has_event, :SDL_HasEvent, [:uint32], :bool
-  attach_function :has_events, :SDL_HasEvents, [:uint32, :uint32], :bool
-  attach_function :flush_event, :SDL_FlushEvent, [:uint32], :void
-  attach_function :flush_events, :SDL_FlushEvents, [:uint32, :uint32], :void
-  attach_function :poll_event, :SDL_PollEvent, [Event.by_ref], :int
-  attach_function :wait_event, :SDL_WaitEvent, [Event.by_ref], :int
-  attach_function :wait_event_timeout, :SDL_WaitEventTimeout, [Event.by_ref, :count], :int
-  attach_function :push_event, :SDL_PushEvent, [Event.by_ref, :count], :int
-  
+
+  module EVENTACTION
+    include EnumerableConstants
+    ADD = next_const_value
+    PEEK = next_const_value
+    GET = next_const_value
+  end
+
+  enum :eventaction, EVENTACTION.flatten_consts
+
+  ##
+  # :class-method: peep_events
+  api :SDL_PeepEvents, [Event.by_ref, :count, :eventaction, :uint32, :uint32], :int
+  api :SDL_HasEvent, [:uint32], :bool
+  api :SDL_HasEvents, [:uint32, :uint32], :bool
+  api :SDL_FlushEvent, [:uint32], :void
+  api :SDL_FlushEvents, [:uint32, :uint32], :void
+  api :SDL_PollEvent, [Event.by_ref], :int
+  api :SDL_WaitEvent, [Event.by_ref], :int
+  api :SDL_WaitEventTimeout, [Event.by_ref, :count], :int
+  api :SDL_PushEvent, [Event.by_ref, :count], :int
+
+  ##
+  # callback event_filter #=> Proc.new do |pointer, event|; return int; end
   callback :event_filter, [:pointer, Event.by_ref], :int
+
+  # This simple structure is used for getting the event filter
   class EventFilterStruct < Struct
     layout :callback, :event_filter
   end
+
+  api :SDL_SetEventFilter, [:event_filter, :pointer], :void
+  api :SDL_GetEventFilter, [:pointer, :pointer], :bool
+  api :SDL_AddEventWatch, [:event_filter, :pointer], :void
+  api :SDL_DelEventWatch, [:event_filter, :pointer], :void
+  api :SDL_FilterEvents, [:event_filter, :pointer], :void
+
+  # Enumeration of event_state query
+  module EVENTSTATE
+    include EnumerableConstants
+    QUERY = -1
+    IGNORE = 0
+    DISABLE = 0
+    ENABLE = 1
+  end
   
-  attach_function :set_event_filter, :SDL_SetEventFilter, [:event_filter, :pointer], :void
-  attach_function :get_event_filter, :SDL_GetEventFilter, [:pointer, :pointer], :bool
-  attach_function :add_event_watch, :SDL_AddEventWatch, [:event_filter, :pointer], :void
-  attach_function :del_event_watch, :SDL_DelEventWatch, [:event_filter, :pointer], :void
-  attach_function :filter_events, :SDL_FilterEvents, [:event_filter, :pointer], :void
-  
-  QUERY = -1
-  IGNORE = 0
-  DISABLE = 0
-  ENABLE = 1
-  
-  attach_function :event_state, :SDL_EventState, [:uint32, :int], :uint8
+  enum :event_state, EVENTSTATE.flatten_consts
+
+  ##
+  # 
+  api :SDL_EventState, [:uint32, :event_state], :uint8
+
   def get_event_state(type)
-    event_state(type, QUERY)
+    event_state(type, EVENTSTATE::QUERY)
   end
-  
-  attach_function :register_events, :SDL_RegisterEvents, [:count], :uint32  
+
+  api :SDL_RegisterEvents, [:count], :uint32
 end