ffi-efl 0.0.2 → 0.0.3

data/spec/eina_list_spec.rb

@@ -0,0 +1,101 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/eina'
+require 'efl/eina_list'
+#
+describe Efl::EinaList do
+    #
+    before(:all) {
+        REinaList = Efl::EinaList::REinaList
+        Efl::Eina.init.should eql 1
+    }
+    after(:all) {
+        Efl::Eina.shutdown.should eql 0
+    }
+    #
+    it "should append prepend and fetch" do
+        l = REinaList.new
+        d1 = ::FFI::MemoryPointer.from_string "D0"
+        d2 = ::FFI::MemoryPointer.from_string "D1"
+        d3 = ::FFI::MemoryPointer.from_string "D2"
+        d4 = ::FFI::MemoryPointer.from_string "D3"
+        l.append d3
+        l.prepend d2
+        l << d4
+        l.unshift d1
+        0.upto 3 do |i|
+            l.nth(i).read_string.should eql "D#{i}"
+        end
+        l.each { |p| p.read_string.empty?.should be_false }
+        l.free
+    end
+    #
+    it "should be able to convert into ruby Array from NULL pointer" do
+        ary = Array.from_eina_list ::FFI::Pointer::NULL
+        ary.empty?.should be_true
+        ary.is_a?(Array).should be_true
+    end
+    #
+    it "should be able to convert into ruby Array from empty REinaList" do
+        ary = Array.from_eina_list REinaList.new
+        ary.empty?.should be_true
+        ary.is_a?(Array).should be_true
+    end
+    #
+    it "should be able to convert into ruby Array from empty REinaList pointer" do
+        ary = Array.from_eina_list REinaList.new.to_ptr
+        ary.empty?.should be_true
+        ary.is_a?(Array).should be_true
+    end
+    #
+    it "should be able to convert into ruby Array from non empty REinaList" do
+        l = REinaList.new
+        d1 = ::FFI::MemoryPointer.from_string "D0"
+        d2 = ::FFI::MemoryPointer.from_string "D1"
+        d3 = ::FFI::MemoryPointer.from_string "D2"
+        d4 = ::FFI::MemoryPointer.from_string "D3"
+        l.append d3
+        l.prepend d2
+        l << d4
+        l.unshift d1
+        ary =  Array.from_eina_list l
+        ary.length.should eql 4
+        0.upto 3 do |i|
+            ary[i].read_string.should eql "D#{i}"
+        end
+        l.free
+    end
+    #
+    it "should be able to convert into ruby Array from non empty REinaList pointer" do
+        l = REinaList.new
+        d1 = ::FFI::MemoryPointer.from_string "D0"
+        d2 = ::FFI::MemoryPointer.from_string "D1"
+        d3 = ::FFI::MemoryPointer.from_string "D2"
+        d4 = ::FFI::MemoryPointer.from_string "D3"
+        l.append d3
+        l.prepend d2
+        l << d4
+        l.unshift d1
+        ary =  Array.from_eina_list l.to_ptr
+        ary.length.should eql 4
+        0.upto 3 do |i|
+            ary[i].read_string.should eql "D#{i}"
+        end
+        l.free
+    end
+    #
+    it "should be able to build from ruby Array" do
+        a =  []
+        a << ::FFI::MemoryPointer.from_string("D0")
+        a << ::FFI::MemoryPointer.from_string("D1")
+        a << ::FFI::MemoryPointer.from_string("D2")
+        a << ::FFI::MemoryPointer.from_string("D3")
+        l = REinaList.new a
+        0.upto 3 do |i|
+            l.nth(i).read_string.should eql "D#{i}"
+        end
+        l.free
+    end
+    #
+end

data/spec/eina_spec.rb

@@ -0,0 +1,20 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/eina'
+#
+describe Efl::Eina do
+    #
+    it "should init" do
+        Efl::Eina.init.should eql 1
+        Efl::Eina.init.should eql 2
+        Efl::Eina.init.should eql 3
+    end
+    #
+    it "should shutdown" do
+        Efl::Eina.shutdown.should eql 2
+        Efl::Eina.shutdown.should eql 1
+        Efl::Eina.shutdown.should eql 0
+    end
+    #
+end

