ffi-efl 0.0.3 → 0.0.4

data/lib/efl/eina_list.rb

@@ -1,34 +1,27 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 #
-require 'efl/ffi/eina_list'
+require 'efl/native/eina_list'
 #
-class Array
-    def self.from_eina_list o
-        if o.is_a? Efl::EinaList::REinaList
-            o.to_ary
-        elsif o.is_a? FFI::Pointer
-            Efl::EinaList::REinaList.new(o).to_ary
-        else
-            raise ArgumentError.new "wrong argument #{o.class.name}"
-        end
-    end
-end
 module Efl
-    module EinaList
+    #
+    module Native
         #
         class EinaListStruct < FFI::Struct
             layout  :data,          :pointer,
-                    :next,          :pointer,
+                        :next,          :pointer,
                     :prev,          :pointer,
                     :accounting,    :pointer,
-                    :magic,         :uint,
+                    :magic,         :uint
         end
+    end
+    #
+    module EinaList
         #
         class REinaList
             include Enumerable
             include Efl::ClassHelper
-            proxy_list [Efl::EinaList,'eina_list_'].freeze
+            search_prefixes 'eina_list_'
             def initialize o=nil
                 @ptr = (
                     case o
@@ -36,24 +29,22 @@ module Efl
                         o
                     when NilClass
                         FFI::Pointer::NULL
-                    when self.class
-                        o.to_ptr
                     when Array
-                        o.inject(FFI::Pointer::NULL) { |p,e| Efl::EinaList.eina_list_append p, e }
+                        o.inject(FFI::Pointer::NULL) { |p,e| Native.eina_list_append p, e }
                     else
                         raise ArgumentError.new "wrong argument #{o.class.name}"
                     end
                 )
             end
-            def free p=nil
-                return Efl::EinaList.eina_list_free p unless p.nil?
-                Efl::EinaList.eina_list_free @ptr
+            def free
+                Native.eina_list_free @ptr
                 @ptr = nil
             end
             def each
+                return if not block_given?
                 p = @ptr
                 while p!=::FFI::Pointer::NULL
-                    l = Efl::EinaList::EinaListStruct.new p
+                    l = Native::EinaListStruct.new p
                     yield l[:data]
                     p = l[:next]
                 end
@@ -63,11 +54,11 @@ module Efl
             end
             # for fun and tests
             def append p
-                @ptr = Efl::EinaList.eina_list_append @ptr, p
+                @ptr = Native.eina_list_append @ptr, p
             end
             alias :<< :append
             def prepend p
-                @ptr = Efl::EinaList.eina_list_prepend @ptr, p
+                @ptr = Native.eina_list_prepend @ptr, p
             end
             alias :unshift :prepend
         end

data/lib/efl/elementary.rb

@@ -2,20 +2,9 @@
 # -*- coding: UTF-8 -*-
 #
 require 'efl/evas'
+require 'efl/native/elementary'
 #
-module Efl
-    module Elm
-        extend Efl::FFIHelper
-        steal_ffitype Efl::Evas, :evas_smart_cb
-        steal_ffitype Efl::Evas, :evas_load_error
-        steal_ffitype Efl::Evas, :evas_callback_type
-        steal_ffitype Efl::Evas, :evas_object_box_data_p
-    end
-end
-#
-require 'efl/ffi/elementary'
-#
-Efl::Evas::REvasObject.proxy_list << [Efl::Elm,'elm_'].freeze   # append not prepend !
+Efl::Evas::REvasObject.search_prefixes << 'elm_'   # append not prepend !
 #
 module Efl
     module Elm
@@ -23,30 +12,30 @@ module Efl
         class << self
             def init *args
                 a = args.select { |e| e.is_a? String }
-                return Efl::Elm.elm_init 0, FFI::MemoryPointer::NULL if a.length==0
+                return Native.elm_init 0, FFI::MemoryPointer::NULL if a.length==0
                 ptr = FFI::MemoryPointer.new :pointer, a.length
                 a.each_with_index do |s,i|
                     ptr[i].write_pointer FFI::MemoryPointer.from_string(s)
                 end
