ffi-efl 0.0.1

data/lib/efl/evas.rb

@@ -0,0 +1,108 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/evas/evas-ffi'
+#
+module Efl
+    module Evas
+        #
+        class Evas
+            include Efl::Helper
+            @func_prefixes = [ 'evas_' ].freeze
+            def initialize o=nil
+                @ptr = (
+                    case o
+                    when NilClass
+                        FFI::AutoPointer.new Efl::API.evas_new, method(:free)
+                    when self.class
+                        o.ptr
+                    when FFI::AutoPointer
+                        o
+                    when FFI::Pointer
+                        FFI::AutoPointer.new o, method(:free)
+                    else
+                        raise ArgumentError.new "#{ptr.class} valid argument"
+                    end
+                )
+                yield self if block_given?
+            end
+            def free
+                Efl::API.evas_free @ptr
+                @ptr=nil
+            end
+            def === o
+                @ptr === o.ptr
+            end
+            def output_size_get
+                x = FFI::MemoryPointer.new :int
+                y = FFI::MemoryPointer.new :int
+                Efl::API.evas_output_size_get @ptr, x, y
+                [ x.read_int, y.read_int ]
+            end
+            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::API.evas_output_viewport_get @ptr, x, y, w, h
+                [ x.read_int, y.read_int, w.read_int, h.read_int ]
+            end
+            def pointer_output_xy_get
+                x = FFI::MemoryPointer.new :int
+                y = FFI::MemoryPointer.new :int
+                Efl::API.evas_pointer_output_xy_get @ptr, x, y
+                [ x.read_int, y.read_int ]
+            end
+            def pointer_canvas_xy_get
+                x = FFI::MemoryPointer.new :int
+                y = FFI::MemoryPointer.new :int
+                Efl::API.evas_pointer_canvas_xy_get @ptr, x, y
+                [ x.read_int, y.read_int ]
+            end
+        end
+        #
+        class EvasObject
+            include Efl::Helper
+            @func_prefixes = [ 'evas_object_', 'evas_' ].freeze
+            def initialize o=nil
+                @ptr = (
+                    case o
+                    when NilClass
+                        FFI::AutoPointer.new Efl::API.evas_new, method(:free)
+                    when self.class
+                        o.ptr
+                    when FFI::AutoPointer
+                        o
+                    when FFI::Pointer
+                        FFI::AutoPointer.new o, method(:free)
+                    else
+                        raise ArgumentError.new "#{ptr.class} valid argument"
+                    end
+                )
+                yield self if block_given?
+            end
+            def free
+                Efl::API.evas_object_del @ptr
+                @ptr=nil
+            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::API.evas_object_geometry_get @evas, x, y, w, h
+                [ x.read_int, y.read_int, w.read_int, h.read_int ]
+            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::API.evas_object_color_get @evas, r, g, b, a
+                [ r.read_int, g.read_int, b.read_int, a.read_int ]
+            end
+        end
+    end
+end
+#
+# EOF

data/lib/efl/ffi.rb

@@ -0,0 +1,63 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'ffi'
+#
+module Efl
+    #
+    module API
+        #
+        extend FFI::Library
+        #
+        def attach_fcts fcts
+            fcts.each do |func|
+                begin
+                    attach_function(*func)
+                rescue Object => e
+                    puts "Could not attach #{func} #{e.message}"
+                end
+            end
+        end
+        module_function :attach_fcts
+        #
+        typedef :pointer, :int_p
+        typedef :pointer, :uint_p
+        typedef :pointer, :void_p
+        typedef :pointer, :uchar_p
+        typedef :pointer, :float_p
+        typedef :pointer, :double_p
+        typedef :pointer, :string_array
+        typedef :pointer, :string_array_p
+        #
+        typedef :pointer, :eina_list_p
+        typedef :pointer, :eina_iterator_p
+        typedef :pointer, :eina_accessor_p
+        typedef :pointer, :evas_p
+        typedef :pointer, :evas_object_p
+        #
+    end
+    #
+    module Helper
+        def self.included m
+            m.class_eval "def ptr; @ptr; end"
+            m.class_eval "def self.func_prefixes; @func_prefixes; end"
+            m.class_eval "def self.inherited sub; sub.class_eval 'def self.func_prefixes; superclass.func_prefixes; end'; end"
+        end
+        def method_missing m, *args, &block
+            self.class.func_prefixes.each do |p|
+                sym = p+m.to_s
+                if Efl::API.respond_to? sym
+                    self.class.class_eval "def #{m} *args, █ r=Efl::API.#{sym}(@ptr,*args); yield r if block_given?; r; end" 
+                    return self.send m, *args, &block
+                end
+            end
+            r = Efl::API.send m, @ptr, *args
+            self.class.class_eval "def #{m} *args, █ r=Efl::API.#{m}(@ptr,*args); yield r if block_given?; r; end" 
+            r
+        end
+    end
+end
+#
+require 'efl/eina/eina_types-ffi'
+#
+# EOF

