MINT-core 1.0.1 → 2.0.0

data/lib/MINT-core/model/cui/gfx/radiobutton.scxml

@@ -0,0 +1,59 @@
+<scxml initial="initialized" name="RadioButton" version="0.9" xmlns="http://www.w3.org/2005/07/scxml"><!--   node-size-and-position x=0.0 y=0.0 w=885.0 h=723.0  -->
+ <state id="initialized"><!--   node-size-and-position x=220.0 y=130.0 w=100.0 h=40.0  -->
+  <transition event="position" target="positioning"></transition>
+ </state>
+ <state id="positioning"><!--   node-size-and-position x=220.0 y=220.0 w=100.0 h=40.0  -->
+  <transition event="calculated" target="positioned">
+   <invoke src="store_calculated_values_in_model" type="x-mint"></invoke>
+  </transition>
+ </state>
+ <state id="positioned"><!--   node-size-and-position x=220.0 y=320.0 w=100.0 h=40.0  -->
+  <transition event="display" target="p"></transition>
+  <transition event="hide" target="hidden"></transition>
+ </state>
+ <parallel id="p"><!--   node-size-and-position x=380.0 y=270.0 w=480.0 h=407.0  -->
+  <transition event="disable" target="disabled"></transition>
+  <transition event="hide" target="hidden"></transition>
+  <state id="s" initial="unselected"><!--   node-size-and-position x=290.0 y=30.0 w=180.0 h=240.0  -->
+   <state id="selected"><!--   node-size-and-position x=50.0 y=170.0 w=100.0 h=30.0  -->
+    <transition event="unselect" target="unselected"></transition>
+   </state>
+   <state id="unselected"><!--   node-size-and-position x=50.0 y=70.0 w=100.0 h=30.0  -->
+    <transition event="select" target="selected"><!--   edge-path [selected]  x=40.0 y=130.0  --></transition>
+   </state>
+  </state>
+  <state id="d"><!--   node-size-and-position x=0.0 y=30.0 w=280.0 h=360.0  -->
+   <state id="displaying" initial="displayed"><!--   node-size-and-position x=10.0 y=30.0 w=270.0 h=170.0  -->
+    <transition event="refresh" target="refreshing"><!--   edge-path [refreshing]  x=100.0 y=230.0  --></transition>
+    <state id="displayed"><!--   node-size-and-position x=80.0 y=40.0 w=100.0 h=30.0  -->
+     <transition event="highlight" target="highlighted"><!--   edge-path [highlighted]  x=70.0 y=100.0 pointx=0.0 pointy=18.0 offsetx=19.0 offsety=-14.0  --></transition>
+    </state>
+    <state id="highlighted"><!--   node-size-and-position x=80.0 y=130.0 w=100.0 h=30.0  -->
+     <transition event="unhighlight" target="displayed"><!--   edge-path [displayed]  x=170.0 y=100.0  --></transition>
+     <transition event="up" target="displayed">
+      <invoke src="highlight_up" type="x-mint"></invoke>
+<!--   edge-path [displayed]  x=210.0 y=140.0 x=210.0 y=60.0 pointx=0.0 pointy=-10.0 offsetx=0.0 offsety=5.0  --></transition>
+     <transition event="down" target="displayed">
+      <invoke src="highlight_down" type="x-mint"></invoke>
+<!--   edge-path [displayed]  x=40.0 y=140.0 x=40.0 y=60.0  --></transition>
+     <transition event="left" target="displayed">
+      <invoke src="highlight_left" type="x-mint"></invoke>
+<!--   edge-path [displayed]  x=10.0 y=150.0 x=10.0 y=50.0  --></transition>
+     <transition event="right" target="displayed">
+      <invoke src="highlight_right" type="x-mint"></invoke>
+<!--   edge-path [displayed]  x=250.0 y=150.0 x=250.0 y=50.0  --></transition>
+    </state>
+   </state>
+   <state id="refreshing"><!--   node-size-and-position x=100.0 y=260.0 w=70.0 h=40.0  -->
+    <transition target="displaying"></transition>
+   </state>
+  </state>
+ </parallel>
+ <state id="disabled"><!--   node-size-and-position x=570.0 y=140.0 w=110.0 h=40.0  -->
+  <transition event="hide" target="hidden"></transition>
+ </state>
+ <state id="hidden"><!--   node-size-and-position x=400.0 y=140.0 w=110.0 h=40.0  -->
+  <transition event="position" target="positioning"></transition>
+  <transition event="display" target="p"><!--   edge-path [p]  x=410.0 y=240.0  --></transition>
+ </state>
+</scxml>

data/lib/MINT-core/model/interactor.rb

@@ -1,18 +1,39 @@
 module MINT