-                Efl::Elm.elm_init a.length, ptr
+                Native.elm_init a.length, ptr
             end
         end
         #
         class ElmWin
             include Efl::ClassHelper
-            proxy_list [Efl::Elm,'elm_win_'].freeze, [Efl::Elm,'elm_'].freeze
+            search_prefixes 'elm_win_', 'elm_'
             def initialize parent, title, type=:elm_win_basic
-                @evas_object = Efl::Evas::REvasObject.new Efl::Elm.elm_win_add parent, title, type
+                @evas_object = Evas::REvasObject.new Native.elm_win_add parent, title, type
                 @ptr = @evas_object.to_ptr
                 yield self,@evas_object if block_given?
             end
             def add e
-                eo = Efl::Evas::REvasObject.new Efl::Elm.send "elm_#{e}_add", @ptr
+                eo = Evas::REvasObject.new Native.send "elm_#{e}_add", @ptr
                 yield eo if block_given?
                 eo
             end
             def smart_callback_add event_str, cb, data=FFI::MemoryPointer::NULL
-                Efl::Evas.evas_object_smart_callback_add @ptr, event_str, cb, data
+                Native.evas_object_smart_callback_add @ptr, event_str, cb, data
             end
         end
         #

data/lib/efl/evas.rb

@@ -1,17 +1,11 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 #
-require 'efl/ffi/evas'
+require 'efl/native/evas'
 #
 module Efl
     #
-    module Evas
-        #
-        EVAS_ENGINE_BUFFER_DEPTH_ARGB32 = 0
-        EVAS_ENGINE_BUFFER_DEPTH_BGRA32 = 1
-        EVAS_ENGINE_BUFFER_DEPTH_RGB24  = 2
-        EVAS_ENGINE_BUFFER_DEPTH_BGR24  = 3
-        EVAS_ENGINE_BUFFER_DEPTH_RGB32  = 4
+    module Native
         #
         callback :new_update_region_cb, [:int, :int, :int, :int, :int_p], :pointer
         callback :free_update_region_cb, [:int, :int, :int, :int, :pointer], :void
@@ -32,118 +26,253 @@ module Efl
                     :color_key_r,           :int,
                     :color_key_g,           :int,
                     :color_key_b,           :int,
-                    :func,                  EngineInfoBufferFuncStruct,
+                    :func,                  EngineInfoBufferFuncStruct
         end
         class EngineInfoBufferStruct < FFI::Struct
             layout  :magic,                 EngineInfoStruct,
                     :info,                  EngineInfoBufferInfoStruct,
 #                    :func,                  EvasEngineInfoBufferFunc,
-                    :mode,                  :evas_engine_render_mode,
+                    :mode,                  :evas_engine_render_mode
         end
         #
+    end
+    #
+    module Evas
+        #
+        EVAS_ENGINE_BUFFER_DEPTH_ARGB32 = 0
+        EVAS_ENGINE_BUFFER_DEPTH_BGRA32 = 1
+        EVAS_ENGINE_BUFFER_DEPTH_RGB24  = 2
+        EVAS_ENGINE_BUFFER_DEPTH_BGR24  = 3
+        EVAS_ENGINE_BUFFER_DEPTH_RGB32  = 4
+        #
         class REvas
             #
             include Efl::ClassHelper
-            proxy_list [Efl::Evas,'evas_'].freeze
+            search_prefixes 'evas_'
             #
             def initialize o=nil
                 @ptr = (
                     case o
                     when NilClass
-                        FFI::AutoPointer.new Efl::Evas.evas_new, method(:free)
-                    when self.class
-                        o.to_ptr
-                    when FFI::AutoPointer
-                        o
+                        FFI::AutoPointer.new Native.evas_new, REvas.method(:release)
                     when FFI::Pointer
-                        FFI::AutoPointer.new o, method(:free)
+                        o
                     else
                         raise ArgumentError.new "wrong argument #{o.class.name}"
                     end
                 )
                 yield self if block_given?
             end
