MINT-core 1.0.0

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

@@ -0,0 +1,51 @@
+
+module MINT
+  class Head < Element
+    attr_accessor :mode
+    #property :angle, Integer, :default  => -1
+    #property :distance, Integer, :default  => -1
+     property :mode, Enum[ :nodding, :turning, :tilting ],  :default => :tilting
+
+    def initialize_statemachine
+
+      if @statemachine.blank?
+
+        parser = StatemachineParser.new(self)
+        @statemachine = parser.build_from_scxml "#{File.dirname(__FILE__)}/head.scxml"
+        @statemachine.reset
+      end
+    end
+
+
+
+    def angle=(angle)
+      if @publish_angle
+        Juggernaut.publish("head/angle", "#{angle}")
+      end
+    end
+
+    def start_publish_angle
+      @publish_angle=true
+    end
+
+    def stop_publish_angle
+      @publish_angle=false
+    end
+
+
+    def in_nodding_mode
+      return true if self.mode.eql? :nodding
+      false
+    end
+
+    def in_turning_mode
+      return true if self.mode.eql? :turning
+      false
+    end
+
+    def in_tilting_mode
+      return true if self.mode.eql? :tilting
+      false
+    end
+  end
+end

data/lib/MINT-core/model/body/head.scxml

@@ -0,0 +1,28 @@
+<scxml initial="disconnected" name="Head" version="0.9" xmlns="http://www.w3.org/2005/07/scxml"><!--   node-size-and-position x=0.0 y=0.0 w=800.0 h=470.0  -->
+ <state id="disconnected"><!--   node-size-and-position x=380.0 y=30.0 w=100.0 h=50.0  -->
+  <transition event="connect" target="connected"><!--   edge-path [connected]  x=520.0 y=100.0 pointx=0.0 pointy=13.0 offsetx=24.0 offsety=12.0  --></transition>
+ </state>
+ <state id="connected"><!--   node-size-and-position x=20.0 y=140.0 w=760.0 h=310.0  -->
+  <transition event="disconnect" target="disconnected"><!--   edge-path [disconnected]  x=340.0 y=100.0 pointx=0.0 pointy=37.0 offsetx=-24.0 offsety=33.0  --></transition>
+  <state id="nodding"><!--   node-size-and-position x=50.0 y=30.0 w=200.0 h=130.0  -->
+   <state id="looking_down"><!--   node-size-and-position x=60.0 y=40.0 w=100.0 h=50.0  -->
+    <transition event="center" target="centered"><!--   edge-path [centered]  pointx=0.0 pointy=-24.0 offsetx=-8.0 offsety=-5.0  --></transition>
+   </state>
+  </state>
+  <state id="tilting"><!--   node-size-and-position x=290.0 y=30.0 w=230.0 h=130.0  -->
+   <state id="tilting_right"><!--   node-size-and-position x=60.0 y=40.0 w=100.0 h=50.0  -->
+    <transition event="center" target="centered"><!--   edge-path [centered]  x=440.0 y=170.0 pointx=0.0 pointy=8.0 offsetx=15.0 offsety=13.0  --></transition>
+   </state>
+  </state>
+  <state id="centered"><!--   node-size-and-position x=350.0 y=230.0 w=100.0 h=60.0  -->
+   <transition cond="in_tilting_mode" event="tilt_right" target="tilting_right"><!--   edge-path [tilting_right]  x=70.0 y=140.0 pointx=0.0 pointy=19.0 offsetx=-14.0 offsety=-32.0  --></transition>
+   <transition cond="in_nodding_mode" event="look_down" target="looking_down"><!--   edge-path [looking_down]  x=160.0 y=260.0 pointx=0.0 pointy=-10.0 offsetx=10.0 offsety=0.0  --></transition>
+   <transition cond="in_turning_mode" event="turn_right" target="looking_right"><!--   edge-path [looking_right]  x=650.0 y=260.0 pointx=0.0 pointy=10.0 offsetx=-20.0 offsety=0.0  --></transition>
+  </state>
+  <state id="turning"><!--   node-size-and-position x=540.0 y=30.0 w=190.0 h=130.0  -->
+   <state id="looking_right"><!--   node-size-and-position x=60.0 y=40.0 w=100.0 h=50.0  -->
+    <transition event="center" target="centered"><!--   edge-path [centered]  pointx=0.0 pointy=24.0 offsetx=8.0 offsety=-5.0  --></transition>
+   </state>
+  </state>
+ </state>
+</scxml>

