ffi-efl 0.0.6 → 0.0.7

data/Changelog

@@ -1,3 +1,8 @@
+2011-05-xx Jérémy Zurcher <jeremy@asynk.ch>
+	* add REinaList#from_a ptrt
+	* add REinaList#to_a ptrt=nil
+	* rework EcoreGetopt
+
 2011-05-11 Jérémy Zurcher <jeremy@asynk.ch>
 	* use ditz ass issure tracker
 	* use FFI.attach_variable for EAPI extern ...

data/MIT-LICENSE

@@ -6,10 +6,10 @@ deal in the Software without restriction, including without limitation the
 rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 sell copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
-  
+
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
-   
+
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

data/README.rdoc

@@ -8,23 +8,48 @@ A ruby-ffi binding to efl libraries (Enlightenment Foundation Libraries).
 
 == FEATURES/PROBLEMS:
 
-* Not 1.8 compatible yet !!!
+* pretty young project ...
 
 == SYNOPSIS:
 
-    require 'efl'
-    Efl::Eet.init
-    Efl::Eet::REetFile.open('/tmp/_eet.cfg', :eet_file_mode_write) do |f|
-        f.write 'config2', 'test--key'
+    require 'efl/elementary'
+
+    Efl::Elm.init
+
+    on_exit = Proc.new do |data, evas_object, event_info|
+        puts "EXIT #{data.read_string}"
+        Efl::Elm.exit
     end
-    Efl::Eet::REetFile.open('/tmp/_eet.cfg', :eet_file_mode_read) do |f|
-        puts f.read('config2')
+
+    win = Efl::Elm::ElmWin.new nil, "Window name" do |w|
+        w.title = "My title"
+        w.alpha = true
+        w.move 300, 300
+        w.resize 200, 100
+        bg = Efl::Elm::ElmBg.new w  do |bg|
+            bg.size_hint_weight_expand
+            bg.size_hint_align_fill
+            bg.evas_object_color_set 200,255,100,150
+            bg.show
+        end
+        w.resize_object_add bg
+        lb = Efl::Elm::ElmLabel.new w do |lb|
+            lb.label_set "Hello World!"
+            lb.size_hint_weight_set 1.0, 1.0
+        end
+        lb.show
+        w.resize_object_add lb
+        w.smart_callback_add "delete,request", on_exit, FFI::MemoryPointer.from_string("my data")
     end
-    Efl::Eet.shutdown
 
-For less minimalistic and more sane examples you may look at:
+    win.show
+
+    Efl::Elm.run
+    Efl::Elm.shutdown
+
+For more examples you may look at:
 