-            def free p=nil
-                return Efl::Evas.evas_free p unless p.nil?
-                Efl::Evas.evas_free @ptr
+            def self.release p
+                Native.evas_free p unless p.nil?
+            end
+            def free
+                @ptr.autorelease=false if @ptr.is_a? FFI::AutoPointer
+                REvas.release @ptr
                 @ptr=nil
             end
             def object_add t
-                Efl::Evas::REvasObject.new Efl::Evas.send "evas_object_#{t}_add", @ptr
+                ts = t.to_s
+                o =  (
+                    case ts
+                    when 'rectangle'
+                        Evas::REvasRectangle.new Native.evas_object_rectangle_add @ptr
+                    when 'line'
+                        Evas::REvasLine.new Native.evas_object_line_add @ptr
+                    when 'polygon'
+                        Evas::REvasPolygon.new Native.evas_object_polygon_add @ptr
+                    else
+                        raise NameError.new "unknown or not implemented yet evas_object type #{ts}"
+                    end
+                )
+                yield o if block_given?
+                o
             end
             def output_size_get
                 x = FFI::MemoryPointer.new :int
                 y = FFI::MemoryPointer.new :int
-                Efl::Evas.evas_output_size_get @ptr, x, y
+                Native.evas_output_size_get @ptr, x, y
                 [ x.read_int, y.read_int ]
             end
+            alias :output_size :output_size_get
+            alias :size :output_size_get
             def output_viewport_get
                 x = FFI::MemoryPointer.new :int
                 y = FFI::MemoryPointer.new :int
                 w = FFI::MemoryPointer.new :int
                 h = FFI::MemoryPointer.new :int
-                Efl::Evas.evas_output_viewport_get @ptr, x, y, w, h
+                Native.evas_output_viewport_get @ptr, x, y, w, h
                 [ x.read_int, y.read_int, w.read_int, h.read_int ]
             end
+            alias :output_viewport :output_viewport_get
+            alias :viewport :output_viewport_get
             def pointer_output_xy_get
                 x = FFI::MemoryPointer.new :int
                 y = FFI::MemoryPointer.new :int
-                Efl::Evas.evas_pointer_output_xy_get @ptr, x, y
+                Native.evas_pointer_output_xy_get @ptr, x, y
                 [ x.read_int, y.read_int ]
             end
+            alias :pointer_output :pointer_output_xy_get
             def pointer_canvas_xy_get
                 x = FFI::MemoryPointer.new :int
                 y = FFI::MemoryPointer.new :int
-                Efl::Evas.evas_pointer_canvas_xy_get @ptr, x, y
+                Native.evas_pointer_canvas_xy_get @ptr, x, y
                 [ x.read_int, y.read_int ]
             end
+            alias :pointer_canvas :pointer_canvas_xy_get
         end
         #
         class REvasObject
             #
             include Efl::ClassHelper
-            proxy_list [Efl::Evas,'evas_object_'].freeze, [Efl::Evas,'evas_'].freeze
+            search_prefixes 'evas_object_', 'evas_'
             #
             def initialize o=nil
                 @ptr = (
                     case o
                     when NilClass
-                        FFI::AutoPointer.new Efl::Evas.evas_new, method(:free)
-                    when self.class
-                        o.to_ptr
-                    when FFI::AutoPointer
-                        o
+                        FFI::AutoPointer.new Native.evas_new, REvasObject.method(:release)
                     when FFI::Pointer
-                        FFI::AutoPointer.new o, method(:free)
+                        o
                     else
                         raise ArgumentError.new "wrong argument #{o.class.name}"
                     end
                 )
                 yield self if block_given?
             end
-            def free p=nil
-                return Efl::Evas.evas_object_del p unless p.nil?
-                Efl::Evas.evas_object_del @ptr
-                @ptr.free
+            def self.release p
+                Native.evas_object_del p unless p.nil?
+            end
+            def free
+                @ptr.autopointer=false if @ptr.is_a? FFI::AutoPointer
+                REvasObject.release @ptr
                 @ptr=nil
             end
