gir_ffi 0.0.14 → 0.1.0

data/lib/gir_ffi/g_object.rb

@@ -1,38 +0,0 @@
-require 'ffi'
-
-module GirFFI
-  # TODO: Rename to avoid constant lookup issues (and confusion).
-  module GObject
-    def self.type_init
-      Lib::g_type_init
-    end
-
-    def self.object_ref obj
-      Lib::g_object_ref obj.to_ptr
-    end
-
-    def self.object_ref_sink obj
-      Lib::g_object_ref_sink obj.to_ptr
-    end
-
-    def self.object_unref obj
-      Lib::g_object_unref obj.to_ptr
-    end
-
-    def self.object_is_floating obj
-      Lib::g_object_is_floating obj.to_ptr
-    end
-
-    module Lib
-      extend FFI::Library
-      ffi_lib "gobject-2.0"
-      attach_function :g_type_init, [], :void
-      attach_function :g_object_ref, [:pointer], :void
-      attach_function :g_object_ref_sink, [:pointer], :void
-      attach_function :g_object_unref, [:pointer], :void
-      attach_function :g_object_is_floating, [:pointer], :bool
-    end
-  end
-end
-
-

data/lib/gir_ffi/overrides/glib.rb

@@ -1,225 +0,0 @@
-module GirFFI
-  module Overrides
-    module GLib
-      def self.included base
-	base.extend ClassMethods
-        extend_classes(base)
-        attach_non_introspectable_functions(base)
-      end
-
-      def self.extend_classes base
-        base::SList.class_eval {
-          attr_accessor :element_type
-          include ListInstanceMethods
-          extend ListClassMethods
-          include Enumerable
-        }
-        base::List.class_eval {
-          attr_accessor :element_type
-          include ListInstanceMethods
-          extend ListClassMethods
-          include Enumerable
-        }
-        base::HashTable.class_eval {
-          attr_accessor :key_type
-          attr_accessor :value_type
-          include HashTableInstanceMethods
-          extend HashTableClassMethods
-          include Enumerable
-        }
-        base::ByteArray.class_eval {
-          include ByteArrayInstanceMethods
-        }
-        base::Array.class_eval {
-          attr_accessor :element_type
-          include ArrayInstanceMethods
-        }
-      end
-
-      def self.attach_non_introspectable_functions base
-        base::Lib.attach_function :g_slist_prepend, [:pointer, :pointer],
-          :pointer
-
-        base::Lib.attach_function :g_list_append, [:pointer, :pointer],
-          :pointer
-
-        base::Lib.attach_function :g_hash_table_foreach,
-          [:pointer, base::HFunc, :pointer], :void
-        base::Lib.attach_function :g_hash_table_new,
-          [base::HashFunc, base::EqualFunc], :pointer
-        base::Lib.attach_function :g_hash_table_insert,
-          [:pointer, :pointer, :pointer], :void
-
-        base::Lib.attach_function :g_byte_array_new, [], :pointer
-        base::Lib.attach_function :g_byte_array_append,
-          [:pointer, :pointer, :uint], :pointer
-
-        base::Lib.attach_function :g_array_new, [:int, :int, :uint], :pointer
-        base::Lib.attach_function :g_array_append_vals,
-          [:pointer, :pointer, :uint], :pointer
-
-        base::Lib.attach_function :g_main_loop_new,
-          [:pointer, :bool], :pointer
-      end
-
-      module ClassMethods
-        # FIXME: Turn into real constructor
-        def slist_new elmttype
-          ::GLib::List._real_new(FFI::Pointer.new(0)).tap {|it|
-            it.element_type = elmttype}
-        end
-
-        # FIXME: Turn into instance method; Use element type.
-        def slist_prepend slist, data
-          ::GLib::SList.wrap(slist.element_type, ::GLib::Lib.g_slist_prepend(slist, data))
-        end
-
-        # FIXME: Turn into real constructor
-        def list_new elmttype
-          ::GLib::List._real_new(FFI::Pointer.new(0)).tap {|it|
-            it.element_type = elmttype}
-        end
-
-        # FIXME: Turn into instance method; Use element type.
-        def list_append list, data
-          ::GLib::List.wrap(list.element_type, ::GLib::Lib.g_list_append(list, data))
-        end
-
-        # FIXME: Turn into real constructor
-        def hash_table_new keytype, valtype
-          hash_fn, eq_fn = case keytype
-                           when :utf8
-                             lib = ::GLib::Lib.ffi_libraries.first
-                             [ FFI::Function.new(:uint, [:pointer], lib.find_function("g_str_hash")),
-                               FFI::Function.new(:int, [:pointer, :pointer], lib.find_function("g_str_equal"))]
-                           else
-                             [nil, nil]
-                           end
-
-          ::GLib::HashTable.wrap(keytype, valtype, ::GLib::Lib.g_hash_table_new(hash_fn, eq_fn))
-        end
-
-        # FIXME: Turn into real constructor
-        def byte_array_new
-          ::GLib::ByteArray.wrap(::GLib::Lib.g_byte_array_new)
-        end
-
-        # FIXME: Turn into instance method
-        def byte_array_append arr, data
-          bytes = GirFFI::InPointer.from :utf8, data
-          len = data.bytesize
-          ::GLib::ByteArray.wrap(::GLib::Lib.g_byte_array_append arr.to_ptr, bytes, len)
-        end
-
-        # FIXME: Turn into real constructor
-        def array_new type
-          ffi_type = type == :utf8 ? :pointer : type
-          arr = ::GLib::Array.wrap(
-            ::GLib::Lib.g_array_new(0, 0, FFI.type_size(ffi_type)))
-          arr.element_type = type
-          arr
-        end
-
-        # FIXME: Turn into instance method
-        def array_append_vals arr, data
-          bytes = GirFFI::InPointer.from_array arr.element_type, data
-          len = data.length
-          res = ::GLib::Array.wrap(
-            ::GLib::Lib.g_array_append_vals(arr.to_ptr, bytes, len))
-          res.element_type = arr.element_type
-          res
-        end
-
-        # FIXME: Turn into real constructor?
-        def main_loop_new context, is_running
-          ::GLib::MainLoop.wrap(::GLib::Lib.g_main_loop_new context, is_running)
-        end
-      end
-
-      module ListInstanceMethods
-        def each
-          list = self
-          rval = nil
-          until list.nil?
-            rval = yield GirFFI::ArgHelper.cast_from_pointer(element_type, list[:data])
-            list = self.class.wrap(element_type, list[:next])
-          end
-          rval
-        end
-      end
-
-      module ListClassMethods
-        def wrap elmttype, ptr
-          super(ptr).tap do |it|
-            break if it.nil?
-            it.element_type = elmttype
-          end
-        end
-      end
-
-      module HashTableClassMethods
-        def wrap keytype, valtype, ptr
-          super(ptr).tap do |it|
-            break if it.nil?
-            it.key_type = keytype
-            it.value_type = valtype
-          end
-        end
-      end
-
-      module HashTableInstanceMethods
-        def each
-          prc = Proc.new {|keyptr, valptr, userdata|
-            key = cast_from_pointer key_type, keyptr
-            val = cast_from_pointer value_type, valptr
-            yield key, val
-          }
-          ::GLib::Lib.g_hash_table_foreach self.to_ptr, prc, nil
-        end
-
-        def to_hash
-          Hash[self.to_a]
-        end
-
-        def insert key, value
-          keyptr = cast_to_pointer key_type, key
-          valptr = cast_to_pointer value_type, value
-          ::GLib::Lib.g_hash_table_insert self.to_ptr, keyptr, valptr
-        end
-
-        def cast_to_pointer type, it
-          if type == :utf8
-            GirFFI::InPointer.from :utf8, it
-          else
-            FFI::Pointer.new(it)
-          end
-        end
-
-        def cast_from_pointer type, it
-          case type
-          when :utf8
-            GirFFI::ArgHelper.ptr_to_utf8 it
-          when :gint32
-            GirFFI::ArgHelper.cast_pointer_to_int32 it
-          else
-            it.address
-          end
-        end
-      end
-
-      module ByteArrayInstanceMethods
-        def to_string
-          GirFFI::ArgHelper.ptr_to_utf8_length self[:data], self[:len]
-        end
-      end
-
-      module ArrayInstanceMethods
-        def to_a
-          GirFFI::ArgHelper.ptr_to_typed_array(self.element_type,
-                                               self[:data], self[:len])
-        end
-      end
-    end
-  end
-end
-

