sdl2_ffi 0.0.6 → 0.0.7

data/lib/sdl2/stdinc.rb

@@ -26,28 +26,25 @@ module SDL2
   # These are for internal use mostly, they test the return result
   # of a function that can return an error.  They are designed to
   # return TRUE if there is NOT_AN_ERROR
-    
-  #Filter Proc, True when arg equals zero
-  TRUE_WHEN_ZERO = Proc.new do |result|
-    # Handles both Negative and Positive error values.
-    result == 0
-  end
-  
-  TRUE_WHEN_ONE = Proc.new{|result| result == 1}
-  
-  TRUE_WHEN_NOT_ZERO = Proc.new do |result|
-    result != 0
-  end
-  
-  # Filter Proc, True when arg not null?
-  TRUE_WHEN_NOT_NULL = Proc.new do |result|
-    # Anything but nil/null is considered valid.
-    (!result.null?)
-  end
   
-  TRUE_WHEN_TRUE = Proc.new do |result|
-    result == true
-  end
+  ##  
+  # When the result is zero, everything is ok.
+  OK_WHEN_ZERO = Proc.new { |result| result == 0 }
+  ##
+  # When the result is one, everything is ok
+  OK_WHEN_ONE = Proc.new{|result| result == 1}
+  ##
+  # When the result must be positive
+  OK_WHEN_GTE_ZERO = Proc.new{|result| result >= 0}
+  ##
+  # When result is anything but zero
+  OK_WHEN_NOT_ZERO = Proc.new { |result| result != 0  }
+  ##
+  # When resultnot null?
+  OK_WHEN_NOT_NULL = Proc.new { |result| (!result.nil?) and (!result.null?) } 
+  ##
+  # When result is true
+  OK_WHEN_TRUE = Proc.new { |result| result == true  }
     
   # NOTE: None of the SDL Memory Macros/Externals
     

data/lib/sdl2/struct.rb