+            def evas_name
+                Native.evas_object_name_get @ptr
+            end
+            def evas_type
+                Native.evas_object_type_get @ptr
+            end
             def geometry_get
                 x = FFI::MemoryPointer.new :int
                 y = FFI::MemoryPointer.new :int
                 w = FFI::MemoryPointer.new :int
                 h = FFI::MemoryPointer.new :int
-                Efl::Evas.evas_object_geometry_get @evas, x, y, w, h
+                Native.evas_object_geometry_get @ptr, x, y, w, h
                 [ x.read_int, y.read_int, w.read_int, h.read_int ]
             end
+            alias :geometry :geometry_get
+            def size
+                geometry_get[2..-1]
+            end
+            def size= wh
+                Native.evas_object_resize @ptr, *wh
+            end
             def color_get
                 r = FFI::MemoryPointer.new :int
                 g = FFI::MemoryPointer.new :int
                 b = FFI::MemoryPointer.new :int
                 a = FFI::MemoryPointer.new :int
-                Efl::Evas.evas_object_color_get @evas, r, g, b, a
+                Native.evas_object_color_get @ptr, r, g, b, a
                 [ r.read_int, g.read_int, b.read_int, a.read_int ]
             end
+            alias :color :color_get
+            def evas_get
+                REvas.new Native.evas_object_evas_get @ptr
+            end
+            alias :evas :evas_get
+            def above_get
+                REvasObject.new Native.evas_object_above_get @ptr
+            end
+            alias :above :above_get
+            def below_get
+                REvasObject.new Native.evas_object_below_get @ptr
+            end
+            alias :below :below_get
+            def size_hint_min_get
+                w = FFI::MemoryPointer.new :int
+                h = FFI::MemoryPointer.new :int
+                Native.evas_object_size_hint_min_get @ptr, w, h
+                [ w.read_int, h.read_int ]
+            end
+            alias :size_hint_min :size_hint_min_get
+            def size_hint_max_get
+                w = FFI::MemoryPointer.new :int
+                h = FFI::MemoryPointer.new :int
+                Native.evas_object_size_hint_max_get @ptr, w, h
+                [ w.read_int, h.read_int ]
+            end
+            alias :size_hint_max :size_hint_max_get
+            def size_hint_request_get
+                w = FFI::MemoryPointer.new :int
+                h = FFI::MemoryPointer.new :int
+                Native.evas_object_size_hint_request_get @ptr, w, h
+                [ w.read_int, h.read_int ]
+            end
+            alias :size_hint_request :size_hint_request_get
+            def size_hint_aspect_get
+                a = FFI::MemoryPointer.new :int
+                w = FFI::MemoryPointer.new :int
+                h = FFI::MemoryPointer.new :int
+                Native.evas_object_size_hint_aspect_get @ptr, a, w, h
+                [ Native.enum_type(:evas_aspect_control)[a.read_int], w.read_int, h.read_int ]
+            end
+            alias :size_hint_aspect :size_hint_aspect_get
+            def size_hint_align_get
+                w = FFI::MemoryPointer.new :double
+                h = FFI::MemoryPointer.new :double
+                Native.evas_object_size_hint_align_get @ptr, w, h
+                [ w.read_double, h.read_double ]
+            end
+            alias :size_hint_align :size_hint_align_get
+            def size_hint_weight_get
+                w = FFI::MemoryPointer.new :double
+                h = FFI::MemoryPointer.new :double
+                Native.evas_object_size_hint_weight_get @ptr, w, h
+                [ w.read_double, h.read_double ]
+            end
+            alias :size_hint_weight :size_hint_weight_get
+            def size_hint_padding_get
+                l = FFI::MemoryPointer.new :int
+                r = FFI::MemoryPointer.new :int
+                t = FFI::MemoryPointer.new :int
+                b = FFI::MemoryPointer.new :int
+                Native.evas_object_size_hint_padding_get @ptr, l, r, t, b
+                [ l.read_int, r.read_int, t.read_int, b.read_int ]
+            end
+            alias :size_hint_padding :size_hint_padding_get
+            def data_get k
+                r = Native.evas_object_data_get @ptr, k
+                return nil if r==FFI::Pointer::NULL
+                r.read_string
+            end
+            alias :data :data_get
+        end
+        #
+        class REvasRectangle < REvasObject
+        end
+        #
+        class REvasLine < REvasObject
+            #
+            search_prefixes 'evas_object_line_'
+            #
+            def line_xy_get
+                x1 = FFI::MemoryPointer.new :int
+                y1 = FFI::MemoryPointer.new :int
+                x2 = FFI::MemoryPointer.new :int
+                y2 = FFI::MemoryPointer.new :int
+                Native.evas_object_line_xy_get @ptr, x1, y1, x2, y2
+                [ x1.read_int, y1.read_int, x2.read_int, y2.read_int ]
+            end
+        end
+        #
+        class REvasPolygon < REvasObject
+            #
+            search_prefixes 'evas_object_polygon_'
+            #
         end