data/lib/efl.rb

@@ -0,0 +1,14 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+#
+module Efl
+#    autoload :Eina,  './lib/efl/eina.rb'
+    autoload :Eet,   './lib/efl/eet.rb'
+    autoload :Evas,  './lib/efl/evas.rb'
+    autoload :Ecore, './lib/efl/ecore.rb'
+    autoload :Edje,  './lib/efl/edje.rb'
+    autoload :Elm,   './lib/efl/elementary.rb'
+end
+#
+# EOF

data/spec/ecore_getopt_spec.rb

@@ -0,0 +1,43 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ecore_getopt'
+#
+describe Efl::EcoreGetopt do
+    #
+    it "should run a single iteration of the mainloop" do
+        Efl::Ecore.init
+#        puts Efl::EcoreGetopt::EcoreGetopt.methods.sort
+#        eg = Efl::EcoreGetopt::EcoreGetopt.new
+#        val1 = Efl::API::Ecore_Getopt_Value.new
+#        val1[:val] = 
+#        val2 = Efl::API::Ecore_Getopt_Value.new
+        #
+        verbosity = 0
+        egd = Efl::API::Ecore_Getopt_Desc.new
+        egd[:shortname] = "V".to_i
+        egd[:longname] = FFI::MemoryPointer.from_string "verbose"
+        egd[:help] = FFI::MemoryPointer.from_string "increase log verbosity"
+        egd[:metavar] = 0
+        egd[:action] = 1 #:ecore_getopt_type_bool
+        egd[:action_param] = 0
+
+        descs = FFI::MemoryPointer.new :pointer, 2, false
+        descs[0] = egd
+        descs[1] = FFI::Pointer::NULL
+        #
+        pointer = FFI::MemoryPointer.new :char, Efl::API::EcoreGetopt.size, false
+        ego = Efl::API::EcoreGetopt.new pointer
+        ego[:prog] = FFI::MemoryPointer.from_string "Prog"
+        ego[:usage] = FFI::MemoryPointer.from_string "Usage"
+        ego[:version] = FFI::MemoryPointer.from_string "0.0.0"
+        ego[:copyright] = FFI::MemoryPointer.from_string "less"
+        ego[:license] = FFI::MemoryPointer.from_string "MIT"
+        ego[:description] = FFI::MemoryPointer.from_string "description"
+        ego[:strict] = 1
+        ego[:descs] = descs
+        args = Efl::EcoreGetopt.parse(ego.to_ptr, FFI::MemoryPointer::NULL, 1, "--help");
+        Efl::Ecore.shutdown
+    end
+    #
+end

data/spec/ecore_spec.rb

