sfml3-rb 0.2.2 → 0.3.1

data/ext/window/window.c

@@ -5,6 +5,7 @@
 #include "graphics/render_state.h"
 #include "graphics/target.h"
 #include "graphics/view.h"
+#include "window/window_base.h"
 #include "window/video_mode.h"
 #include "window/event.h"
 #include "window/input_enums.h"
@@ -19,22 +20,28 @@
 
 static VALUE rb_cWindow;
 
-static sfRenderWindow* Window_create(sfVideoMode* mode, const sfChar32* title, uint32_t style,
-                                     sfWindowState state, const sfContextSettings* settings) {
-    return sfRenderWindow_createUnicode(*mode, title, style, state, settings);
-}
-
-static void Window_free(void* ptr) {
-    sfRenderWindow_destroy((sfRenderWindow*)ptr);
-}
-
-static const rb_data_type_t Window_data_type = {
-    .wrap_struct_name = "SFML::Window",
-    .function = {.dmark = NULL, .dfree = Window_free, .dsize = NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
-
-static VALUE Window_new(int argc, VALUE* argv, VALUE klass) {
-    VALUE self, rb_video_mode, rb_title, rb_style, rb_state, rb_settings, title_buffer;
+/* Window overrides every WindowBase method with the sfRenderWindow_ entry
+   point: its handle is an sfRenderWindow*, and CSFML keys its functions off the
+   concrete type, so inheriting the sfWindowBase_ bodies would be wrong. The
+   generated bodies live in window_base.inc. */
+#define WB_FN(name) sfRenderWindow_##name
+#define WB_METHOD(name) Window_##name
+#define WB_HANDLE(self) Get_Window_Struct(self)
+#include "window/window_base.inc"
+#undef WB_FN
+#undef WB_METHOD
+#undef WB_HANDLE
+
+/* call-seq:
+ *   Window.new(video_mode, title, style = :default, state = :windowed, settings = nil) -> Window
+ *
+ * Creates a window with an OpenGL context from +video_mode+ and +title+.
+ *
+ * @return [Window]
+ * @raise [RuntimeError] if window creation fails
+ */
+static VALUE Window_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_video_mode, rb_title, rb_style, rb_state, rb_settings, title_buffer;
     sfWindowState state = sfWindowed;
     sfContextSettings settings;
     const sfContextSettings* settings_ptr = NULL;
@@ -61,17 +68,16 @@ static VALUE Window_new(int argc, VALUE* argv, VALUE klass) {
     }
 
     title_buffer = utf32_from_rb(rb_title);
-    window = Window_create(Get_Mode_Struct(rb_video_mode), UTF32_PTR(title_buffer), style, state,
-                           settings_ptr);
+    window = sfRenderWindow_createUnicode(*Get_Mode_Struct(rb_video_mode), UTF32_PTR(title_buffer),
+                                          style, state, settings_ptr);
     RB_GC_GUARD(title_buffer);
 
     if (window == NULL) {
         rb_raise(rb_eRuntimeError, "failed to create window");
     }
 
-    self = TypedData_Wrap_Struct(klass, &Window_data_type, window);
-
-    rb_obj_call_init(self, argc, argv);
+    Get_Window_Data(self)->handle = window;
+    Get_Window_Data(self)->kind = SFML_WINDOW_KIND_WINDOW;
 
     return self;
 }
@@ -80,8 +86,14 @@ static VALUE Window_new(int argc, VALUE* argv, VALUE klass) {
    Window#native_handle returns, or one obtained from a GUI toolkit. The window
    is not owned by the toolkit afterwards: destroying it stays the toolkit's
    job, and closing the Ruby object only tears down the render context. */
+/* call-seq:
+ *   Window.from_handle(handle, settings = nil) -> Window
+ *
+ * @return [Window]
+ * @raise [RuntimeError] if window creation fails
+ */
 static VALUE Window_s_from_handle(int argc, VALUE* argv, VALUE klass) {
-    VALUE self, rb_handle, rb_settings;
+    VALUE rb_handle, rb_settings;
     sfContextSettings settings;
     const sfContextSettings* settings_ptr = NULL;
     sfRenderWindow* window;
@@ -100,26 +112,17 @@ static VALUE Window_s_from_handle(int argc, VALUE* argv, VALUE klass) {
         rb_raise(rb_eRuntimeError, "failed to create window from handle");
     }
 
-    self = TypedData_Wrap_Struct(klass, &Window_data_type, window);
-
-    rb_obj_call_init(self, 0, NULL);
-
-    return self;
-}
-
-static VALUE Window_init(int argc, VALUE* argv, VALUE self) {
-    return self;
-}
-
-static VALUE Window_is_open(VALUE self) {
-    return BOOL2RB(sfRenderWindow_isOpen(Get_Window_Struct(self)));
-}
-
-static VALUE Window_close(VALUE self) {
-    sfRenderWindow_close(Get_Window_Struct(self));
-    return self;
+    return Window_wrap_handle(klass, window, SFML_WINDOW_KIND_WINDOW);
 }
 
+/* call-seq:
+ *   clear(color = Color::BLACK) -> self
+ *
+ * Clears the window to +color+ (black by default).
+ *
+ * @return [self]
+ * @raise [ArgumentError] if given more than one argument
+ */
 static VALUE Window_clear(int argc, VALUE* argv, VALUE self) {
     sfColor color = sfBlack;
 
@@ -137,181 +140,71 @@ static VALUE Window_clear(int argc, VALUE* argv, VALUE self) {
     return self;
 }
 
+/* call-seq: display -> self
+ *
+ * Presents everything drawn since the last call to the screen.
+ *
+ * @return [self]
+ */
 static VALUE Window_display(VALUE self) {
     sfRenderWindow_display(Get_Window_Struct(self));
     return self;
 }
 
-static VALUE Window_poll_event(VALUE self, VALUE rb_event) {
-    if (!rb_obj_is_kind_of(rb_event, Get_Klass_Event())) {
-        raise_invalid_argument_class(Get_Klass_Event());
-    }
-
-    return BOOL2RB(sfRenderWindow_pollEvent(Get_Window_Struct(self), Get_Event_Struct(rb_event)));
-}
-
-static VALUE Window_wait_event(VALUE self, VALUE rb_event) {
-    if (!rb_obj_is_kind_of(rb_event, Get_Klass_Event())) {
-        raise_invalid_argument_class(Get_Klass_Event());
-    }
-
-    return BOOL2RB(
-        sfRenderWindow_waitEvent(Get_Window_Struct(self), sfTime_Zero, Get_Event_Struct(rb_event)));
-}
-
-static VALUE Window_get_position(VALUE self) {
-    return VEC2_C2RB(sfRenderWindow_getPosition(Get_Window_Struct(self)));
-}
-
-static VALUE Window_set_position(VALUE self, VALUE rb_arr) {
-    sfRenderWindow_setPosition(Get_Window_Struct(self), vec2i_new_from_ruby(rb_arr));
-    return self;
-}
-
+/* call-seq:
+ *   frame_rate=(value) -> self
+ *
+ * Limits the framerate to +value+ frames per second; 0 disables the limit.
+ *
+ * @return [self]
+ */
 static VALUE Window_set_frame_rate(VALUE self, VALUE rb_limit) {
     sfRenderWindow_setFramerateLimit(Get_Window_Struct(self), NUM2INT(rb_limit));
     return self;
 }
 
-static VALUE Window_set_size(VALUE self, VALUE rb_size) {
-    sfRenderWindow_setSize(Get_Window_Struct(self), vec2u_from_rb(rb_size));
-    return self;
-}
-
-static VALUE Window_get_size(VALUE self) {
-    return VEC2_C2RB(sfRenderWindow_getSize(Get_Window_Struct(self)));
-}
-
-static VALUE Window_set_minimum_size(VALUE self, VALUE rb_size) {
-    sfVector2u size = vec2u_from_rb(rb_size);
-
-    sfRenderWindow_setMinimumSize(Get_Window_Struct(self), &size);
-
-    return rb_size;
-}
-
-static VALUE Window_set_maximum_size(VALUE self, VALUE rb_size) {
-    sfVector2u size = vec2u_from_rb(rb_size);
-
-    sfRenderWindow_setMaximumSize(Get_Window_Struct(self), &size);
-
-    return rb_size;
-}
-
+/* call-seq:
+ *   active=(value) -> true or false
+ *
+ * Activates or deactivates this window's OpenGL context as the current one on
+ * the calling thread.
+ *
+ * @return [Boolean] whether activation succeeded
+ */
 static VALUE Window_set_active(VALUE self, VALUE rb_active) {
     return BOOL2RB(sfRenderWindow_setActive(Get_Window_Struct(self), RTEST(rb_active)));
 }
 
-static VALUE Window_get_native_handle(VALUE self) {
-    return ULL2NUM(
-        (unsigned long long)(uintptr_t)sfRenderWindow_getNativeHandle(Get_Window_Struct(self)));
-}
-
-/* Vulkan handles cross this binding as Integers, the same way
-   SFML::Vulkan.function already returns one -- there is no Vulkan object model
-   here to wrap them in. Returns the new VkSurfaceKHR, or nil if creation
-   failed. */
-static VALUE Window_create_vulkan_surface(int argc, VALUE* argv, VALUE self) {
-    VALUE rb_instance, rb_allocator;
-    VkInstance instance;
-    VkSurfaceKHR surface;
-    const VkAllocationCallbacks* allocator = NULL;
-
-    rb_scan_args(argc, argv, "11", &rb_instance, &rb_allocator);
-
-    instance = (VkInstance)(uintptr_t)NUM2ULL(rb_instance);
-
-    if (!NIL_P(rb_allocator)) {
-        allocator = (const VkAllocationCallbacks*)(uintptr_t)NUM2ULL(rb_allocator);
-    }
-
-    if (!sfRenderWindow_createVulkanSurface(Get_Window_Struct(self), &instance, &surface,
-                                            allocator)) {
-        return Qnil;
-    }
-
-    return ULL2NUM((unsigned long long)(uintptr_t)surface);
-}
-
-static VALUE Window_set_icon(VALUE self, VALUE rb_size, VALUE rb_pixels) {
-    StringValue(rb_pixels);
-
-    sfRenderWindow_setIcon(Get_Window_Struct(self), vec2u_from_rb(rb_size),
-                           (const uint8_t*)RSTRING_PTR(rb_pixels));
-
-    return rb_pixels;
-}
-
-static VALUE Window_get_settings(VALUE self) {
-    return context_settings_to_rb(sfRenderWindow_getSettings(Get_Window_Struct(self)));
-}
-
-/* Through the UTF-32 entry point: sfRenderWindow_setTitle decodes the bytes
-   with the C locale and mangles anything outside ASCII. */
-static VALUE Window_set_title(VALUE self, VALUE rb_title) {
-    VALUE buffer = utf32_from_rb(rb_title);
-
-    sfRenderWindow_setUnicodeTitle(Get_Window_Struct(self), UTF32_PTR(buffer));
-
-    RB_GC_GUARD(buffer);
-
-    return self;
-}
-
-static VALUE Window_set_visible(VALUE self, VALUE rb_visible) {
-    sfRenderWindow_setVisible(Get_Window_Struct(self), RTEST(rb_visible));
-    return self;
-}
-
+/* call-seq:
+ *   vertical_sync_enabled=(value) -> self
+ *
+ * Enables or disables vertical synchronization.
+ *
+ * @return [self]
+ */
 static VALUE Window_set_vertical_sync_enabled(VALUE self, VALUE rb_enable) {
     sfRenderWindow_setVerticalSyncEnabled(Get_Window_Struct(self), RTEST(rb_enable));
     return self;
 }
 
-static VALUE Window_set_mouse_cursor_visible(VALUE self, VALUE rb_visible) {
-    sfRenderWindow_setMouseCursorVisible(Get_Window_Struct(self), RTEST(rb_visible));
-    return self;
-}
-
-static VALUE Window_set_mouse_cursor_grabbed(VALUE self, VALUE rb_grabbed) {
-    sfRenderWindow_setMouseCursorGrabbed(Get_Window_Struct(self), RTEST(rb_grabbed));
-    return self;
-}
-
-static VALUE Window_set_mouse_cursor(VALUE self, VALUE rb_cursor) {
-    if (NIL_P(rb_cursor)) {
-        sfRenderWindow_setMouseCursor(Get_Window_Struct(self), NULL);
-        return rb_cursor;
-    }
-
-    if (!rb_obj_is_kind_of(rb_cursor, Get_Klass_Cursor())) {
-        raise_invalid_argument_class(Get_Klass_Cursor());
-    }
-
-    sfRenderWindow_setMouseCursor(Get_Window_Struct(self), Get_Cursor_Struct(rb_cursor));
-
-    return rb_cursor;
-}
-
-static VALUE Window_set_key_repeat_enabled(VALUE self, VALUE rb_enabled) {
-    sfRenderWindow_setKeyRepeatEnabled(Get_Window_Struct(self), RTEST(rb_enabled));
-    return self;
-}
-
-static VALUE Window_set_joystick_threshold(VALUE self, VALUE rb_threshold) {
-    sfRenderWindow_setJoystickThreshold(Get_Window_Struct(self), NUM2DBL(rb_threshold));
-    return rb_threshold;
-}
-
-static VALUE Window_request_focus(VALUE self) {
-    sfRenderWindow_requestFocus(Get_Window_Struct(self));
-    return self;
-}
-
-static VALUE Window_has_focus(VALUE self) {
-    return BOOL2RB(sfRenderWindow_hasFocus(Get_Window_Struct(self)));
+/* call-seq: settings -> ContextSettings
+ *
+ * Returns the context settings this window was created with.
+ *
+ * @return [ContextSettings] the settings this window's context was created with
+ */
+static VALUE Window_get_settings(VALUE self) {
+    return context_settings_to_rb(sfRenderWindow_getSettings(Get_Window_Struct(self)));
 }
 
+/* call-seq:
+ *   draw(drawable, state = nil) -> self
+ *
+ * Draws +drawable+ into the window.
+ *
+ * @return [self]
+ * @raise [ArgumentError] if given no arguments or more than 2
+ */
 static VALUE Window_draw(int argc, VALUE* argv, VALUE self) {
     VALUE rb_drawable, rb_state;
 
@@ -327,6 +220,13 @@ static VALUE Window_draw(int argc, VALUE* argv, VALUE self) {
     return self;
 }
 
+/* call-seq: view=(value) -> self
+ *
+ * Sets the window's active view to +value+.
+ *
+ * @return [self]
+ * @raise [ArgumentError] if +value+ is not a View
+ */
 static VALUE Window_set_view(VALUE self, VALUE rb_view) {
     if (!rb_obj_is_kind_of(rb_view, Get_Klass_View())) {
         rb_raise(rb_eArgError, "invalid object, expected a View object");
@@ -337,10 +237,22 @@ static VALUE Window_set_view(VALUE self, VALUE rb_view) {
     return self;
 }
 
+/* call-seq: view -> View
+ *
+ * Returns a copy of the window's currently active view.
+ *
+ * @return [View] a copy of the window's currently active view
+ */
 static VALUE Window_get_view(VALUE self) {
     return Get_Casting_View(sfView_copy(sfRenderWindow_getView(Get_Window_Struct(self))));
 }
 
+/* call-seq: default_view -> View
+ *
+ * Returns a copy of the window's default view.
+ *
+ * @return [View] a copy of the window's default view
+ */
 static VALUE Window_get_default_view(VALUE self) {
     return Get_Casting_View(sfView_copy((sfRenderWindow_getDefaultView(Get_Window_Struct(self)))));
 }
@@ -353,62 +265,149 @@ static VALUE Window_get_default_view(VALUE self) {
 #undef RT_METHOD
 #undef RT_HANDLE
 
-void Init_Window(VALUE rb_module) {
-    rb_cWindow = rb_define_class_under(rb_module, "Window", rb_cObject);
+/* Document-class: SFML::Window
+ * A renderable OS window with an OpenGL context attached. It derives from
+ * SFML::WindowBase; SFML::RenderWindow is the same object under the name that
+ * includes SFML::RenderTarget.
+ *
+ * @!method is_open?
+ *   Returns +true+ while the window is open.
+ *   @return [Boolean]
+ * @!method close!
+ *   Closes the window.
+ *   @return [self]
+ * @!method poll_event!(event)
+ *   Pops the next pending event into +event+, if any, without blocking.
+ *   @return [Boolean] whether an event was popped
+ * @!method wait_event!(event)
+ *   Blocks until an event is available and pops it into +event+.
+ *   @return [Boolean] whether an event was popped
+ * @!method position
+ *   Returns the window's position in desktop coordinates.
+ *   @return [Vector2]
+ * @!method position=(value)
+ *   Moves the window to +value+.
+ *   @return [Vector2] +value+
+ * @!method size
+ *   Returns the client area size in pixels.
+ *   @return [Vector2]
+ * @!method size=(value)
+ *   Resizes the window's client area.
+ *   @return [self]
+ * @!method minimum_size=(value)
+ *   Sets the window's minimum allowed client size.
+ *   @return [Vector2] +value+
+ * @!method maximum_size=(value)
+ *   Sets the window's maximum allowed client size.
+ *   @return [Vector2] +value+
+ * @!method title=(value)
+ *   Sets the window title.
+ *   @return [self]
+ * @!method set_icon(size, pixels)
+ *   Sets the window's icon from RGBA32 pixel data.
+ *   @return [String] +pixels+
+ * @!method visible=(value)
+ *   Shows or hides the window.
+ *   @return [self]
+ * @!method cursor_visible=(value)
+ *   Shows or hides the mouse cursor over the window.
+ *   @return [self]
+ * @!method cursor_grabbed=(value)
+ *   Confines or releases the mouse cursor to the window's client area.
+ *   @return [self]
+ * @!method mouse_cursor=(value)
+ *   Sets the window's mouse cursor.
+ *   @return [Cursor] +value+
+ * @!method cursor=(value)
+ *   Sets the window's mouse cursor.
+ *   @return [Cursor] +value+
+ * @!method key_repeat_enabled=(value)
+ *   Enables or disables key-repeat events.
+ *   @return [self]
+ * @!method joystick_threshold=(value)
+ *   Sets the minimum joystick axis change that generates a move event.
+ *   @return [Float] +value+
+ * @!method request_focus
+ *   Requests focus for this window.
+ *   @return [self]
+ * @!method focus?
+ *   Returns +true+ if the window currently has focus.
+ *   @return [Boolean]
+ * @!method native_handle
+ *   Returns the OS-specific window handle.
+ *   @return [Integer]
+ * @!method create_vulkan_surface(instance, allocator = nil)
+ *   Creates a Vulkan surface for this window.
+ *   @return [Integer, nil] the new +VkSurfaceKHR+, or +nil+ if creation failed
+ * @!method srgb?
+ *   Returns +true+ if the target's framebuffer is sRGB-capable.
+ *   @return [Boolean]
+ * @!method clear_stencil(value)
+ *   Clears the stencil buffer to +value+.
+ *   @return [self]
+ * @!method clear_color_and_stencil(color, stencil)
+ *   Clears the color buffer to +color+ and the stencil buffer to +stencil+.
+ *   @return [self]
+ * @!method viewport(view = nil)
+ *   Returns the current viewport rectangle in pixels.
+ *   @return [Rect] the current viewport in pixels; +view+ defaults to the target's current view
+ * @!method scissor(view = nil)
+ *   Returns the current scissor rectangle in pixels.
+ *   @return [Rect] the current scissor rectangle in pixels; +view+ defaults to the target's current
+ * view
+ * @!method map_pixel_to_coords(point, view = nil)
+ *   Converts a pixel position to world coordinates, using the inverse of the view transform.
+ *   @return [Vector2]
+ * @!method map_coords_to_pixel(point, view = nil)
+ *   Converts a world position to pixel coordinates.
+ *   @return [Vector2]
+ * @!method push_gl_states
+ *   Saves the current OpenGL state.
+ *   @return [self]
+ * @!method pop_gl_states
+ *   Restores the OpenGL state saved by #push_gl_states.
+ *   @return [self]
+ * @!method reset_gl_states
+ *   Resets the OpenGL state to SFML's defaults.
+ *   @return [self]
+ * @!method draw_primitives(vertices, primitive, state = nil)
+ *   Draws raw vertex data as the given primitive type.
+ *   @return [self]
+ * @!method draw_vertex_buffer_range(buffer, first, count, state = nil)
+ *   Draws a range of vertices from a vertex buffer.
+ *   @return [self]
+ */
+void Init_Window(VALUE rb_mSFML) {
+    rb_cWindow = rb_define_class_under(rb_mSFML, "Window", Get_Klass_WindowBase());
+
+    rb_define_alloc_func(rb_cWindow, Window_alloc);
 
-    rb_define_singleton_method(rb_cWindow, "new", Window_new, -1);
     rb_define_singleton_method(rb_cWindow, "from_handle", Window_s_from_handle, -1);
 
+    // methods generated from window_base.inc, overridden with sfRenderWindow_*
+    Window_define_methods(rb_cWindow);
+
     // methods
-    rb_define_method(rb_cWindow, "initialize", Window_init, -1);
-    rb_define_method(rb_cWindow, "is_open?", Window_is_open, 0);
-    rb_define_method(rb_cWindow, "close!", Window_close, 0);
+    rb_define_method(rb_cWindow, "initialize", Window_initialize, -1);
     rb_define_method(rb_cWindow, "clear", Window_clear, -1);
     rb_define_method(rb_cWindow, "display", Window_display, 0);
-    rb_define_method(rb_cWindow, "poll_event!", Window_poll_event, 1);
-    rb_define_method(rb_cWindow, "wait_event!", Window_wait_event, 1);
 
     // setters
     rb_define_method(rb_cWindow, "frame_rate=", Window_set_frame_rate, 1);
     rb_define_method(rb_cWindow, "framerate_limit=", Window_set_frame_rate, 1);
-    rb_define_method(rb_cWindow, "size=", Window_set_size, 1);
-    rb_define_method(rb_cWindow, "minimum_size=", Window_set_minimum_size, 1);
-    rb_define_method(rb_cWindow, "maximum_size=", Window_set_maximum_size, 1);
-    rb_define_method(rb_cWindow, "title=", Window_set_title, 1);
-    rb_define_method(rb_cWindow, "set_icon", Window_set_icon, 2);
-    rb_define_method(rb_cWindow, "visible=", Window_set_visible, 1);
     rb_define_method(rb_cWindow, "active=", Window_set_active, 1);
     rb_define_method(rb_cWindow, "vertical_sync_enabled=", Window_set_vertical_sync_enabled, 1);
-    rb_define_method(rb_cWindow, "cursor_visible=", Window_set_mouse_cursor_visible, 1);
-    rb_define_method(rb_cWindow, "cursor_grabbed=", Window_set_mouse_cursor_grabbed, 1);
-    rb_define_method(rb_cWindow, "mouse_cursor=", Window_set_mouse_cursor, 1);
-    rb_define_method(rb_cWindow, "cursor=", Window_set_mouse_cursor, 1);
-    rb_define_method(rb_cWindow, "key_repeat_enabled=", Window_set_key_repeat_enabled, 1);
-    rb_define_method(rb_cWindow, "joystick_threshold=", Window_set_joystick_threshold, 1);
-    rb_define_method(rb_cWindow, "position=", Window_set_position, 1);
     rb_define_method(rb_cWindow, "view=", Window_set_view, 1);
 
     // getters
-    rb_define_method(rb_cWindow, "request_focus", Window_request_focus, 0);
-    rb_define_method(rb_cWindow, "focus?", Window_has_focus, 0);
     rb_define_method(rb_cWindow, "draw", Window_draw, -1);
-    rb_define_method(rb_cWindow, "position", Window_get_position, 0);
-    rb_define_method(rb_cWindow, "size", Window_get_size, 0);
     rb_define_method(rb_cWindow, "view", Window_get_view, 0);
     rb_define_method(rb_cWindow, "default_view", Window_get_default_view, 0);
     rb_define_method(rb_cWindow, "settings", Window_get_settings, 0);
-    rb_define_method(rb_cWindow, "native_handle", Window_get_native_handle, 0);
-    rb_define_method(rb_cWindow, "create_vulkan_surface", Window_create_vulkan_surface, -1);
 
     Window_define_render_target_methods(rb_cWindow);
 }
 
-void* Get_Window_Struct(VALUE self) {
-    sfRenderWindow* ptr;
-    TypedData_Get_Struct(self, sfRenderWindow, &Window_data_type, ptr);
-    return ptr;
-}
-
-VALUE Get_Klass_Window() {
+VALUE Get_Klass_Window(void) {
     return rb_cWindow;
-}
+}

data/ext/window/window.h

@@ -3,10 +3,10 @@
 
 #include <ruby.h>
 
-void Init_Window(VALUE rb_module);
+#include "window/window_base.h"
 
-void *Get_Window_Struct(VALUE self);
+void Init_Window(VALUE rb_module);
 
-VALUE Get_Klass_Window();
+VALUE Get_Klass_Window(void);
 
-#endif //SFML_RB_WINDOW_WINDOW_H
+#endif // SFML_RB_WINDOW_WINDOW_H