+        #
     end
 end
 #

data/lib/efl/ffi.rb

@@ -72,40 +72,51 @@ module Efl
         def === o; @ptr === o.to_ptr; end
         def address; @ptr.address; end
         def self.included kls
-            # create class instance @proxy_list
-            kls.class_eval "@proxy_list ||=[]"
-            # access and prepend *args to @proxy_list
-            kls.class_eval "def self.proxy_list *args; @proxy_list.unshift *args unless args.empty?; @proxy_list; end"
-            # on inheritance, copy ancestor's @proxy_list
+            # create class instance @search_prefixes
+            kls.class_eval "@search_prefixes ||=[]"
+            # access and prepend *args to @search_prefixes
+            kls.class_eval "def self.search_prefixes *args; @search_prefixes.unshift *args unless args.empty?; @search_prefixes; end"
+            # on inheritance, copy ancestor's @search_prefixes
             kls.class_eval <<-EOF
             def self.inherited sub
-                sub.class_eval '@proxy_list = []'
-                sub.proxy_list *self.proxy_list
+                sub.class_eval '@search_prefixes = []'
+                sub.search_prefixes *self.search_prefixes
             end
             EOF
         end
         def method_missing m, *args, &block
-            if m =~/^(.*)=$/
+            m_s = m.to_s
+            if m_s =~/^(.*)=$/
                 m_s = $1+'_set'
                 args_s = '*args[0]'
-            elsif m =~/^(.*)\?$/
+            elsif m_s =~/^(.*)\?$/
                 m_s = $1+'_get'
                 args_s = '*args'
             else
-                m_s = m.to_s
                 args_s = '*args'
             end
-            self.class.proxy_list.each do |mod,p|
+            self.class.search_prefixes.each do |p|
                 sym = p+m_s
-                if mod.respond_to? sym
-                    self.class.class_eval "def #{m} *args, &block; r=#{mod.name}.#{sym}(@ptr,#{args_s}); yield r if block_given?; r; end"
-                    return self.send m, *args, &block
-                elsif mod.respond_to? m
-                    self.class.class_eval "def #{m} *args, &block; r=#{mod.name}.#{m}(@ptr,#{args_s}); yield r if block_given?; r; end"
+                meth = (
+                    if Efl::Native.respond_to? sym
+                        sym
+                    elsif Efl::Native.respond_to? m
+                        m
+                    elsif Efl::Native.respond_to? sym+'_get'
+                        sym+'_get'
+                    elsif Efl::Native.respond_to? m_s+'_get'
+                        m_s+'_get'
+                    else
+                        nil
+                    end
+                )
+                if not meth.nil?
+                    self.class.class_eval "def #{m} *args, &block; r=Efl::Native.#{meth}(@ptr,#{args_s}); yield r if block_given?; r; end"
                     return self.send m, *args, &block
                 end
             end
