MINT-core 1.0.0

data/lib/MINT-core/model/aui/AIINChoose.rb

@@ -0,0 +1,54 @@
+module MINT
+  class AIINChoose_sync_callback < AIO_sync_callback
+     def initialize(element)
+       @element=element
+     end
+     def sync_cio_to_listed
+       true
+     end
+
+     def sync_cio_to_selected
+       true
+     end
+
+
+
+     def unchoose_others
+       aios = @element.parent.childs.all(:states=>/\bchosen\b/)
+       aios.each do |aio|
+         aio.process_event("unchoose") if aio.is_in? :chosen
+       end
+       true
+     end
+   end
+
+   class AIINChoose < AIINDiscrete
+
+     def sync_event(event)
+       process_event(event, AIINChoose_sync_callback.new(self))
+     end
+     def sync_cio_to_selected
+       cio =  MINT::Selectable.first(:name=>self.name)
+       if (cio and not cio.is_in? :selected)
+         cio.sync_event(:select)
+       end
+       true
+     end
+
+     def sync_cio_to_listed
+       cio =  MINT::Selectable.first(:name=>self.name)
+       if (cio and not cio.is_in? :listed)
+         cio.sync_event(:listed)
+       end
+       true
+     end
+
+     def unchoose_others
+       aios = self.parent.childs.all(:states=>/\bchosen\b/)
+       aios.each do |aio|
+         aio.process_event("unchoose")
+       end
+     end
+   end
+
+end

data/lib/MINT-core/model/aui/AIMultiChoice.rb

@@ -0,0 +1,5 @@
+module MINT
+  class AIMultiChoice < AIChoice
+  
+  end
+end

data/lib/MINT-core/model/aui/AIMultiChoiceElement.rb

@@ -0,0 +1,56 @@
+module MINT
+  class AIMultiChoiceElement < AIINChoose
+    def initialize_statemachine
+      if @statemachine.blank?
+        @statemachine = Statemachine.build do
+
+#          superstate :AIO do # TODO not supported so far!
+          trans :initialized,:organize, :organized
+          trans :organized, :present, :p
+          trans :suspended,:present, :initialized
+
+          parallel :p do
+            statemachine :s1 do
+              superstate :presenting do
+                state :defocused do
+                  on_entry :sync_cio_to_displayed
+                end
+                state :focused do
+                  on_entry :sync_cio_to_highlighted
+                end
+                trans :defocused,:focus,:focused
+                trans :focused,:defocus, :defocused
+                trans :focused, :next, :defocused, :focus_next,  Proc.new { exists_next}
+                trans :focused, :prev, :defocused, :focus_previous, Proc.new { exists_prev}
+                trans :focused, :parent, :defocused, :focus_parent
+                event :suspend, :suspended
+              end
+            end
+            statemachine :s2 do
+              superstate :choice do
+                trans :listed, :choose, :chosen
+#                trans :chosen, :drag, :dragging
+ #               trans :dragging, :drop, :chosen
+              trans :chosen, :unchoose, :listed
+
+                trans :listed,  :drag, :dragging
+                trans :dragging, :drop, :listed
+                
+                state :chosen do
+                  on_entry :sync_cio_to_selected
+                end
+
+                state :listed do
+                  on_entry :sync_cio_to_listed
+                end
+
+              end
+            end
+          end
+          #end
+        end
+      end
+    end
+    
+  end
+end

data/lib/MINT-core/model/aui/AIO.rb