-  # An {Element} is the basic abstract element of the complete MINT markup language. Nearly all  other
-  # classes are derived  from {MINT::Element} since early everything can be activated by {#state} and has 
+  # An {Interactor} is the basic abstract element of the complete MINT markup language. Nearly all  other
+  # classes are derived  from {MINT::Interactor} since early everything can be activated by {#state} and has
   # a {#name}. 
   #
-  class Element
+  class Interactor
     include DataMapper::Resource
+    include MINT::InteractorHelpers
+    def self.getModel
+      "core"
+    end
+
+
+    class << self
+        alias get_dm get
+    end
+
+    def self.get(*name)
+        if name.length == 1
+          get_dm(getModel,name[0])
+        else
+          get_dm(*name)
+        end
+    end
+
     private
-    property :id, Serial
+
+
     property :classtype, Discriminator
+    property :mint_model, String, :default => lambda { |r,p| r.class.getModel}, :key=>true
 
-    # Each abstract  {Element} needs to have a name that we will use as the primary key for each model.
-    property :name, String
+    # Each abstract  {Interactor} needs to have a name that we will use as the primary key for each model.
+    property :name, String, :key => true
+    #property :id, Serial
 
-    # States of the {Element} Reflects the actual atomic states of the interactors state machine.
+    # States of the {Interactor} Reflects the actual atomic states of the interactors state machine.
     property :states, String
 
     # reflects all active states including abstract superstates of an interactor as a |-seperated state id list
@@ -21,15 +42,97 @@ module MINT
     #always contains the new atomic states that have been entered by the event that has been processed - especially useful for parallel states
     property :new_states, String
 
-   protected
+    protected
     before :save, :save_statemachine
+    after :create, :init_statemachine
 
     public
 
+    def init_statemachine
+      initialize_statemachine true
+    end
+
+
+    PUBLISH_ATTRIBUTES = [:name,:states,:abstract_states,:new_states,:classtype, :mint_model]
+
+    def self.create_channel_name
+      a = [self]
+      a.unshift a.first.superclass while (a.first!=MINT::Interactor)
+      a.map!{|x| x.to_s.split('::').last}
+      a.join(".")
+    end
+
+    def create_attribute_channel_name(attribute)
+      "#{attribute}:"+self.class.create_channel_name+".#{self.name}"
+    end
+
+    def create_channel_w_name
+      self.class.create_channel_name+".#{self.name}"
+    end
+
+
+    def self.class_from_channel_name(channel)
+      Object.const_get("MINT").const_get channel.split('.').last
+    end
+
+    def publish_update(states,abstract_states, atomic_states)
+
+
+      as_copy = attribute_get(:abstract_states)
+      new_copy = attribute_get(:new_states)
+      states_copy = attribute_get(:states)
+
+      attribute_set(:abstract_states, abstract_states.join('|'))
+      attribute_set(:new_states, states.join('|'))
+      attribute_set(:states, atomic_states.join('|'))
+
+      RedisConnector.redis.publish self.create_channel_w_name, self.to_json(:only => self.class::PUBLISH_ATTRIBUTES)
+
+      attribute_set(:abstract_states, as_copy)
+      attribute_set(:new_states, new_copy)
+      attribute_set(:states, states_copy)
+    end
+
+    def sync_states()
+      values = RedisConnector.sync_redis.hmget "mint_interactors:#{self.class.getModel}#{name}","states","new_states","abstract_states"
+
+      attribute_set(:abstract_states, values[2])
+      attribute_set(:new_states, values[1])
+      attribute_set(:states, values[0])
+      recover_statemachine
+    end
+
+    def self.notify(action,query,callback,time = nil)
+      RedisConnector.sub.subscribe("#{self.create_channel_name}")
+
+      RedisConnector.sub.on(:message) { |channel, message|
+        found=MultiJson.decode message
+        puts query.inspect
+        query.keys.each do |k|
+          if found[k.to_s]
+            a = found[k.to_s]
+            query[k].each do |e|
+              puts "found #{e} a:#{a.inspect}"
+              if a.include? e
+                callback.call found
+                break
+              end
+            end
+          end
+        end
+      }
+    end
+
+
+    def self.wait(action,query,callback,time = nil)
+      # q = scoped_query(query)
+      # q.repository.notify(action,query,callback,self,q, time)
+    end
+
     def to_dot(filename)
-       if not @statemachine
+      if not @statemachine
         initialize_statemachine
-       end
+      end
       @statemachine.to_dot(:output => filename)
     end
     def states
@@ -42,7 +145,7 @@ module MINT
 
     def new_states
       if attribute_get(:new_states)
-            return attribute_get(:new_states).split("|").map &:to_sym if attribute_get(:new_states).class!=Array
+        return attribute_get(:new_states).split("|").map &:to_sym if attribute_get(:new_states).class!=Array
         return attribute_get(:new_states)
       else return []
       end