@@ -0,0 +1,151 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ecore'
+#
+describe Efl::Ecore do
+    #
+    include Efl
+    #
+    before(:all) do
+        USER_SIGNAL_CB = Proc.new do |data, type, event|
+            data.read_string.should eql "ok"
+            type.should eql Ecore::EVENT_SIGNAL_USER
+            event.read_int.should eql 666
+            Ecore.event_current_type_get.should eql Ecore::EVENT_SIGNAL_USER
+            Ecore.event_current_event_get.address.should eql event.address
+            Ecore.main_loop_quit
+        end
+        EVENT_FREE_CB = Proc.new do |data,event|
+            data.read_string.should eql "none"
+            event.read_int.should eql 666
+        end
+        OK = FFI::MemoryPointer.from_string "ok"
+        KO = FFI::MemoryPointer.from_string "ko"
+        NONE = FFI::MemoryPointer.from_string "none"
+    end
+    #
+    it "should init" do
+        Ecore.init.should eql 1
+        Ecore.init.should eql 2
+        Ecore.init.should eql 3
+    end
+    #
+    it "should shutdown" do
+        Ecore.shutdown.should eql 2
+        Ecore.shutdown.should eql 1
+        Ecore.shutdown.should eql 0
+    end
+    #
+    it "should run a single iteration of the mainloop" do
+        Ecore.init
+        Ecore.main_loop_iterate
+        Ecore.shutdown
+    end
+    #
+    it 'should write and read data from pipe' do
+        data = FFI::MemoryPointer.from_string("none")
+        cb = Proc.new do |data,buffer,bytes|
+            data.read_string.should eql 'none'
+            buffer.read_string.should eql 'hello world'
+            bytes.should eql 12
+        end
+        Ecore.init
+        pipe = Ecore::EcorePipe.new cb, data
+        pipe.write("hello world").should be_true
+        Ecore.main_loop_iterate
+        pipe.read_close
+        pipe.write_close
+        pipe.del.address.should eql data.address
+        Ecore.shutdown
+    end
+    #
+    it 'should be able to add, del event hanlder and process event' do
+        Ecore.init
+        evt = FFI::MemoryPointer.new(:int)
+        evt.write_int 666
+        # add, del, add event handler
+        evt_handler = Ecore.event_handler_add Ecore::EVENT_SIGNAL_USER, USER_SIGNAL_CB, KO
+        evt_handler.null?.should be_false
+        Ecore.event_handler_del(evt_handler).address.should eql KO.address
+        evt_handler = Ecore.event_handler_add Ecore::EVENT_SIGNAL_USER, USER_SIGNAL_CB, OK
+        evt_handler.null?.should be_false
+        # add, del, add event
+        ecore_evt = Ecore.event_add Ecore::EVENT_SIGNAL_USER, evt, EVENT_FREE_CB, NONE
+        ecore_evt.null?.should be_false
+        Ecore.event_del(ecore_evt).address.should eql NONE.address
+        ecore_evt = Ecore.event_add Ecore::EVENT_SIGNAL_USER, evt, EVENT_FREE_CB, NONE
+        ecore_evt.null?.should be_false
+        Ecore.main_loop_begin   # process event
+        Ecore.shutdown
+    end
+    #
+    it "should be able to get and set event handler data" do
+        Ecore.init
+        evt = FFI::MemoryPointer.new(:int)
+        evt.write_int 666
+        evt_handler = Ecore.event_handler_add Ecore::EVENT_SIGNAL_USER, USER_SIGNAL_CB, KO
+        evt_handler.null?.should be_false
+        Ecore.event_handler_data_get(evt_handler).read_string.should eql "ko"
+        Ecore.event_handler_data_set(evt_handler, OK).address.should eql KO.address
+        Ecore.event_handler_data_get(evt_handler).read_string.should eql "ok"
+        ecore_evt = Ecore.event_add Ecore::EVENT_SIGNAL_USER, evt, EVENT_FREE_CB, NONE
+        ecore_evt.null?.should be_false
+        Ecore.main_loop_begin   # process event
+        Ecore.shutdown
+    end
+    #
+    it "should be able to create new event type" do
+        Ecore.init
+        Ecore.event_type_new.should_not eql 0
+        Ecore.event_type_new.should_not eql 0
+        Ecore.event_type_new.should_not eql 0
+        Ecore.shutdown
+    end
+    #
+    it "should be possible to add and del event filters" do
+        Ecore.init
+        loop_data = FFI::MemoryPointer.from_string("loop_data")
+        event_free_cb = Proc.new do |data,event|
+            data.read_string.should eql "ko"
+            event.read_int.should eql 69
+        end
+        start_cb = Proc.new do |data|
+            data.read_string.should eql "ok"
+            loop_data
+        end
+        count = 0
+        filter_cb = Proc.new do |data,loop_data,type,event|
+            data.read_string.should eql "ok"
+            loop_data.read_string.should eql "loop_data"
+            type.should eql Ecore::EVENT_SIGNAL_USER
+            count += 1
+            if event.read_int == 69
+                count.should eql 1
+                false   # drop first event
+            else
+                count.should eql 2
+                event.read_int.should eql 666
+                true
+            end
+        end
+        end_cb = Proc.new do |data,loop_data|
+            data.read_string.should eql "ok"
+            loop_data.read_string.should eql "loop_data"
+        end
+        filter = Ecore.event_filter_add start_cb, filter_cb, end_cb, OK
+        Ecore.event_handler_add Ecore::EVENT_SIGNAL_USER, USER_SIGNAL_CB, OK
+        e1 = FFI::MemoryPointer.new(:int)
+        e1.write_int 69
+        evt1 = Ecore.event_add Ecore::EVENT_SIGNAL_USER, e1, event_free_cb, KO
+        e2 = FFI::MemoryPointer.new(:int)
+        e2.write_int 666
+        evt2 = Ecore.event_add Ecore::EVENT_SIGNAL_USER, e2, EVENT_FREE_CB, NONE
+        Ecore.main_loop_begin   # process event
+        Ecore.event_filter_del(filter).address.should eql OK.address
+        evt2 = Ecore.event_add Ecore::EVENT_SIGNAL_USER, e2, EVENT_FREE_CB, NONE
+        Ecore.main_loop_begin   # process event
+        Ecore.shutdown
+    end
+    #
+end

