ffi-efl 0.0.2 → 0.0.3

data/Changelog

@@ -1,5 +1,17 @@
+2011-05-01 Jérémy Zurcher <jeremy@asynk.ch>
+	* release 0.0.3
+	+ Evas, Evas_Ecore, Edje, Elm ... usable
+	* use FFI::AutoPointer in ruby classes
+	* cleanup method_missing proxies usage and definition
+	* Eina_List <=> Array
+	* Eina_Hash <=> Hash
+	* .*= setters handled
+	* .*? getters handled
+	* evas test from http://docs.enlightenment.org/auto/evas/ implemented
+	* edje test from http://docs.enlightenment.org/auto/edje/ implemented
+
 2011-04-25 Jérémy Zurcher <jeremy@asynk.ch>
-	* release 0.2.0
+	* release 0.0.2
 	* ecore getopt seems good
 	* basis of module function mapping and class method_missing usage setup
 	* small elementary elm_Win test app

data/README.rdoc

@@ -4,31 +4,27 @@ ffi-efl
 
 == DESCRIPTION:
 
-ffi-efl is a FFI[https://github.com/ffi/ffi/wiki] binding to Enlightenment Foundation Libraries (eina,eet,evas,ecore,edje...)
-base components of the Enlightenment project. (EFL API[http://www.enlightenment.org/p.php?p=docs&l=en])
-
-ffi-efl project is developed on asynk[http://cgit.asynk.ch/cgi-bin/cgit/ffi-efl], github[https://github.com/jeremyz] and gitorious[https://gitorious.org/~jeyzu]
+A ruby-ffi binding to efl libraries (Enlightenment Foundation Libraries).
 
 == FEATURES/PROBLEMS:
 
-* Project just started
+* Not 1.8 compatible yet !!!
 
 == SYNOPSIS:
 
-    require './lib/efl'
-    include Efl
-    Eet.init
-    Eet.open('/tmp/_eet.cfg', :eet_file_mode_write) do |f|
+    require 'efl'
+    Efl::Eet.init
+    Efl::Eet::REetFile.open('/tmp/_eet.cfg', :eet_file_mode_write) do |f|
         f.write 'config2', 'test--key'
     end
-    Eet.open('/tmp/_eet.cfg', :eet_file_mode_read) do |f|
+    Efl::Eet::REetFile.open('/tmp/_eet.cfg', :eet_file_mode_read) do |f|
         puts f.read('config2')
     end
-    Eet.shutdown
+    Efl::Eet.shutdown
 
 For less minimalistic and more sane examples you may look at:
 
-* the spec/ folder
+* the spec/ and test/ folders
 
 == REQUIREMENTS:
 
@@ -37,7 +33,7 @@ For less minimalistic and more sane examples you may look at:
 
 == DOWNLOAD/INSTALL:
 
-From rubyforge:
+From rubygems:
 
   [sudo] gem install ffi-efl
 
@@ -47,11 +43,25 @@ or from the git repository on github:
   cd ffi-efl
   rake gem:install
 
+== RESOURCES:
+
+You can find this project in a few places:
+
+Online repositories:
+
+* https://github.com/jeremyz/ffi-efl
+* http://cgit.asynk.ch/cgi-bin/cgit/ffi-efl/
+* https://gitorious.org/ffi-efl
+
+Gem:
+
+* https://rubygems.org/gems/ffi-efl
+
 == CREDITS:
 
 Special thanks to:
 
-* need help ...
+* Lionel Orry
 
 == LICENSE:
 

data/lib/efl/ecore.rb

@@ -1,7 +1,7 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 #
-require 'efl/ecore/ecore-ffi'
+require 'efl/ffi/ecore'
 #
 module Efl
     module Ecore
@@ -15,15 +15,15 @@ module Efl
         EVENT_SIGNAL_REALTIME = 5 # Realtime signal event
         EVENT_COUNT = 6
         #
-        class EcorePipe
+        class REcorePipe
             def initialize cb, data
-                @ptr = Efl::API.ecore_pipe_add cb, data
+                @ptr = Efl::Ecore.ecore_pipe_add cb, data
             end
-            def del; Efl::API.ecore_pipe_del @ptr; end
-            def read_close; Efl::API.ecore_pipe_read_close @ptr; end
-            def write_close; Efl::API.ecore_pipe_write_close @ptr; end
+            def del; Efl::Ecore.ecore_pipe_del @ptr; end
+            def read_close; Efl::Ecore.ecore_pipe_read_close @ptr; end
+            def write_close; Efl::Ecore.ecore_pipe_write_close @ptr; end
             def write data
-                Efl::API.ecore_pipe_write @ptr, FFI::MemoryPointer.from_string(data.to_s), data.to_s.length+1
+                Efl::Ecore.ecore_pipe_write @ptr, FFI::MemoryPointer.from_string(data.to_s), data.to_s.length+1
             end
             #
         end

data/lib/efl/ecore_evas.rb

@@ -0,0 +1,78 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ffi/ecore_evas'
+#
+module Efl
+    #
+    module EcoreEvas
+        #
+        class REcoreEvas
+            include Efl::ClassHelper
+            proxy_list [Efl::EcoreEvas,'ecore_evas_'].freeze
+            def initialize o=nil, &block
+                @ptr = (
+                    case o
+                    when NilClass
+                        FFI::AutoPointer.new Efl::EcoreEvas.ecore_evas_new(nil, 0, 0, 0, 0, nil), method(:free)
+                    when self.class
+                        o.to_ptr
+                    when FFI::AutoPointer
+                        o
+                    when FFI::Pointer
+                        FFI::AutoPointer.new o, method(:free)
+                    else
+                        raise ArgumentError.new "wrong argument #{o.class.name}"
+                    end
+                )
+                yield self if block_given?
+            end
+            def free p=nil
+                return Efl::EcoreEvas.ecore_evas_free p unless p.nil?
+                Efl::EcoreEvas.ecore_evas_free @ptr
+                @ptr.free
+                @ptr=nil
+            end
+            def get
+                # EAPI Evas *ecore_evas_get(const Ecore_Evas *ee);
+                Efl::Evas::REvas.new Efl::EcoreEvas.ecore_evas_get @ptr
+            end
+            def object_image_new
+                # EAPI Evas_Object *ecore_evas_object_image_new(Ecore_Evas *ee_target);
+                Efl::Evas::REvasObject.new Efl::EcoreEvas.ecore_evas_object_image_new @prt
+            end
+            def object_associate_get
+                # EAPI Evas_Object *ecore_evas_object_associate_get(const Ecore_Evas *ee);
+                Efl::Evas::REvasObject.new Efl::EcoreEvas.ecore_evas_object_associate_get @prt
+            end
+            #
+        end
+        #
+    end
+    #
+    module Evas
+        #
+        class REvas
+            def ecore_evas_get
+                # EAPI Ecore_Evas *ecore_evas_ecore_evas_get(const Evas *e);
+                Efl::EcoreEvas::REcoreEvas.new Efl::EcoreEvas.ecore_evas_ecore_evas_get @ptr
+            end
+        end
+        #
+        class REvasObject
+            def ecore_evas_get
+                # EAPI Ecore_Evas *ecore_evas_object_ecore_evas_get(Evas_Object *obj);
+                Efl::EcoreEvas::REcoreEvas.new Efl::EcoreEvas.ecore_evas_object_ecore_evas_get @ptr
+            end
+            def evas_get
+                # EAPI Evas *ecore_evas_object_evas_get(Evas_Object *obj);
+                Efl::Evas::REvas.new Efl::EcoreEvas.ecore_evas_object_evas_get @ptr
+            end
+        end
+    end
+    # TODO
+    #EAPI unsigned char ecore_getopt_callback_ecore_evas_list_engines(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
+    #
+end
+#
+# EOF

data/lib/efl/ecore_getopt.rb

@@ -1,12 +1,13 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 #
-require 'efl/ecore/ecore_getopt-ffi'
+require 'efl/ffi/ecore_getopt'
 #
 module Efl
-    module API
+    #
+    module EcoreGetopt
         #
-        class EcoreGetoptValue < FFI::Union
+        class Value < FFI::Union
             layout  :strp,          :pointer,
                     :boolp,         :eina_bool_p,
                     :shortp,        :short_p,
@@ -20,7 +21,7 @@ module Efl
                     :ptrp,          :void_p,
         end
         #
-        class EcoreGetoptDescStoreDef < FFI::Union
+        class DescStoreDef < FFI::Union
             layout  :strv,          :pointer,
                     :boolv,         :uchar,
                     :shortv,        :short,
@@ -32,37 +33,37 @@ module Efl
                     :doublev,       :double,
         end
         #
-        class EcoreGetoptDescStore < FFI::Struct
+        class DescStore < FFI::Struct
             layout  :type,          :ecore_getopt_type,                 # enum
                     :arg_req,       :ecore_getopt_desc_arg_requirement, # enum
-                    :def,           EcoreGetoptDescStoreDef,
+                    :def,           DescStoreDef,
         end
         #
         callback :ecore_getopt_desc_cb, [:ecore_getopt_p, :ecore_getopt_desc_p, :string, :pointer, :ecore_getopt_value_p ], :eina_bool
         #
-        class EcoreGetoptDescCallback < FFI::Struct
+        class DescCallback < FFI::Struct
             layout  :func,          :ecore_getopt_desc_cb,
                     :data,          :pointer,
                     :arg_req,       :ecore_getopt_desc_arg_requirement, # enum
                     :def,           :pointer,
         end
         #
-        class EcoreActionParam < FFI::Union
-            layout  :store,         EcoreGetoptDescStore,
+        class ActionParam < FFI::Union
+            layout  :store,         DescStore,
                     :store_const,   :pointer,
                     :choices,       :pointer,
                     :append_type,   :ecore_getopt_type,                 # enum
-                    :callback,      EcoreGetoptDescCallback,
+                    :callback,      DescCallback,
                     :dummy,         :pointer,
         end
         #
-        class EcoreGetoptDesc < FFI::Struct
+        class Desc < FFI::Struct
             layout  :shortname,     :char,
                     :longname,      :pointer,
                     :help,          :pointer,
                     :metavar,       :pointer,
                     :action,        :ecore_getopt_action,               # enum
-                    :action_param,  EcoreActionParam,
+                    :action_param,  ActionParam,
         end
         #
         class EcoreGetopt < FFI::Struct
@@ -76,15 +77,13 @@ module Efl
 #                    :descs,         :pointer,   # NULL terminated  EcoreGetopt_Desc[]
 
             def desc_ptr idx
-                EcoreGetoptDesc.new to_ptr+Efl::API::EcoreGetopt.size+(idx*Efl::API::EcoreGetoptDesc.size)
+                Efl::EcoreGetopt::Desc.new to_ptr+Efl::EcoreGetopt::EcoreGetopt.size+(idx*Efl::EcoreGetopt::Desc.size)
             end
         end
         #
-    end
-    #
-    module EcoreGetopt
-        class Parser
+        class REcoreGetopt
             def initialize desc
+                @ecore_getopt = nil
                 @desc = desc
                 @options = [
                     [ 0, FFI::Pointer::NULL, FFI::Pointer::NULL, FFI::Pointer::NULL, 0, {:dummy=>FFI::Pointer::NULL} ]
@@ -107,16 +106,16 @@ module Efl
                 @values.insert -2, [ type, ptr ]
             end
             def to_ptr
-                @parser_p.to_ptr
+                @ecore_getopt.to_ptr
             end
             def create
-                @parser_p = Efl::API::EcoreGetopt.new FFI::MemoryPointer.new (Efl::API::EcoreGetopt.size+Efl::API::EcoreGetoptDesc.size*@options.length), 1
+                @ecore_getopt = Efl::EcoreGetopt::EcoreGetopt.new FFI::MemoryPointer.new (Efl::EcoreGetopt::EcoreGetopt.size+Efl::EcoreGetopt::Desc.size*@options.length), 1
                 [:prog,:usage,:version,:copyright,:license,:description].each do |sym|
-                    @parser_p[sym] = ( @desc.has_key?(sym) ? FFI::MemoryPointer.from_string(@desc[sym]) : FFI::Pointer::NULL )
+                    @ecore_getopt[sym] = ( @desc.has_key?(sym) ? FFI::MemoryPointer.from_string(@desc[sym]) : FFI::Pointer::NULL )
                 end
-                @parser_p[:strict] = @desc[:strict] if @desc.has_key? :strict
+                @ecore_getopt[:strict] = @desc[:strict] if @desc.has_key? :strict
                 @options.each_with_index do |o,i|
-                    d = @parser_p.desc_ptr i
+                    d = @ecore_getopt.desc_ptr i
                     d[:shortname] = o[0].ord
                     d[:longname] = p_from_string o[1]
                     d[:help] = p_from_string o[2]
@@ -153,9 +152,9 @@ module Efl
                         d[:action_param][:dummy] = FFI::Pointer::NULL
                     end
                 end
-                @values_p = FFI::MemoryPointer.new Efl::API::EcoreGetoptValue, @values.length, false
+                @values_p = FFI::MemoryPointer.new Efl::EcoreGetopt::Value, @values.length, false
                 @values.each_with_index do |v,i|
-                    Efl::API::EcoreGetoptValue.new(@values_p+(i*Efl::API::EcoreGetoptValue.size))[v[0]] = v[1]
+                    Efl::EcoreGetopt::Value.new(@values_p+(i*Efl::EcoreGetopt::Value.size))[v[0]] = v[1]
                 end
             end
             def parse argv
@@ -164,7 +163,7 @@ module Efl
                     ptr[i].put_pointer 0, p_from_string(s)
                 end
                 ptr[argv.length].put_pointer 0, FFI::Pointer::NULL
-                Efl::EcoreGetopt.parse @parser_p, @values_p, argv.length, ptr
+                Efl::EcoreGetopt.ecore_getopt_parse @ecore_getopt, @values_p, 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] ] ]
@@ -251,14 +250,14 @@ module Efl
             #
             def debug
                 r = ''
-                r << "#{self.class} : #{@parser_p.to_ptr}\n"
+                r << "#{self.class} : #{@ecore_getopt.to_ptr}\n"
                 [:prog,:usage,:version,:copyright,:license,:description].each do |sym|
-                    r<< "  #{sym.to_s} : #{@parser_p[sym]==FFI::Pointer::NULL ? 'NULL' : @parser_p[sym].read_string}\n"
+                    r<< "  #{sym.to_s} : #{@ecore_getopt[sym]==FFI::Pointer::NULL ? 'NULL' : @ecore_getopt[sym].read_string}\n"
                 end
-                r << "  strict : #{@parser_p[:strict]}\n"
+                r << "  strict : #{@ecore_getopt[:strict]}\n"
                 i=0
                 while true
-                    d = @parser_p.desc_ptr i
+                    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

data/lib/efl/ecore_input.rb

@@ -0,0 +1,14 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ffi/ecore_input'
+#
+module Efl
+    #
+    module EcoreInput
+        #
+    end
+    #
+end
+#
+# EOF

data/lib/efl/edje.rb

@@ -1,11 +1,57 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 #
-require 'efl/edje/edje-ffi'
+require 'efl/evas'
+require 'efl/ffi/edje'
 #
 module Efl
+    #
     module Edje
         #
+        class REdje < Efl::Evas::REvasObject
+            #
+            proxy_list [Efl::Edje,'edje_object_'].freeze
+            def part_object_get part
+                # EAPI const Evas_Object *edje_object_part_object_get (const Evas_Object *obj, const char *part);
+                Efl::Evas::RevasObject.new Efl::Edje.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);
+                Efl::Evas::RevasObject.new Efl::Edje.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);
+                Efl::Evas::RevasObject.new Efl::Edje.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);
+                Efl::Evas::RevasObject.new Efl::Edje.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);
+                Efl::Evas::RevasObject.new Efl::Edje.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);
+                Efl::Evas::RevasObject.new Efl::Edje.edje_object_part_box_remove_at @ptr, part, pos
+            end
+            def part_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);
+                Efl::Evas::RevasObject.new Efl::Edje.edje_object_part_child_get @ptr, part, col, row
+            end
+        end
+        #
+    end
+    #
+    module Evas
+        #
+        class REvas
+            def edje_object_add
+                # EAPI Evas_Object *edje_object_add (Evas *evas);
+                Efl::Edje::REdje.new Efl::Edje.edje_object_add @ptr
+            end
+        end
+        #
     end
 end
 #

