sdl2_ffi 0.0.6 → 0.0.7

data/lib/sdl2/blendmode.rb

@@ -0,0 +1,18 @@
+module SDL2
+  module BLENDMODE
+    include EnumerableConstants
+    NONE = 0x00000000
+    BLEND = 0x00000001
+    ADD = 0x00000002
+    MOD = 0x00000004
+  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.
+  enum :blend_mode, BLENDMODE.flatten_consts
+
+  class SDL2::TypedPointer::BlendMode < SDL2::TypedPointer
+    layout :value, :blend_mode
+  end
+
+end

data/lib/sdl2/color.rb

@@ -20,10 +20,8 @@ module SDL2
     # If possible, convert argument into a SDL::Color
     def self.cast(something)
       if something.kind_of? Array
-        something.map!(&:to_i)
         result = new
-        result.set(*something)
-
+        result.set(*(something.map(&:to_i)))
         return result
       else
         return super

data/lib/sdl2/debug.rb

@@ -0,0 +1,58 @@
+module SDL2
+  # This class manages logging output
+  module Debug
+
+    ENABLED = Hash.new do 
+      false # Always defaults to false
+    end
+    
+    STATE = {
+      log_to: STDERR,
+      recursion: 0,
+      last_caller: [],
+    }
+    
+    ##
+    # Returns true if the instance
+    # It will return true if the object inherits from a class enabled for debugging.
+    def self.enabled?(obj)
+      # Immediately return true if we are debugging this instance specifically.
+      return true if ENABLED[obj] 
+      # Otherwise, check if the object is a class or get it's class.
+      klass = obj.kind_of?(Class) ? obj : obj.class
+      # And until there is no more superclass.
+      until klass == nil
+        # Return true if the class is enabled for debugging.
+        return true if ENABLED[klass]
+        # Otherwise keep searching.
+        klass = klass.superclass
+      end
+      # If we got this far, it is a bust.
+      false
+    end
+    
+    ##
+    # Takes an instance or a class to enable for debugging.
+    # NOTE: If you only enable a single instance, then you will not see messages from the class-level.
+    def self.enable(obj)
+      ENABLED[obj] = true
+    end
+
+    ##
+    # This will log a message from a method.
+    # The source object is required (usually self) and this is how debugging is controlled.
+    # The message must be specified in a block which will never be evaluated unless debugging is enabled for the source.
+    # The source class will be identified along with the method name calling log in the output.
+    def self.log(src, &msg_block)
+      return unless klass = enabled?(src)
+      method_name =  /.*`(.*)'/.match(caller.first)[1]
+      is_class = src.kind_of?(Class)
+      klass = is_class ? src : src.class
+      msg_start = "#{klass.to_s}#{is_class ? '::' : '#'}#{method_name} >"     
+      msg = msg_block.nil? ? "No message" : msg_block.call
+      STATE[:log_to].puts(caller.first)
+      STATE[:log_to].puts(msg_start + msg)
+    end
+  end
+
+end

data/lib/sdl2/display.rb

@@ -3,22 +3,24 @@ require 'sdl2/display/modes'
 require 'sdl2/display/mode'
 
 module SDL2
-
+  ##
   # Abstract representation of what SDL calls a "Display"
   class Display
-
-    attr_reader :id   
-       
+    ##
+    # Every display has an id, an index.
+    attr_reader :id       
+    ##
+    # Initialize a new display for index display_id
     def initialize(display_id)
       @id = display_id.to_i # It should be an integer.
-      
     end
-
-        
+    ##
+    # Every display has many modes        
     def modes
       @modes ||= Modes.new(self)
     end
-
+    ##
+    # Get the display instance for index display_id
     def self.[](display_id)
       if (idx = display_id.to_i) < count
         return Display.new(display_id)
@@ -26,32 +28,37 @@ module SDL2
         return nil
       end
     end
-
+    ##
+    # Get the number of displays
     def self.count
-      SDL2.get_num_video_displays()
+      SDL2.get_num_video_displays!()
     end
-
-    def self.count!
-      total = count
-      SDL2.raise_error_if total < 0
-      return total
+    ##
+    # An alias for count, the number of displays
+    def self.num
+      self.count
     end
-
+    ##
+    # Return the first display
     def self.first
       self[0]
     end
-
+    ##
+    # Retrieve a display mode closest to a requested ideal.
+    # May return nil
     def closest_display_mode(wanted)
       closest = SDL2::Display::Mode.new # Make a new structure.
       return SDL2.get_closest_display_mode(@id, wanted, closest)
     end
-
-    def closest_display_mode!(wanted)
-      found = closest_display_mode(wanted)
-      SDL2.raise_error_if(found.nil?)
-      return found
+    ##
+    # Get the current display mode
+    def current_display_mode
+      display_mode = SDL2::Display::Mode.new
+      SDL2.get_current_display_mode!(@id, display_mode)
+      display_mode
     end
-
+    ##
+    # Returns the bounds
     def bounds
       rect = SDL2::Rect.new
       if SDL2.get_display_bounds(@id, rect) == 0

data/lib/sdl2/error.rb

@@ -1,15 +1,17 @@
 require 'sdl2'
 
+##
+# sdl_error.h - Error handling routines.
 module SDL2
-
+  
   ##
-	#
+	# Remove current SDL error string.
 	api :SDL_ClearError, [], :void
   ##
-	#
+	# Retrieve current SDL error string.
 	api :SDL_GetError, [], :string
   ##
-	#
+	# Set current SDL error string.
 	api :SDL_SetError, [:string, :varargs], :int
     
 end

data/lib/sdl2/event.rb

@@ -0,0 +1,229 @@
+module SDL2
+  ##
+  # # Object oriented representation of SDL_Event union
+  class Event < Union
+  end
+  ##
+  # ## Event Enumerations/Constants:
+  # - TYPE
+  # - ACTION
+  # - STATE
+  class Event 
+    autoload(:TYPE, 'sdl2/event/type')
+    autoload(:ACTION, 'sdl2/event/action')
+    autoload(:STATE, 'sdl2/event/state')
+  end
+  enum :event_type, Event::TYPE.flatten_consts
+  enum :eventaction, Event::ACTION.flatten_consts
+
+  ##
+  # Sub-Structures
+  class Event
+    autoload(:Abstract, 'sdl2/event/abstract')
+    autoload(:Common, 'sdl2/event/common')
+    autoload(:Window, 'sdl2/event/window')
+    autoload(:Keyboard, 'sdl2/event/keyboard')
+    autoload(:TextEditing,'sdl2/event/text_editing')
+    autoload(:TextInput,'sdl2/event/text_input')
+    autoload(:MouseMotion,'sdl2/event/mouse_motion')
+    autoload(:MouseButton,'sdl2/event/mouse_button')
+    autoload(:MouseWheel,'sdl2/event/mouse_wheel')
+    autoload(:JoyAxis, 'sdl2/event/joy_axis')
+    autoload(:JoyBall, 'sdl2/event/joy_ball')
+    autoload(:JoyHat, 'sdl2/event/joy_hat')
+    autoload(:JoyButton, 'sdl2/event/joy_button')
+    autoload(:JoyDevice, 'sdl2/event/joy_device')
+    autoload(:ControllerAxis, 'sdl2/event/controller_axis')
+    autoload(:ControllerButton, 'sdl2/event/controller_button')
+    autoload(:ControllerDevice, 'sdl2/event/controller_device')
+    autoload(:TouchFinger, 'sdl2/event/touch_finger')
+    autoload(:MultiGesture, 'sdl2/event/multi_gesture')
+    autoload(:DollarGesture, 'sdl2/event/dollar_gesture')
+    autoload(:Drop,'sdl2/event/drop')
+    autoload(:Quit,'sdl2/event/quit')
+    autoload(:OS, 'sdl2/event/os')
+    autoload(:User, 'sdl2/event/user')
+    autoload(:SysWM, 'sdl2/event/sys_wm')
+  end
+  ##
+  # Union Layout
+  class Event
+    layout :type, :event_type,
+    :common, Common,
+    :window, Window,
+    :key, Keyboard,
+    :edit, TextEditing,
+    :text, TextInput,
+    :motion, MouseMotion,
+    :button, MouseButton,
+    :wheel, MouseWheel,
+    :jaxis, JoyAxis,
+    :jball, JoyBall,
+    :jbutton, JoyButton,
+    :jdevice, JoyDevice,
+    :caxis, ControllerAxis,
+    :cbutton, ControllerButton,
+    :cdevice, ControllerDevice,
+    :quit, Quit,
+    :user, User,
+    :syswm, SysWM,
+    :tfinger, TouchFinger,
+    :mgesture, MultiGesture,
+    :drop, Drop,
+    :padding, [:uint8, 56] # From SDL_events.h:529
+
+    member_readers *members
+    member_writers *members
+    
+    ##
+    # Set the state of processing event types:
+    def self.state(type,state=:QUERY)
+      SDL2.event_state(type,state)
+    end
+    ##
+    # Polls for currently pending events.
+    # @returns SDL2::Event or nil if there are no events.
+    def self.poll()
+      tmp_event = SDL2::Event.new
+      unless SDL2.poll_event?(tmp_event)
+        tmp_event.pointer.free
+        tmp_event = nil
+      end
+      return tmp_event # May be nil if SDL2.poll_event fails.
+    end
+    ##
+    # Use this function to filter events on current event Que
+    # removing any events for which this filter returns 0 (Zero)
+    # If called without arguments, it will check and return any
+    # currently defined global filters and associated user data
+    # as: [filter, data]
+    def self.filter(user_data = nil, &event_filter)
+      if event_filter
+        SDL2.filter_events(event_filter, user_data)
+      else
+        event_filter = SDL2::TypedPointer::EventFilter.new
+        user_data = SDL2::TypedPointer::Pointer.new
+        if SDL2.get_event_filter?(event_filter, user_data)
+          [event_filter.value, user_data.value]
+        else
+          false
+        end
+      end
+    end
+    ##
+    # This routine sets the global event filter, it expects
+    # either a single lambda parameter or an array with
+    # or paired with a user_data_pointer
+    def self.filter=(filter_lambda, user_data_pointer = nil)
+      SDL2.set_event_filter(filter_lambda, user_data_pointer)    
+    end  
+    ##
+    # Check if this event type, or a range of event types exist
+    def self.has?(type, type_end = nil)
+      unless type_end
+        SDL2.has_event?(type)
+      else
+        SDL2.has_events?(type, type_end)
+      end
+    end
+    ##
+    # Flush this kind of event (or this range of event types) from the que
+    def self.flush(type, type_end = nil)
+      unless type_end
+        SDL2.flush_event(type)
+      else
+        SDL2.flush_events(type, type_end)
+      end
+    end
+    ##
+    # Add an event to the que
+    def self.push(event)
+      event = Event.cast(event) unless event.kind_of? Event
+      SDL2.push_event!(event)
+    end
+    ##
+    # General Utility for Peek/Get/Del/Add many events
+    def self.peep(events = nil, num_events = nil, action = :PEEK, first_event = :FIRSTEVENT, last_event = :LASTEVENT)
+      if events.is_a?(Array)
+        events = SDL2::StructArray.clone_from(events, SDL2::Event)
+      end
+      num_events ||= events.try(:count)
+      raise 'num_events must be specified unless events responds to count' if num_events.nil?
+      events ||= SDL2::StructArray.new(SDL2::Event, num_events) unless num_events == 0     
+      returned = SDL2.peep_events!(events.nil? ? nil : events.first, num_events, action, first_event, last_event)
+      events.nil? ? Array.new(returned, nil) : events.first(returned)      
+    end
+    ##
+    # Peek at events, default maximum to return at once is 10
+    def self.peek(count = 10, f = :FIRSTEVENT, l = :LASTEVENT)
+      self.peep(nil, count, :PEEK, f, l)
+    end
+    ##
+    # Add a bunch of events, expects them as arguments so
+    # make sure you add that astrik/star: `SDL2::Event.add(*array)`
+    def self.add(*events)
+      self.peep(events, nil, :ADD, f, l)
+    end
+    ##
+    # Get a bunch of events, defaults to 10 at once
+    def self.get(count = 10, f = :FIRSTEVENT, l = :LASTEVENT)
+      self.peep(nil, count, :GET, f, l)
+    end
+    ##
+    # Pump the events.
+    def self.pump
+      SDL2.pump_events()
+    end
+    ##
+    # Indicates if a Quit event is waiting in the que.
+    def self.quit_requested?
+      self.pump()
+      # Peek into the event que and return the count of quit events.
+      # Return true if that is greater than zero.
+      self.peep(nil,0,:PEEK,:QUIT,:QUIT).count > 0
+    end
+    ##
+    # Coerce some value into an Event
+    def self.cast(something)
+      SDL2::Debug.log(self){"Casting Something: #{something.inspect}"}
+      if something.kind_of? Abstract
+        return something.to_event
+      elsif something.kind_of? Hash
+        raise "Must have type : #{something.inspect}" unless something.has_key? :type
+        tmp = self.new
+        fields = members & something.keys
+        SDL2::Debug.log(self){"Using fields: #{fields.inspect}"}
+        fields.each do |field|
+          if tmp[field].kind_of? Struct and something[field].kind_of? Hash
+            tmp[field].update_members(something[field])
+          else
+            tmp[field] = something[field]
+          end
+        end
+        return tmp
+      else
+        raise "Is not an Abstract!: #{something.inspect}"
+      end
+    end
+
+    def ==(other)
+      if other.kind_of?(Hash)
+        # False if there are fields that do not exist
+        return false unless (other.keys - members).empty?
+
+        (other.keys & members).each do |field|
+          return false unless self[field] == other[field]
+        end
+
+        return true #if we get this far
+
+      else
+
+        return super(other)
+
+      end
+    end
+
+  end
+
+end

data/lib/sdl2/event/abstract.rb

@@ -0,0 +1,11 @@
+module SDL2
+  class Event
+    class Abstract < Struct
+      SHARED = [:type, :event_type, :timestamp, :uint32]
+
+      def to_event
+        SDL2::Event.new(self.pointer)
+      end
+    end
+  end
+end

data/lib/sdl2/event/action.rb

@@ -0,0 +1,19 @@
+module SDL2
+  class Event
+    ##
+    #
+    # Constants for use with SDL2::peep_events() as eventaction
+    module ACTION
+      include EnumerableConstants
+      ##
+      # Causes the creation of messages
+      ADD = next_const_value
+      ##
+      # Retrieves events without removing them
+      PEEK = next_const_value
+      ##
+      # Retrieves events and removes them
+      GET = next_const_value
+    end
+  end
+end