data/spec/edje_spec.rb

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

data/spec/eet_spec.rb

@@ -0,0 +1,107 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/eet'
+#
+describe Efl::Eet do
+    #
+    include Efl
+    #
+    FP = '/tmp/_eet.cfg'
+    #
+    it "should init" do
+        Eet.init.should eql 1
+        Eet.init.should eql 2
+        Eet.init.should eql 3
+    end
+    #
+    it "should shutdown" do
+        Eet.shutdown.should eql 2
+        Eet.shutdown.should eql 1
+        Eet.shutdown.should eql 0
+    end
+    #
+    it "should clearcache" do
+        Eet.clearcache
+        Eet.clearcache
+        Eet.clearcache
+    end
+    #
+    it "should have good enums" do
+        Efl::API.enum_type(:eet_file_mode)[:eet_file_mode_invalid].should eql -1
+        Efl::API.enum_type(:eet_file_mode)[:eet_file_mode_read].should eql 0
+        Efl::API.enum_type(:eet_file_mode)[:eet_file_mode_write].should eql 1
+        Efl::API.enum_type(:eet_file_mode)[:eet_file_mode_read_write].should eql 2
+    end
+    #
+    it "should open and close" do
+        Eet.init
+        f = Eet.open FP, Efl::API.enum_type(:eet_file_mode)[:eet_file_mode_write]
+        f.write 'fake', 'value'
+        f.close
+        Eet.shutdown
+    end
+    #
+    it "should be able to get file access mode" do
+        Eet.init
+        Efl::API.enum_type(:eet_file_mode).symbols.each do |m|
+            next if m==:eet_file_mode_invalid
+            Eet.open FP, Efl::API.enum_type(:eet_file_mode)[m] do |f|
+                f.mode_get.should eql m
+            end
+        end
+        Eet.shutdown
+    end
+    #
+    it "should write" do
+        Eet.init
+        f = Eet.open FP, :eet_file_mode_write
+        f.mode_get.should eql :eet_file_mode_write
+        f.write 'config', 'test key'
+        f.close
+        Eet.shutdown
+    end
+    #
+    it "should read" do
+        Eet.init
+        f = Eet.open FP, :eet_file_mode_read
+        f.mode_get.should eql :eet_file_mode_read
+        f.read('config').should eql 'test key'
+        f.close
+        Eet.shutdown
+    end
+    #
+    it "should read/write" do
+        Eet.init
+        f = Eet.open FP, :eet_file_mode_read_write
+        f.write 'configg', 'test key'
+        f.read('configg').should eql 'test key'
+        f.close
+        Eet.shutdown
+    end
+    #
+    it "should write in block" do
+        Eet.init
+        Eet.open FP, :eet_file_mode_write do |f|
+            f.write 'config2', 'test--key'
+        end
+        Eet.shutdown
+    end
+    #
+    it "should read in block" do
+        Eet.init
+        Eet.open FP, :eet_file_mode_read do |f|
+            f.read('config2').should eql 'test--key'
+        end
+        Eet.shutdown
+    end
+    #
+    it "should read/write in block" do
+        Eet.init
+        Eet.open FP, :eet_file_mode_read_write do |f|
+            f.write 'config22', 'test--key'
+            f.read('config22').should eql 'test--key'
+        end
+        Eet.shutdown
+    end
+end