data/lib/MINT-core/model/cui/gfx/CIC.rb

@@ -0,0 +1,266 @@
+module MINT
+  class CIC < CIO
+    property :rows, Integer
+    property :cols, Integer
+
+    def calculate_position(parent_cic,elements,solver,i,b,layer=0)
+      p "container #{self.name} #{b}"
+      aic = AIC.first(:name=>self.name)
+      elements = []
+
+
+      if aic.childs && aic.childs.length>0
+
+        calculateColsAndRows(aic.childs.length)
+        grid_hash= mda(self.rows,self.cols)
+
+        aic.childs.each_with_index do |e,i|
+          cio = CIO.first(:name=>e.name)
+          elements << cio
+          if (not cio)
+            cio = CIO.createCIOfromAIO(e,layer)
+          end
+
+
+
+          # Save the actual row,column, and  layer to the element
+          cio.col =  i % self.cols
+          cio.row =  i / self.cols
+          cio.layer = layer+1
+
+
+          cio.calculate_position(self,elements,solver,i,b,layer+1)
+          grid_hash[cio.row][cio.col] = cio
+          p "child #{cio.name} 1.positioning step"
+        end
+
+        if self.process_event("position")
+          if parent_cic
+            solver.AddConstraint(ClLinearEquation.new(self.pos.Y,ClLinearExpression.new(parent_cic.pos.Y.Value).Plus(ClLinearExpression.new(b))))
+            solver.AddConstraint(ClLinearEquation.new(self.pos.X,ClLinearExpression.new(parent_cic.pos.X.Value).Plus(ClLinearExpression.new(b))))
+          end
+
+
+          # parent(height) = SUM(AllElementsOfColumn(c)(height))+((self.rows+1)*b)
+          if (self.rows >0)
+            self.cols.times do |c|
+              solver.AddConstraint(ClLinearInequality.new(size.Y,CnGEQ,iterate_rows_of_column(grid_hash,c,self.rows-1).Plus(ClLinearExpression.new((self.rows+1)*b)),Cassowary.ClsStrong))
+            end
+          end
+
+          # parent(width) = SUM(AllElementsOfRow(r)(width))+((self.cols+1)*b)
+          if (self.cols>0)
+            self.rows.times do |r|
+              solver.AddConstraint(ClLinearInequality.new(size.X,CnGEQ,iterate_cols_of_row(grid_hash,r,self.cols-1).Plus(ClLinearExpression.new((self.cols+1)*b)),Cassowary.ClsStrong))
+            end
+          end
+        else
+          # fixed position
+          p "CIC fixed#{self.inspect}"
+          setFixedPositionConstraints(solver)
+          setFixedSizeConstraints(solver)
+        end
+
+      else
+        self.cio_calculate_position(parent_cic,elements,solver,i,b,layer)
+      end
+
+      self.process_event("calculated")
+    end
+
+
+
+    # elements array of elements from left to right and first to last row
+    # cx, cy container position
+    # ch,cw container size
+    # rows and columns
+    # b minimal border space between elements
+    def calculate_container(solver,b,layer=0)
+
+      #handle special cases where nr(elements) < self.cols * rows by overwriting rows and self.cols properties to fit elemnt amounts
+
+      if self.process_event!("position")
+     #   p "in positionion #{self.name}"
+        self.layer = layer
+        aic = AIC.first(:name=>self.name)
+
+        elements_count = aic.childs.length
+
+        calculateColsAndRows(elements_count)
+
+        # create grid with helper method
+        self.rows= elements_count if (self.rows == nil)
+        self.cols= 1 if (self.cols == nil)
+
+        grid_hash= mda(self.rows,self.cols)
+        #       p "hash #{ self.name} rows #{self.rows} cols #{self.cols}"
+
+        ai_childs =  aic.childs.all(:abstract_states=> /#{Regexp.quote("organized")}/)
+        #      p aic.name
+        elements=[]
+        ai_childs.each_with_index do |e,i|
+          cio = CIO.first(:name=>e.name)
+
+          if (not cio)
+            cio = CIO.createCIOfromAIO(e,layer)
+          else
+            cio.layer=layer+1
+          end
+
+          if (not cio.kind_of? MINT::CIC)
+            cio.process_event!("position")
+          end
+
+          elements << cio
+
+          cio.setMinimumSizeConstraints(solver)
+
+          act_col = i % self.cols
+          act_row = i / self.cols
+
+      #    p "#{e.name} parent #{act_row} #{act_col}"
+
+          grid_hash[act_row][act_col] = cio
+
+          # Save the actual row and column of the element
+          cio.col = act_col
+          cio.row = act_row
+
+          cio.setTableElementConstraints(solver,elements, self,act_col,act_row,i,b)
+
+          if (cio.kind_of? MINT::CIC)
+            cio.calculate_container(solver,b,layer+1)
+          end
+
+        end
+
+        # calculate navigation
+       # calculate_gfx__navigation(grid_hash)
+        save_grid(grid_hash)
+
+        # Specify the parent container minimal width and height by summing ab all children widths and heights resp.
+
+        # parent(height) = SUM(AllElementsOfColumn(c)(height))+((self.rows+1)*b)
+        if (self.rows >0)
+          self.cols.times do |c|
+            solver.AddConstraint(ClLinearInequality.new(size.Y,CnGEQ,iterate_rows_of_column(grid_hash,c,self.rows-1).Plus(ClLinearExpression.new((self.rows+1)*b)),Cassowary.ClsStrong))
+          end
+        end
+
+        # parent(width) = SUM(AllElementsOfRow(r)(width))+((self.cols+1)*b)
+        if (self.cols>0)
+          self.rows.times do |r|
+            solver.AddConstraint(ClLinearInequality.new(size.X,CnGEQ,iterate_cols_of_row(grid_hash,r,self.cols-1).Plus(ClLinearExpression.new((self.cols+1)*b)),Cassowary.ClsStrong))
+          end
+        end
+
+        elements.each { |e|
+        # e.print
+          if (not e.kind_of? MINT::CIC)
+            e.process_event!("calculated")
+          end
+          e.save
+        }
+        self.process_event("calculated")
+      else
+        aic = AIC.first(:name=>name)
+        elements = []
+        aic.childs.each_with_index do |e,i|
+          cio = CIO.first(:name=>e.name)
+          elements << cio
+          if (not cio)
+            cio = CIO.createCIOfromAIO(e,layer)
+          end
+
+          calculateColsAndRows(aic.childs.length)
+
+          # Save the actual row,column, and  layer to the element
+          cio.col =  i % self.cols
+          cio.row =  i / self.cols
+          cio.layer = layer+1
+
+          cio.calculate_position(self,elements,solver,i,b)
+
+        end
+      end
+    end
+
+    def mda(width, height)
+      return Array.new(width){Array.new(height)}
+    end
+
+    def calculateColsAndRows(elements_count)
+      if not self.cols and not self.rows
+        self.rows = elements_count
+        self.cols = 1
+      end
+
+      if (elements_count < self.cols*self.rows)
+        if self.cols == 1
+          self.rows = elements_count
+        elsif self.rows ==1
+          self.cols = elements_count
+        else
+          factor = elements_count / self.cols*self.rows
+          self.cols = (self.cols*factor).round
+          self.rows = (self.cols*factor).round
+        end
+      end
+    end
+
+    def calculate_gfx__navigation(array)
+      array.each_with_index  do |row,r|
+        row.each_with_index do |column,c|
+          if not c==0
+            # left and right in a table
+            array[r][c-1].right = array[r][c]
+            array[r][c].left = array[r][c-1]
+        #    puts "left<>right: #{array[r][c-1].name} <>  #{array[r][c].name}"
+          end
+          if not r ==0
+            # up and down in a table
+            array[r-1][c].down = array[r][c]
+            array[r][c].up = array[r-1][c]
+         #   puts "up<>down: #{array[r-1][c].name} <>  #{array[r][c].name}"
+          end
+        end
+      end
+    end
+
+    def save_grid(array)
+      array.each_with_index  do |row,r|
+        row.each_with_index do |column,c|
+          array[r][c].save
+        end
+      end
+    end
+
+    # Iterates over all columns of one row that is set by #row_nr
+    #
+    # @param array the two dimensional array that should be iterated
+    # @param row_nr the index of the row that should be used for iteration
+    # @param index the highest index of a column that shoul be iterated (the iteration starts with this index and iterates backwards until 0.
+    # @return [CLinearExpression] a Plus composed linear expressions with all variables
+    #
+    def iterate_cols_of_row(array,row_nr,index)
+      if (index>0)
+        return ClLinearExpression.new(array[row_nr][index].size.X).Plus(iterate_cols_of_row(array,row_nr,index-1))
+      else
+        return ClLinearExpression.new(array[row_nr][index].size.X)
+      end
+    end
+
+    def iterate_rows_of_column(array,col_nr,index)
+      begin
+
+        if (index>0)
+          return ClLinearExpression.new(array[index][col_nr].size.Y).Plus(iterate_rows_of_column(array,col_nr,index-1))
+        else
+          return ClLinearExpression.new(array[index][col_nr].size.Y)
+        end
+      rescue NoMethodError
+        p "rescue with index #{index} and col_nr #{col_nr}"
+      end
+    end
+  end
+end

data/lib/MINT-core/model/cui/gfx/CIO.rb

@@ -0,0 +1,381 @@
+module MINT
+  class CIO_sync_callback
+    def sync_aio_to_focused
+      true
+    end
+
+    def sync_aio_to_presented
+      true
+    end
+    def sync_aio_to_defocus
+      true
+    end
+
+    def sync_aio_to_suspended
+          true
+        end
+
+  end
+
+  class CIO < Element
+    include Cassowary
+
+    has 1, :up, self,
+        :parent_key => [ :id ],       # in the remote model (Blog)
+        :child_key  => [ :up_id ]  # local to this model (Post)
+    has 1,  :down, self,
+        :parent_key => [ :id ],       # in the remote model (Blog)
+        :child_key  => [ :down_id ]  # local to this model (Post)
+    has 1, :left, self,
+        :parent_key => [ :id ],       # in the remote model (Blog)
+        :child_key  => [ :left_id ]  # local to this model (Post)
+    has 1,  :right, self,
+        :parent_key => [ :id ],       # in the remote model (Blog)
+        :child_key  => [ :right_id ]  # local to this model (Post)
+
+    property :text,     Text,   :lazy => false
+    property :fontname,     String, :default  => "Helvetica"
+    property :fontsize,     Integer, :default  => 13
+    property :minwidth, Integer
+    property :minheight, Integer
+    property :minspace, Integer
+    property :optspace, Integer
+    property :width, Integer
+    property :height, Integer
+    property :x,  Integer
+    property :y, Integer
+    property :layer, Integer
+    property :row, Integer
+    property :col,Integer
+
+
+#    before :create, :recover_statemachine
+
+    before :create, :initialize_points
+#    before :update,  :initialize_points
+#    before :save!, :store_calculated_values_in_model
+#    before :save, :store_calculated_values_in_model
+
+    before :update!, :initialize_points
+    public
+    def initialize_points
+      @pos = Cassowary::ClPoint.new()
+      if (self.x and self.y)
+        @pos = Cassowary::ClPoint.new(self.x,self.y)
+      end
+      @size = Cassowary::ClPoint.new()
+      if (self.width and self.height)
+        @size = Cassowary::ClPoint.new(self.width, self.height)
+      elsif (self.minwidth and self.minheight)
+        @size = Cassowary::ClPoint.new(self.minwidth, self.minheight)
+      end
+      true
+    end
+
+    def store_calculated_values_in_model
+
+      attribute_set(:x,pos.Xvalue)
+      attribute_set(:y,pos.Yvalue)
+      attribute_set(:width,size.Xvalue)
+      attribute_set(:height,size.Yvalue)
+
+    end
+
+    def pos(x=-1,y=-1)
+      if (x > -1 and y> -1)
+        @pos = Cassowary::ClPoint.new(x,y)
+      elsif not @pos
+        #if not @pos
+        @pos = Cassowary::ClPoint.new
+
+        if (attribute_get(:x) and attribute_get(:y))
+          @pos = Cassowary::ClPoint.new(attribute_get(:x),attribute_get(:y))
+        end
+      end
+      return @pos
+    end
+
+    def size(width=-1,height=-1)
+      if (width > -1 and height> -1)
+        @size = Cassowary::ClPoint.new(with,height)
+      elsif not @size
+        #if not @size
+        @size = Cassowary::ClPoint.new
+        if (attribute_get(:width) and attribute_get(:height))
+          @size = Cassowary::ClPoint.new(attribute_get(:width), attribute_get(:height))
+        elsif (attribute_get(:minwidth) and attribute_get(:minheight))
+          @size = Cassowary::ClPoint.new(attribute_get(:minwidth), attribute_get(:minheight))
+        end
+      end
+      return @size
+    end
+
+    def calculateMinimumSize(border = 5)
+      if text
+
+        label = Magick::Draw.new
+        label.font = fontname
+        label.text_antialias(true)
+        label.font_style=Magick::NormalStyle
+        label.font_weight=Magick::NormalWeight
+        label.gravity=Magick::CenterGravity
+        label.text(0,0,text)
+        label.pointsize = fontsize
+        metrics = label.get_type_metrics(text)
+
+        self.minheight=metrics.height+2*border
+        self.minwidth=metrics.width+2*border
+      end
+    end
+
+    def calculate_position(parent_cic,elements,solver,i,b,layer =0)
+      if self.process_event("position")
+        p "cio #{self.inspect} parent #{parent_cic.inspect}"
+        self.layer=layer
+        setMinimumSizeConstraints(solver)
+
+        setTableElementConstraints(solver,elements,parent_cic,self.col,self.row,i,b) if elements and elements.length>0
+        self.process_event("calculated")
+      else
+        p "cio fixed#{self.inspect}"
+        setFixedPositionConstraints(solver)
+        setFixedSizeConstraints(solver)
+      end
+
+    end
+
+    alias :cio_calculate_position :calculate_position
+
+    def setFixedPositionConstraints(solver)
+      solver.AddConstraint(ClLinearEquation.new(self.pos.X,ClLinearExpression.new(self.pos.X.Value),Cassowary.ClsStrong))
+      solver.AddConstraint(ClLinearEquation.new(self.pos.Y,ClLinearExpression.new(self.pos.Y.Value),Cassowary.ClsStrong))
+    end
+
+    def setFixedSizeConstraints(solver)
+      solver.AddConstraint(ClLinearEquation.new(self.size.X,ClLinearExpression.new(self.size.X.Value),Cassowary.ClsStrong))
+      solver.AddConstraint(ClLinearEquation.new(self.size.Y,ClLinearExpression.new(self.size.Y.Value),Cassowary.ClsStrong))
+    end
+
+    def setMinimumSizeConstraints(solver)
+      # p "l11"
+      # take care of generate only positive values for height,width, x,y
+      # p "#{name} -calculating>#{self.name}"
+      # Consider minimum Sizes
+      if self.minwidth
+        solver.AddConstraint(ClLinearInequality.new(self.size.X,CnGEQ,ClLinearExpression.new(self.minwidth),Cassowary.ClsStrong))
+      else
+        solver.AddConstraint(ClLinearInequality.new(self.size.X,CnGEQ,ClLinearExpression.new(0),Cassowary.ClsStrong))
+      end
+      if self.minheight
+        solver.AddConstraint(ClLinearInequality.new(self.size.Y,CnGEQ,ClLinearExpression.new(self.minheight),Cassowary.ClsStrong))
+      else
+        solver.AddConstraint(ClLinearInequality.new(self.size.Y,CnGEQ,ClLinearExpression.new(0),Cassowary.ClsStrong))
+      end
+
+      #      solver.AddConstraint(ClLinearInequality.new(self.pos.X,CnGEQ,ClLinearExpression.new(parent.pos.X),Cassowary.ClsStrong))
+      #     solver.AddConstraint(ClLinearInequality.new(self.pos.Y,CnGEQ,ClLinearExpression.new(parent.pos.Y),Cassowary.ClsStrong))
+
+    end
+
+    def setTableElementConstraints(solver,elements, cic,act_col,act_row,i,b)
+      total_cols = cic.cols
+      total_rows = cic.rows
+
+      if (act_col == 0)
+        solver.AddConstraint(ClLinearEquation.new(self.pos.X,ClLinearExpression.new(cic.pos.X.Value).Plus(ClLinearExpression.new(b)),Cassowary.ClsStrong))
+      else
+        # e(x) = e-1(x)+e-1(width)+b
+        solver.AddConstraint(ClLinearEquation.new(self.pos.X,ClLinearExpression.new(elements[i-1].pos.X.Value).Plus(ClLinearExpression.new(elements[i-1].size.X)).Plus(ClLinearExpression.new(b))))
+      end
+
+      # Y coordinate handling for first row
+      if (i<total_cols)
+        solver.AddConstraint(ClLinearEquation.new(self.pos.Y,ClLinearExpression.new(cic.pos.Y.Value).Plus(ClLinearExpression.new(b))))
+      else
+        solver.AddConstraint(ClLinearEquation.new(self.pos.Y,ClLinearExpression.new(elements[i-total_cols].pos.Y.Value).Plus(ClLinearExpression.new(elements[i-total_cols].size.Y)).Plus(ClLinearExpression.new(b))))
+      end
+
+
+      # maximize sizes
+      #e(width)=c(width)/total_cols - ((total_cols+1)*b)/total_cols
+      solver.AddConstraint(ClLinearEquation.new(self.size.X,ClLinearExpression.new(
+          cic.size.X.Value).Divide(total_cols).Minus(ClLinearExpression.new(((total_cols+1)*b)/total_cols)),Cassowary.ClsWeak
+                           ))
+
+      #       solver.AddConstraint(ClLinearInequality.new(self.size.X,CnLEQ,ClLinearExpression.new(parent.size.X),Cassowary.ClsStrong))
+      #e(height)= c(height)/total_rows - ((total_rows+1)*b)/total_rows
+      solver.AddConstraint(ClLinearEquation.new(self.size.Y,ClLinearExpression.new(
+          cic.size.Y.Value).Divide(total_rows).Minus(ClLinearExpression.new(((total_rows+1)*b)/total_rows)),Cassowary.ClsWeak
+                           ))
+      #      solver.AddConstraint(ClLinearInequality.new(e.size.Y,CnLEQ,ClLinearExpression.new(),Cassowary.ClsStrong))
+
+      # relative size to the parent: e.size.X*e.size.Y/parent.size.X*parent.size.Y=e.minspace/parent.minspace
+      #     if (parent.minspace and e.minspace and parent.minspace>0 and e.minspace>0)
+      #   solver.AddConstraint(ClLinearEquation.new(e.size.Y,ClLinearExpression.new(parent.size.Y).Times(e.minspace/parent.minspace),Cassowary.ClsWeak
+      #                                          ))
+
+      #   solver.AddConstraint(ClLinearEquation.new(e.size.X,ClLinearExpression.new(parent.size.X).Times(e.minspace/parent.minspace),Cassowary.ClsWeak
+      ###                                           ))
+      # end
+
+    end
+    def CIO.createCIOfromAIO(e,layer)
+      p "creating CIO for #{e.class}"
+      case e.class.name
+        when "MINT::AIC","MINT::AISinglePresence"
+          aic = AIC.first(:name=>e.name)           # TODO: if its not retrieved again, childs.length returns 0!
+
+          elements_count = aic.childs.length
+          elements_count = 1 if elements_count== 0
+          cio = CIC.create(:name=>e.name,:cols=>1,:rows=>elements_count,:layer =>layer+1)
+
+
+          p "create #{e.name} rows: #{elements_count}"
+        when "MINT::AIMultiChoice"
+          cio = CheckBoxGroup.create(:name=>e.name,:layer =>layer+1)
+        when "MINT::AISingleChoice"
+          cio = RadioButtonGroup.create(:name=>e.name,:layer =>layer+1)
+        when "MINT::AIMultiChoiceElement"
+          cio = CheckBox.create(:name=>e.name,:layer =>layer+1)
+        when "MINT::AISingleChoiceElement"
+          cio = RadioButton.create(:name=>e.name,:layer =>layer+1)
+        when "MINT::AIOUTContext"
+          cio = BasicText.create(:name=>e.name,:layer =>layer+1)
+        when "MINT::AIINReference"
+          cio = Label.create(:name=>e.name,:layer =>layer+1)
+        when "MINT::AICommand"
+          cio = Button.create(:name=>e.name,:layer =>layer+1)
+        else
+          cio = CIO.create(:name=>e.name,:layer =>layer+1)
+
+      end
+      p "Created #{cio.inspect}"
+      return cio
+    end
+
+    def initialize_statemachine
+      if @statemachine.blank?
+
+        @statemachine = Statemachine.build do
+
+          superstate :CIO do
+            trans :initialized,:position,:positioning
+            trans :positioning,:calculated,:positioned, :store_calculated_values_in_model
+            trans :positioned, :display, :presenting
+            trans :disabled, :hide, :hidden
+            trans :hidden,:display, :presenting
+
+            state :hidden do
+              on_entry :sync_aio_to_suspended
+            end
+
+            superstate :presenting do
+              on_entry :sync_aio_to_presented
+
+              state :displayed do
+                on_entry :sync_aio_to_defocus
+              end
+
+              state :highlighted  do
+                on_entry :sync_aio_to_focused
+              end
+
+              trans :displayed, :highlight, :highlighted
+              #trans :displayed, :display, :displayed # a display request can be issued several times even if the object is already displayed (in case of refresh or multimple presentations
+              #trans :highlighted, :display, :highlighted # this is because display requests should not change the highlighting
+              trans :highlighted,:unhighlight, :displayed
+              trans :highlighted, :up, :displayed, :highlight_up
+              trans :highlighted, :down, :displayed, :highlight_down
+              trans :highlighted, :left, :displayed, :highlight_left
+              trans :highlighted, :right, :displayed, :highlight_right
+
+              event :disable, :disabled
+              event :hide, :hidden
+
+            end
+          end
+        end
+      end
+    end
+
+
+     def sync_event(event)
+      process_event(event, CIO_sync_callback.new)
+     end
+
+    # callbacks
+
+    def  highlight_up
+      if (self.up)
+        self.up.process_event("highlight")
+      else
+        return nil # TODO not working, find abbruchbedingung!!!
+      end
+    end
+
+    def  highlight_down
+      if (self.down)
+        self.down.process_event("highlight")
+      else
+        return nil # TODO not working, find abbruchbedingung!!!
+      end
+    end
+
+    def  highlight_left
+      if (self.left)
+        self.left.process_event("highlight")
+      else
+        return nil # TODO not working, find abbruchbedingung!!!
+      end
+    end
+
+    def  highlight_right
+      if (self.right)
+        self.right.process_event("highlight")
+      else
+        return nil # TODO not working, find abbruchbedingung!!!
+      end
+    end
+
+
+    def sync_aio_to_presented
+      aio =  MINT::AIO.first(:name=>self.name)
+       if (aio and not aio.is_in? :presenting)
+        aio.sync_event(:present)
+       end
+      true
+    end
+
+
+    def sync_aio_to_defocus
+      aio =  MINT::AIO.first(:name=>self.name)
+       if (aio and not aio.is_in? :defocused)
+         aio.sync_event(:defocus)
+       end
+      true
+    end
+
+    def sync_aio_to_focused
+      aio =  MINT::AIO.first(:name=>self.name)
+       if (aio and not aio.is_in? :focused)
+        aio.sync_event(:focus)
+       end
+      true
+    end
+
+    def sync_aio_to_suspended
+          aio =  MINT::AIO.first(:name=>self.name)
+           if (aio and not aio.is_in? :suspended)
+            aio.sync_event(:suspend)
+           end
+          true
+        end
+
+
+
+    def print
+      puts "\"#{self.name}\",#{pos.Xvalue}, #{pos.Yvalue}, #{size.Xvalue}, #{size.Yvalue}"
+    end
+
+  end
+end