data/spec/evas_spec.rb

@@ -5,7 +5,7 @@ require 'efl/evas'
 #
 describe Efl::Evas do
     #
-    include Efl
+    before(:all) { Evas = Efl::Evas }
     #
     it "should init" do
         Evas.init.should eql 1
@@ -20,15 +20,15 @@ describe Efl::Evas do
     end
     #
     it "evas alloc error enum is ok" do
-        Efl::API.enum_value(:evas_alloc_error_none).should eql 0
-        Efl::API.enum_value(:evas_alloc_error_fatal).should eql 1
-        Efl::API.enum_value(:evas_alloc_error_recovered).should eql 2
-        Efl::API.enum_type(:evas_alloc_error)[0].should eql :evas_alloc_error_none
-        Efl::API.enum_type(:evas_alloc_error)[1].should eql :evas_alloc_error_fatal
-        Efl::API.enum_type(:evas_alloc_error)[2].should eql :evas_alloc_error_recovered
-        Efl::API.enum_type(:evas_alloc_error)[:evas_alloc_error_none].should eql 0
-        Efl::API.enum_type(:evas_alloc_error)[:evas_alloc_error_fatal].should eql 1
-        Efl::API.enum_type(:evas_alloc_error)[:evas_alloc_error_recovered].should eql 2
+        Efl::Evas.enum_value(:evas_alloc_error_none).should eql 0
+        Efl::Evas.enum_value(:evas_alloc_error_fatal).should eql 1
+        Efl::Evas.enum_value(:evas_alloc_error_recovered).should eql 2
+        Efl::Evas.enum_type(:evas_alloc_error)[0].should eql :evas_alloc_error_none
+        Efl::Evas.enum_type(:evas_alloc_error)[1].should eql :evas_alloc_error_fatal
+        Efl::Evas.enum_type(:evas_alloc_error)[2].should eql :evas_alloc_error_recovered
+        Efl::Evas.enum_type(:evas_alloc_error)[:evas_alloc_error_none].should eql 0
+        Efl::Evas.enum_type(:evas_alloc_error)[:evas_alloc_error_fatal].should eql 1
+        Efl::Evas.enum_type(:evas_alloc_error)[:evas_alloc_error_recovered].should eql 2
     end
     #
     it "should have no memory allocation error occured" do
@@ -52,15 +52,39 @@ describe Efl::Evas do
         Evas.shutdown
     end
     #
-    describe Efl::Evas::Evas do
+    describe Efl::Evas::REvas do
+        before(:all) do
+            Evas.init
+            @width = 800
+            @height = 600
+            @pixels = FFI::MemoryPointer.new :int, @width*@height
+            @e = Evas::REvas.new
+            @e.output_method_set Evas::render_method_lookup("buffer")
+            @e.output_viewport_set 0, 0, @width, @height
+            @e.output_size_set @width, @height
+            einfo = Efl::Evas::EngineInfoBufferStruct.new @e.engine_info_get
+            einfo[:info][:depth_type] = Efl::Evas::EVAS_ENGINE_BUFFER_DEPTH_ARGB32
+            einfo[:info][:dest_buffer] = @pixels
+            einfo[:info][:dest_buffer_row_bytes] = @width * FFI::type_size(:int);
+            einfo[:info][:use_color_key] = 0;
+            einfo[:info][:alpha_threshold] = 0;
+            einfo[:info][:func][:new_update_region] = nil #FFI::Pointer::NULL;
+            einfo[:info][:func][:free_update_region] = nil #FFI::Pointer::NULL;
+            @e.engine_info_set einfo
+        end
+        after(:all) do
+            @e.free
+            @pixels.free
+            Evas.shutdown
+        end
         it "should be able to create and destroy evas" do