data/spec/evas_spec.rb

@@ -0,0 +1,103 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/evas'
+#
+describe Efl::Evas do
+    #
+    include Efl
+    #
+    it "should init" do
+        Evas.init.should eql 1
+        Evas.init.should eql 2
+        Evas.init.should eql 3
+    end
+    #
+    it "should shutdown" do
+        Evas.shutdown.should eql 2
+        Evas.shutdown.should eql 1
+        Evas.shutdown.should eql 0
+    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
+    end
+    #
+    it "should have no memory allocation error occured" do
+        Evas.init
+        Evas.alloc_error.should eql :evas_alloc_error_none
+        Evas.shutdown
+    end
+    #
+    it "should process async events" do
+        cb = Proc.new do |target,type,evt|
+            target.read_string.should eql "target"
+            type.should eql :evas_callback_show
+            evt.read_string.should eql "work"
+        end
+        Evas.init
+        target = FFI::MemoryPointer.from_string("target")
+        work = FFI::MemoryPointer.from_string("work")
+        Evas.async_events_put target, :evas_callback_show, work, cb
+        Evas.async_events_process.should eql 1
+        Evas.async_events_process.should eql 0
+        Evas.shutdown
+    end
+    #
+    describe Efl::Evas::Evas do
+        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==e2).should be_false
+            (e2==e3).should be_false
+            (e1==e3).should be_false
+            (e1===e2).should be_true
+            (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
+            e5 = e4.dup
+            e4.ptr.address.should eql e5.ptr.address
+            e6 = e4.clone
+            e4.ptr.address.should eql e6.ptr.address
+            e4.free
+            e4.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
+        end
+        #
+    end
+    #
+end

data/tasks/ann.rake

@@ -0,0 +1,83 @@
+# -*- coding: UTF-8 -*-
+#
+begin
+    require 'bones/smtp_tls'
+rescue LoadError
+    require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+    # A prerequisites task that all other tasks depend upon
+    task :prereqs
+    file PROJ.ann.file do
+        ann = PROJ.ann
+        puts "Generating #{ann.file}"
+        File.open(ann.file,'w') do |fd|
+            fd.puts("#{PROJ.name} version #{PROJ.version}")
+            fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+            fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+            fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+            fd.puts
+            fd.puts("== DESCRIPTION")
+            fd.puts
+            fd.puts(PROJ.description)
+            fd.puts
+            fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+            fd.puts
+            ann.paragraphs.each do |p|
+                fd.puts "== #{p.upcase}"
+                fd.puts
+                fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+                fd.puts
+            end
+            fd.puts ann.text if ann.text
+        end
+    end
+
+    desc "Create an announcement file"
+    task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+    desc "Send an email announcement"
+    task :email => ['ann:prereqs', PROJ.ann.file] do
+        ann = PROJ.ann
+        from = ann.email[:from] || Array(PROJ.authors).first || PROJ.email
+        to   = Array(ann.email[:to])
+
+        ### build a mail header for RFC 822
+        rfc822msg =  "From: #{from}\n"
+        rfc822msg << "To: #{to.join(',')}\n"
+        rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+        rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+        rfc822msg << "\n"
+        rfc822msg << "Date: #{Time.new.rfc822}\n"
+        rfc822msg << "Message-Id: "
+        rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+        rfc822msg << File.read(ann.file)
+
+        params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+            ann.email[key]
+        end
+
+        params[3] = (PROJ.ann.email[:from] || PROJ.email) if params[3].nil?
+
+#        if ann.email[:tls] and params[4].nil?
+        if params[4].nil?
+            STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+            params[4] = STDIN.gets.chomp
+        end
+#        params = params.shift 2 if not ann.email[:tls]
+
+        ### send email
+        # TODO find a way to bypass /var/lib/gems/1.9/gems/bones-3.6.5/lib/bones/smtp_tls.rb which forces starttls usage
+        Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+    end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF