MINT-core 1.0.0

data/lib/MINT-core.rb

@@ -0,0 +1,42 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module MINTCore
+  VERSION = '1.0.0'
+end
+
+require 'rubygems'
+require "bundler/setup"
+require 'statemachine'
+require "cassowary"
+require 'RMagick'
+require "rinda/tuplespace"
+require 'drb/drb'
+require 'dm-core'
+require 'dm-types'
+require "MINT-scxml"
+
+require "MINT-core/agent/agent"
+require "MINT-core/mapping/mapping"
+require "MINT-core/mapping/on_state_change"
+require "MINT-core/mapping/complementary"
+require "MINT-core/mapping/sequential"
+
+require "MINT-core/model/interactor"
+require "MINT-core/model/task"
+require "MINT-core/agent/auicontrol"
+require "MINT-core/agent/aui"
+require "MINT-core/agent/cuicontrol"
+require "MINT-core/agent/cui-gfx"
+require "MINT-core/model/aui/model"
+require "MINT-core/model/cui/gfx/model"
+
+require "MINT-core/model/device/pointer"
+require "MINT-core/model/device/button"
+require "MINT-core/model/device/wheel"
+require "MINT-core/model/device/joypad"
+require "MINT-core/model/device/mouse"
+
+require "MINT-core/model/body/gesture_button"
+require "MINT-core/model/body/handgesture"
+require "MINT-core/model/body/head"

data/lib/MINT-core/agent/agent.rb

@@ -0,0 +1,28 @@
+
+module MINT
+  class Agent
+    attr_reader :running_mappings
+
+    def initialize(connection_options = { :adapter => "rinda", :host =>"localhost",:port=>4000})
+      DataMapper.setup(:default, connection_options)
+      DRb.start_service
+      @running_mappings = []
+#       DataMapper::Logger.new("data.log", :debug)
+    end
+
+    def addMapping(mapping)
+      m = mapping.execute
+
+      if not m.is_a? Array
+        m= [m]
+      end
+      @running_mappings += m
+    end
+
+    def run
+      @running_mappings.each do |thread|
+        thread.join
+      end
+    end
+  end
+end

data/lib/MINT-core/agent/aui.rb

@@ -0,0 +1,52 @@
+
+
+module DataMapper
+  class Collection
+    def each
+      super do |resource|
+        begin
+        # original, resource.collection = resource.collection, self
+          yield resource
+        ensure
+          # resource.collection = original
+        end
+      end
+    end
+  end
+end
+
+class AUIAgent < MINT::Agent
+  include AUIControl
+  
+  def initialize
+    super
+  end
+  
+  def initial_calculation(result)
+   
+    current_screen = Screen.first_or_create(:name => "current_screen")
+    current_screen.process_event(:calculate)
+
+    pts = InteractionTask.all(:abstract_states => /running/).map &:name
+    p  "Initial Layout recalculation requested for new PTS #{pts.inspect} "   
+   
+    root = AUIControl.find_common(pts)
+
+    #layer=0
+    # remove all layoutements
+    # Layoutelement.all.destroy
+    mask = AIO.first(:name=>root)
+    AUIControl.organize2(mask)
+    
+ #   mask=composeScreen(root,true,layer)
+    mask.save
+    
+    current_screen.update(:root=>root) # BUG/??w thereafter no iteration in calculateMinimumSizes is possible???
+    current_screen.process_event(:done)
+    p "finished: AUI root>#{root}"
+  end
+  
+  end
+# DataMapper::Logger.new("log/datamapper.log", :debug)
+
+

data/lib/MINT-core/agent/auicontrol.rb