-            e1 = Evas::Evas.new
-            e1.ptr.address.should_not eql 0
-            e2 = Evas::Evas.new e1
-            e1.ptr.address.should eql e2.ptr.address
-            e3 = Evas::Evas.new e1.ptr
-            e1.ptr.address.should eql e3.ptr.address
-            e2.ptr.address.should eql e3.ptr.address
+            e1 = Evas::REvas.new
+            e1.address.should_not eql 0
+            e2 = Evas::REvas.new e1
+            e1.address.should eql e2.address
+            e3 = Evas::REvas.new e1.to_ptr
+            e1.address.should eql e3.address
+            e2.address.should eql e3.address
             (e1==e2).should be_false
             (e2==e3).should be_false
             (e1==e3).should be_false
@@ -68,36 +92,260 @@ describe Efl::Evas do
             (e2===e3).should be_true
             (e1===e3).should be_true
             e1.free
-            e1.ptr.should be_nil
-            e4 = Evas::Evas.new Efl::API.evas_new
-            e4.ptr.address.should_not eql 0
+            e1.to_ptr.should be_nil
+            e4 = Evas::REvas.new Evas.evas_new
+            e4.address.should_not eql 0
             e5 = e4.dup
-            e4.ptr.address.should eql e5.ptr.address
+            e4.address.should eql e5.address
             e6 = e4.clone
-            e4.ptr.address.should eql e6.ptr.address
+            e4.address.should eql e6.address
             e4.free
-            e4.ptr.should be_nil
+            e4.to_ptr.should be_nil
         end
         #
         it "focus should work" do