@@ -56,28 +159,34 @@ module MINT
       save_statemachine
     end
 
-    def initialize(attributes = {}, &block)
-      super(attributes, &block)
-      recover_statemachine
-    end
+   # def initialize(attributes = nil)
+   #   super(attributes)
+
+  #    recover_statemachine
+   # end
 
     # The sync event method is overwritten in the derived classes to prevent synchronization cycles by setting an empty callback
     def sync_event(event)
       process_event(event)
     end
 
-    def process_event(event, callback=nil)
+    #allows to set variables that will be passed as parameters to the actions
+    def process_event_vars(event, *vars)
+      process_event(event,nil,vars)
+    end
+
+    def process_event(event, callback=nil, vars = nil)
 
-      states = process_event!(event,callback)
+      states = process_event!(event,callback,vars)
       if states
         save_statemachine
-        states
+        return states
       else
-        false
+        return false
       end
     end
 
-    def process_event!(event, callback=nil)
+    def process_event!(event, callback=nil,vars=nil)
       if not @statemachine
         initialize_statemachine
         recover_statemachine
@@ -88,53 +197,69 @@ module MINT
         @statemachine.context = self
       end
       begin
-         old_states = @statemachine.states_id
-         old_abstract_states = @statemachine.abstract_states
-         @statemachine.process_event(event)
-         calc_new_states = @statemachine.states_id-old_states
-         calc_new_states = calc_new_states + (@statemachine.abstract_states - old_abstract_states)
-         calc_new_states = @statemachine.states_id  if calc_new_states.length==0
+        old_states = @statemachine.states_id
+        old_abstract_states = @statemachine.abstract_states
+        @statemachine.process_event(event,*vars)
+        calc_new_states = @statemachine.states_id-old_states
+        calc_new_states = calc_new_states + (@statemachine.abstract_states - old_abstract_states)
+        calc_new_states = @statemachine.states_id  if calc_new_states.length==0
         attribute_set(:new_states, calc_new_states.join('|'))
       rescue Statemachine::TransitionMissingException
         p "#{self.name} is in state #{self.states} and could not handle #{event}"
         return false
       end
-      @statemachine.states_id
+      return @statemachine.states_id
     end
 
     def is_in?(state)
-       if not @statemachine
+      if not @statemachine
+
+        #return true if (attribute_get(:states).split('|').map &:intern).include? state.intern
+        #return true if (attribute_get(:abstract_states).split('|').map &:intern).include? state.intern
+        #return false
         initialize_statemachine
         recover_statemachine
-       end
+      end
       @statemachine.In(state)
     end
+
+
+    def getSCXML
+      "#{File.dirname(__FILE__)}/interactor.scxml"
+    end
+
     protected
-    def initialize_statemachine
-      if @statemachine.blank?
-        @statemachine = Statemachine.build do
-          trans :initialized, :run, :running
-          trans :running, :done, :finished
-        end
+
+    def initialize_statemachine(publish_initialize = false)
+      if @statemachine.nil?
+        parser = StatemachineParser.new(self)
+        @statemachine = parser.build_from_scxml getSCXML
+
+        @statemachine.activation=self.method(:publish_update)
+
+        @statemachine.reset(nil,publish_initialize)
+
       end
     end
 
     private
 
     def save_statemachine
-       if not @statemachine
-        initialize_statemachine
+      if not @statemachine
+        initialize_statemachine true
         recover_statemachine
       end
       attribute_set(:states, @statemachine.states_id.join('|'))
-      attribute_set(:abstract_states, @statemachine.abstract_states.concat(@statemachine.states_id).join('|'))
+      attribute_set(:abstract_states, @statemachine.abstract_states.join('|'))
       # attribute_set(:new_states,new_states) if new_states and new_states.length>0 # second condition to
       save!
+      # publish_update
     end
 
+
     # @TODO check this for parallel states!
     def recover_statemachine
-      if (@statemachine.blank?)
+      if (@statemachine.nil?)
         initialize_statemachine
       end
       if attribute_get(:states)
@@ -148,9 +273,9 @@ module MINT
         attribute_set(:states, @statemachine.states_id.join('|'))
         attribute_set(:abstract_states, @statemachine.abstract_states.concat(@statemachine.states_id).join('|'))
       end
-       if not attribute_get(:new_states)
-         attribute_set(:new_states, @statemachine.states_id.join('|'))
-       end
+      if not attribute_get(:new_states)
+        attribute_set(:new_states, @statemachine.states_id.join('|'))
+      end
     end
 
     def is_set(attribute)
@@ -158,10 +283,6 @@ module MINT
     end
   end
 
-  class IR <Element
- end
 