data/lib/efl/eet.rb

@@ -1,49 +1,41 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 #
-require 'efl/eet/eet-ffi'
+require 'efl/ffi/eet'
 #
 module Efl
+    #
     module Eet
         #
-        class << self
+        class REetFile
             #
-            def open path, mode=FILE_MODE_READ, &blk
-                if blk
-                    f = Efl::API.eet_open path, mode
-                    raise Exception.new "Unable to open file #{path}" if f.nil?
-                    yield EetFile.new f
-                    Efl::API.eet_close f
-                else
-                    f = Efl::API.eet_open path, mode
-                    return EetFile.new f unless f.nil?
-                end
-            end
-        end
-        #
-        class EetFile
+            include Efl::ClassHelper
+            proxy_list [Efl::Eet,'eet_'].freeze
             #
             def initialize ptr
                 @ptr=ptr
             end
             private :initialize
             #
-            def close
-                Efl::API.eet_close @ptr
-                @ptr=nil
-            end
-            #
-            def mode_get
-                Efl::API.eet_mode_get @ptr
+            def self.open path, mode=:eet_file_mode_read, &blk
+                if blk
+                    f = Efl::Eet.eet_open path, mode
+                    raise Exception.new "Unable to open file #{path}" if f.nil?
+                    yield REetFile.new f
+                    Efl::Eet.eet_close f
+                else
+                    f = Efl::Eet.eet_open path, mode
+                    return REetFile.new f unless f.nil?
+                end
             end
             #
             def write key, data, compress=false
