sdl2_ffi 0.0.3 → 0.0.4

data/lib/sdl2/window.rb

@@ -7,9 +7,9 @@ require 'sdl2/display/mode'
 
 module SDL2
 
-  # System Window
-  # A rectangular area you can blit into.
-  class Window < Struct
+  # Window Flags Constants
+  module WINDOW
+    include EnumerableConstants
     FULLSCREEN         = 0x00000001
     OPENGL             = 0x00000002
     SHOWN              = 0x00000004
@@ -23,6 +23,66 @@ module SDL2
     MOUSE_FOCUS        = 0x00000400
     FULLSCREEN_DESKTOP = ( FULLSCREEN | 0x00001000 )
     FOREIGN            = 0x00000800
+  end
+
+  # Used to indicate that you don't care what the window position is.
+  module WINDOWPOS
+    include EnumerableConstants
+    UNEDFINED_MASK = 0x1FFF0000
+
+    # Used to generate the UNDEFINED constant,
+    # which if I understand correctly is just UNDEFINED_MASK anyways.
+    # I think this is to encourage divers/applications to write specific
+    # undefined codes? `</ramble>`
+    def self.undefined_display(x)
+      self::UNEDFINED_MASK|x
+    end
+
+    UNDEFINED = undefined_display(0)
+
+    # SDL_video.h doesn't have much documentation on this,
+    # I think it is used internally, but may be useful for applications.
+    def self.is_undefined(x)
+      (((x)&0xFFFFF00000) == self::UNDEFINED_MASK)
+    end
+
+    CENTERED_MASK = 0x2FFF0000
+
+    def self.centered_display(x)
+      self::CENTERED_MASK | x
+    end
+
+    CENTERED = centered_display(0)
+
+    def self.is_centered(x)
+      (((x)&0xFFFF0000) == self::CENTERED_MASK)
+    end
+  end
+
+  # Event subtype for window events
+  module WINDOWEVENT
+    include EnumerableConstants
+    NONE          = next_const_value
+    SHOWN         = next_const_value
+    HIDDEN        = next_const_value
+    EXPOSED       = next_const_value
+    MOVED         = next_const_value
+    RESIZED       = next_const_value
+    SIZE_CHANGED  = next_const_value
+    MINIMIZED     = next_const_value
+    MAXIMIZED     = next_const_value
+    RESTORED      = next_const_value
+    ENTER         = next_const_value
+    LEAVE         = next_const_value
+    FOCUS_GAINED  = next_const_value
+    FOCUS_LOST    = next_const_value
+    CLOSE         = next_const_value
+  end
+
+  # System Window
+  # A rectangular area you can blit into.
+  class Window < Struct
+    include WINDOW
 
     layout :magic, :pointer,
     :id, :uint32,
@@ -47,53 +107,69 @@ module SDL2
     :shaper, :pointer, # TODO: WindowShaper.by_ref,
     :data, :pointer,
     :driverdata, :pointer,
-    :prev, Window.by_ref,
-    :next, Window.by_ref
+    :prev, :pointer,
+    :next, :pointer
 
+    # A simple wrapper for data objects associated with a window.
     class Data
 
+      # Create a data object manager for a given window
       def initialize(for_window)
         @for_window = for_window
       end
 
-      def [](name)
-        named(name)
-      end
-
+      # Return the data named
       def named(name)
         SDL2.get_window_data(@for_window, name.to_s)
       end
 
+      alias_method :[], :named
+
+      # Set the data named to value specified.
       def named=(name, value)
         SDL2.set_window_data(@for_window, name.to_s, value.to_s)
       end
+
+      alias_method :[]=, :named=
     end
 
+    # The Window's data manager.
     attr_reader :data
 
+    # Construct a new window.
     def initialize(*args, &block)
       super(*args, &block)
       @data = Data.new(self)
     end
 
+    # Construct a new window with given:
+    # @param title: The caption to use for the window
+    # @param x: The x-position of the window
+    # @param y: The y-position of the window
+    # @param w: The width of the window
+    # @param h: The height of the window
+    # @param flags: Window Flags to use in construction
     def self.create(title ='', x = 0, y = 0, w = 100, h = 100, flags = 0)
-      SDL2.create_window(title, x, y, w, h, flags)
+      SDL2.create_window!(title, x, y, w, h, flags)
     end
 
+    # Constructs a new window from arbitrary system-specific structure
+    # @param data: Some system-specific pointer
+    # See SDL Documentation
     def self.create_from(data)
-      create_window_from(data)
+      create_window_from!(data)
     end
 
+    # Returns the identified window already created
+    # @param id: The window identifier to retrieve
     def self.from_id(id)
-      get_window_from_id(id)
-    end
-
-    def self.create!(*args)
-      creation = create(*args)
-      get_error() if creation.null?
-      return creation
+      get_window_from_id!(id)
     end
 