@@ -0,0 +1,135 @@
+
+module AUIControl
+ include MINT
+  
+  # ensures that all prev/next relationships are setup properlyin one complete sequence
+  def AUIControl.organize(aio,parent_aio = nil, layer = 0)
+    
+    if (aio.kind_of? AIC)
+      aio.entry = aio.childs[0]
+      last = aio
+      aio.childs.each do |child|
+        last.next = child
+        child.previous = last
+
+        last = organize(child,aio,layer+1) 
+      end
+      aio.process_event("organize")
+      return last
+    else
+      aio.process_event("organize")
+      return aio
+    end
+  end
+ 
+  # connects all  aios on the same level 
+  def AUIControl.organize2(aio,parent_aio = nil, layer = 0)
+   # if layer == 0 
+    #  aio.next = aio
+    #  aio.previous = aio
+   # end
+ 
+    if (aio.kind_of? AIC)
+      first = aio.childs.first
+      last = nil
+
+      aio.childs.each do |child|
+        if last
+        last.next = child
+        end
+        child.previous = last
+        copy = child
+        organize2(copy,nil,layer+1)
+        last = child
+      end
+      aio.process_event!("organize")
+    else
+      aio.process_event!("organize")
+    end
+    p "organized #{aio.name}"
+  end
+ 
+  # Searches for the common root aic that contains all tasks of {elements}.
+  # During the search towards the root it activates all relevant containters in the 
+  # {Layout}model in case {activate} is set to true. 
+  #
+  # @param tasks [String} an array of strings of task names
+  # @param activate [Boolean] defines if all common comtainers should be activated
+  # @return [String] name of common root aic
+  #
+  def AUIControl.find_common_aic(tasks,activate=false, parents ={ })
+    
+    if tasks.length==1
+      return tasks[0]
+    end
+    
+    tasks.each do |e|
+      p "processing #{e}"
+      aio = AIO.first(:name=>e)
+      if (aio==nil)
+        throw ("AIO with name #{e} not found in AUI model!")
+      end
+      if (activate)
+        aio.process_event("present")
+      end
+      if aio.parent and not parents[aio.parent.name]
+        parents[aio.parent.name]=aio.name
+      elsif aio.parent and parents[aio.parent.name]  
+        # already existing parent, thus all further saved parents of this task needs to be removed
+        puts "parents  #{parents.inspect}"
+        parents.each {|k,v| 
+          if (v.eql? parents[aio.parent.name] or v.eql? aio.name)
+            parents.delete(k)
+            p "delete key #{k} value #{v}" 
+          end
+        }
+        parents[aio.parent.name]=aio.name
+        #        parents.delete(parents.invert[ parents[aio.parent.name]])
+      end
+    end
+    
+    p "next step"
+    if parents.length>0
+      return find_common_aic(parents.keys,activate,parents)
+    else
+      return tasks.first
+    end
+  end
+  
+  def AUIControl.find_common(tasks)
+    
+    if tasks.length==1
+      return tasks[0]
+    end
+    
+    parents ={ }
+    
+    tasks.each do |name|
+      t = AIO.first(:name=>name)
+      tname = t.name
+      parents[tname] = [tname]
+      
+      while (t.parent)
+        parents[tname].push t.parent.name
+        t = t.parent
+      end
+    end
+    
+    lasttaskname = nil
+    while 1==1
+      taskname = nil
+      parents.keys.each_with_index do |k,i|
+        if (i==0)
+          taskname = parents[k].pop
+        else
+          comp = parents[k].pop
+          if not comp.eql? taskname 
+            return lasttaskname
+          end
+        end
+      end
+      lasttaskname = taskname
+    end
+  end
+end
+

data/lib/MINT-core/agent/cui-gfx.rb