@@ -0,0 +1,184 @@
+module SDL2
+  ##
+  # BadQuanta: sdl2_ffi messes with the FFI::Struct class for some useful additions.
+  class Struct < FFI::Struct
+    extend StructHelper
+    ##
+    # Allows creation and use within block, automatically freeing pointer after block.
+    def initialize(*args, &block)
+      Debug.log(self){"Initializing with args: #{args.inspect}"}
+      super(*args)
+      if block_given?
+        Debug.log(self){'Block given, will be disposed of later'}
+        throw 'Release must be defined to use block' unless self.class.respond_to?(:release)
+        yield self
+        Debug.log(self){'Block returned, now disposing.'}
+        self.class.release(self.pointer)
+      end
+    end
+
+    ##
+    # Placeholder for Structs that need to initialize values.
+    def self.create(values = {})
+      Debug.log(self){"Constructing with values: #{values.inspect}"}
+      created = self.new
+      created.update_members(values)
+      created
+    end
+
+    ##
+    # A default release scheme is defined, but should be redefined where appropriate.
+    def self.release(pointer)
+      Debug.log(self){"Freeing pointer: #{pointer.inspect}"}
+      pointer.free
+    end
+
+    ##
+    # A default free operation, but should be redefined where appropriate.
+    # TODO: Is this wrong to do in conjuction with release?
+    def free()
+      if self.pointer.autorelease?
+        Debug.log(self){"Freeing autorelease pointer: #{pointer.inspect}"}
+        self.pointer.free
+      else
+        Debug.log(self){"Not freeing pointer"}
+        binding.pry
+      end
+    end
+
+    # A human-readable representation of the struct and it's values.
+    #def inspect
+    #  return 'nil' if self.null?
+    #
+    #  #binding.pry
+    #  #return self.to_s
+    #
+    #      report = "struct #{self.class.to_s}{"
+    #      report += self.class.members.collect do |field|
+    #        "#{field}->#{self[field].inspect}"
+    #      end.join(' ')
+    #      report += "}"
+    #    end
+
+    ##
+    # Compare two structures by class and values.
+    # This will return true when compared to a "partial hash" and
+    # all the key/value pairs the hash defines equal the
+    # corrisponding members in the structure.
+    # Otherwise all values must match between structures.
+    # TODO: CLEAN UP THIS COMPARISON CODE!!!
+    def ==(other)
+      Debug.log(self){
+        "COMPARING #{self} to #{other}"
+      }
+
+      result = catch(:result) do
+        unless self.class == other.class or other.kind_of? Hash
+          Debug.log(self){"Class Mismatch"}
+          throw :result, false
+        end
+
+        if (other.kind_of? Hash) and (other.keys - members).any?
+          Debug.log(self){"Extra Keys: #{other.keys-members}"}
+          thorw :result, false
+        end
+
+        if (other.respond_to?:null?) and (self.null? or other.null?)
+          unless self.null? and other.null?
+            Debug.log(self){"AHHHAOne is null and the other is not"}
+            throw :result, false
+          end
+        else
+          fields = other.kind_of?(Hash) ? members & other.keys : members
+          fields.each do |field|
+            Debug.log(self){"#{field}:#{self[field].class} = "}
+
+            unless self[field] == other[field]
+
+              Debug.log(self){"NO MATCH: #{self[field].to_s} #{other[field].to_s}"}
+              throw :result, false
+            end
+            Debug.log(self){"MATCH"}
+          end
+        end
+
+        # Everything passed
+        throw :result, true
+
+      end
+      Debug.log(self){
+        "RESULT = #{result}"
+      }
+      return result
+    end
+
+    ##
+    # Default cast handler.
+    #
+    #
+    # BadQuanta says:
+    #   Casting means to take something and try to make it into a Structure
+    #   - Other instances of the same class (simply returns that instance)
+    #   - Any hash, this structure will be "created" with the has specifying members.
+    #   - A nil object, which will return the same nil object assuming that is o.k.
+    def self.cast(something)
+      if something.kind_of? self
+        Debug.log(self){'No casting required.'}
+        return something
+      elsif something.kind_of? Hash
+        Debug.log(self){'Attempting to construct from hash.'}
+        return self.create(something)
+      elsif something.nil?
+        Debug.log(self){'Something is nil, returning nil.'}
+        return something #TODO: Assume NUL is ok?
+      else
+        # No need for a debug message, exception will act as one.
+        raise "#{self} can't cast #{something.insepct}"
+      end
+    end
+
+    ##
+    # Set members to values contained within hash.
+    def update_members(values)
+      Debug.log(self){"Updating members from values: #{values.inspect}"}
+      if values.kind_of? Array
+        raise "#{self} has less fields then #{values.inspect}" if values.count > members.count
+        Debug.log(self){"Field to value map: #{Hash.new(members.first(values.count).zip(values)).inspect}"}
+        members.first(values.count).each_with_index do |field, idx|
+          self[field] = values[idx]
+        end
+      elsif values.kind_of? Hash
+        common = (self.members & values.keys)
+        Debug.log(self){
+          ignored_keys = values.keys - common
+          ignored_keys.empty? ? "All hash keys mapped to struct members." : "Ignored these value keys: #{ignored_keys.inspect}"
+        }
+        common.each do |field|
+          unless self[field].kind_of?(Struct)
+            self[field] = values[field]
+          else
+            self[field] = self[field].class.cast(values[field])
+          end
+        end
+      elsif values.kind_of? self.class
+        Debug.log(self){'Coping values from another instance.'}
+        members.each do |member|
+          self[member] = values[member]
+        end
+      else
+        raise "#{self}#update_members unable to update from #{values.inspect}"
+      end
+    end
+
+    ##
+    # Human readable translation of a structure
+    def to_s
+      null = self.to_ptr.null?
+      values = members.map do |member|
+        "#{member}=#{null ? 'null' : self[member]}"
+      end unless null
+      "<#{self.class.to_s} #{null ? 'NULL' : values.join(' ')}>"
+    end
+  end
+
+end

data/lib/sdl2/struct_helper.rb

@@ -0,0 +1,32 @@
+
+module SDL2
+  ##
+  # A struct helper provides member_reader/member_writer helpers for quickly accessing those damn members.
+  # This is extended into sdl2_ffi's usage of Structs, ManagedStructs, and Unions. Do I know exatcly what I'm
+  # doing, no... but teach me what I'm doing wrong.
+  module StructHelper
+    # Define a set of member readers
+    # Ex1: `member_readers [:one, :two, :three]`
+    # Ex2: `member_readers *members`
+    def member_readers(*members_to_define)
+      members_to_define.each do |member|
+        define_method member do
+          self[member]
+        end
+      end
+
+    end
+
+    # Define a set of member writers
+    # Ex1: `member_writers [:one, :two, :three]`
+    # Ex2: `member_writers *members`
+    def member_writers(*members_to_define)
+      members_to_define.each do |member|
+        define_method "#{member}=".to_sym do |value|
+          self[member]= value
+        end
+      end
+    end
+
+  end
+end

data/lib/sdl2/surface.rb

@@ -21,6 +21,7 @@ module SDL2
     :format, PixelFormat.by_ref,
     :w, :int,
     :h, :int,