-* the spec/ and test/ folders
+* the spec/[https://github.com/jeremyz/ffi-efl/tree/master/spec] and test/[https://github.com/jeremyz/ffi-efl/tree/master/test] folders
 
 == REQUIREMENTS:
 

data/lib/efl/ecore_evas.rb

@@ -33,7 +33,7 @@ module Efl
                 yield self if block_given?
             end
             def self.release p
-                Native.ecore_evas_free p unless p.nil?
+                Native.ecore_evas_free p
             end
             def free p=nil
                 @ptr.autorelease=false

data/lib/efl/ecore_getopt.rb

@@ -19,6 +19,10 @@ module Efl
                     :doublep,       :double_p,
                     :listp,         :eina_list_p,
                     :ptrp,          :void_p
+
+            def value_ptr idx
+                Native::EcoreGetoptValue.new to_ptr+(idx*Native::EcoreGetoptValue.size)
+            end
         end
         #
         class EcoreGetoptDescStoreDef < FFI::Union
@@ -85,49 +89,112 @@ module Efl
     module EcoreGetopt
         #
         class REcoreGetopt
+            #
             def initialize desc
-                @ecore_getopt = nil
+                @pts = []
+                @ecore_getopt_st = nil
+                @ecore_values_st = nil
                 @desc = desc
                 @options = [
                     [ 0 ],
                 ]
-                @values = [
-                    [ :ptrp, FFI::Pointer::NULL ]
-                ]
-                @refs = [] # to prevent FFI::MemoryPointer.from_string from beeing GC'ed
-            end
-            def p_from_string r
-                return r if r==FFI::Pointer::NULL
+                @values = {
+                    :sentinel0 => [ :pointer, FFI::Pointer::NULL ]
+                }
+                @values_order = [ :sentinel0 ]
+                @types = {
+                    :string => [ :ecore_getopt_type_str, :strv, :strp ],
+                    :uchar  => [ :ecore_getopt_type_bool, :boolv, :boolp ],
+                    :short  => [ :ecore_getopt_type_short, :shortv, :shortp ],
+                    :int    => [ :ecore_getopt_type_int, :intv, :intp ],
+                    :long   => [ :ecore_getopt_type_long, :longv, :longp ],
+                    :ushort => [ :ecore_getopt_type_ushort, :ushortv, :ushortp ],
+                    :uint   => [ :ecore_getopt_type_uint, :uintv, :uintp ],
+                    :ulong  => [ :ecore_getopt_type_ulong, :ulongv, :ulongp ],
+                    :double => [ :ecore_getopt_type_double, :doublev, :doublep ],
+                    :list   => [ :list, nil, :listp ],
+                    :pointer=> [ :pointer, nil, :ptrp ],
+                    :choice => [ :pointer, nil, :ptrp ]
+                }
+            end
+            def want_p r
+                return r if r.is_a? FFI::Pointer
+                return FFI::Pointer::NULL if r.nil?
                 p = FFI::MemoryPointer.from_string r
-                @refs << p
+                @pts << p
                 p
             end
-            private :p_from_string
-            def << o
+            private :want_p
+            def set_option o
                 @options.insert -2, o
             end
-            def value type, ptr
-                @values.insert -2, [ type, ptr ]
+            def set_value key, ptype, val=nil
+                skey = key.to_s
+                r = @values[skey]
+                if r.nil?
+                    case ptype
+                    when :list
+                        p = FFI::MemoryPointer.new :pointer
+                        p.write_pointer val[0]
+                        r = @values[skey] = [ ptype, p, val[1] ]    # add sub_type info
+                    when :choice
+                        p = FFI::MemoryPointer.new :pointer
+                        p.write_pointer FFI::Pointer::NULL
+                        r = @values[skey] = [ ptype, p ]
+                    when :string
+                        p = FFI::MemoryPointer.new :pointer
+                        p.write_pointer FFI::Pointer::NULL
+                        r = @values[skey] = [ ptype, p ]
+                    when :pointer
+                        r = @values[skey] = [ ptype, val ]
+                    else
+                        p = FFI::MemoryPointer.new ptype
+                        p.send 'write_'+ptype.to_s, val unless val.nil?
+                        r = @values[skey] = [ ptype, p ]
+                    end
+                    @pts << p
+                end
+                @values_order.insert -2, skey
+                r
+            end
+            def [] k
+                ptype, ptr, sub_type = @values[k.to_s]
+                return nil if ptype.nil?
+                case ptype
+                when:list
+                    require 'efl/eina_list'
+                    Efl::EinaList::REinaList.new(ptr.read_pointer).to_a sub_type
+                when :choice
+                    p = ptr.read_pointer
+                    ( p==FFI::Pointer::NULL ? nil : p.read_string )
+                when :string
+                    p = ptr.read_pointer
+                    (p==FFI::Pointer::NULL ? nil : p.read_string )
+                when :pointer
+                    ptr.to_ptr
+                else
+                    ptr.send 'read_'+ptype.to_s
+                end
             end
             def to_ptr
-                @ecore_getopt.to_ptr
+                ( @ecore_getopt_st.nil? ? nil : @ecore_getopt_st.to_ptr )
             end
             def create
-                @ecore_getopt = Native::EcoreGetopt.new( FFI::MemoryPointer.new( :uchar, Native::EcoreGetopt.size+Native::EcoreGetoptDesc.size*@options.length) )
+                @ecore_getopt_st = Native::EcoreGetopt.new( FFI::MemoryPointer.new( :uchar, Native::EcoreGetopt.size+Native::EcoreGetoptDesc.size*@options.length) )
                 [:prog,:usage,:version,:copyright,:license,:description].each do |sym|
-                    @ecore_getopt[sym] = ( @desc.has_key?(sym) ? FFI::MemoryPointer.from_string(@desc[sym]) : FFI::Pointer::NULL )
+                    @ecore_getopt_st[sym] = ( @desc.has_key?(sym) ? FFI::MemoryPointer.from_string(@desc[sym]) : FFI::Pointer::NULL )
                 end
-                @ecore_getopt[:strict] = @desc[:strict] if @desc.has_key? :strict
+                @ecore_getopt_st[:strict] = @desc[:strict] if @desc.has_key? :strict
                 @options.each_with_index do |o,i|
-                    d = @ecore_getopt.desc_ptr i
+                    d = @ecore_getopt_st.desc_ptr i
                     if o[0]==0
                         d[:shortname] = d[:longname] = d[:help] = d[:metavar] = d[:action] = d[:action_param][:dummy] = 0
                         break
                     end
                     d[:shortname] = o[0].to_s.bytes.first
-                    d[:longname] = p_from_string o[1]
-                    d[:help] = p_from_string o[2]
-                    d[:metavar] = o[3]
+                    d[:longname] = want_p o[1]
+                    d[:help] = want_p o[2]
+                    d[:metavar] = want_p o[3]
                     d[:action] = o[4]
                     k, v = o[5]
                     case k
@@ -143,13 +210,7 @@ module Efl
                         st = d[:action_param][:store]
                         st[:type] = v[0]
                         st[:arg_req] = v[1]
-                        if not v[2].nil?
-                            if v[2][0]==:strv
-                                st[:def][:strv] = p_from_string v[2][1]
-                            else
-                                st[:def][v[2][0]] = v[2][1]
-                            end
-                        end
+                        st[:def][v[2]] = (v[2]==:strv ?  want_p(v[3]) : v[3] ) unless v[3].nil?
                     when :store_const
                         d[:action_param][:store_const] = v
                     when :choices
@@ -160,119 +221,139 @@ module Efl
                         d[:action_param][:dummy] = FFI::Pointer::NULL
                     end
                 end
-                @values_p = FFI::MemoryPointer.new Native::EcoreGetoptValue, @values.length, false
-                @values.each_with_index do |v,i|
-                    Native::EcoreGetoptValue.new(@values_p+(i*Native::EcoreGetoptValue.size))[v[0]] = v[1]
+                @ecore_values_st = Native::EcoreGetoptValue.new FFI::MemoryPointer.new Native::EcoreGetoptValue, @values_order.length, false
+                @values_order.each_with_index do |k,i|
+                    vtype, vpointer, *sub_type = @values[k]
+                    vpointer.write_pointer @ecore_getopt_st.desc_ptr(i)[:action_param][:store][:def][:strv] if vtype==:string
+                    etype, vfield, pfield = @types[vtype]
+                    @ecore_values_st.value_ptr(i)[pfield] = vpointer
                 end
+                self
             end
             def parse argv
                 ptr = FFI::MemoryPointer.new(:pointer, argv.length+1)
                 argv.each_with_index do |s, i|
-                    ptr[i].put_pointer 0, p_from_string(s)
+                    ptr[i].put_pointer 0, want_p(s)
                 end
                 ptr[argv.length].put_pointer 0, FFI::Pointer::NULL
-                Native.ecore_getopt_parse @ecore_getopt, @values_p, argv.length, ptr
+                Native.ecore_getopt_parse @ecore_getopt_st, @ecore_values_st, argv.length, ptr
             end
-            def store_full short, long, help, meta, type, arg_req, def_val
-                self << [ short, long, help, meta, :ecore_getopt_action_store, [:store, [type,arg_req, def_val] ] ]
+            def help short, long, key=nil
+                set_value key||short, :uchar, 0
+                set_option [ short, long, 'show this message.', FFI::Pointer::NULL, :ecore_getopt_action_help, [:dummy,FFI::Pointer::NULL] ]
             end
-            def store short, long, help, type
-                store_full short, long, help, FFI::Pointer::NULL, type, :ecore_getopt_desc_arg_requirement_yes, nil
+            def version short, long, key=nil
+                set_value key||short, :uchar, 0
+                set_option [ short, long, 'show program version.', FFI::Pointer::NULL, :ecore_getopt_action_version, [:dummy,FFI::Pointer::NULL] ]
             end
-            def store_type type, short, long, help
-                store short, long, help, ('ecore_getopt_type_'+type.to_s).to_sym
+            def copyright short, long, key=nil
+                set_value key||short, :uchar, 0
+                set_option [ short, long, 'show copyright.', FFI::Pointer::NULL, :ecore_getopt_action_copyright, [:dummy,FFI::Pointer::NULL] ]
             end
-            def store_metavar short, long, help, meta, type
-                store_full short, long, help, meta, type, :ecore_getopt_desc_arg_requirement_yes, nil
+            def license short, long, key=nil
+                set_value key||short, :uchar, 0
+                set_option [ short, long, 'show license.', FFI::Pointer::NULL, :ecore_getopt_action_license, [:dummy,FFI::Pointer::NULL] ]
             end
-            def store_meta_type type, short, long, help, meta
-                store_metavar short, long, help, meta, ('ecore_getopt_type_'+type.to_s).to_sym
+            def store_full short, long, help, meta, arg_req, type, def_val
+                vtype, vpointer = set_value short, type, def_val
+                etype, vfield, pfield = @types[vtype]
+                set_option [ short, long, help, meta, :ecore_getopt_action_store, [:store, [etype, arg_req, vfield, def_val] ] ]
             end
-            def store_def short, long, help, type, def_val
-                store_full short, long, help, FFI::Pointer::NULL, type, :ecore_getopt_desc_arg_requirement_optional, def_val
+            def store short, long, help, type, def_val=nil
+                store_full short, long, help, FFI::Pointer::NULL, :ecore_getopt_desc_arg_requirement_yes, type, def_val
             end
-            def store_def_type type, short, long, help, def_val
-                store_def short, long, help, ('ecore_getopt_type_'+type.to_s).to_sym, [ (type.to_s+'v').to_sym, def_val ]
+            def store_meta short, long, help, meta, type, def_val=nil
+                store_full short, long, help, meta, :ecore_getopt_desc_arg_requirement_yes, type, def_val
             end
-            def store_full_type type, short, long, help, meta, arg_req, def_val
-                store_full short, long, help, meta, ('ecore_getopt_type_'+type.to_s).to_sym, arg_req, [ (type.to_s+'v').to_sym, def_val ]
+            def store_def short, long, help, type, def_val
+                store_full short, long, help, FFI::Pointer::NULL, :ecore_getopt_desc_arg_requirement_optional, type, def_val
             end
-            def store_const short, long, help, value
-                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_const, [:store_const, value] ]
+            def store_const short, long, help, def_val, value
+                set_value short, :int, def_val
+                set_option [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_const, [:store_const, value] ]
             end
             def store_true short, long, help