@@ -0,0 +1,160 @@
+
+class LayoutAgent < MINT::Agent
+
+  include CUIControl
+
+  def initialize
+    @solver = Cassowary::ClSimplexSolver.new
+    super
+  end
+
+  def initial_calculation(result)
+    p  "Initial Layout recalculation requested for new PTS #{result.inspect} "
+
+    #MINT::CIO.all.each { |c|
+    #  c.calculateMinimumSize
+    # }
+
+
+    root_cio = CIO.first(:name=>result.root)
+
+
+    # p "#{root_le} root:#{root}"
+    #p "minimumspace  = "+ calculateMinimumSquareSpace(root_le).to_s
+
+    #calculateOptSquareSpace(result.root, 800*600, 10)
+
+    root_cio.print
+    # pts = result.interactionTasks.map &:name
+    #root = find_common_container(pts,true)
+#    c = Box.new(:name=>le.name, :x=>0,:y=>0, :width=>1200, :height=>800, :layer=>1)
+    # c.save
+
+    root_cio.calculate_container(@solver,20)
+
+    CUIControl.fill_active_cio_cache
+
+  end
+
+
+  def calculate_layout_on_task_change(result)
+    p "Layout agent has recieved task removal request #{result.inspect}"
+
+    deactivate_layout_on_task_deactivate(result.name)
+    p "after task deaktivate"
+    root = find_container_to_recalculate(result.name)
+    c = Box.first(:name=>root)
+    setup_constraints(c)
+  end
+  #private
+
+  # @param [String] taskname name of container
+  # @return [String] container name to recalculate
+
+  def find_container_to_recalculate(taskname)
+    le = Layout.first(:name=>taskname)
+
+    if le.state.eql?("inactive")
+      # luis = Layout.all(:parent=>le.parent).map &:task
+      #   luis.each do |name|
+      #    cui = CUI.first(:task=>name)
+      #    if (cui != nil)
+      #      cui.destroy!
+      #    end
+      #  end
+      find_container_to_recalculate(le.layout)
+    else
+      #p "Container to recalculate #{le.inspect}"
+      return le.name
+    end
+  end
+
+  def calculateMinimumSquareSpace(le)
+    if le.type=="layoutcontainer"
+      #   p "Calculating space for container #{le.name}"
+      space = 0
+
+      le.layoutelements.each do |e|
+        space = space + calculateMinimumSquareSpace(e)
+
+      end
+      #  p "Calculated from container #{space}"
+      le.update(:minspace => space)
+
+
+      return space
+    else
+      #     p "Calculating space for element #{le.inspect}"
+      if (le.minwidth  and le.minheight)
+        space =  le.minwidth*le.minheight
+        le.update(:minspace => space)
+        # p "calculated from element #{space}"
+        return space
+      else
+        return 0
+      end
+    end
+  end
+
+  def calculateOptSquareSpace(root_container, available_space,border)
+    root_le=Layoutelement.first(:name=>root_container)
+    min_space_used = root_le.minspace
+    quota =  Float(available_space )/Float( min_space_used)
+    # p "quota: #{quota}"
+    calc_opt_square_traverse(quota, root_le,border)
+  end
+
+  def calc_opt_square_traverse(quota, root_le,border)
+    max_space = root_le.minspace*quota
+    kantenlaenge = Math.sqrt(max_space)
+    border_space = 4 * border * kantenlaenge  -   (2 * border)**2
+    optspace = root_le.minspace*quota-border_space
+    #   p "Optspace for #{root_le.name} = #{optspace}"
+    root_le.update(:optspace => optspace)
+
+    if root_le.type=="layoutcontainer"
+      root_le.layoutelements.each do |e|
+        calc_opt_square_traverse(quota,e,border)
+      end
+    end
+  end
+
+  def wait_border_crossing(result)
+    p "subscribing to pointer #{result.parent.inspect}"
+
+    cio = CIO.first(:name=>result.parent.name)
+
+    p "got #{cio.inspect}"
+    Thread.new(cio.name,cio.x,cio.y,cio.width,cio.height) { |name,cx,cy,cw,ch|
+
+      Redis.new.subscribe("juggernaut") do |on|
+        on.message do |c,msg|
+          r = JSON.parse(msg)
+          if (r["channels"].include? "pointer")
+            if /POS/.match(r["data"])
+              z,x,y = /POS-(\d+),(\d+)/.match(r["data"]).to_a.map &:to_i
+              p "data #{x},#{y} #{cx} #{cy} #{cw} #{ch}"
+
+              if (x<cx or x>(cx+cw) or y<cy or y>(cy+ch))
+                p "outside!!!"
+
+                # Hacks start here
+
+                aio = AIO.first(:name=>"0")
+                aio.process_event(:suspend)
+
+                arframe = AIO.first(:name=>"ar_frame")
+                arframe.process_event(:present)
+                p "after"
+
+                Thread.stop
+              end
+            end
+          end
+        end
+      end
+
+    }
+  end
+
+end

data/lib/MINT-core/agent/cuicontrol.rb

@@ -0,0 +1,46 @@
+module CUIControl
+  include MINT
+
+  @active_cios = nil
+  
+  def CUIControl.find_cio_from_coordinates(result)
+    puts "mouse stopped #{result.inspect}"
+    if result == nil or @active_cios == nil  # we have not finished cui poition calculation, but we already received a mouse stopped event
+      return
+    end
+    x = result.x
+    y = result.y
+
+    highlighted_cio = CIO.first(:abstract_states=>/highlighted/)
+
+    if (highlighted_cio!=nil && highlighted_cio.x<=x && highlighted_cio.y<=y && highlighted_cio.x+highlighted_cio.width>=x && highlighted_cio.y+highlighted_cio.height>=y)
+      puts "unchanged"
+      return
+    else
+      found = @active_cios.select{ |e|  e.x <=x && e.y<=y && e.x+e.width>=x && e.y+e.height>=y}
+     
+      puts "found #{found.inspect}"
+      
+      if (highlighted_cio)
+        highlighted_cio.process_event("unhighlight") # old focus
+        puts "unhighlight:"+highlighted_cio.name
+        # @highlighted_cio.update(:state=>"calculated") # old focus
+      end
+      
+      if (found.first)
+        highlighted_cio = CIO.first(:name=>found.first.name)
+        highlighted_cio.process_event("highlight")
+        puts "highlighted:"+highlighted_cio.name
+      else
+        puts "no highlight"
+        return
+      end
+    end
+  end
+
+  def CUIControl.fill_active_cio_cache(result=nil)
+    @active_cios = CIO.all.select{ |e| e.is_in?(:presenting) and not e.kind_of? MINT::CIC }
+    puts "CIO cache initialized with #{@active_cios.length} elements"
+  end 
+  
+end