sdl2-win93 1.0.0

data/ext/sdl2_ext/clipboard.c

@@ -0,0 +1,61 @@
+#include "rubysdl2_internal.h"
+#include <SDL_clipboard.h>
+
+/*
+ * Document-module: SDL2::Clipboard
+ *
+ * This module has clipboard manipulating functions.
+ * 
+ */
+
+/*
+ * Get the text from the clipboard.
+ *
+ * @return [String] a string in the clipboard
+ * @return [nil] if the clipboard is empty
+ */ 
+static VALUE Clipboard_s_text(VALUE self)
+{
+    if (SDL_HasClipboardText()) {
+        char* text = SDL_GetClipboardText();
+        VALUE str;
+        if (!text)
+            SDL_ERROR();
+        str = utf8str_new_cstr(text);
+        SDL_free(text);
+        return str;
+    } else {
+        return Qnil;
+    }
+}
+
+/*
+ * @overload text=(text) 
+ *   Set the text in the clipboard.
+ *   
+ *   @param text [String] a new text
+ *   @return [String] text
+ */
+static VALUE Clipboard_s_set_text(VALUE self, VALUE text)
+{
+    HANDLE_ERROR(SDL_SetClipboardText(StringValueCStr(text)));
+    return text;
+}
+
+/*
+ * Return true if the clipboard has any text.
+ *
+ */
+static VALUE Clipboard_s_has_text_p(VALUE self)
+{
+    return INT2BOOL(SDL_HasClipboardText());
+}
+
+void rubysdl2_init_clipboard(void)
+{
+    VALUE mClipBoard = rb_define_module_under(mSDL2, "Clipboard");
+    
+    rb_define_module_function(mClipBoard, "text", Clipboard_s_text, 0);
+    rb_define_module_function(mClipBoard, "text=", Clipboard_s_set_text, 1);
+    rb_define_module_function(mClipBoard, "has_text?", Clipboard_s_has_text_p, 0);
+}

data/ext/sdl2_ext/color.c