+    # Constructs both a window and a renderer
+    # @param w: The Width of the pair to create
+    # @param h: The Height of the pair to create
+    # @param flags: Window flags to utilize in creation
     def self.create_with_renderer(w, h, flags)
       window = Window.new
       renderer = Renderer.new
@@ -104,18 +180,22 @@ module SDL2
       end
     end
 
+    # Release memory utilized by structure
     def self.release(pointer)
       destroy_window(pointer)
     end
 
+    # Return the brightness level
     def brightness
       SDL2.get_window_brightness(self)
     end
 
+    # Set the brightness level
     def brightness=(level)
       SDL2.set_window_brightness(self, level.to_f)
     end
 
+    # Get a copy of the DisplayMode structure
     def display_mode
       dm = SDL2::Display::Mode.new
       if SDL2.get_window_display_mode(self, dm) == 0
@@ -126,82 +206,93 @@ module SDL2
       end
     end
 
+    # Get the display index associated with this window
     def display_index
       SDL2.get_window_display_index(self)
     end
 
+    # Get the display associated with this window
     def display
       Display[display_index]
     end
 
+    # Get the window flags
     def flags
       SDL2.get_window_flags(self)
     end
 
+    # The window's input grab mode
     def grab?
-      get_window_grab(self) == :true
+      SDL2.get_window_grab?(self)
     end
 
+    # Set the input grab mode
     def grab=(value)
-      unless value == :true or value == :false
-        value = value ? :true : :false
-      end
-      set_window_grab(self, value)
+      SDL2.set_window_grab(self, value)
     end
 
+    # Get the window identifier
     def id
       SDL2.get_window_id(self)
     end
 
+    # Get the window pixel format
     def pixel_format
       SDL2.get_window_pixel_format(self)
     end
 
+    # Get the window title caption
     def title
       SDL2.get_window_title(self)
     end
 
+    # Set the window title caption
     def title=(value)
       SDL2.set_window_title(self, value)
     end
 
+    # Hide the window
     def hide
       SDL2.hide_window(self)
     end
 
+    # Maximize the window
     def maximize
       SDL2.maximize_window(self)
     end
 
+    # Minimize the window
     def minimize
       SDL2.minimize_window(self)
     end
 
+    # Raise the window
     def raise_above
       SDL2.raise_window(self)
     end
 
+    # Restore the window
     def restore
       SDL2.restore_window(self)
     end
-    
+
+    # Show the window
     def show
       SDL2.show_window(self)
     end
 
+    # Set the window's icon from a surface
     def icon=(surface)
       set_window_icon(self, surface)
     end
 
+    # Update the window's surface
     def update_surface()
-      SDL2.update_window_surface(self)
-    end
-    
-    def update_surface!()      
-      SDL2.raise_error_unless update_surface == 0
-      return 0
+      SDL2.update_window_surface!(self)
     end
 
+    # Get the window's current size
+    # @return Array => [<width>, <height>]
     def current_size()
       w_struct, h_struct = IntStruct.new, IntStruct.new
       SDL2::get_window_size(self, w_struct, h_struct)
@@ -209,10 +300,14 @@ module SDL2
       [w, h]
     end
 
+    # Set the window's current size
+    # @param size: A array containing the [width,height]
     def current_size=(size)
       SDL2.set_window_size(self, size[0], size[1])
     end
 
+    # Get the window's maximum_size
+    # @return Array => [<width>, <height>]
     def maximum_size
       w_struct, h_struct = IntStruct.new, IntStruct.new
       SDL2::get_window_maximum_size(self, w_struct, h_struct)
@@ -220,21 +315,29 @@ module SDL2
       [w, h]
     end
 
+    # Set the window's maximum size
+    # @param size: A array containing the [width,height]
     def maximum_size=(size)
       SDL2.set_window_maximum_size(self, size[0], size[1])
     end
 
+    # Get the window's minimum size
+    # @return Array => [<width>, <height>]
     def minimum_size
       w_struct, h_struct = IntStruct.new, IntStruct.new
       SDL2::get_window_minimum_size(self, w_struct, h_struct)
-      w, h = w_struct[:value], h_struct[:value]      
+      w, h = w_struct[:value], h_struct[:value]
       [w, h]
     end
 
+    # Set the window's minimum size
+    # @param size: A array containing the [width,height]
     def minimum_size=(size)
       SDL2.set_window_minimum_size(self, size[0], size[1])
-    end    
-    
+    end
+
+    # Get the window's position
+    # @return Array => [<x>, <y>]
     def position
       position = [IntStruct.new, IntStruct.new]
       SDL2::get_window_position(self, position[0], position[1])
@@ -242,15 +345,19 @@ module SDL2
       position.each{|struct|struct.pointer.free}
       [x, y]
     end
-    
+
+    # Set the window's position
+    # @param size: A array containing the [x,y]
     def position=(location)
       SDL2::set_window_position(self, location[0],location[1])
     end