-                Efl::API.eet_write @ptr, key, FFI::MemoryPointer.from_string(data), data.bytesize, ( compress ? 1 : 0 )
+                Efl::Eet.eet_write @ptr, key, FFI::MemoryPointer.from_string(data), data.bytesize, ( compress ? 1 : 0 )
             end
             #
             def read key
                 ptr = FFI::MemoryPointer.new(:int)
-                data = Efl::API.eet_read @ptr, key, ptr
+                data = Efl::Eet.eet_read @ptr, key, ptr
                 s = ptr.read_int
                 ptr.free
                 return nil if s==0
@@ -53,6 +45,7 @@ module Efl
         end
         #
     end
+    #
 end
 #
 # EOF

data/lib/efl/eina.rb

@@ -0,0 +1,14 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ffi/eina'
+#
+module Efl
+    #
+    module Eina
+        #
+    end
+    #
+end
+#
+# EOF

data/lib/efl/eina_hash.rb

@@ -0,0 +1,84 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ffi/eina_hash'
+#
+class Hash
+    def self.from_eina_hash o
+        if o.is_a? Efl::EinaHash::REinaHash
+            o.to_h
+        elsif o.is_a? FFI::Pointer
+            Efl::EinaHash::REinaHash.new(o).to_h
+        else
+            raise ArgumentError.new " wrong argument #{o.class.name}"
+        end
+    end
+end
+module Efl
+    module EinaHash
+        #
+        class REinaHash
+            include Enumerable
+            include Efl::ClassHelper
+            proxy_list [Efl::EinaHash,'eina_hash_'].freeze
+            def initialize o=nil, &block
+                cstr = ( block_given? ? block : Proc.new { Efl::EinaHash.eina_hash_string_djb2_new FFI::Pointer::NULL } )
+                @ptr = (
+                    case o
+                    when NilClass
+                        FFI::AutoPointer.new cstr.call, method(:free)
+                    when self.class
+                        o.to_ptr
+                    when FFI::AutoPointer
+                        o
+                    when FFI::Pointer
+                        FFI::AutoPointer.new ( o==FFI::Pointer::NULL ? cstr.call : o ), method(:free)
+                    when Hash
+                        ptr = cstr.call
+                        o.each do |k,v| Efl::EinaHash.eina_hash_add ptr, k, v end
+                        FFI::AutoPointer.new ptr, method(:free)
+                    else
+                        raise ArgumentError.new "wrong argument #{o.class.name}"
+                    end
+                )
+            end
+            def free p=nil
+                return Efl::EinaHash.eina_hash_free p unless p.nil?
+                Efl::EinaHash.eina_hash_free @ptr
+                @ptr.free
+                @ptr = nil
+            end
+            def each data=FFI::Pointer::NULL, &block
+                return if not block_given?
+                Efl::EinaHash::eina_hash_foreach @ptr, Proc.new{|h,k,v,d| block.call(k,v) }, data
+            end
+            def to_h
+                 rh = {}
+                 each { |k,v| rh[k]=v; true }
+                 rh
+            end
+            def to_h_conv &block
+                 rh = {}
+                 if block_given?
+                    each { |k,v| rh[block.call(k)]=v; true }
+                 else
+                    each { |k,v| rh[k.read_string]=v; true }
+                 end
+                 rh
+            end
+            # for fun and tests
+            def add k, v
+                Efl::EinaHash.eina_hash_add @ptr, k, v
+                v
+            end
+            alias :[]= :add
+            def find k
+                r = Efl::EinaHash.eina_hash_find @ptr, k
+                return ( r==FFI::Pointer::NULL ? nil : r )
+            end
+            alias :[] :find
+        end
+    end
+end
+#
+# EOF