-            e = Evas::Evas.new
-            Efl::API.evas_focus_in e.ptr
-            Efl::API.evas_focus_state_get(e.ptr).should be_true
-            Efl::API.evas_focus_out e.ptr
-            Efl::API.evas_focus_state_get(e.ptr).should be_false
-            Efl::Evas.focus_in e.ptr
-            Efl::Evas.focus_state_get(e.ptr).should be_true
-            Efl::Evas.focus_out e.ptr
-            Efl::Evas.focus_state_get(e.ptr).should be_false
-            e.focus_in { |r| r.should be_nil }
-            e.focus_state_get.should be_true
-            e.focus_state_get { |r| r.should be_true }
-            e.focus_out.should be_nil
-            e.focus_state_get.should be_false
-            e.focus_state_get { |r| r.should be_false }
-            e.free
+            Efl::Evas.evas_focus_in @e.to_ptr
+            Efl::Evas.evas_focus_state_get(@e.to_ptr).should be_true
+            Efl::Evas.evas_focus_out @e.to_ptr
+            Efl::Evas.evas_focus_state_get(@e.to_ptr).should be_false
+            Efl::Evas.focus_in @e.to_ptr
+            Efl::Evas.focus_state_get(@e.to_ptr).should be_true
+            Efl::Evas.focus_out @e.to_ptr
+            Efl::Evas.focus_state_get(@e.to_ptr).should be_false
+            @e.focus_in { |r| r.should be_nil }
+            @e.focus_state_get.should be_true
+            @e.focus_state_get { |r| r.should be_true }
+            @e.focus_out.should be_nil
+            @e.focus_state_get.should be_false
+            @e.focus_state_get { |r| r.should be_false }
+        end
+        #
+        it "nochange should work" do
+            @e.nochange_push
+            @e.nochange_pop
+        end
+        #
+        it "attach data should work" do
+            data = FFI::MemoryPointer.from_string "my data"
+            @e.data_attach_set data
+            @e.data_attach_get.read_string.should eql "my data"
+        end
+        #
+        it "should not crash" do
+            @e.damage_rectangle_add 1, 2, 3, 4
+            @e.obscured_rectangle_add 1, 2, 3, 4
+            @e.obscured_clear
+            list = @e.render_updates
+            Evas.render_updates_free list
+            @e.render
+            @e.norender
+            @e.render_idle_flush
+            @e.render_dump
+        end
+        it "output method should work" do
+            @e.output_method_get.should eql Evas::render_method_lookup("buffer")
+            # output_method_set tested in before(:all)
+            l = Efl::Evas::render_method_list
+            Evas::render_method_list_free l
+        end
+        #
+        it "engine info should work" do
+            # engine_info_get and engine_info_set tested in before(:all)
+            true.should be_true
+        end
+        #
+        it "output size should work" do
+            @e.output_size_set 69, 666
+            @e.output_size_get.should eql [69,666]
+        end
+        it "output viewport should work" do
+            @e.output_viewport_set 0, 0, 666, 69
+            @e.output_viewport_get.should eql [0,0,666,69]
+        end
+        #
+        it "coordinates evas<=>world should work" do
+            @e.output_viewport_set 0, 0, 800, 600
+            x = @e.coord_screen_x_to_world 666
+            r = @e.coord_world_x_to_screen x
+            r.should <= 668
+            r.should >= 664
+            y = @e.coord_screen_y_to_world 69
+            r = @e.coord_world_y_to_screen y
+            r.should <= 71
+            r.should >= 67
+        end
+        #
+        it "freeze and thaw should work" do
+            @e.event_freeze_get.should eql 0
+            @e.event_freeze
+            @e.event_freeze_get.should eql 1
+            @e.event_thaw
+            @e.event_freeze_get.should eql 0
+        end
+        #
+        it "up/down mouse event should work" do
+            @e.event_feed_mouse_down 2, :evas_button_double_click, Time.now.to_i, FFI::Pointer::NULL
+            @e.pointer_button_down_mask_get.should eql 2
+            @e.event_feed_mouse_up 2, :evas_button_double_click, Time.now.to_i, FFI::Pointer::NULL
+            @e.pointer_button_down_mask_get.should eql 0
+        end
+        #
+        it "move mouse event should work" do
+            @e.pointer_output_xy_get.should eql [0,0]
+            @e.pointer_canvas_xy_get.should eql [0,0]
+            @e.event_feed_mouse_move 6, 6, Time.now.to_i, FFI::Pointer::NULL
+            @e.pointer_output_xy_get.should eql [6,6]
+            @e.pointer_canvas_xy_get.should eql [6,6]
+        end
+        #
+        it "in/out mouse event should work" do
+            @e.pointer_inside_get.should be_false
+            @e.event_feed_mouse_in Time.now.to_i, FFI::Pointer::NULL
+            @e.pointer_inside_get.should be_true
+            @e.event_feed_mouse_out Time.now.to_i, FFI::Pointer::NULL
+            @e.pointer_inside_get.should be_false
+        end
+        #
+        # TODO
+        #   evas_event_feed_multi_down
+        #   evas_event_feed_multi_up
+        #   evas_event_feed_multi_move
+        #   evas_event_feed_mouse_cancel
+        #   evas_event_feed_mouse_wheel
+        #   evas_event_feed_key_down
+        #   evas_event_feed_key_up
+        #   evas_event_feed_hold
+        #
+        it "add/del event callback should work" do
+            @cb = false
+            kd_cb = Proc.new do |data, e, obj, event_info|
+                data.read_string.should eq "mouse_in"
+                e.address.should eql @e.address
+                obj.address.should eql @bg.address
+                @db=true
+                true
+            end
+            kd_d = FFI::MemoryPointer.from_string "mouse_in"
+            @bg = Evas::REvasObject.new @e.object_rectangle_add
+            @bg.move 0, 0
+            @bg.resize 20, 20
+            @bg.show
+            @bg.event_callback_add :evas_callback_mouse_in, kd_cb, kd_d
+            @e.event_feed_mouse_in Time.now.to_i, FFI::Pointer::NULL
+            @bg.event_callback_del(:evas_callback_mouse_in, kd_cb).address.should eql kd_d.address
+            @db.should be_true
+        end
+        #
+        it "image cache functions should work" do
+            @e.image_cache_flush
+            @e.image_cache_reload
+            @e.image_cache_set 666
+            @e.image_cache_get.should eql 666
+        end
+        #
+        it "font functions should work" do
+            @e.font_hinting_set :evas_font_hinting_bytecode
+            @e.font_hinting_get.should eql :evas_font_hinting_bytecode
+            @e.font_hinting_can_hint(:evas_font_hinting_none).should be_true
+            @e.font_cache_flush
+            @e.font_cache_set 666
+            @e.font_cache_get.should eql 666
+            l = @e.font_available_list
+            @e.font_available_list_free l
+            @e.font_path_clear
+            a = ['/tmp1','/tmp2']
+            @e.font_path_append a[1]
+            @e.font_path_prepend a[0]
+            require 'efl/eina_list'
+            Efl::EinaList::REinaList.new(@e.font_path_list).each_with_index do |p,i|
+                p.read_string.should eql a[i]
+            end
+        end
+    end
+    describe Efl::Evas::REvasObject do
+        #
+        before(:all) do
+            Evas.init
+            @pixels = FFI::MemoryPointer.new :int, 100*100
+            @e = Evas::REvas.new
+            @e.output_method_set Evas::render_method_lookup("buffer")
+            @e.output_viewport_set 0, 0, 100, 100
+            @e.output_size_set 100, 100
+            einfo = Efl::Evas::EngineInfoBufferStruct.new @e.engine_info_get
+            einfo[:info][:depth_type] = Efl::Evas::EVAS_ENGINE_BUFFER_DEPTH_ARGB32
+            einfo[:info][:dest_buffer] = @pixels
+            einfo[:info][:dest_buffer_row_bytes] = 100 * FFI::type_size(:int);
+            einfo[:info][:use_color_key] = 0;
+            einfo[:info][:alpha_threshold] = 0;
+            einfo[:info][:func][:new_update_region] = nil #FFI::Pointer::NULL;
+            einfo[:info][:func][:free_update_region] = nil #FFI::Pointer::NULL;
+            @e.engine_info_set einfo
+            @o = @e.object_add :rectangle
+            @o.color = 200,200,200,200
+            @o.move 0, 0
+            @o.resize 100, 100
+            @o.show
+        end
+        after(:all) do
+            @e.free
+            @o.free
+            @pixels.free
+            Evas.shutdown
         end
         #