@@ -0,0 +1,170 @@
+module MINT
+
+
+  # An abstract
+  class AIO < Element
+    property :label, String
+    property :description, Text,   :lazy => false
+    has 1, :next, self,
+        :parent_key => [ :id ],       # in the remote model (Blog)
+        :child_key  => [ :next_id ]  # local to this model (Post)
+    has 1,  :previous, self,
+        :parent_key => [ :id ],       # in the remote model (Blog)
+        :child_key  => [ :prev_id ]  # local to this model (Post)
+
+
+    belongs_to  :parent, 'AIC', # BUG figure out how to declare AIC
+                :parent_key => [ :id ],       # in the remote model (Blog)
+                :child_key  => [ :aic_id ],  # local to this model (Post)
+                :required   => true
+
+
+
+    def initialize_statemachine
+      if @statemachine.blank?
+        parser = StatemachineParser.new(self)
+        @statemachine = parser.build_from_scxml "#{File.dirname(__FILE__)}/aio.scxml"
+=begin
+@statemachine = Statemachine.build do
+
+          superstate :AIO do
+            trans :initialized,:organize, :organized
+            trans :organized, :present, :presenting
+            trans :organized, :suspend, :suspended
+            trans :suspended,:present, :presenting
+            trans :suspended, :organize, :organized
+            state :suspended do
+               on_entry :sync_cio_to_hidden
+              end
+
+            superstate :presenting do
+              on_entry :inform_parent_presenting
+              event :suspend, :suspended
+              state :defocused do
+                on_entry :sync_cio_to_displayed
+              end
+              state :focused do
+                on_entry :sync_cio_to_highlighted
+              end
+              trans :defocused,:focus,:focused
+              trans :focused,:defocus, :defocused
+              trans :focused, :next, :defocused, :focus_next,  Proc.new { exists_next}
+              trans :focused, :prev, :defocused, :focus_previous, Proc.new { exists_prev}
+              trans :focused, :parent, :defocused, :focus_parent
+
+            end
+          end
+        end
+=end
+        @statemachine.reset
+        #else
+        #@statemachine.reset
+      end
+    end
+
+    # hook to inform parent about presenting state
+    def inform_parent_presenting
+      self.parent.child_to_presenting(self) if (self.parent)
+      true
+    end
+
+    def sync_event(event)
+      process_event(event, AIO_sync_callback.new)
+    end
+
+    # callbacks
+
+    def exists_next
+      self.next!=nil
+    end
+
+    def exists_prev
+      self.previous!=nil
+    end
+
+    def focus_next
+      if (self.next)
+        if self.next.process_event("focus")
+          return true
+        else
+          puts "ERRROR #{self.next.name} could not execute focus event"
+          return false
+        end
+      else
+        puts "WARNING!! > no next element found!"
+        return false
+      end
+    end
+
+    def focus_previous
+      if (self.previous)
+        self.previous.process_event("focus")
+      else
+        return false # TODO not working, find abbruchbedingung!!!
+      end
+    end
+
+    def focus_parent
+      if (self.parent)
+        self.parent.process_event("focus")
+      else
+        return false # TODO not working, find abbruchbedingung!!!
+      end
+    end
+
+    def sync_cio_to_highlighted
+      cio =  MINT::CIO.first(:name=>self.name)
+      if (cio and not cio.is_in? :highlighted)
+        cio.sync_event(:highlight)
+        # cio.states=[:highlighted]
+      end
+      true
+    end
+
+    def sync_cio_to_displayed
+      cio =  MINT::CIO.first(:name=>self.name)
+      if (cio and not cio.is_in? :displayed)
+        if (cio.is_in? :suspended or cio.is_in? :positioned)
+          cio.sync_event(:display)
+        else
+          cio.sync_event(:unhighlight)
+        end
+        #cio.states=[:displayed]
+      end
+      true
+    end
+
+    def sync_cio_to_hidden
+      cio =  MINT::CIO.first(:name=>self.name)
+      if (cio and not cio.is_in? :hidden)
+        cio.sync_event(:hide)
+        end
+      true
+    end
+  end
+
+
+   class AIO_sync_callback
+    def sync_cio_to_highlighted
+      true
+    end
+
+    def sync_cio_to_displayed
+      true
+    end
+
+    def sync_cio_to_suspended
+      true
+    end
+    def inform_parent_presenting
+          true
+        end
+    def present_first_child
+      true
+    end
+
+     def present_children
+       true
+     end
+  end
+end

data/lib/MINT-core/model/aui/AIOUTDiscrete.rb

@@ -0,0 +1,43 @@
+module MINT
+
+  class AIOUTDiscrete < AIOUT
+    def initialize_statemachine
+      if @statemachine.blank?
+        @statemachine = Statemachine.build do
+          trans :initialized,:organize, :organized
+          trans :organized, :present, :p
+          trans :suspended,:present, :p, :present_children
+          state :suspended do
+            on_entry :sync_cio_to_hidden
+          end
+
+          superstate :p_t do     # TODO artificial superstate required to get following event working!
+            event :suspend, :suspended, :hide_children
+            parallel :p do
+              statemachine :s1 do
+                superstate :presenting do
+                  state :defocused do
+                    on_entry :sync_cio_to_displayed
+                  end
+                  state :focused do
+                    on_entry :sync_cio_to_highlighted
+                  end
+                  trans :defocused,:focus,:focused
+                  trans :focused, :defocus, :defocused
+                  trans :focused, :next, :defocused, :focus_next,  Proc.new { exists_next}
+                  trans :focused, :prev, :defocused, :focus_previous, Proc.new { exists_prev}
+                  trans :focused, :parent, :defocused, :focus_parent
+                end
+              end
+              statemachine :s2 do
+                superstate :l do
+                  trans :listing, :update, :listing, :sync_cio_to_updated
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/MINT-core/model/aui/AISingleChoice.rb

@@ -0,0 +1,9 @@
+module MINT
+  class AISingleChoice < AIChoice
+
+  end
+
+  class ARContainer < AISingleChoice
+
+  end
+end

data/lib/MINT-core/model/aui/AISingleChoiceElement.rb