-                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_true, [:dummy,FFI::MemoryPointer::NULL] ]
+                set_value short, :uchar, 0
+                set_option [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_true, [:dummy,FFI::MemoryPointer::NULL] ]
             end
             def store_false short, long, help
-                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_false, [:dummy,FFI::MemoryPointer::NULL] ]
-            end
-            def choice short, long, help, choices
-                ptr = FFI::MemoryPointer.new(:pointer, choices.length+1)
-                choices.each_with_index do |s, i|
-                    ptr[i].put_pointer 0, p_from_string(s)
+                set_value short, :uchar, 1
+                set_option [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_false, [:dummy,FFI::MemoryPointer::NULL] ]
+            end
+            def count short, long, help, def_val
+                set_value short, :int, def_val
+                set_option [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_count, [:dummy,FFI::Pointer::NULL] ]
+            end
+            def append_meta short, long, help, meta, sub_type, def_val=nil
+                if def_val.nil?
+                    p = FFI::Pointer::NULL
+                else
+                    p = def_val.inject(FFI::Pointer::NULL) { |list,e|
+                        ptr = FFI::MemoryPointer.new sub_type
+                        @pts << ptr
+                        ptr.send 'write_'+sub_type.to_s, e
+                        Native.eina_list_append list, ptr
+                    }
                 end