+        it "clipper should work" do
+            clipper = @e.object_add :rectangle
+            clipper.color = 255,255,255,255
+            clipper.move 25, 25
+            clipper.resize 50, 50
+            @o.clip = clipper.to_ptr
+            clipper.show
+            @o.clip_get.address.should eql clipper.address
+            require 'efl/eina_list'
+            Efl::EinaList::REinaList.new(clipper.clipees_get).to_ary[0].address.should eql @o.address
+            @o.clip_unset
+            @o.clip_get.address.should eql 0
+
+        end
+        #
+        it "focus functions should work" do
+            @o.focus_get.should be_false
+            @o.focus_set true
+            @o.focus_get.should be_true
+            @o.focus = false
+            @o.focus_get.should be_false
+        end
+        #
+        it "layer functions should work" do
+            @o.layer_get.should eql 0
+            @o.layer_set 2
+            @o.layer_get.should eql 2
+            @o.layer = 0
+            @o.layer_get.should eql 0
+        end
+        #
+        it "name functions should work" do
+            @o.name_set "My name"
+            @o.name_get.should eql "My name"
+        end
+        #
+        it "geometry functions should work" do
+            # FIXME
+#            @o.geometry_get.should eql [0,0,100,100]
+#            @o.resize 50,50
+#            @o.geometry_get.should eql [0,0,50,50]
+#            @o.move 10, 10
+#            @o.geometry_get.should eql [10,10,50,50]
+        end
+        #
+        it "show hide visible should work" do
+            @o.show
+            @o.visible?.should be_true
+            @o.hide
+            @o.visible_get.should be_false
+            @o.show
+            @o.visible?.should be_true
+        end
     end
     #
 end

data/tasks/ffi.rake

@@ -12,7 +12,7 @@ namespace :ffi do
     #
     desc "generate ffi bindings"
     task :ruby do
-        sh 'ruby ./tools/genruby.rb'
+        sh './tools/genruby.rb'
     end
 end
 #

data/test/test_edje.rb

