gir_ffi 0.0.14 → 0.1.0

data/History.txt

@@ -1,3 +1,9 @@
+== 0.1.0 / 2011-10-28
+
+* Put bindings for GObjectIntrospection in their own namespace.
+* GirFFI.setup no longer loads overrides.
+* Add ffi-gtk2 and ffi-gtk3 files for loading Gtk+ overrides.
+
 == 0.0.14 / 2011-10-28
 
 * Support GObject Introspection version 1.30:

data/README.rdoc

@@ -8,18 +8,48 @@ http://www.github.com/mvz/ruby-gir-ffi
 
 Ruby bindings for GNOME using the GObject Introspection Repository.
 
-== Features/Problems
+== Features/Notes
 
-* Create bindings to GObject-based libraries at runtime
-* Almost, but not entirely done yet
+* Create bindings to any GObject-based library.
+* Supports both Gtk+ 2 and Gtk+ 3.
+* Bindings generated at runtime.
+* Provides overridden bindings for selected methods.
+* Require 'ffi-gtk2' or 'ffi-gtk3' to load overrides for Gtk2 or Gtk3.
+
+== Install
+
+* sudo gem install gir_ffi
 
 == Synopsis
 
+Basic usage:
+
   require 'gir_ffi'
 
-  GirFFI.setup :Gtk
+  GirFFI.setup :TheNamespace
+
+  TheNamespace.some_function
+
+  obj = TheNamespace::SomeClass.new
+  obj.some_method with, some, args
+
+Gtk2:
+
+  require 'ffi-gtk2'
   Gtk.init
   win = Gtk::Window.new :toplevel
+  win.show
+  GObject.signal_connect(win, "destroy") { Gtk.main_quit }
+  Gtk.main
+
+Gtk3:
+
+  require 'ffi-gtk3'
+  Gtk.init
+  win = Gtk::Window.new :toplevel
+  win.show
+  GObject.signal_connect(win, "destroy") { Gtk.main_quit }
+  Gtk.main
 
 See the `examples/` directory for more, well, examples.
 
@@ -40,10 +70,8 @@ On Debian and Ubuntu, the following set of packages should be enough to get
 
 == Hacking and contributing
 
-This is still very much a work in progress. You can start exploring by
-running the example programs in the `examples/` folder. Some illustrate
-what works, some are a test bed for how things should work. Have a look at
-the output of `rake notes`. Feel free to file bugs or send pull requests.
+If you want to help out, have a look at TODO.rdoc, and the output of `rake
+notes`. Feel free to file bugs or send pull requests.
 
 If you want to send pull requests or patches, please:
 
@@ -56,10 +84,6 @@ If you want to send pull requests or patches, please:
 * Try not to include changes that are irrelevant to your feature in the
   same commit.
 
-== Install
-
-* sudo gem install gir_ffi
-
 == License
 
 Copyright (c) 2009--2011 Matijs van Zuijlen

data/examples/01_empty_window.rb

@@ -3,9 +3,7 @@
 # http://library.gnome.org/devel/gtk-tutorial/2.90/c39.html
 #
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'gir_ffi'
-
-GirFFI.setup :Gtk, '2.0'
+require 'ffi-gtk3'
 
 Gtk.init
 win = Gtk::Window.new :toplevel

data/examples/02_hello_world.rb

@@ -3,9 +3,7 @@
 # http://library.gnome.org/devel/gtk-tutorial/2.90/c39.html#SEC-HELLOWORLD
 #
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'gir_ffi'
-
-GirFFI.setup :Gtk, '2.0'
+require 'ffi-gtk3'
 
 Gtk.init
 

data/examples/03_upgraded_hello_world.rb