data/lib/gir_ffi/overrides/gobject.rb

@@ -1,330 +0,0 @@
-module GirFFI
-  module Overrides
-    module GObject
-
-      def self.included base
-	base.extend ClassMethods
-        extend_classes(base)
-        attach_non_introspectable_functions(base)
-        preload_methods(base)
-        build_extra_classes(base)
-      end
-
-      def self.extend_classes base
-        base::InitiallyUnowned.extend InitiallyUnownedClassMethods
-        base::Value.class_eval {
-          include ValueInstanceMethods
-          extend ValueClassMethods
-        }
-        base::Closure.class_eval {
-          include ClosureInstanceMethods
-        }
-      end
-
-      def self.attach_non_introspectable_functions base
-        base::Lib.attach_function :g_signal_connect_data,
-          [:pointer, :string, base::Callback, :pointer, base::ClosureNotify,
-            base::ConnectFlags],
-            :ulong
-        base::Lib.attach_function :g_closure_set_marshal,
-          [:pointer, base::ClosureMarshal], :void
-      end
-
-      def self.preload_methods base
-        base._setup_method :signal_emitv
-      end
-
-      def self.build_extra_classes base
-        build_ruby_closure_class base
-      end
-
-      # Build the GObject::RubyClosure class. This class encapsulates Ruby
-      # blocks as GObject Closures.
-      def self.build_ruby_closure_class base
-        klass = Class.new(base::Closure) do
-          const_set :BLOCK_STORE, {}
-
-          const_set :Struct, Class.new(FFI::Struct) {
-            layout :parent, base::Closure::Struct, 0,
-            :blockhash, :int64
-          }
-
-          def self.new &block
-            raise ArgumentError unless block_given?
-            wrap(new_simple(self::Struct.size, nil).to_ptr).tap do |it|
-              h = block.object_id
-              self::BLOCK_STORE[h] = block
-              it[:blockhash] = h
-              it.set_marshal Proc.new {|*args| marshaller(*args)}
-            end
-          end
-
-          def self.marshaller(closure, return_value, n_param_values,
-                              param_values, invocation_hint, marshal_data)
-            rclosure = self.wrap(closure.to_ptr)
-
-            args = []
-            n_param_values.times {|i|
-              gv = ::GObject::Value.wrap(param_values.to_ptr +
-                                         i * ::GObject::Value::Struct.size)
-              args << gv.ruby_value
-            }
-
-            r = rclosure.invoke_block(*args)
-            return_value.set_ruby_value r unless return_value.nil?
-          end
-
-          def block
-            self.class::BLOCK_STORE[self[:blockhash]]
-          end
-
-          def invoke_block *args
-            block.call(*args)
-          end
-        end
-        base.const_set :RubyClosure, klass
-      end
-
-      module ClassMethods
-	# FIXME: These four helper methods belong elsewhere.
-	def type_from_instance_pointer inst_ptr
-	  base = ::GObject::TypeInstance.wrap inst_ptr
-	  kls = ::GObject::TypeClass.wrap(base[:g_class])
-	  kls[:g_type]
-	end
-
-	def type_from_instance instance
-	  type_from_instance_pointer instance.to_ptr
-	end
-
-	def signal_emit object, signal, *args
-	  type = type_from_instance object
-	  id = signal_lookup signal, type
-
-	  arr = Helper.signal_arguments_to_gvalue_array signal, object, *args
-	  rval = Helper.gvalue_for_signal_return_value signal, object
-
-	  ::GObject::Lib.g_signal_emitv arr[:values], id, 0, rval
-
-	  rval
-	end
-
-	def signal_connect object, signal, data=nil, &block
-	  sig = object.class._find_signal signal
-	  if sig.nil?
-	    raise "Signal #{signal} is invalid for #{object}"
-	  end
-	  if block.nil?
-	    raise ArgumentError, "Block needed"
-	  end
-
-	  rettype = GirFFI::Builder.itypeinfo_to_ffitype sig.return_type
-
-	  argtypes = GirFFI::Builder.ffi_argument_types_for_signal sig
-
-	  callback = FFI::Function.new rettype, argtypes,
-	    &(Helper.signal_callback_args(sig, object.class, &block))
-          ::GObject::Lib::CALLBACKS << callback
-
-          data_ptr = GirFFI::ArgHelper.object_to_inptr data
-
-	  ::GObject::Lib.g_signal_connect_data object, signal, callback, data_ptr, nil, 0
-	end
-      end
-
-      module Helper
-        TAG_TYPE_TO_GTYPE_NAME_MAP = {
-          :utf8 => "gchararray",
-          :gboolean => "gboolean",
-          :void => "void"
-        }
-
-	def self.signal_callback_args sig, klass, &block
-	  return Proc.new do |*args|
-	    mapped = cast_back_signal_arguments sig, klass, *args
-	    block.call(*mapped)
-	  end
-	end
-
-	def self.signal_arguments_to_gvalue_array signal, instance, *rest
-	  sig = instance.class._find_signal signal
-
-	  arr = ::GObject::ValueArray.new sig.n_args+1
-
-          arr.append signal_reciever_to_gvalue instance
-
-	  sig.args.zip(rest).each do |info, arg|
-	    arr.append signal_argument_to_gvalue info, arg
-	  end
-
-	  arr
-	end
-
-        def self.signal_reciever_to_gvalue instance
-          val = ::GObject::Value.new
-          val.init ::GObject.type_from_instance instance
-          val.set_instance instance
-          return val
-        end
-
-	def self.signal_argument_to_gvalue info, arg
-          arg_type = info.argument_type
-
-          val = gvalue_for_type_info arg_type
-
-	  if arg_type.tag == :interface
-	    interface = arg_type.interface
-	    case interface.info_type
-	    when :struct
-	      val.set_boxed arg
-	    when :object
-	      val.set_instance arg
-            when :enum
-              val.set_enum arg
-	    else
-	      raise NotImplementedError, interface.info_type
-	    end
-	  else
-            val.set_ruby_value arg
-	  end
-
-          return val
-	end
-
-        def self.gvalue_for_type_info info
-          tag = info.tag
-          gtype = case tag
-                  when :interface
-                    info.interface.g_type
-                  when :void
-                    return nil
-                  else
-                    ::GObject.type_from_name(TAG_TYPE_TO_GTYPE_NAME_MAP[tag])
-                  end
-          ::GObject::Value.new.tap {|val| val.init gtype}
-        end
-
-	def self.gvalue_for_signal_return_value signal, object
-          sig = object.class._find_signal signal
-          rettypeinfo = sig.return_type
-
-          gvalue_for_type_info rettypeinfo
-	end
-
-        # TODO: Generate cast back methods using existing Argument builders.
-	def self.cast_back_signal_arguments signalinfo, klass, *args
-	  result = []
-
-	  # Instance
-	  instptr = args.shift
-	  instance = klass.wrap instptr
-	  result << instance
-
-	  # Extra arguments
-	  signalinfo.args.each do |info|
-            result << cast_signal_argument(info, args.shift)
-	  end
-
-	  # User Data
-	  arg = args.shift
-          arg = GirFFI::ArgHelper::OBJECT_STORE[arg.address]
-	  result << arg
-
-	  return result
-	end
-
-        def self.cast_signal_argument info, arg
-          arg_t = info.argument_type
-          if arg_t.tag == :interface
-            iface = arg_t.interface
-            kls = GirFFI::Builder.build_class iface
-            case iface.info_type
-            when :enum, :flags
-              kls[arg]
-            else
-              kls.wrap(arg)
-            end
-          else
-            arg
-          end
-        end
-      end
-
-      module InitiallyUnownedClassMethods
-        def constructor_wrap ptr
-          super.tap {|obj| GirFFI::GObject.object_ref_sink obj}
-        end
-      end
-
-      module ValueClassMethods
-        def wrap_ruby_value val
-          self.new.set_ruby_value val
-        end
-      end
-
-      module ValueInstanceMethods
-        def set_ruby_value val
-          if current_gtype == 0
-            init_for_ruby_value val
-          end
-
-	  case current_gtype_name
-	  when "gboolean"
-	    set_boolean val
-          when "gint"
-	    set_int val
-	  when "gchararray"
-	    set_string val
-	  else
-	    nil
-	  end
-          self
-        end
-
-        def init_for_ruby_value val
-	  case val
-	  when true, false
-	    init ::GObject.type_from_name("gboolean")
-          when Integer
-	    init ::GObject.type_from_name("gint")
-	  end
-          self
-        end
-
-        def current_gtype
-          self[:g_type]
-        end
-
-        def current_gtype_name
-          ::GObject.type_name current_gtype
-        end
-
-        def ruby_value
-	  case current_gtype_name.to_sym
-	  when :gboolean
-	    get_boolean
-	  when :gint
-	    get_int
-          when :gchararray
-            get_string
-          when :GDate
-            ::GLib::Date.wrap(get_boxed)
-          when :GStrv
-            ArgHelper.strv_to_utf8_array get_boxed
-	  else
-	    nil
-	  end
-        end
-      end
-
-      module ClosureInstanceMethods
-        def set_marshal marshal
-	  _v1 = GirFFI::CallbackHelper.wrap_in_callback_args_mapper(
-            "GObject", "ClosureMarshal", marshal)
-	  ::GObject::Lib::CALLBACKS << _v1
-	  ::GObject::Lib.g_closure_set_marshal self, _v1
-        end
-      end
-    end
-  end
-end