@@ -0,0 +1,69 @@
+module MINT
+  class AISingleChoiceElement < AIINChoose
+    def initialize_statemachine
+      p "enter init"
+      if @statemachine.blank?
+        parser = StatemachineParser.new(self)
+                          p "after parsing"
+#        @statemachine = parser.build_from_scxml "#{File.dirname(__FILE__)}/aisinglechoiceelement.scxml"
+        @statemachine = Statemachine.build do
+
+#          superstate :AIO do # TODO not supported so far!
+          trans :initialized,:organize, :organized
+          trans :organized, :present, :p_t
+          trans :organized, :suspend, :suspended
+          trans :suspended, :present, :p_t
+          trans :suspended, :organize, :organized
+          state :suspended do
+            on_entry :sync_cio_to_hidden
+          end
+
+          superstate :p_t do
+            event :suspend, :suspended
+            parallel :p do
+              statemachine :s1 do
+                superstate :presenting do
+                  state :defocused do
+                    on_entry :sync_cio_to_displayed
+                  end
+                  state :focused do
+                    on_entry :sync_cio_to_highlighted
+                  end
+                  trans :defocused,:focus,:focused
+                  trans :focused, :defocus, :defocused
+                  trans :focused, :next, :defocused, :focus_next,  Proc.new { exists_next}
+                  trans :focused, :prev, :defocused, :focus_previous, Proc.new { exists_prev}
+                  trans :focused, :parent, :defocused, :focus_parent
+                  trans :focused, :drag, :dragging, :choose
+                  trans :dragging, :drop, :defocused
+                end
+              end
+              statemachine :s2 do
+                superstate :selection_H do
+                  state :unchosen do
+                    on_entry :sync_cio_to_listed
+                    event :choose, :chosen
+                  end
+                  state :chosen do
+                    on_entry [:sync_cio_to_selected,:unchoose_others]
+                    event :unchoose, :unchosen
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    def remove_from_origin
+        self.parent.childs.get(self.id).destroy
+    end
+
+    def choose
+      if self.is_in? :unchosen
+        self.process_event(:choose)
+      end
+    end
+
+  end
+end

data/lib/MINT-core/model/aui/AISinglePresence.rb

@@ -0,0 +1,100 @@
+module MINT
+  class AISinglePresence < AIC
+    def initialize_statemachine
+      if @statemachine.blank?
+        parser = StatemachineParser.new(self)
+        @statemachine = parser.build_from_scxml "#{File.dirname(__FILE__)}/aisinglepresence.scxml"
+=begin
+@statemachine = Statemachine.build do
+          trans :initialized,:organize, :organized
+          trans :organized, :present, :presenting
+          trans :suspended, :present, :presenting
+          state :suspended do
+            on_entry [:sync_cio_to_hidden]
+          end
+
+          superstate :presenting do
+            on_entry :present_first_child
+            on_exit :hide_children
+            event :suspend, :suspended
+
+            state :defocused do
+              on_entry :sync_cio_to_displayed
+              event :focus, :focused
+            end
+            superstate :focused do
+              event :defocus, :defocused
+              state :waiting do
+                on_entry :sync_cio_to_highlighted
+                event :enter, :entered
+                event :next, :defocused, :focus_next,  Proc.new { exists_next}
+                event :prev, :defocused, :focus_previous, Proc.new { exists_prev}
+                event :parent, :defocused, :focus_parent
+              end
+              state :entered do
+                event :leave, :waiting
+                event :next, :entered, :present_next_child,  Proc.new { exists_next_child}
+                event :prev, :entered, :present_previous_child, Proc.new { exists_prev_child}
+              end
+
+            end
+          end
+        end
+=end
+      end
+    end
+
+    # hook that is called from a child if it enters presenting state
+    def child_to_presenting(child)
+      childs.all.each do |e|
+        e.process_event(:suspend) if e.id != child.id and not e.is_in? :suspended
+        end
+    end
+
+    def present_first_child
+      childs[0].process_event :present
+    end
+
+    def present_next_child
+      active = false
+      childs.each do |c|
+        if active
+          c.process_event(:present)
+          active = false
+        else
+          active = true if c.states!=[:suspended]
+        end
+      end
+    end
+
+    def present_previous_child
+      active = false
+      childs.reverse_each do |c|
+        if active
+          c.process_event(:present)
+          active = false
+        else
+          active = true if c.states!=[:suspended]
+        end
+      end
+    end
+
+    def add_element
+      f = AISingleChoiceElement.first(:new_states=> /#{Regexp.quote("dragging")}/)
+      self.childs << f
+      self.childs.save
+      f.process_event(:drop)
+      f.destroy
+    end
+
+    def exists_next_child
+      self.childs.next!=nil
+    end
+
+    def exists_prev_child
+      self.childs.previous!=nil
+    end
+
+  end
+
+end