+    :pitch, :int,
     :pixels, :pointer,
     :userdata, :pointer,
     :locked, :int,
@@ -128,7 +129,7 @@ module SDL2
     alias_method :rle=, :set_rle
 
     # Sets the color key for this surface.
-    # @param key may be 1) A pixel value encoded for this surface's format
+    #   *  key may be 1) A pixel value encoded for this surface's format
     # 2) Anything that Color::cast can handle.
     # 3) Nil, which will disable the color key for this surface.
     def set_color_key(key)
@@ -149,7 +150,7 @@ module SDL2
     # Gets the color key for this surface.
     # @returns Nil, indicating no color keying, or the encoded pixel value used.
     def get_color_key()
-      key_s = UInt32Struct.new
+      key_s = TypedPointer::UInt32.new
       if SDL2.get_color_key?(self, key_s)
         result = key_s[:value]
       else
@@ -190,7 +191,7 @@ module SDL2
 
   ##
 	#
-	api :SDL_CreateRGBSurface, [:surface_flags, :int, :int, :int, :uint32, :uint32, :uint32, :uint32], Surface.auto_ptr, {error: true, filter: TRUE_WHEN_NOT_NULL}
+	api :SDL_CreateRGBSurface, [:surface_flags, :int, :int, :int, :uint32, :uint32, :uint32, :uint32], Surface.ptr, {error: true, filter: OK_WHEN_NOT_NULL}
   ##
 	#
 	api :SDL_FreeSurface, [Surface.by_ref], :void
@@ -205,14 +206,14 @@ module SDL2
 	api :SDL_UnlockSurface, [Surface.by_ref], :void
   ##
 	#
-	api :SDL_LoadBMP_RW, [RWops.by_ref, :int], Surface.auto_ptr
+	api :SDL_LoadBMP_RW, [RWops.by_ref, :int], Surface.ptr
 
   # Redefine SDL_LoadBMP macro:
   def self.load_bmp(file)
     SDL2.load_bmp_rw(RWops.from_file(file, 'rb'), 1)
   end
 
-  returns_error(:load_bmp,TRUE_WHEN_NOT_NULL)
+  returns_error(:load_bmp,OK_WHEN_NOT_NULL)
 
   ##
 	#
@@ -230,27 +231,27 @@ module SDL2
 	api :SDL_SetColorKey, [Surface.by_ref, :bool, :uint32], :int, {error: true}
   ##
 	#
-	api :SDL_GetColorKey, [Surface.by_ref, UInt32Struct.by_ref], :uint32, {error: true}
+	api :SDL_GetColorKey, [Surface.by_ref, TypedPointer::UInt32.by_ref], :uint32, {error: true}
   # Could mean an SDL error... or maybe not?
-  boolean? :get_color_key, TRUE_WHEN_ZERO
+  boolean? :get_color_key, OK_WHEN_ZERO
   ##
 	#
 	api :SDL_SetSurfaceColorMod, [Surface.by_ref, :uint8, :uint8, :uint8], :int
   ##
 	#
-	api :SDL_GetSurfaceColorMod, [Surface.by_ref, UInt8Struct.by_ref,UInt8Struct.by_ref,UInt8Struct.by_ref], :int
+	api :SDL_GetSurfaceColorMod, [Surface.by_ref, TypedPointer::UInt8.by_ref,TypedPointer::UInt8.by_ref,TypedPointer::UInt8.by_ref], :int
   ##
 	#
 	api :SDL_SetSurfaceAlphaMod, [Surface.by_ref, :uint8], :int, {error: true}
   ##
 	#
-	api :SDL_GetSurfaceAlphaMod, [Surface.by_ref,UInt8Struct.by_ref], :int, {error: true}
+	api :SDL_GetSurfaceAlphaMod, [Surface.by_ref,TypedPointer::UInt8.by_ref], :int, {error: true}
   ##
 	#
 	api :SDL_SetSurfaceBlendMode, [Surface.by_ref, :blend_mode], :int, {error: true}
   ##
 	#
-	api :SDL_GetSurfaceBlendMode, [Surface.by_ref, BlendModeStruct.by_ref], :int, {error: true}
+	api :SDL_GetSurfaceBlendMode, [Surface.by_ref, SDL2::TypedPointer::BlendMode.by_ref], :int, {error: true}
   ##
 	#
 	api :SDL_SetClipRect, [Surface.by_ref, Rect.by_ref], :int, {error: true}
@@ -259,10 +260,10 @@ module SDL2
 	api :SDL_GetClipRect, [Surface.by_ref, Rect.by_ref], :int, {error: true}
   ##
 	#