-                ptr[choices.length].put_pointer 0, FFI::Pointer::NULL
-                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_choice, [:choices,ptr] ]
+                set_value short, :list, [want_p(p),sub_type]
+                set_option [ short, long, help, meta, :ecore_getopt_action_append, [:append,@types[sub_type][0]] ]
             end
-            def choice_metavar short, long, help, meta, choices
-                ptr = FFI::MemoryPointer.new(:pointer, choices.length+1)
+            def append short, long, help, sub_type, def_val=nil
+                append_meta short, long, help, FFI::Pointer::NULL, sub_type, def_val
+            end
+            def choice_meta short, long, help, meta, choices
+                p = FFI::MemoryPointer.new(:pointer, choices.length+1)
+                @pts << p
                 choices.each_with_index do |s, i|
-                    ptr[i].put_pointer 0, p_from_string(s)
+                        p[i].put_pointer 0, want_p(s)
                 end
-                ptr[choices.length].put_pointer 0, FFI::Pointer::NULL
-                self << [ short, long, help, meta, :ecore_getopt_action_choice, [:choices,ptr] ]
-            end
-            def append short, long, help, sub_type
-                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_append, [:append,sub_type] ]
-            end
-            def append_metavar short, long, help, meta, sub_type
-                self << [ short, long, help, meta, :ecore_getopt_action_append, [:append,sub_type] ]
+                p[choices.length].put_pointer 0, FFI::Pointer::NULL
+                set_value short, :choice
+                set_option [ short, long, help, meta, :ecore_getopt_action_choice, [:choices,p] ]
             end