@@ -3,9 +3,7 @@
 # http://library.gnome.org/devel/gtk-tutorial/2.90/x344.html
 #
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'gir_ffi'
-
-GirFFI.setup :Gtk, '2.0'
+require 'ffi-gtk3'
 
 callback = lambda { |widget, data|
   puts "Hello again - #{data} was pressed"

data/examples/04_webkit.rb

@@ -1,8 +1,8 @@
 # Based on http://www.idle-hacking.com/2010/02/webkit-ruby-and-gtk/
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'gir_ffi'
+require 'ffi-gtk3'
 
-GirFFI.setup :WebKit, '1.0'
+GirFFI.setup :WebKit, '3.0'
 
 Gtk.init
 

data/examples/05_notification.rb

@@ -2,9 +2,8 @@
 # Simple notification example.
 #
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'gir_ffi'
+require 'ffi-gtk3'
 
-GirFFI.setup :Gtk
 GirFFI.setup :Notify
 
 # Both Gtk and Notify need to be init'ed.

data/examples/print_class.rb

@@ -1,3 +1,4 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'gir_ffi'
 
 # File activesupport/lib/active_support/inflector/methods.rb, line 48
@@ -11,10 +12,11 @@ def underscore(camel_cased_word)
   word
 end
 
-namespace = 'Tracker'
+namespace = 'GObject'
 GirFFI.setup namespace
+modul = Kernel.const_get(namespace)
 
-gir = GirFFI::IRepository.default
+gir = GObjectIntrospection::IRepository.default
 gir.require namespace, nil
 infos = gir.infos namespace
 
@@ -25,7 +27,7 @@ main_file.write "module #{namespace}\n"
 infos.each do |info|
   case info.info_type
   when :function
-    fbuilder = GirFFI::Builder::Function.new info, Tracker::Lib
+    fbuilder = GirFFI::Builder::Function.new info, modul::Lib
     main_file.write "\n"
     main_file.write fbuilder.generate
     main_file.write "\n"
@@ -41,7 +43,7 @@ infos.each do |info|
       end
       main_file.write "# @return [#{minfo.return_type.tag}]\n"
 
-      fbuilder = GirFFI::Builder::Function.new minfo, Tracker::Lib
+      fbuilder = GirFFI::Builder::Function.new minfo, modul::Lib
       main_file.write fbuilder.generate
       unless minfo.method?
         main_file.write "end\n"

data/lib/ffi-glib.rb

@@ -0,0 +1,107 @@
+GirFFI.setup :GLib
+
+require 'ffi-glib/s_list'
+require 'ffi-glib/list'
+require 'ffi-glib/hash_table'
+require 'ffi-glib/byte_array'
+require 'ffi-glib/array'
+
+module GLib
+  # FIXME: Turn into real constructor
+  def self.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 self.slist_prepend slist, data
+    ::GLib::SList.wrap(slist.element_type, ::GLib::Lib.g_slist_prepend(slist, data))
+  end
+
+  # FIXME: Turn into real constructor
+  def self.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 self.list_append list, data
+    ::GLib::List.wrap(list.element_type, ::GLib::Lib.g_list_append(list, data))
+  end
+
+  # FIXME: Turn into real constructor
+  def self.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 self.byte_array_new
+    ::GLib::ByteArray.wrap(::GLib::Lib.g_byte_array_new)
+  end
+
+  # FIXME: Turn into instance method
+  def self.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 self.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 self.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 self.main_loop_new context, is_running
+    ::GLib::MainLoop.wrap(::GLib::Lib.g_main_loop_new context, is_running)
+  end
+
+  load_class :HFunc
+  load_class :HashFunc
+  load_class :EqualFunc
+  module Lib
+    attach_function :g_slist_prepend, [:pointer, :pointer], :pointer
+
+    attach_function :g_list_append, [:pointer, :pointer], :pointer
+
+    attach_function :g_hash_table_foreach,
+      [:pointer, HFunc, :pointer], :void
+    attach_function :g_hash_table_new,
+      [HashFunc, EqualFunc], :pointer
+    attach_function :g_hash_table_insert,
+      [:pointer, :pointer, :pointer], :void
+
+    attach_function :g_byte_array_new, [], :pointer
+    attach_function :g_byte_array_append,
+      [:pointer, :pointer, :uint], :pointer
+
+    attach_function :g_array_new, [:int, :int, :uint], :pointer
+    attach_function :g_array_append_vals,
+      [:pointer, :pointer, :uint], :pointer
+
+    attach_function :g_main_loop_new, [:pointer, :bool], :pointer
+  end
+end

data/lib/ffi-glib/array.rb

@@ -0,0 +1,14 @@
+module GLib
+  load_class :Array
+
+  class Array
+    attr_accessor :element_type
+
+    def to_a
+      GirFFI::ArgHelper.ptr_to_typed_array(self.element_type,
+                                           self[:data], self[:len])
+    end
+  end
+end
+
+

data/lib/ffi-glib/byte_array.rb

@@ -0,0 +1,10 @@
+module GLib
+  load_class :ByteArray
+
+  class ByteArray
+    def to_string
+      GirFFI::ArgHelper.ptr_to_utf8_length self[:data], self[:len]
+    end
+  end
+end
+

data/lib/ffi-glib/hash_table.rb

@@ -0,0 +1,55 @@
+module GLib
+  load_class :HashTable
+
+  class HashTable
+    include Enumerable
+    attr_accessor :key_type
+    attr_accessor :value_type
+
+    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
+
+    def self.wrap keytype, valtype, ptr
+      super(ptr).tap do |it|
+        break if it.nil?
+        it.key_type = keytype
+        it.value_type = valtype
+      end
+    end
+  end
+end

data/lib/ffi-glib/list.rb

@@ -0,0 +1,9 @@
+require 'ffi-glib/list_methods'
+
+module GLib
+  load_class :List
+
+  class List
+    include ListMethods
+  end
+end

data/lib/ffi-glib/list_methods.rb

@@ -0,0 +1,31 @@
+module GLib
+  module ListMethods
+    include Enumerable
+    attr_accessor :element_type
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    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
+
+    module ClassMethods
+      def wrap elmttype, ptr
+        super(ptr).tap do |it|
+          break if it.nil?
+          it.element_type = elmttype
+        end
+      end
+    end
+  end
+end
+
+

data/lib/ffi-glib/s_list.rb

@@ -0,0 +1,9 @@
+require 'ffi-glib/list_methods'
+
+module GLib
+  load_class :SList
+
+  class SList
+    include ListMethods
+  end
+end

data/lib/ffi-gobject.rb

@@ -0,0 +1,94 @@
+GirFFI.setup :GObject
+
+require 'ffi-gobject/value'
+require 'ffi-gobject/initially_unowned'
+require 'ffi-gobject/closure'
+require 'ffi-gobject/ruby_closure'
+require 'ffi-gobject/helper'
+
+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
+
+  def self.type_from_instance_pointer inst_ptr
+    klsptr = inst_ptr.get_pointer 0
+    klsptr.send "get_#{GirFFI::TypeMap::TAG_TYPE_MAP[:gtype]}", 0
+  end
+
+  def self.type_from_instance instance
+    type_from_instance_pointer instance.to_ptr
+  end
+
+  _setup_method :signal_emitv
+
+  def self.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 self.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
+
+  load_class :Callback
+  load_class :ClosureNotify
+  load_class :ConnectFlags
+  load_class :ClosureMarshal
+
+  module Lib
+    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
+
+    attach_function :g_signal_connect_data,
+      [:pointer, :string, Callback, :pointer, ClosureNotify,
+        ConnectFlags],
+        :ulong
+    attach_function :g_closure_set_marshal,
+      [:pointer, ClosureMarshal], :void
+  end
+end