-	api :SDL_ConvertSurface, [Surface.by_ref, PixelFormat.by_ref, :surface_flags], Surface.auto_ptr, {error: true, filter: TRUE_WHEN_NOT_NULL}
+	api :SDL_ConvertSurface, [Surface.by_ref, PixelFormat.by_ref, :surface_flags], Surface.ptr, {error: true, filter: OK_WHEN_NOT_NULL}
   ##
 	#
-	api :SDL_ConvertSurfaceFormat, [Surface.by_ref, :pixel_format, :surface_flags], Surface.auto_ptr
+	api :SDL_ConvertSurfaceFormat, [Surface.by_ref, :pixel_format, :surface_flags], Surface.ptr
   ##
 	#
 	api :SDL_ConvertPixels, [:int, :int, :pixel_format, :pointer, :int, :pixel_format, :pointer, :int], :int, {error: true}
@@ -282,7 +283,7 @@ module SDL2
     upper_blit(src, srcrect, dst, dstrect)
   end
 
-  returns_error(:blit_surface, TRUE_WHEN_ZERO)
+  returns_error(:blit_surface, OK_WHEN_ZERO)
 
   ##
 	#
@@ -299,7 +300,7 @@ module SDL2
     upper_blit_scaled(src, srcrect, dst, dstrect)
   end
 
-  returns_error(:blit_scaled, TRUE_WHEN_ZERO)
+  returns_error(:blit_scaled, OK_WHEN_ZERO)
 
   ##
 	#

data/lib/sdl2/syswm.rb

@@ -4,19 +4,35 @@ require 'sdl2/video'
 require 'sdl2/syswm/info'
 require 'sdl2/syswm/msg'
 
-module SDL2 # SDL_syswm.h
-  
+##
+# SDL_syswm.h - "Include file for SDL custom system window manager hooks."
+#
+#   Your application has access to a special type of event ::SDL_SYSWMEVENT,
+#   which contains window-manager specific information and arrives whenever
+#   an unhandled window event occurs.  This event is ignored by default, but
+#   you can enable it with SDL_EventState().
+module SDL2
   module SysWM
-    
+    module TYPE
+      extend EnumerableConstants
+      UNKOWN
+      WINDOWS
+      X11
+      DIRECTFB
+      COCOA
+      UIKIT
+      WAYLAND
+      WINRT
+    end
   end
-  
+
   SYSWM = SysWM # Because I don't care about case.
-  
+
   # Line 99~107
-  enum :syswm_type, [:unkown, :window, :x11, :directfb, :cocoa, :uikit]
-  
+  enum :syswm_type, SysWM::TYPE.flatten_constants
+
   ##
-	#
-	api :SDL_GetWindowWMInfo, [Window.by_ref, SYSWM::Info.by_ref], :bool
-  
+  #
+  api :SDL_GetWindowWMInfo, [Window.by_ref, SYSWM::Info.by_ref], :bool
+
 end

data/lib/sdl2/syswm/msg.rb

@@ -1,10 +1,16 @@
 require 'sdl2'
 
 module SDL2 # SDL_syswm.h
-          
+    
   module SysWM
+    ##
+    # "The custom event structure."
     class Msg < Struct
       
+      private
+      
+      ##
+      #
       class Win < Struct
         layout :hwnd, :pointer,
           :msg, :uint,
@@ -12,23 +18,33 @@ module SDL2 # SDL_syswm.h
           :lparam, :int32
       end      
       
-      
+      ##
+      #
       class X11 < Struct
         layout :dummy, :uint32 # TODO: FIXME: NOT YET SUPPORTED!
       end
       
+      ##
+      #
       class DirectFB < Struct
         layout :event, :uint32 # TODO: FIXME: NOT YET SUPPORTED!
       end
       
+      ##
+      #
       class Cocoa < Struct
-        layout :dummy, :long # SDL2 says 'No Cocoa window events yet'
+        layout :dummy, :long # TODO: REVIEW: SDL2 says 'No Cocoa window events yet'
       end
       
+      
+      ##
+      #
       class UIKit < Struct
-        layout :dummy, :long # SDL2 says 'No UIKit window events yet'
+        layout :dummy, :long # TODO: REVIEW: SDL2 says 'No UIKit window events yet'
       end
       
+      ##
+      #
       class MsgUnion < FFI::Union
         layout :win, Win,
           :x11, X11,
@@ -38,6 +54,8 @@ module SDL2 # SDL_syswm.h
           :dummy, :int
       end
       
+      public 
+      
       layout :version, Version,
         :subsystem, :int,
         :msg, MsgUnion