-            def count short, long, help
-                self << [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_count, [:dummy,FFI::Pointer::NULL] ]
+            def choice short, long, help, choices
+                choice_meta short, long, help, FFI::Pointer::NULL, choices
             end
-            def callback_full short, long, help, meta, cb, data, arg_req, def_val
-                self << [ short, long, help, meta, :ecore_getopt_action_callback, [:callback, [cb, data, arg_req, def_val] ] ]
+            def callback_full short, long, help, meta, cb, data, arg_req, type, def_val
+                pt, ptr = set_value short, type, def_val
+                arg_req = ( arg_req ? :ecore_getopt_desc_arg_requirement_yes : :ecore_getopt_desc_arg_requirement_no )
+                set_option [ short, long, help, meta, :ecore_getopt_action_callback, [:callback, [cb, want_p(data), arg_req, ptr ] ] ]
             end
             def callback_noargs short, long, help, cb, data=nil
-                callback_full short, long, help, FFI::Pointer::NULL, cb, data, :ecore_getopt_desc_arg_requirement_no, FFI::Pointer::NULL
-            end
-            def callback_args short, long, help, meta, cb, data=nil
-                callback_full short, long, help, meta, cb, data, :ecore_getopt_desc_arg_requirement_yes, FFI::Pointer::NULL
-            end
-            def help short, long
-                self << [ short, long, 'show this message.', FFI::Pointer::NULL, :ecore_getopt_action_help, [:dummy,FFI::Pointer::NULL] ]
+                callback_full short, long, help, FFI::Pointer::NULL, cb, data, false, :uchar, 0
             end
-            def version short, long
-                self << [ short, long, 'show program version.', FFI::Pointer::NULL, :ecore_getopt_action_version, [:dummy,FFI::Pointer::NULL] ]
+            def callback_args short, long, help, meta, cb, data, type, def_val
+                callback_full short, long, help, meta, cb, data, true, type, def_val
             end
-            def copyright short, long
-                self << [ short, long, 'show copyright.', FFI::Pointer::NULL, :ecore_getopt_action_copyright, [:dummy,FFI::Pointer::NULL] ]
-            end
-            def license short, long
-                self << [ short, long, 'show license.', FFI::Pointer::NULL, :ecore_getopt_action_license, [:dummy,FFI::Pointer::NULL] ]
-            end
-#            def sentinel
-#                self << [ 0, FFI::Pointer::NULL, FFI::Pointer::NULL, FFI::Pointer::NULL, 0, {:dummy=>FFI::Pointer::NULL} ]
-#            end
             #
             def debug
                 r = ''
-                r << "#{self.class} : #{@ecore_getopt.to_ptr}\n"
+                r << "#{self.class} : #{@ecore_getopt_st.to_ptr}\n"
                 [:prog,:usage,:version,:copyright,:license,:description].each do |sym|
-                    r<< "  #{sym.to_s} : #{@ecore_getopt[sym]==FFI::Pointer::NULL ? 'NULL' : @ecore_getopt[sym].read_string}\n"
+                    r<< "  #{sym.to_s} : #{@ecore_getopt_st[sym]==FFI::Pointer::NULL ? 'NULL' : @ecore_getopt_st[sym].read_string}\n"
                 end
-                r << "  strict : #{@ecore_getopt[:strict]}\n"
+                r << "  strict : #{@ecore_getopt_st[:strict]}\n"
                 i=0
+                r << "  Descriptions\n"
                 while true
-                    d = @ecore_getopt.desc_ptr i
-                    break if d[:shortname]==0 and d[:longname] == FFI::Pointer::NULL
-                    r << "    desc #{d.to_ptr}\n"
-                    r << "     short: #{d[:shortname].chr}\n" unless d[:shortname]==0
-                    r << "     long:  #{d[:longname].read_string}\n" unless d[:longname]==FFI::Pointer::NULL
-                    r << "     help:  #{d[:help].read_string}\n" unless d[:help]==FFI::Pointer::NULL
+                    st = @ecore_getopt_st.desc_ptr i
+                    break if st[:shortname]==0 and st[:longname] == FFI::Pointer::NULL
+                    r << "    desc #{st.to_ptr}\n"
+                    r << "     short: #{st[:shortname].chr}\n" unless st[:shortname]==0
+                    r << "     long:  #{st[:longname].read_string}\n" unless st[:longname]==FFI::Pointer::NULL
+                    r << "     help:  #{st[:help].read_string}\n" unless st[:help]==FFI::Pointer::NULL
                     i+=1
                 end