-  class IN < IR
-  end
 
 end

data/lib/MINT-core/model/interactor.scxml

@@ -0,0 +1,3 @@
+<scxml initial="initialized" name="Interactor" version="0.9" xmlns="http://www.w3.org/2005/07/scxml"><!--   node-size-and-position x=0.0 y=0.0 w=662.0 h=581.0  -->
+ <state id="initialized"><!--   node-size-and-position x=280.0 y=122.0 w=100.0 h=100.0  --></state>
+</scxml>

data/lib/MINT-core/model/interactor_helpers.rb

@@ -0,0 +1,25 @@
+module MINT
+  module InteractorHelpers
+    def start_timeout(seconds,event,cb = nil)
+        if not @timer
+          @timer = EventMachine::Timer.new(seconds) do
+            cb.call if cb
+            process_event event
+          end
+        else
+          puts "timer already started!!!"
+        end
+      end
+      def stop_timeout
+        if @timer
+          # p "stopped timer"
+          @timer.cancel
+          @timer = nil
+        end
+      end
+      def restart_timeout(seconds,event,cb = nil)
+        stop_timeout
+        start_timeout(seconds,event,cb)
+      end
+  end
+end

data/lib/MINT-core/model/ir/body/OneHandPoseNavigation.rb

@@ -0,0 +1,15 @@
+
+module MINT
+
+  class OneHandPoseNavigation < Pose
+
+    def getSCXML
+      "#{File.dirname(__FILE__)}/onehandposenavigation.scxml"
+    end
+
+    def initialize(attributes = nil)
+      super(attributes)
+
+    end
+  end
+end

data/lib/MINT-core/model/ir/body/body.rb

@@ -0,0 +1,5 @@
+module MINT
+  class Body < IRMode
+
+  end
+end

data/lib/MINT-core/model/ir/body/fingertip.rb

@@ -0,0 +1,114 @@
+module MINT
+  class Fingertip < Hand
+    property :x, Integer, :default  => -1
+    property :y, Integer, :default  => -1
+    property :touched, Boolean, :default  => false
+    property :threshold_x, Integer, :default  => 15
+    property :threshold_y, Integer, :default  => 10
+
+    property :screen_width, Integer, :default => 640
+    PUBLISH_ATTRIBUTES += [:x,:y,:touched]
+
+    # performance optimization to prevent mulitple subscribes
+    @subscribed = false
+
+    def getSCXML
+      "#{File.dirname(__FILE__)}/fingertip.scxml"
+    end
+  end
+
+  def cache_coordinates(x,y)
+    @cached_x = x
+    @cached_y = y
+  end
+
+  def start_timeout
+    if not @timer
+      @timer = EventMachine::Timer.new(0.3) do
+        attribute_set(:x, @cached_x)
+        attribute_set(:y, @cached_y)
+        process_event("stop")
+      end
+    else
+      puts "timer already started!!!"
+    end
+  end
+  def stop_timeout
+    if @timer
+      # p "stopped timer"
+      @timer.cancel
+      @timer = nil
+    end
+  end
+
+  def start_one_time_tick(time,event)
+    EventMachine::Timer.new(time) {
+      process_event event
+    }
+  end
+
+  def restart_timeout
+    stop_timeout
+    start_timeout
+  end
+
+  def touch_changed?(touch)
+    return  true if  attribute_get(:touched) != touch
+    false
+  end
+
+  def cache_touched(touch)
+    attribute_set(:touched, touch)
+  end
+
+  def filter(x,y)
+    [(attribute_get(:screen_width) - x),y]
+  end
+
+  def has_moved?(x,y)
+    return true if @cached_x.nil? or @cached_y.nil?
+    return true if ((x-@cached_x).abs > threshold_x) or ((y-@cached_y).abs > threshold_y)
+    false
+  end
+
+  def consume(id)
+    # subscription = "data:"+self.class.create_channel_name+"."+id.to_s+":*"
+
+    return if @subscribed
+
+    redis = RedisConnector.redis
+
+    redis.pubsub.subscribe("ss:event") { |message|
+
+      # if (key.eql? subscription)
+      data = MultiJson.decode message
+
+      if data["e"].eql? "touches"
+        touches = data["p"][0]
+        touched_value,x,y = touches[0].map &:to_i
+
+        x,y = filter x,y
+        touched_value= (touched_value==0)?false:true
+
+        if has_moved? x,y
+          cache_coordinates x,y
+          process_event("move") if not is_in? :moving
+          restart_timeout
+        else
+          if is_in? :stopped
+            if touch_changed? touched_value
+              if touched_value
+                process_event :press
+              else
+                process_event :release
+              end
+              cache_touched touched_value
+            end
+          end
+        end
+      end
+      # end
+    }
+    @subscribed = true
+  end
+end