-    
+
+    # Return the surface associated with the window
     def surface
       SDL2.get_window_surface(self)
     end
-    
+
+    # Set the window's FULLSCREEN mode flags.
     def fullscreen=(flags)
       SDL2.set_window_fullscreen(self, flags)
     end

data/lib/sdl2_ffi.rb

@@ -1,6 +1,7 @@
 require 'sdl2'
 require 'ffi'
 
-# Alias the module, in case of confusion?
+# Simple ALIAS of SDL2
 SDL2_FFI = SDL2 
+# Simple ALIAS of SDL2
 Sdl2_Ffi = SDL2

data/sdl2_ffi.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   
   spec.add_dependency 'ffi'
-  spec.add_dependency 'yinum'
   spec.add_dependency 'activesupport'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
@@ -28,4 +27,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'guard'
   spec.add_development_dependency 'guard-minitest'
+  spec.add_development_dependency 'yard'
+  
+  
 end

data/test/functional/examples/test_lazy_foo_examples.rb

@@ -0,0 +1,123 @@
+require_relative '../../test_helper'
+
+describe "Hello World example translated from: http://lazyfoo.net/SDL_tutorials/lesson01/index2.php" do
+
+  BMP = Hash.new(){ | bmps, key |  bmps[key] = File.expand_path("#{key}.bmp", FIXTURE_DIR) }
+  PNG = Hash.new(){ | bmps, key |  bmps[key] = File.expand_path("#{key}.png", FIXTURE_DIR) }
+  
+  
+  # Functional Translated from: 
+  # http://lazyfoo.net/SDL_tutorials/lesson01/index2.php
+  it "runs LazyFoo.net's Hello World example" do
+    
+    require 'sdl2'
+    
+    hello = nil
+    window = nil
+    screen = nil
+    
+    # BANG(!) versions of methods Raise RuntimeErrors if needed.
+    SDL2.init!(:EVERYTHING) 
+    
+    window = SDL2::Window.create('Hello World', :UNDEFINED, :UNDEFINED, 640, 480, :SHOWN)
+    
+    
+    screen = window.surface
+    
+    #binding.pry
+    hello = SDL2::Surface.load_bmp(BMP[:hello])
+    
+    screen.blit_in(hello) 
+    
+    window.update_surface
+    
+    #SDL2::delay(2000)
+        
+    SDL2::quit() # Since the Quit function can't fail, there is no BANG(!) version.
+            
+  end
+  
+  # Functional Example Translated from:
+  # http://lazyfoo.net/SDL_tutorials/lesson02/index.php
+  it "runs LazyFoo.net's Optimized Surface Loading and Blitting " do
+    
+    width = 640
+    height = 480
+    
+    message = nil
+    background = nil
+    SDL2.init!(:EVERYTHING)
+    
+    window = SDL2::Window.create("Optimized Images!", :CENTERED, :CENTERED, width, height)
+    @screen = window.surface
+   
+    
+    def load_image(filename)      
+      loadedImage = SDL2.load_bmp!(filename)            
+      optimizedImage = @screen.convert(loadedImage)
+      loadedImage.free
+      return optimizedImage
+    end
+    
+    def apply_surface(x, y, source, dest)
+      offset = SDL2::Rect.new
+      offset.x, offset.y = x,y
+      offset.w, offset.h = source.w, source.h
+      source.blit_out(dest, offset)
+    end
+    
+    
+    
+    message = load_image(BMP[:hello])    
+    background = load_image(BMP[:background])
+      
+    apply_surface(0,0, background, @screen)
+    apply_surface(320,0, background, @screen)
+    apply_surface(0,240, background, @screen)
+    apply_surface(320,240, background, @screen)
+    
+    apply_surface(180, 140, message, @screen)
+    
+    
+    window.update_surface
+    
+    # SDL2.delay(2000) # Watch it for a sec.
+    
+    message.free
+    background.free
+    
+    SDL2.quit()
+    
+  end
+  
+  it "runs LazyFoo.net's SDL Extension Libraries" do
+    require 'sdl2/image'
+    
+    SDL2.init! :EVERYTHING
+    
+    @window = SDL2::Window.create("Extension Libraries", :CENTERED, :CENTERED, 640, 480)
+    @screen = @window.surface
+    
+    # We can load more now, not just BMPs!
+    def load_image(filename)
+      loadedImage = SDL2::Image.load!(filename)
+      optimizedImage = @screen.convert(loadedImage)
+      loadedImage.free
+      return optimizedImage
+    end
+    
+    a_png = load_image(PNG[:an_example])
+      
+    a_png.blit_out(@screen)
+    
+    @window.update_surface
+    
+    SDL2.delay(2000) # sleep 1
+    
+    a_png.free
+    
+    SDL2.quit()
+    
+  end
+    
+end