+                r << "  Values\n"
+                @values_order.each_with_index do |k,i|
+                    st = @ecore_values_st.value_ptr i
+                    vtype, vpointer = @values[k]
+                    etype, vfield, pfield = @types[vtype]
+                    r << "    value #{st.to_ptr}\n"
+                    r << "     key:   #{k}\n"
+                    r << "     type:  #{vtype}\n"
+                    r << "     value: #{self[k]}\n"
+                end
                 r
             end
         end

data/lib/efl/edje.rb

@@ -18,31 +18,31 @@ module Efl
             #
             def part_object_get part
                 # EAPI const Evas_Object *edje_object_part_object_get (const Evas_Object *obj, const char *part);
-                Evas::RevasObject.new Native.edje_object_part_object_get @ptr, part
+                Evas::REvasObject.new Native.edje_object_part_object_get @ptr, part
             end
             def part_swallow_get part
                 # EAPI Evas_Object *edje_object_part_swallow_get (const Evas_Object *obj, const char *part);
-                Evas::RevasObject.new Native.edje_object_part_swallow_get @ptr, part
+                Evas::REvasObject.new Native.edje_object_part_swallow_get @ptr, part
             end
             def external_object_get part
                 # EAPI Evas_Object *edje_object_part_external_object_get (const Evas_Object *obj, const char *part);
-                Evas::RevasObject.new Native.edje_object_part_external_object_get @ptr, part
+                Evas::REvasObject.new Native.edje_object_part_external_object_get @ptr, part
             end
             def external_content_get part, content
                 # EAPI Evas_Object *edje_object_part_external_content_get (const Evas_Object *obj, const char *part, const char *content);
-                Evas::RevasObject.new Native.edje_object_part_external_content_get @ptr, part, content
+                Evas::REvasObject.new Native.edje_object_part_external_content_get @ptr, part, content
             end
             def part_box_remove part, child
                 # EAPI Evas_Object *edje_object_part_box_remove (Evas_Object *obj, const char *part, Evas_Object *child);
-                Evas::RevasObject.new Native.edje_object_part_box_remove @ptr, part, child
+                Evas::REvasObject.new Native.edje_object_part_box_remove @ptr, part, child
             end
             def part_box_remove_at part, pos
                 # EAPI Evas_Object *edje_object_part_box_remove_at (Evas_Object *obj, const char *part, unsigned int pos);
-                Evas::RevasObject.new Native.edje_object_part_box_remove_at @ptr, part, pos
+                Evas::REvasObject.new Native.edje_object_part_box_remove_at @ptr, part, pos
             end
             def part_table_child_get part, col, row
                 # EAPI Evas_Object *edje_object_part_table_child_get (Evas_Object *obj, const char *part, unsigned int col, unsigned int row);
-                Evas::RevasObject.new Native.edje_object_part_table_child_get @ptr, part, col, row
+                Evas::REvasObject.new Native.edje_object_part_table_child_get @ptr, part, col, row
             end
             def file_get
                 f = FFI::MemoryPointer.new :pointer

data/lib/efl/eina_list.rb

@@ -40,6 +40,13 @@ module Efl
                 Native.eina_list_free @ptr
                 @ptr = nil
             end
+            def self.from_a ary, ptrt
+                REinaList.new ary.inject(FFI::Pointer::NULL) { |p,e|
+                    ptr = FFI::MemoryPointer.new ptrt
+                    ptr.send 'write_'+ptrt.to_s, e
+                    Native.eina_list_append p, ptr
+                }
+            end
             def each
                 return if not block_given?
                 p = @ptr
@@ -49,8 +56,9 @@ module Efl
                     p = l[:next]
                 end
             end
-            def to_a
-                inject([]) { |s,e| s<<e }
+            def to_a ptrt=nil
+                return inject([]) { |s,e| s<<e } if ptrt.nil?
+                inject([]) { |s,e| s<< e.send('read_'+ptrt.to_s) }
             end
             alias :to_ary :to_a
             # for fun and tests