-            raise NameError.new "#{self.class} is unable to resolve #{m} within #{self.class.proxy_list.inspect}"
+            return [self.to_s+' ['+self.to_ptr.to_s+']'] if m_s=~/^to_ary$/
+            Kernel.raise NameError.new "#{self.class.name} is unable to resolve #{m} within #{self.class.search_prefixes.inspect}"
         end
     end
 end

data/lib/efl/{ffi → native}/ecore.rb

@@ -6,16 +6,20 @@ require 'efl/ffi'
 module Efl
     #
     module Ecore
-        #
-        extend Efl::FFIHelper
         #
         def self.method_missing m, *args, &block
             sym = 'ecore_'+m.to_s
-            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
-            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
-            self.send sym, *args, &block
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not Efl::Native.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=Efl::Native.#{sym}(*args); yield r if block_given?; r; end"
+            self.send m, *args, &block
         end
         #
+    end
+    #
+    module Native
+        #
+        extend Efl::FFIHelper
+        #
         ffi_lib 'ecore'
         #
         # ENUMS

data/lib/efl/{ffi → native}/ecore_evas.rb

@@ -6,16 +6,20 @@ require 'efl/ffi'
 module Efl
     #
     module EcoreEvas
-        #
-        extend Efl::FFIHelper
         #
         def self.method_missing m, *args, &block
             sym = 'ecore_evas_'+m.to_s
-            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
-            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
-            self.send sym, *args, &block
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not Efl::Native.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=Efl::Native.#{sym}(*args); yield r if block_given?; r; end"
+            self.send m, *args, &block
         end
         #
+    end
+    #
+    module Native
+        #
+        extend Efl::FFIHelper
+        #
         ffi_lib 'ecore_evas'
         #
         # ENUMS
@@ -49,6 +53,9 @@ module Efl
         typedef :pointer, :ecore_evas_p
         #
         # CALLBACKS
+        # void (*func) (Ecore_Evas *ee)
+        callback :ecore_evas_event_cb, [:ecore_evas_p], :void
+        #
         #
         # FUNCTIONS
         fcts = [
@@ -185,35 +192,35 @@ module Efl
         # EAPI void ecore_evas_data_set(Ecore_Evas *ee, const char *key, const void *data);
         [ :ecore_evas_data_set, [ :ecore_evas_p, :string, :void_p ], :void ],
         # EAPI void ecore_evas_callback_resize_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_resize_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_move_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_move_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_show_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_show_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_hide_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_hide_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_delete_request_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_delete_request_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_destroy_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_destroy_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_focus_in_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_focus_in_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_focus_out_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_focus_out_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_sticky_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_sticky_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_unsticky_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_unsticky_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_mouse_in_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_mouse_in_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_mouse_out_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_mouse_out_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_pre_render_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_pre_render_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_post_render_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_post_render_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI void ecore_evas_callback_pre_free_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
-        # FIXME
+        [ :ecore_evas_callback_pre_free_set, [:ecore_evas_p, :ecore_evas_event_cb], :void],
         # EAPI Evas *ecore_evas_get(const Ecore_Evas *ee);
         [ :ecore_evas_get, [ :ecore_evas_p ], :evas_p ],
         # EAPI void ecore_evas_move(Ecore_Evas *ee, int x, int y);

data/lib/efl/{ffi → native}/ecore_getopt.rb

@@ -6,16 +6,20 @@ require 'efl/ffi'
 module Efl
     #
     module EcoreGetopt
-        #
-        extend Efl::FFIHelper
         #
         def self.method_missing m, *args, &block
             sym = 'ecore_getopt_'+m.to_s
-            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
-            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
-            self.send sym, *args, &block
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not Efl::Native.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=Efl::Native.#{sym}(*args); yield r if block_given?; r; end"
+            self.send m, *args, &block
         end
         #
+    end
+    #
+    module Native
+        #
+        extend Efl::FFIHelper
+        #
         ffi_lib 'ecore'
         #
         # ENUMS