@@ -0,0 +1,141 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/eina'
+require 'efl/evas'
+require 'efl/ecore'
+require 'efl/ecore_evas'
+require 'efl/edje'
+#
+Efl::Eina::init
+Efl::Evas::init
+Efl::Ecore::init
+Efl::EcoreEvas::init
+Efl::Edje::init
+#
+WIDTH=320
+HEIGHT=240
+EDC_FILE=File.join '/tmp','edje_test.edc'
+EDJE_FILE=File.join '/tmp','edje_test.edj'
+#
+if not File.exists? EDJE_FILE
+    File.open(EDC_FILE,'w') do |f| f << DATA.read end
+    system "edje_cc #{EDC_FILE}"
+end
+#
+def create_my_group canvas, txt
+    #edje = edje_object_add(canvas);
+    edje = canvas.edje_object_add
+    if not edje.file_set EDJE_FILE, "my_group"
+        puts "unable to open #{EDJE_FILE}"
+        exit 1
+    end
+    edje.part_text_set "text", txt unless txt.nil?
+    edje.move 0, 0
+    edje.resize WIDTH, HEIGHT
+    edje.show
+    edje
+end
+#
+txt = ( ARGV.length>0 ? ARGV[0] : nil )
+#
+window = Efl::EcoreEvas::REcoreEvas.new { |w|
+    w.resize WIDTH, HEIGHT
+}
+#
+canvas = window.get
+edje = create_my_group canvas, txt
+window.show
+#
+Efl::Ecore.main_loop_begin
+#
+edje.free
+window.free
+#
+
+__END__
+
+// compile: edje_cc edje_example.edc
+collections {
+   group {
+        name: "my_group"; // must be the same as in edje_example.c
+        parts {
+            part {
+                name: "background";
+                type: RECT; // plain boring rectangle
+                mouse_events: 0; // we don't need any mouse event on the background
+                // just one state "default"
+                description {
+                    state: "default" 0.0; // must always exist
+                    color: 255 255 255 255; // white
+                    // define part coordinates:
+                    rel1 { // top-left point at (0, 0) [WIDTH * 0 + 0, HEIGHT * 0 + 0]
+                        relative: 0.0 0.0;
+                        offset: 0 0;
+                    }
+                    rel2 { // bottom-right point at (WIDTH * 1.0 - 1, HEIGHT * 1.0 - 1)
+                        relative: 1.0 1.0;
+                        offset: -1 -1;
+                    }
+                }
+            }
+            part {
+                name: "text";
+                type: TEXT;
+                mouse_events: 1; // we want to change the color on mouse-over
+                // 2 states, one "default" and another "over" to be used
+                // on mouse over effect
+                description {
+                    state: "default" 0.0;
+                    color: 255 0 0 255; // red
+                    // define part coordinates:
+                    rel1 { // top-left at (WIDTH * 0.1 + 5, HEIGHT * 0.2 + 10)
+                        relative: 0.1 0.2;
+                        offset: 5 10;
+                    }
+                    rel2 { // bottom-right at (WIDTH * 0.9 - 6, HEIGHT * 0.8 - 11)
+                        relative: 0.9 0.8;
+                        offset: -6 -11;
+                    }
+                    // define text specific state details
+                    text {
+                        font: "Sans"; /* using fontconfig name! */
+                        size: 10;
+                        text: "hello world";
+                    }
+                }
+                description {
+                    state: "over" 0.0;
+                    inherit: "default" 0.0; // copy everything from "default" at this point
+                    color: 0 255 0 255; // override color, now it is green
+                }
+            }
+            // do programs to change color on text mouse in/out (over)
+            programs {
+                program {
+                    // what triggers this program:
+                    signal: "mouse,in";
+                    source: "text";
+                    // what this program does:
+                    action: STATE_SET "over" 0.0;
+                    target: "text";
+                    // do the state-set in a nice interpolation animation
+                    // using linear time in 0.1 second
+                    transition: LINEAR 0.1;
+                }
+                program {
+                    // what triggers this program:
+                    signal: "mouse,out";
+                    source: "text";
+                    // what this program does:
+                    action: STATE_SET "default" 0.0;
+                    target: "text";
+                    // do the state-set in a nice interpolation animation
+                    // using linear time in 0.1 second
+                    transition: LINEAR 0.1;
+                }
+            }
+        }
+    }
+}
+