data/lib/efl/eina_list.rb

@@ -0,0 +1,77 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ffi/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
+        #
+        class EinaListStruct < FFI::Struct
+            layout  :data,          :pointer,
+                    :next,          :pointer,
+                    :prev,          :pointer,
+                    :accounting,    :pointer,
+                    :magic,         :uint,
+        end
+        #
+        class REinaList
+            include Enumerable
+            include Efl::ClassHelper
+            proxy_list [Efl::EinaList,'eina_list_'].freeze
+            def initialize o=nil
+                @ptr = (
+                    case o
+                    when FFI::Pointer
+                        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 }
+                    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
+                @ptr = nil
+            end
+            def each
+                p = @ptr
+                while p!=::FFI::Pointer::NULL
+                    l = Efl::EinaList::EinaListStruct.new p
+                    yield l[:data]
+                    p = l[:next]
+                end
+            end
+            def to_ary
+                inject([]) { |s,e| s<<e }
+            end
+            # for fun and tests
+            def append p
+                @ptr = Efl::EinaList.eina_list_append @ptr, p
+            end
+            alias :<< :append
+            def prepend p
+                @ptr = Efl::EinaList.eina_list_prepend @ptr, p
+            end
+            alias :unshift :prepend
+        end
+    end
+end
+#
+# EOF