@@ -0,0 +1,103 @@
+/*
+  PORTIONS OF THIS ARE BASED ON
+  https://raw.githubusercontent.com/wvanbergen/oily_png/master/ext/oily_png/color.{c,h}
+ 
+  Original Version Copyright (c) 2010-2014 Willem van Bergen
+
+  Permission is hereby granted, free of charge, to any person obtaining
+  a copy of this software and associated documentation files (the
+  "Software"), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include <math.h>
+#include "rubysdl2_internal.h"
+
+typedef uint32_t PIXEL; // Pixels use 32 bits unsigned integers
+typedef unsigned char BYTE; // Bytes use 8 bits unsigned integers
+
+#define R_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0xff000000) >> 24))
+#define G_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x00ff0000) >> 16))
+#define B_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x0000ff00) >> 8))
+#define A_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x000000ff)))
+
+#define BUILD_PIXEL(r, g, b, a)  (((PIXEL) (r) << 24) + ((PIXEL) (g) << 16) + ((PIXEL) (b) << 8) + (PIXEL) (a))
+
+VALUE Color_s_r(VALUE self, VALUE value) {
+  return INT2FIX(R_BYTE(NUM2UINT(value)));
+}
+
+VALUE Color_s_g(VALUE self, VALUE value) {
+  return INT2FIX(G_BYTE(NUM2UINT(value)));
+}
+
+VALUE Color_s_b(VALUE self, VALUE value) {
+  return INT2FIX(B_BYTE(NUM2UINT(value)));
+}
+
+VALUE Color_s_a(VALUE self, VALUE value) {
+  return INT2FIX(A_BYTE(NUM2UINT(value)));
+}
+
+VALUE Color_s_rgb(VALUE self, VALUE r, VALUE g, VALUE b) {
+  return UINT2NUM(BUILD_PIXEL(FIX2INT(r),
+                              FIX2INT(g),
+                              FIX2INT(b),
+                              0xFF));
+}
+
+VALUE Color_s_rgba(VALUE self, VALUE r, VALUE g, VALUE b, VALUE a) {
+  return UINT2NUM(BUILD_PIXEL(FIX2INT(r),
+                              FIX2INT(g),
+                              FIX2INT(b),
+                              FIX2INT(a)));
+}
+
+
+SDL_Color rubysdl2_Color_to_SDL_Color(VALUE rgba)
+{
+    SDL_Color color;
+    if (rgba == Qnil) {
+        color.r = color.g = color.b = 0; color.a = 255;
+        return color;
+    } else {
+      PIXEL pixel = NUM2UINT(rgba);
+      color.r = R_BYTE(pixel);
+      color.g = G_BYTE(pixel);
+      color.b = B_BYTE(pixel);
+      color.a = A_BYTE(pixel);
+      return color;
+    }
+
+}
+
+void rubysdl2_init_color(void) {
+  VALUE cColor = rb_define_module_under(mSDL2, "Color");
+  rb_define_singleton_method(cColor, "rgb", Color_s_rgb, 3);
+  rb_define_singleton_method(cColor, "rgba", Color_s_rgba, 4);
+  rb_define_singleton_method(cColor, "r", Color_s_r, 1);
+  rb_define_singleton_method(cColor, "g", Color_s_g, 1);
+  rb_define_singleton_method(cColor, "b", Color_s_b, 1);
+  rb_define_singleton_method(cColor, "a", Color_s_a, 1);
+
+  rb_define_const(cColor, "WHITE", UINT2NUM(0xFFFFFFFF));
+  rb_define_const(cColor, "BLACK", UINT2NUM(0x000000FF));
+  rb_define_const(cColor, "RED",   UINT2NUM(0xFF0000FF));
+  rb_define_const(cColor, "GREEN",   UINT2NUM(0x00FF00FF));
+  rb_define_const(cColor, "BLUE",   UINT2NUM(0x0000FFFF));
+}
+

data/ext/sdl2_ext/color.h

@@ -0,0 +1,4 @@
+#pragma once
+#include <SDL_pixels.h>
+
+

data/ext/sdl2_ext/event.c

@@ -0,0 +1,1298 @@
+#include "rubysdl2_internal.h"
+#include <SDL_events.h>
+#include <SDL_version.h>
+
+static VALUE cEvent;
+static VALUE cEvQuit;
+static VALUE cEvWindow;
+static VALUE cEvSysWM;
+static VALUE cEvKeyboard;
+static VALUE cEvKeyDown;
+static VALUE cEvKeyUp;
+static VALUE cEvTextEditing;
+static VALUE cEvTextInput;
+static VALUE cEvMouseButton;
+static VALUE cEvMouseButtonDown;
+static VALUE cEvMouseButtonUp;
+static VALUE cEvMouseMotion;
+static VALUE cEvMouseWheel;
+static VALUE cEvJoyAxisMotion;
+static VALUE cEvJoyBallMotion;
+static VALUE cEvJoyButton;
+static VALUE cEvJoyButtonDown;
+static VALUE cEvJoyButtonUp;
+static VALUE cEvJoyHatMotion;
+static VALUE cEvJoyDevice;
+static VALUE cEvJoyDeviceAdded;
+static VALUE cEvJoyDeviceRemoved;
+static VALUE cEvControllerAxisMotion;
+static VALUE cEvControllerButton;
+static VALUE cEvControllerButtonDown;
+static VALUE cEvControllerButtonUp;
+static VALUE cEvControllerDevice;
+static VALUE cEvControllerDeviceAdded;
+static VALUE cEvControllerDeviceRemoved;
+static VALUE cEvControllerDeviceRemapped;
+static VALUE cEvTouchFinger;
+static VALUE cEvFingerDown;
+static VALUE cEvFingerUp;
+static VALUE cEvFingerMotion;
+static VALUE cEvMultigesture;
+/* static VALUE cEvUser; */
+/* static VALUE cEvDrop; */
+
+/* TODO:
+   - easy
+   SDL_FlushEvent{,s}
+   SDL_HasEvent{,s}
+   SDL_PumpEvent
+   SDL_PeepEvents
+   SDL_DropEvent
+   SDL_QuitRequested
+   - difficult
+   SDL_PushEvent
+   SDL_WaitEvent{,Timeout}
+   SDL_UserEvent, SDL_RegisterEvents
+ */
+
+static VALUE event_type_to_class[SDL_LASTEVENT];
+
+/*
+ * Document-class: SDL2::Event
+ *
+ * This class represents SDL's events.
+ *
+ * All events are represented by the instance of subclasses of this class.
+ *
+ * # Introduction of event subsystem
+ * Event handling allows your application to receive input from the user. Event handling is
+ * initialized (along with video) with a call to:
+ *
+ *     SDL2.init(SDL2::INIT_VIDEO|SDL2::INIT_EVENTS)
+ *
+ * Internally, SDL stores all the events waiting to be handled in an event queue.
+ * Using methods like {SDL2::Event.poll}, you can observe and handle input events.
+ *
+ * The queue is conceptually a sequence of objects of SDL2::Event.
+ * You can read an event from the queue with {SDL2::Event.poll} and
+ * you can process the information from the object.
+ * 
+ * Note: peep and wait will be implemented later.
+ *
+ * @attribute [rw] type
+ *   SDL's internal event type enum
+ *   @return [Integer] 
+ *
+ * @attribute [rw] timestamp
+ *   timestamp of the event
+ *   @return [Integer] 
+ */
+static VALUE Event_new(SDL_Event* ev)
+{
+    SDL_Event* e = ALLOC(SDL_Event);
+    *e = *ev;
+    return Data_Wrap_Struct(event_type_to_class[ev->type], 0, free, e);
+}
+
+static VALUE Event_s_allocate(VALUE klass)
+{
+    SDL_Event* e;
+    VALUE event_type = rb_iv_get(klass, "event_type");
+    if (event_type == Qnil)
+        rb_raise(rb_eArgError, "Cannot allocate %s", rb_class2name(klass));
+    
+    e = ALLOC(SDL_Event);
+    memset(e, 0, sizeof(SDL_Event));
+    e->common.type = NUM2INT(event_type);
+    return Data_Wrap_Struct(klass, 0, free, e);
+}
+
+/*
+ * Poll for currently pending events.
+ *
+ * @return [SDL2::Event] next event from the queue
+ * @return [nil] the queue is empty
+ */
+static VALUE Event_s_poll(VALUE self)
+{
+    SDL_Event ev;
+    if (SDL_PollEvent(&ev)) {
+        return Event_new(&ev);
+    } else {
+        return Qnil;
+    }
+}
+
+/*
+ * Get whether the event is enabled.
+ *
+ * This method is available for subclasses of SDL2::Event corresponding to
+ * SDL's event types.
+ *
+ * @see .enabled= 
+ */
+static VALUE Event_s_enabled_p(VALUE self)
+{
+    VALUE event_type = rb_iv_get(self, "event_type");
+    if (event_type == Qnil) {
+        rb_warn("You cannot enable %s directly", rb_class2name(self));
+        return Qfalse;
+    }
+    return INT2BOOL(SDL_EventState(NUM2INT(event_type), SDL_QUERY) == SDL_ENABLE);
+}
+
+/*
+ * @overload enable=(bool)
+ *   Set wheter the event is enable
+ *   
+ *   This method is only available for subclasses of SDL2::Event corresponding to
+ *   SDL's event types.
+ *
+ *   @example disable mouse wheel events
+ *     SDL2::Event::MouseWheel.enable = false
+ *   
+ *   @param [Boolean] bool true for enabling the event.
+ *   @return [Boolean]
+ *   @see SDL2::Event.enabled?
+ *
+ */
+static VALUE Event_s_set_enable(VALUE self, VALUE val)
+{
+    VALUE event_type = rb_iv_get(self, "event_type");
+    if (event_type == Qnil) 
+        rb_raise(rb_eArgError, "You cannot enable %s directly", rb_class2name(self));
+    SDL_EventState(NUM2INT(event_type), RTEST(val) ? SDL_ENABLE : SDL_DISABLE);
+    return val;
+}
+
+static void set_string(char* field, VALUE str, int maxlength)
+{
+    StringValueCStr(str);
+    if (RSTRING_LEN(str) > maxlength)
+        rb_raise(rb_eArgError, "string length must be less than %d", maxlength);
+    strcpy(field, RSTRING_PTR(str));
+}
+
+#define EVENT_READER(classname, name, field, c2ruby)            \
+    static VALUE Ev##classname##_##name(VALUE self)             \
+    {                                                           \
+        SDL_Event* ev;                                          \
+        Data_Get_Struct(self, SDL_Event, ev);                   \
+        return c2ruby(ev->field);                               \
+    }                                                           \
+
+#define EVENT_WRITER(classname, name, field, ruby2c)                    \
+    static VALUE Ev##classname##_set_##name(VALUE self, VALUE val)      \
+    {                                                                   \
+        SDL_Event* ev;                                                  \
+        Data_Get_Struct(self, SDL_Event, ev);                           \
+        ev->field = ruby2c(val);                                        \
+        return Qnil;                                                    \
+    }
+
+#define EVENT_ACCESSOR(classname, name, field, ruby2c, c2ruby)  \
+    EVENT_READER(classname, name, field, c2ruby)                \
+    EVENT_WRITER(classname, name, field, ruby2c)
+
+#define EVENT_ACCESSOR_UINT(classname, name, field) \
+    EVENT_ACCESSOR(classname, name, field, NUM2UINT, UINT2NUM)
+
+#define EVENT_ACCESSOR_UINT8(classname, name, field) \
+    EVENT_ACCESSOR(classname, name, field, NUM2UCHAR, UCHAR2NUM)
+
+#define EVENT_ACCESSOR_INT(classname, name, field) \
+    EVENT_ACCESSOR(classname, name, field, NUM2INT, INT2NUM)
+
+#define EVENT_ACCESSOR_DBL(classname, name, field) \
+    EVENT_ACCESSOR(classname, name, field, NUM2DBL, DBL2NUM)
+
+#define EVENT_ACCESSOR_BOOL(classname, name, field)             \
+    EVENT_ACCESSOR(classname, name, field, RTEST, INT2BOOL)
+
+
+EVENT_READER(Event, type, common.type, INT2NUM);
+EVENT_ACCESSOR_UINT(Event, timestamp, common.timestamp);
+/* @return [String] inspection string */
+static VALUE Event_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp);
+}
+
+/*
+ * Return the object of {SDL2::Window} corresponding to the window_id attribute.
+ *
+ * Some subclasses of SDL2::Event have window_id attribute to point the
+ * window which creates the event. The type of the window_id attribute
+ * is integer, and you need to convert it with {SDL2::Window.find_by_id}
+ * to get the {SDL2::Window} object. This method returns the {SDL2::Window}
+ * object.
+ *
+ * @return [SDL2::Window] the window which creates the event.
+ * @raise [NoMethodError] raised if the window_id attribute is not present.
+ */
+static VALUE Event_window(VALUE self)
+{
+    VALUE window_id = rb_funcall(self, rb_intern("window_id"), 0);
+    return find_window_by_id(NUM2UINT(window_id));
+}
+
+/*
+ * Document-class: SDL2::Event::Quit
+ *
+ * This class represents the quit requested event.
+ *
+ * This event occurs when a user try to close window, command-Q on OS X,
+ * or any other quit request by a user. Normally if your application
+ * receive this event, the application should exit. But the application
+ * can query something to the users like "save", or ignore it.
+ */
+
+/*
+ * Document-class: SDL2::Event::Window
+ *
+ * This class represents window event. This type of event occurs when
+ * window state is changed.
+ * 
+ * @attribute [rw] window_id
+ *   the associate window id
+ *   @return [Integer]
+ *
+ * @attribute [rw] event
+ *   event type, one of the following:
+ *
+ *   * SDL2::Event::Window::NONE - (never used)
+ *   * SDL2::Event::Window::SHOWN - window has been shown
+ *   * SDL2::Event::Window::HIDDEN - window has been hidden
+ *   * SDL2::Event::Window::EXPOSED - window has been exposed and should be redrawn
+ *   * SDL2::Event::Window::MOVED - window has been moved to data1, data2
+ *   * SDL2::Event::Window::RESIZED - window has been resized to data1xdata2;
+ *       this is event is always preceded by SIZE_CHANGED
+ *   * SDL2::Event::Window::SIZE_CHANGED -
+ *       window size has changed, either as a result of an API call or through
+ *       the system or user changing the window size;
+ *       this event is followed by
+ *       RESIZED if the size was changed by an external event,
+ *       i.e. the user or the window manager
+ *   * SDL2::Event::Window::MINIMIZED - window has been minimized
+ *   * SDL2::Event::Window::MAXIMIZED - window has been maximized
+ *   * SDL2::Event::Window::RESTORED - window has been restored to normal size and position
+ *   * SDL2::Event::Window::ENTER - window has gained mouse focus
+ *   * SDL2::Event::Window::LEAVE - window has lost mouse focus
+ *   * SDL2::Event::Window::FOCUS_GAINED - window has gained keyboard focus
+ *   * SDL2::Event::Window::FOCUS_LOST -window has lost keyboard focus
+ *   * SDL2::Event::Window::CLOSE - 
+ *       the window manager requests that the window be closed
+ *   
+ *   @return [Integer]
+ *
+ * @attribute data1
+ *   event dependent data
+ *   @return [Integer]
+ *
+ * @attribute data2
+ *   event dependent data
+ *   @return [Integer]
+ *
+ */
+EVENT_ACCESSOR_UINT(Window, window_id, window.windowID);
+EVENT_ACCESSOR_UINT(Window, event, window.event);
+EVENT_ACCESSOR_INT(Window, data1, window.data1);
+EVENT_ACCESSOR_INT(Window, data2, window.data2);
+
+/* @return [String] inspection string */
+static VALUE EvWindow_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u window_id=%u event=%u data1=%d data2=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->window.windowID, ev->window.event,
+                      ev->window.data1, ev->window.data2);
+}
+
+/*
+ * Document-class: SDL2::Event::Keyboard
+ *
+ * This class represents keyboard event.
+ *
+ * You don't handle the instance 
+ * of this class directly, but you handle the instances of 
+ * two subclasses of this subclasses:
+ * {SDL2::Event::KeyDown} and {SDL2::Event::KeyUp}.
+ *
+ * @attribute [rw] window_id
+ *   the associate window id
+ *   @return [Integer]
+ *
+ * @attribute pressed
+ *   key is pressed
+ *   @return [Integer]
+ *
+ * @attribute repeat
+ *   key repeat
+ *   @return [Integer]
+ *   
+ * @attribute scancode
+ *   physical key code
+ *   @return [Integer]
+ *   @see SDL2::Key::Scan
+ *
+ * @attribute sym
+ *   virtual key code
+ *   @return [Integer]
+ *   @see SDL2::Key
+ *
+ * @attribute mod
+ *   current key modifier
+ *   @return [Integer]
+ *   @see SDL2::Key::Mod
+ *   
+ */
+EVENT_ACCESSOR_UINT(Keyboard, window_id, key.windowID);
+EVENT_ACCESSOR_BOOL(Keyboard, pressed, key.state);
+EVENT_ACCESSOR_BOOL(Keyboard, repeat, key.repeat);
+EVENT_ACCESSOR_UINT(Keyboard, scancode, key.keysym.scancode);
+EVENT_ACCESSOR_UINT(Keyboard, sym, key.keysym.sym);
+EVENT_ACCESSOR_UINT(Keyboard, mod, key.keysym.mod);
+/* @return [String] inspection string */
+static VALUE EvKeyboard_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " window_id=%u state=%u repeat=%u"
+                      " scancode=%u sym=%u mod=%u>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->key.windowID, ev->key.state, ev->key.repeat,
+                      ev->key.keysym.scancode, ev->key.keysym.sym, ev->key.keysym.mod);
+}
+
+
+/*
+ * Document-class: SDL2::Event::KeyDown
+ *
+ * This class represents a key down event.
+ */
+
+/*
+ * Document-class: SDL2::Event::KeyUp
+ *
+ * This class represents a key up event.
+ */
+
+/*
+ * Document-class: SDL2::Event::TextEditing
+ *
+ * This class represents text editing event.
+ *
+ * @attribute window_id
+ *   the associate window id
+ *   @return [Integer]
+ *
+ * @attribute text
+ *   the editing text
+ *   @return [String]
+ *
+ * @attribute start
+ *   the start cursor of selected editing text
+ *   @return [Integer]
+ *
+ * @attribute length
+ *   the length of selected editing text
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_UINT(TextEditing, window_id, edit.windowID);
+EVENT_ACCESSOR_INT(TextEditing, start, edit.start);
+EVENT_ACCESSOR_INT(TextEditing, length, edit.length);
+EVENT_READER(TextEditing, text, edit.text, utf8str_new_cstr);
+static VALUE EvTextEditing_set_text(VALUE self, VALUE str)
+{
+    SDL_Event* ev;
+    Data_Get_Struct(self, SDL_Event, ev);
+    set_string(ev->edit.text, str, 30);
+    return str;
+}
+
+/* @return [String] inspection string */
+static VALUE EvTextEditing_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " window_id=%u text=%s start=%d length=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->edit.windowID, ev->edit.text, ev->edit.start, ev->edit.length);
+}
+
+
+/*
+ * Document-class: SDL2::Event::TextInput
+ *
+ * This class represents text input events.
+ *
+ * @attribute window_id
+ *   the associate window id
+ *   @return [Integer]
+ *
+ * @attribute text
+ *   the input text
+ *   @return [String]
+ */
+EVENT_ACCESSOR_UINT(TextInput, window_id, text.windowID);
+EVENT_READER(TextInput, text, text.text, utf8str_new_cstr);
+static VALUE EvTextInput_set_text(VALUE self, VALUE str)
+{
+    SDL_Event* ev;
+    Data_Get_Struct(self, SDL_Event, ev);
+    set_string(ev->text.text, str, 30);
+    return str;
+}
+
+/* @return [String] inspection string */
+static VALUE EvTextInput_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u window_id=%u text=%s>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->text.windowID, ev->text.text);
+}
+
+/*
+ * Document-class: SDL2::Event::MouseButton
+ *
+ * This class represents mouse button events.
+ * 
+ * You don't handle the instance 
+ * of this class directly, but you handle the instances of 
+ * two subclasses of this subclasses:
+ * {SDL2::Event::MouseButtonDown} and {SDL2::Event::MouseButtonUp}.
+ *
+ * @attribute window_id
+ *   the window id with mouse focus
+ *   @return [Integer]
+ *
+ * @attribute which
+ *   the mouse index
+ *   @return [Integer]
+ *
+ * @attribute button
+ *   the mouse button index
+ *   @return [Integer]
+ *
+ * @attribute pressed
+ *   button is pressed or not
+ *   @return [Boolean]
+ *
+ * @attribute clicks
+ *   1 for single click, 2 for double click
+ *   
+ *   This attribute is available after SDL 2.0.2
+ *   @return [Integer]
+ *
+ * @attribute x
+ *   the x coordinate of the mouse pointer, relative to window
+ *   @return [Integer]
+ *
+ * @attribute y
+ *   the y coordinate of the mouse pointer, relative to window
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_UINT(MouseButton, window_id, button.windowID);
+EVENT_ACCESSOR_UINT(MouseButton, which, button.which);
+EVENT_ACCESSOR_UINT8(MouseButton, button, button.button);
+EVENT_ACCESSOR_BOOL(MouseButton, pressed, button.state);
+#if SDL_VERSION_ATLEAST(2,0,2)
+EVENT_ACCESSOR_UINT8(MouseButton, clicks, button.clicks);
+#endif
+EVENT_ACCESSOR_INT(MouseButton, x, button.x);
+EVENT_ACCESSOR_INT(MouseButton, y, button.y);
+/* @return [String] inspection string */
+static VALUE EvMouseButton_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " window_id=%u which=%u button=%hhu pressed=%s"
+#if SDL_VERSION_ATLEAST(2,0,2)
+                      " clicks=%hhu"
+#endif
+                      " x=%d y=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->button.windowID, ev->button.which,
+                      ev->button.button, INT2BOOLCSTR(ev->button.state),
+#if SDL_VERSION_ATLEAST(2,0,2)
+                      ev->button.clicks,
+#endif
+                      ev->button.x, ev->button.y);
+}
+
+/*
+ * Document-class: SDL2::Event::MouseButtonDown
+ * This class represents mouse button press events.
+ */
+/*
+ * Document-class: SDL2::Event::MouseButtonUp
+ * This class represents mouse button release events.
+ */
+
+/*
+ * Document-class: SDL2::Event::MouseMotion
+ *
+ * This class represents mouse motion events.
+ *
+ * @attribute window_id
+ *   the window id with mouse focus
+ *   @return [Integer]
+ *
+ * @attribute which
+ *   the mouse index 
+ *   @return [Integer]
+ *
+ * @attribute state
+ *   the current mouse state
+ *   @return [Integer]
+ *   @todo use SDL2::Mouse::State
+ *   
+ * @attribute x
+ *   the x coordinate of the mouse pointer, relative to window
+ *   @return [Integer]
+ *
+ * @attribute y
+ *   the y coordinate of the mouse pointer, relative to window
+ *   @return [Integer]
+ *
+ * @attribute xrel
+ *   the relative motion in the x direction
+ *   @return [Integer]
+ *
+ * @attribute yrel
+ *   the relative motion in the y direction
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_UINT(MouseMotion, window_id, motion.windowID);
+EVENT_ACCESSOR_UINT(MouseMotion, which, motion.which);
+EVENT_ACCESSOR_UINT(MouseMotion, state, motion.state);
+EVENT_ACCESSOR_INT(MouseMotion, x, motion.x);
+EVENT_ACCESSOR_INT(MouseMotion, y, motion.y);
+EVENT_ACCESSOR_INT(MouseMotion, xrel, motion.xrel);
+EVENT_ACCESSOR_INT(MouseMotion, yrel, motion.yrel);
+/* @return [String] inspection string */
+static VALUE EvMouseMotion_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " window_id=%u which=%u state=%u"
+                      " x=%d y=%d xrel=%d yrel=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->motion.windowID, ev->motion.which, ev->motion.state,
+                      ev->motion.x, ev->motion.y, ev->motion.xrel, ev->motion.yrel);
+}
+
+/*
+ * Document-class: SDL2::Event::MouseWheel
+ *
+ * This class represents mouse wheel events.
+ *
+ * @attribute window_id
+ *   the window id with mouse focus
+ *   @return [Integer]
+ *
+ * @attribute which
+ *   the mouse index 
+ *   @return [Integer]
+ *
+ * @attribute x
+ *   the amount of scrolled horizontally, positive to the right and negative
+ *   to the left
+ *   @return [Integer]
+ *
+ * @attribute y
+ *   the amount of scrolled vertically, positve away from the user and negative
+ *   toward the user
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_UINT(MouseWheel, window_id, wheel.windowID);
+EVENT_ACCESSOR_UINT(MouseWheel, which, wheel.which);
+EVENT_ACCESSOR_INT(MouseWheel, x, wheel.x);
+EVENT_ACCESSOR_INT(MouseWheel, y, wheel.y);
+/* @return [String] inspection string */
+static VALUE EvMouseWheel_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " window_id=%u which=%u x=%d y=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->wheel.windowID, ev->wheel.which, ev->wheel.x, ev->wheel.y);
+}
+
+/*
+ * Document-class: SDL2::Event::JoyButton
+ *
+ * This class represents joystick button events.
+ *
+ * You don't handle the instance 
+ * of this class directly, but you handle the instances of 
+ * two subclasses of this subclasses:
+ * {SDL2::Event::JoyButtonDown} and {SDL2::Event::JoyButtonUp}.
+ *
+ * @attribute which
+ *   the joystick index
+ *   @return [Integer]
+ *
+ * @attribute button
+ *   the joystick button index
+ *   @return [Integer]
+ *
+ * @attribute pressed
+ *   button is pressed or not
+ *   @return [Boolean]
+ * 
+ */
+EVENT_ACCESSOR_INT(JoyButton, which, jbutton.which);
+EVENT_ACCESSOR_UINT8(JoyButton, button, jbutton.button);
+EVENT_ACCESSOR_BOOL(JoyButton, pressed, jbutton.state);
+/* @return [String] inspection string */
+static VALUE EvJoyButton_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " which=%d button=%u pressed=%s>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->jbutton.which, ev->jbutton.button,
+                      INT2BOOLCSTR(ev->jbutton.state));
+}
+/*
+ * Document-class: SDL2::Event::JoyButtonDown
+ *
+ * This class represents the joystick button press events.
+ */
+
+/*
+ * Document-class: SDL2::Event::JoyButtonUp
+ *
+ * This class represents the joystick button release events.
+ */
+
+/*
+ * Document-class: SDL2::Event::JoyAxisMotion
+ *
+ * This class represents the joystick axis motion events.
+ *
+ * @attribute which
+ *   the joystick index
+ *   @return [Integer]
+ *
+ * @attribute axis
+ *   the axis index
+ *   @return [Integer]
+ *
+ * @attribute value
+ *   the axis value (range: -32768 to -32767, 0 for newtral)
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_INT(JoyAxisMotion, which, jaxis.which);
+EVENT_ACCESSOR_UINT8(JoyAxisMotion, axis, jaxis.axis);
+EVENT_ACCESSOR_INT(JoyAxisMotion, value, jaxis.value);
+/* @return [Stirng] inspection string */
+static VALUE EvJoyAxisMotion_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " which=%d axis=%u value=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->jaxis.which, ev->jaxis.axis, ev->jaxis.value);
+}
+
+/*
+ * Document-class: SDL2::Event::JoyBallMotion
+ *
+ * This class represents the joystick trackball motion events.
+ *
+ * @attribute which
+ *   the joystick index
+ *   @return [Integer]
+ *
+ * @attribute ball
+ *   the joystick trackball index
+ *   @return [Integer]
+ *
+ * @attribute xrel
+ *   the relative motion in the x direction
+ *   @return [Integer]
+ *
+ * @attribute yrel
+ *   the relative motion in the y direction
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_INT(JoyBallMotion, which, jball.which);
+EVENT_ACCESSOR_UINT8(JoyBallMotion, ball, jball.ball);
+EVENT_ACCESSOR_INT(JoyBallMotion, xrel, jball.xrel);
+EVENT_ACCESSOR_INT(JoyBallMotion, yrel, jball.yrel);
+/* @return [String] inspection string */
+static VALUE EvJoyBallMotion_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " which=%d ball=%u xrel=%d yrel=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->jball.which, ev->jball.ball, ev->jball.xrel, ev->jball.yrel);
+}
+
+/*
+ * Document-class: SDL2::Event::JoyHatMotion
+ *
+ * This class represents the joystick hat position change events.
+ *
+ * @attribute which
+ *   the joystick index
+ *   @return [Integer]
+ *
+ * @attribute hat
+ *   the joystick hat index
+ *   @return [Integer]
+ *
+ * @attribute value
+ *   the hat position value, same value as {SDL2::Joystick#hat}.
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_INT(JoyHatMotion, which, jhat.which);
+EVENT_ACCESSOR_UINT8(JoyHatMotion, hat, jhat.hat);
+EVENT_ACCESSOR_UINT8(JoyHatMotion, value, jhat.value);
+/* @return [String] inspection string */
+static VALUE EvJoyHatMotion_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u which=%d hat=%u value=%u>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->jhat.which, ev->jhat.hat, ev->jhat.value);
+}
+
+/*
+ * Document-class: SDL2::Event::JoyDevice
+ *
+ * This class represents joystick device events
+ * ({SDL2::Event::JoyDeviceAdded joystick connected events} and
+ *  {SDL2::Event::JoyDeviceRemoved joystick disconnected events}).
+ */
+EVENT_ACCESSOR_INT(JoyDevice, which, jdevice.which);
+/* @return [String] inspection string */
+static VALUE EvJoyDevice_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u which=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->jdevice.which);
+}
+
+/*
+ * Document-class: SDL2::Event::JoyDeviceAdded
+ *
+ * This class represents joystick device connected events.
+ */
+/*
+ * Document-class: SDL2::Event::JoyDeviceRemoved
+ *
+ * This class represents joystick device disconnected events.
+ */
+
+
+/*
+ * Document-class: SDL2::Event::ControllerAxisMotion
+ *
+ * This class represents the {SDL2::GameController controller} axis motion events.
+ *
+ * @attribute which
+ *   the controller index
+ *   @return [Integer]
+ *
+ * @attribute axis
+ *   the axis index
+ *   @return [Integer]
+ *
+ * @attribute value
+ *   the axis value (range: -32768 to -32767, 0 for newtral)
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_INT(ControllerAxis, which, caxis.which);
+EVENT_ACCESSOR_UINT8(ControllerAxis, axis, caxis.axis);
+EVENT_ACCESSOR_INT(ControllerAxis, value, caxis.value);
+/* @return [String] inspection string */
+static VALUE ControllerAxis_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " which=%d axis=%s value=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->caxis.which, SDL_GameControllerGetStringForAxis(ev->caxis.axis),
+                      ev->caxis.value);
+}
+
+/*
+ * Document-class: SDL2::Event::ControllerButton
+ *
+ * This class represents the {SDL2::GameController controller} button events.
+ *
+ * You don't handle the instance 
+ * of this class directly, but you handle the instances of 
+ * two subclasses of this subclasses:
+ * {SDL2::Event::ControllerButtonDown} and {SDL2::Event::ControllerButtonUp}.
+ *
+ * @attribute which
+ *   the controller index
+ *   @return [Integer]
+ *
+ * @attribute button
+ *   the controller button index
+ *   @return [Integer]
+ *
+ * @attribute pressed
+ *   button is pressed or not
+ *   @return [Boolean]
+ *
+ */
+EVENT_ACCESSOR_INT(ControllerButton, which, cbutton.which);
+EVENT_ACCESSOR_UINT8(ControllerButton, button, cbutton.button);
+EVENT_ACCESSOR_BOOL(ControllerButton, pressed, cbutton.state);
+/* @return [String] inspection string */
+static VALUE ControllerButton_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " which=%d button=%s state=%s>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->cbutton.which,
+                      SDL_GameControllerGetStringForButton(ev->cbutton.button),
+                      INT2BOOLCSTR(ev->cbutton.state));
+}
+/*
+ * Document-class: SDL2::Event::ControllerButtonDown
+ *
+ * This class represents the {SDL2::GameController controller} button press events.
+ */
+
+/*
+ * Document-class: SDL2::Event::ControllerButtonUp
+ *
+ * This class represents the {SDL2::GameController controller} button release events.
+ */
+
+/*
+ * Document-class: SDL2::Event::ControllerDevice
+ *
+ * This class represents {SDL2::GameController controller} device events (connected/disconnected/remapped).
+ *
+ * The event of this event doesn't occur. Only the event of the following subclasses
+ * occur in Ruby/SDL2.
+ *
+ *   * {SDL2::Event::ControllerDeviceAdded}
+ *   * {SDL2::Event::ControllerDeviceRemoved}
+ *   * {SDL2::Event::ControllerDeviceRemapped}
+ *
+ * @attribute which
+ *   the controller index
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_INT(ControllerDevice, which, cdevice.which);
+/* @return [String] inspection string */
+static VALUE ControllerDevice_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u which=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      ev->cdevice.which);
+}
+
+/*
+ * Document-class: SDL2::Event::ControllerDeviceAdded
+ *
+ * This class represents {SDL2::GameController controller} device connected events.
+ */
+/*
+ * Document-class: SDL2::Event::ControllerDeviceRemoved
+ *
+ * This class represents {SDL2::GameController controller} device disconnected events.
+ */
+/*
+ * Document-class: SDL2::Event::ControllerDeviceRemapped
+ *
+ * This class represents {SDL2::GameController controller} device remapped events.
+ */
+
+/*
+ * Document-class: SDL2::Event::TouchFinger
+ *
+ * This class represents touch finger events.
+ * 
+ * You don't handle the instance 
+ * of this class directly, but you handle the instances of 
+ * two subclasses of this subclasses:
+ * {SDL2::Event::FingerMotion}, {SDL2::Event::FingerDown}, and {SDL2::Event::FingerUp}.
+ *
+ * @attribute touch_id
+ *   the touch device id
+ *   @return [Integer]
+ *
+ * @attribute finger_id
+ *   the finger id
+ *   @return [Integer]
+ *
+ * @attribute x
+ *   the x-axis location of the touch event, normalized (0...1)
+ *   @return [Float]
+ *
+ * @attribute y
+ *   the y-axis location of the touch event, normalized (0...1)
+ *   @return [Float]
+ *
+ * @attribute pressure
+ *   the quantity of pressure applied, normalized (0...1)
+ *   @return [Float]
+ */
+EVENT_ACCESSOR_INT(TouchFinger, touch_id, tfinger.touchId);
+EVENT_ACCESSOR_INT(TouchFinger, finger_id, tfinger.fingerId);
+EVENT_ACCESSOR_DBL(TouchFinger, x, tfinger.x);
+EVENT_ACCESSOR_DBL(TouchFinger, y, tfinger.y);
+EVENT_ACCESSOR_DBL(TouchFinger, pressure, tfinger.pressure);
+/* @return [String] inspection string */
+static VALUE EvTouchFinger_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " touch_id=%d finger_id=%d"
+                      " x=%f y=%f pressure=%f>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      (int)ev->tfinger.touchId, (int)ev->tfinger.fingerId,
+                      ev->tfinger.x, ev->tfinger.y, ev->tfinger.pressure);
+}
+
+/*
+ * Document-class: SDL2::Event::FingerUp
+ * This class represents finger touch events.
+ */
+/*
+ * Document-class: SDL2::Event::FingerDown
+ * This class represents finger release events.
+ */
+
+/*
+ * Document-class: SDL2::Event::FingerMotion
+ *
+ * This class represents touch move events.
+ *
+ * @attribute dx
+ *   the distance moved in the x-axis, normalized (0...1)
+ *   @return [Float]
+ *
+ * @attribute dy
+ *   the distance moved in the y-axis, normalized (0...1)
+ *   @return [Float]
+ *
+ */
+EVENT_ACCESSOR_DBL(FingerMotion, dx, tfinger.dx);
+EVENT_ACCESSOR_DBL(FingerMotion, dy, tfinger.dy);
+/* @return [String] inspection string */
+static VALUE EvFingerMotion_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " touch_id=%d finger_id=%d"
+                      " x=%f y=%f pressure=%f"
+                      " dy=%f dx=%f>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      (int) ev->tfinger.touchId, (int) ev->tfinger.fingerId,
+                      ev->tfinger.x, ev->tfinger.y, ev->tfinger.pressure,
+                      ev->tfinger.dx, ev->tfinger.dx);
+}
+
+
+/*
+ * Document-class: SDL2::Event::Multigesture
+ *
+ * This class represents multiple finger gesture events.
+ *
+ *
+ * @attribute touch_id
+ *   the touch device id
+ *   @return [Integer]
+ *
+ * @attribute d_theta
+ *   rotation of fingers
+ *   @return [Float]
+ *
+ * @attribute d_dist
+ *   amount of fingers pinched
+ *   @return [Float]
+ *
+ * @attribute x
+ *   the x-axis location of the touch event, normalized (0...1)
+ *   @return [Float]
+ *
+ * @attribute y
+ *   the y-axis location of the touch event, normalized (0...1)
+ *   @return [Float]
+ *
+ * @attribute num_fingers
+ *   number of fingers involved
+ *   @return [Integer]
+ */
+EVENT_ACCESSOR_INT(Multigesture, touch_id, mgesture.touchId);
+EVENT_ACCESSOR_DBL(Multigesture, x, mgesture.x);
+EVENT_ACCESSOR_DBL(Multigesture, y, mgesture.y);
+EVENT_ACCESSOR_DBL(Multigesture, d_theta, mgesture.dTheta);
+EVENT_ACCESSOR_DBL(Multigesture, d_dist, mgesture.dDist);
+EVENT_ACCESSOR_INT(Multigesture, num_fingers, mgesture.numFingers);
+/* @return [String] inspection string */
+static VALUE EvMultigesture_inspect(VALUE self)
+{
+    SDL_Event* ev; Data_Get_Struct(self, SDL_Event, ev);
+    return rb_sprintf("<%s: type=%u timestamp=%u"
+                      " touch_id=%d d_theta=%f d_dist=%f"
+                      " x=%f y=%f num_fingers=%d>",
+                      rb_obj_classname(self), ev->common.type, ev->common.timestamp,
+                      (int)ev->mgesture.touchId, ev->mgesture.dTheta, ev->mgesture.dDist,
+                      ev->mgesture.x, ev->mgesture.y, ev->mgesture.numFingers);
+}
+
+
+/*
+ * Document-class: SDL2::Event::SysWM
+ *
+ * This class represents video driver dependent system events.
+ *
+ * This event is disabled by default. You can enable it with {SDL2::Event.enable=}.
+ * This event is now useless because now there is no way to get
+ * driver dependent information from this event class.
+ * You are encouraged to avoid this event.
+ * 
+ */
+static void connect_event_class(SDL_EventType type, VALUE klass)
+{
+    event_type_to_class[type] = klass;
+    rb_iv_set(klass, "event_type", INT2NUM(type));
+}
+
+static void init_event_type_to_class(void)
+{
+    int i;
+    for (i=0; i<SDL_LASTEVENT; ++i)
+        event_type_to_class[i] = cEvent;
+    
+    connect_event_class(SDL_QUIT, cEvQuit);
+    connect_event_class(SDL_WINDOWEVENT, cEvWindow);
+    connect_event_class(SDL_KEYDOWN, cEvKeyDown);
+    connect_event_class(SDL_KEYUP, cEvKeyUp);
+    connect_event_class(SDL_TEXTEDITING, cEvTextEditing);
+    connect_event_class(SDL_TEXTINPUT, cEvTextInput);
+    connect_event_class(SDL_MOUSEBUTTONDOWN, cEvMouseButtonDown);
+    connect_event_class(SDL_MOUSEBUTTONUP, cEvMouseButtonUp);
+    connect_event_class(SDL_MOUSEMOTION, cEvMouseMotion);
+    connect_event_class(SDL_MOUSEWHEEL, cEvMouseWheel);
+    connect_event_class(SDL_JOYBUTTONDOWN, cEvJoyButtonDown);
+    connect_event_class(SDL_JOYBUTTONUP, cEvJoyButtonUp);
+    connect_event_class(SDL_JOYAXISMOTION, cEvJoyAxisMotion);
+    connect_event_class(SDL_JOYBALLMOTION, cEvJoyBallMotion);
+    connect_event_class(SDL_JOYDEVICEADDED, cEvJoyDeviceAdded);
+    connect_event_class(SDL_JOYDEVICEREMOVED, cEvJoyDeviceRemoved);
+    connect_event_class(SDL_JOYHATMOTION, cEvJoyHatMotion);
+    connect_event_class(SDL_CONTROLLERAXISMOTION, cEvControllerAxisMotion);
+    connect_event_class(SDL_CONTROLLERBUTTONDOWN, cEvControllerButtonDown);
+    connect_event_class(SDL_CONTROLLERBUTTONUP, cEvControllerButtonUp);
+    connect_event_class(SDL_CONTROLLERDEVICEADDED, cEvControllerDeviceAdded);
+    connect_event_class(SDL_CONTROLLERDEVICEREMOVED, cEvControllerDeviceRemoved);
+    connect_event_class(SDL_CONTROLLERDEVICEREMAPPED, cEvControllerDeviceRemapped);
+    connect_event_class(SDL_FINGERDOWN, cEvFingerDown);
+    connect_event_class(SDL_FINGERUP, cEvFingerUp);
+    connect_event_class(SDL_FINGERMOTION, cEvFingerMotion);
+    connect_event_class(SDL_MULTIGESTURE, cEvMultigesture);
+}
+
+#define DEFINE_EVENT_READER(classname, classvar, name)                  \
+    rb_define_method(classvar, #name, Ev##classname##_##name, 0)
+
+#define DEFINE_EVENT_WRITER(classname, classvar, name)                  \
+    rb_define_method(classvar, #name "=", Ev##classname##_set_##name, 1)
+
+#define DEFINE_EVENT_ACCESSOR(classname, classvar, name)                \
+    do {                                                                \
+        DEFINE_EVENT_READER(classname, classvar, name);                 \
+        DEFINE_EVENT_WRITER(classname, classvar, name);                 \
+    } while(0)
+
+void rubysdl2_init_event(void)
+{
+    cEvent = rb_define_class_under(mSDL2, "Event", rb_cObject);
+    rb_define_alloc_func(cEvent, Event_s_allocate);
+    rb_define_singleton_method(cEvent, "poll", Event_s_poll, 0);
+    rb_define_singleton_method(cEvent, "enabled?", Event_s_enabled_p, 0);
+    rb_define_singleton_method(cEvent, "enable=", Event_s_set_enable, 1);
+    
+    cEvQuit = rb_define_class_under(cEvent, "Quit", cEvent);
+    cEvWindow = rb_define_class_under(cEvent, "Window", cEvent);
+    cEvSysWM = rb_define_class_under(cEvent, "SysWM", cEvent);
+    cEvKeyboard = rb_define_class_under(cEvent, "Keyboard", cEvent);
+    cEvKeyUp = rb_define_class_under(cEvent, "KeyUp", cEvKeyboard);
+    cEvKeyDown = rb_define_class_under(cEvent, "KeyDown", cEvKeyboard);
+    cEvTextEditing = rb_define_class_under(cEvent, "TextEditing", cEvent);
+    cEvTextInput = rb_define_class_under(cEvent, "TextInput", cEvent);
+    cEvMouseButton = rb_define_class_under(cEvent, "MouseButton", cEvent);
+    cEvMouseButtonDown = rb_define_class_under(cEvent, "MouseButtonDown", cEvMouseButton);
+    cEvMouseButtonUp = rb_define_class_under(cEvent, "MouseButtonUp", cEvMouseButton);
+    cEvMouseMotion = rb_define_class_under(cEvent, "MouseMotion", cEvent);
+    cEvMouseWheel = rb_define_class_under(cEvent, "MouseWheel", cEvent);
+    cEvJoyButton = rb_define_class_under(cEvent, "JoyButton", cEvent);
+    cEvJoyButtonDown = rb_define_class_under(cEvent, "JoyButtonDown", cEvJoyButton);
+    cEvJoyButtonUp = rb_define_class_under(cEvent, "JoyButtonUp", cEvJoyButton);
+    cEvJoyAxisMotion = rb_define_class_under(cEvent, "JoyAxisMotion", cEvent);
+    cEvJoyBallMotion = rb_define_class_under(cEvent, "JoyBallMotion", cEvent);
+    cEvJoyHatMotion = rb_define_class_under(cEvent, "JoyHatMotion", cEvent);
+    cEvJoyDevice = rb_define_class_under(cEvent, "JoyDevice", cEvent);
+    cEvJoyDeviceAdded = rb_define_class_under(cEvent, "JoyDeviceAdded", cEvJoyDevice);
+    cEvJoyDeviceRemoved = rb_define_class_under(cEvent, "JoyDeviceRemoved", cEvJoyDevice);
+    cEvControllerAxisMotion = rb_define_class_under(cEvent, "ControllerAxisMotion", cEvent);
+    cEvControllerButton = rb_define_class_under(cEvent, "ControllerButton", cEvent);
+    cEvControllerButtonDown = rb_define_class_under(cEvent, "ControllerButtonDown", cEvControllerButton);
+    cEvControllerButtonUp = rb_define_class_under(cEvent, "ControllerButtonUp", cEvControllerButton);
+    cEvControllerDevice = rb_define_class_under(cEvent, "ControllerDevice", cEvent);
+    cEvControllerDeviceAdded = rb_define_class_under(cEvent, "ControllerDeviceAdded", cEvControllerDevice);
+    cEvControllerDeviceRemoved = rb_define_class_under(cEvent, "ControllerDeviceRemoved", cEvControllerDevice);
+    cEvControllerDeviceRemapped = rb_define_class_under(cEvent, "ControllerDeviceRemapped", cEvControllerDevice);
+    cEvTouchFinger = rb_define_class_under(cEvent, "TouchFinger", cEvent);
+    cEvFingerUp = rb_define_class_under(cEvent, "FingerUp", cEvTouchFinger);
+    cEvFingerDown = rb_define_class_under(cEvent, "FingerDown", cEvTouchFinger);
+    cEvFingerMotion = rb_define_class_under(cEvent, "FingerMotion", cEvTouchFinger);
+    cEvMultigesture = rb_define_class_under(cEvent, "Multigesture", cEvent);
+    
+    
+    DEFINE_EVENT_READER(Event, cEvent, type);
+    DEFINE_EVENT_ACCESSOR(Event, cEvent, timestamp);
+    rb_define_method(cEvent, "inspect", Event_inspect, 0);
+    rb_define_method(cEvent, "window", Event_window, 0);
+    
+    DEFINE_EVENT_ACCESSOR(Window, cEvWindow, window_id);
+    DEFINE_EVENT_ACCESSOR(Window, cEvWindow, event);
+    DEFINE_EVENT_ACCESSOR(Window, cEvWindow, data1);
+    DEFINE_EVENT_ACCESSOR(Window, cEvWindow, data2);
+    rb_define_method(cEvWindow, "inspect", EvWindow_inspect, 0);
+#define DEFINE_EVENT_ID_CONST(t) \
+    rb_define_const(cEvWindow, #t, INT2NUM(SDL_WINDOWEVENT_##t))
+    DEFINE_EVENT_ID_CONST(NONE);
+    DEFINE_EVENT_ID_CONST(SHOWN);
+    DEFINE_EVENT_ID_CONST(HIDDEN);
+    DEFINE_EVENT_ID_CONST(EXPOSED);
+    DEFINE_EVENT_ID_CONST(MOVED);
+    DEFINE_EVENT_ID_CONST(RESIZED);
+    DEFINE_EVENT_ID_CONST(SIZE_CHANGED);
+    DEFINE_EVENT_ID_CONST(MINIMIZED);
+    DEFINE_EVENT_ID_CONST(MAXIMIZED);
+    DEFINE_EVENT_ID_CONST(RESTORED);
+    DEFINE_EVENT_ID_CONST(ENTER);
+    DEFINE_EVENT_ID_CONST(LEAVE);
+    DEFINE_EVENT_ID_CONST(FOCUS_GAINED);
+    DEFINE_EVENT_ID_CONST(FOCUS_LOST);
+    DEFINE_EVENT_ID_CONST(CLOSE);
+    
+                    
+    DEFINE_EVENT_ACCESSOR(Keyboard, cEvKeyboard, window_id);
+    DEFINE_EVENT_ACCESSOR(Keyboard, cEvKeyboard, pressed);
+    DEFINE_EVENT_ACCESSOR(Keyboard, cEvKeyboard, repeat);
+    DEFINE_EVENT_ACCESSOR(Keyboard, cEvKeyboard, scancode);
+    DEFINE_EVENT_ACCESSOR(Keyboard, cEvKeyboard, sym);
+    DEFINE_EVENT_ACCESSOR(Keyboard, cEvKeyboard, mod);
+    rb_define_alias(cEvKeyboard, "pressed?", "pressed");
+    rb_define_alias(cEvKeyboard, "repeat?", "repeat");
+    rb_define_method(cEvKeyboard, "inspect", EvKeyboard_inspect, 0);
+    
+    DEFINE_EVENT_ACCESSOR(TextEditing, cEvTextEditing, window_id);
+    DEFINE_EVENT_ACCESSOR(TextEditing, cEvTextEditing, text);
+    DEFINE_EVENT_ACCESSOR(TextEditing, cEvTextEditing, start);
+    DEFINE_EVENT_ACCESSOR(TextEditing, cEvTextEditing, length);
+    rb_define_method(cEvTextEditing, "inspect", EvTextEditing_inspect, 0);
+    
+    DEFINE_EVENT_ACCESSOR(TextInput, cEvTextInput, window_id);
+    DEFINE_EVENT_ACCESSOR(TextInput, cEvTextInput, text);
+    rb_define_method(cEvTextInput, "inspect", EvTextInput_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(MouseButton, cEvMouseButton, window_id);
+    DEFINE_EVENT_ACCESSOR(MouseButton, cEvMouseButton, which);
+    DEFINE_EVENT_ACCESSOR(MouseButton, cEvMouseButton, button);
+    DEFINE_EVENT_ACCESSOR(MouseButton, cEvMouseButton, pressed);
+#if SDL_VERSION_ATLEAST(2,0,2)
+    DEFINE_EVENT_ACCESSOR(MouseButton, cEvMouseButton, clicks);
+#endif
+    DEFINE_EVENT_ACCESSOR(MouseButton, cEvMouseButton, x);
+    DEFINE_EVENT_ACCESSOR(MouseButton, cEvMouseButton, y);
+    rb_define_alias(cEvMouseButton, "pressed?", "pressed");
+    rb_define_method(cEvMouseButton, "inspect", EvMouseButton_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(MouseMotion, cEvMouseMotion, window_id);
+    DEFINE_EVENT_ACCESSOR(MouseMotion, cEvMouseMotion, which);
+    DEFINE_EVENT_ACCESSOR(MouseMotion, cEvMouseMotion, state);
+    DEFINE_EVENT_ACCESSOR(MouseMotion, cEvMouseMotion, x);
+    DEFINE_EVENT_ACCESSOR(MouseMotion, cEvMouseMotion, y);
+    DEFINE_EVENT_ACCESSOR(MouseMotion, cEvMouseMotion, xrel);
+    DEFINE_EVENT_ACCESSOR(MouseMotion, cEvMouseMotion, yrel);
+    rb_define_method(cEvMouseMotion, "inspect", EvMouseMotion_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(MouseWheel, cEvMouseWheel, window_id);
+    DEFINE_EVENT_ACCESSOR(MouseWheel, cEvMouseWheel, which);
+    DEFINE_EVENT_ACCESSOR(MouseWheel, cEvMouseWheel, x);
+    DEFINE_EVENT_ACCESSOR(MouseWheel, cEvMouseWheel, y);
+    rb_define_method(cEvMouseWheel, "inspect", EvMouseWheel_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(JoyButton, cEvJoyButton, which);
+    DEFINE_EVENT_ACCESSOR(JoyButton, cEvJoyButton, button);
+    DEFINE_EVENT_ACCESSOR(JoyButton, cEvJoyButton, pressed);
+    rb_define_alias(cEvJoyButton, "pressed?", "pressed");
+    rb_define_method(cEvJoyButton, "inspect", EvJoyButton_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(JoyAxisMotion, cEvJoyAxisMotion, which);
+    DEFINE_EVENT_ACCESSOR(JoyAxisMotion, cEvJoyAxisMotion, axis);
+    DEFINE_EVENT_ACCESSOR(JoyAxisMotion, cEvJoyAxisMotion, value);
+    rb_define_method(cEvJoyAxisMotion, "inspect", EvJoyAxisMotion_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(JoyBallMotion, cEvJoyBallMotion, which);
+    DEFINE_EVENT_ACCESSOR(JoyBallMotion, cEvJoyBallMotion, ball);
+    DEFINE_EVENT_ACCESSOR(JoyBallMotion, cEvJoyBallMotion, xrel);
+    DEFINE_EVENT_ACCESSOR(JoyBallMotion, cEvJoyBallMotion, yrel);
+    rb_define_method(cEvJoyBallMotion, "inspect", EvJoyBallMotion_inspect, 0);
+    
+    DEFINE_EVENT_ACCESSOR(JoyHatMotion, cEvJoyHatMotion, which);
+    DEFINE_EVENT_ACCESSOR(JoyHatMotion, cEvJoyHatMotion, hat);
+    DEFINE_EVENT_ACCESSOR(JoyHatMotion, cEvJoyHatMotion, value);
+    rb_define_method(cEvJoyHatMotion, "inspect", EvJoyHatMotion_inspect, 0);
+    
+    DEFINE_EVENT_ACCESSOR(JoyDevice, cEvJoyDevice, which);
+    rb_define_method(cEvJoyDevice, "inspect", EvJoyDevice_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(ControllerAxis, cEvControllerAxisMotion, which);
+    DEFINE_EVENT_ACCESSOR(ControllerAxis, cEvControllerAxisMotion, axis);
+    DEFINE_EVENT_ACCESSOR(ControllerAxis, cEvControllerAxisMotion, value);
+    rb_define_method(cEvControllerAxisMotion, "inspect", ControllerAxis_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(ControllerButton, cEvControllerButton, which);
+    DEFINE_EVENT_ACCESSOR(ControllerButton, cEvControllerButton, button);
+    DEFINE_EVENT_ACCESSOR(ControllerButton, cEvControllerButton, pressed);
+    rb_define_method(cEvControllerButton, "inspect", ControllerButton_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(ControllerDevice, cEvControllerDevice, which);
+    rb_define_method(cEvControllerDevice, "inspect", ControllerDevice_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(TouchFinger, cEvTouchFinger, touch_id);
+    DEFINE_EVENT_ACCESSOR(TouchFinger, cEvTouchFinger, finger_id);
+    DEFINE_EVENT_ACCESSOR(TouchFinger, cEvTouchFinger, x); 
+    DEFINE_EVENT_ACCESSOR(TouchFinger, cEvTouchFinger, y);
+    DEFINE_EVENT_ACCESSOR(TouchFinger, cEvTouchFinger, pressure);
+    rb_define_method(cEvTouchFinger, "inspect", EvTouchFinger_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(FingerMotion, cEvFingerMotion, dx); 
+    DEFINE_EVENT_ACCESSOR(FingerMotion, cEvFingerMotion, dy);
+    rb_define_method(cEvFingerMotion, "inspect", EvFingerMotion_inspect, 0);
+
+    DEFINE_EVENT_ACCESSOR(Multigesture, cEvMultigesture, touch_id);
+    DEFINE_EVENT_ACCESSOR(Multigesture, cEvMultigesture, d_theta);
+    DEFINE_EVENT_ACCESSOR(Multigesture, cEvMultigesture, d_dist);
+    DEFINE_EVENT_ACCESSOR(Multigesture, cEvMultigesture, x);
+    DEFINE_EVENT_ACCESSOR(Multigesture, cEvMultigesture, y);
+    DEFINE_EVENT_ACCESSOR(Multigesture, cEvMultigesture, num_fingers);
+    rb_define_method(cEvMultigesture, "inspect", EvMultigesture_inspect, 0);
+    
+    init_event_type_to_class();
+}