cura 0.0.1

data/lib/cura/event/click.rb

@@ -0,0 +1,14 @@
+if Kernel.respond_to?(:require)
+  require "cura/event/base"
+end
+
+module Cura
+  module Event
+    
+    # Dispatched when a component is clicked.
+    class Click < Base
+      
+    end
+    
+  end
+end

data/lib/cura/event/dispatcher.rb

@@ -0,0 +1,122 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_initialize"
+  require "cura/attributes/has_attributes"
+  require "cura/attributes/has_application"
+  require "cura/attributes/has_events"
+  
+  require "cura/event/base"
+  
+  require "cura/error/invalid_middleware"
+end
+
+module Cura
+  module Event
+    
+    # Polls or peeks for events since the last execution and dispatches them to the appropriate component.
+    class Dispatcher
+      
+      include Attributes::HasInitialize
+      include Attributes::HasAttributes
+      include Attributes::HasApplication
+      
+      def initialize(attributes={})
+        super
+        
+        raise ArgumentError, "application must be set" if @application.nil?
+        
+        @wait_time = 100
+        @target = @application if @target.nil?
+        @middleware = []
+      end
+      
+      # @method wait_time
+      # Get the time to wait for events in milliseconds in the run loop.
+      #
+      # @return [Integer]
+      
+      # @method wait_time=(value)
+      # Set the time to wait for events in milliseconds in the run loop.
+      # Set to 0 to wait forever (poll instead of peek).
+      #
+      # @param [#to_i] value
+      # @return [Integer]
+      
+      attribute(:wait_time) do |value|
+        value = value.to_i
+        value = 0 if value < 0
+        
+        value
+      end
+      
+      # @method target
+      # Get the object with an event handler to dispatch events to.
+      #
+      # @return [Cura::Attributes::HasEvents]
+      attr_reader :target # TODO: use .attribute() { |value| ... }
+      
+      # @method target=(value)
+      # Set the object with an event handler to dispatch events to.
+      # Setting to nil will automatially set the target to the application.
+      #
+      # @param [nil, Cura::Attributes::HasEvents] value
+      # @return [Cura::Attributes::HasEvents]
+      def target=(value)
+        raise TypeError, "target must be a Cura::Attributes::HasEvents or nil" unless value.nil? || value.is_a?(Attributes::HasEvents)
+        
+        dispatch_event(:unfocus)
+        @target = value.nil? ? @application : value
+        dispatch_event(:focus)
+        
+        value
+      end
+      
+      # The middleware stack which an event will pass through before being dispatched.
+      # Middleware must be an object responding to #call.
+      #
+      # @return [Array]
+      attr_reader :middleware
+      
+      # Poll or peek for events and dispatch it if one was found.
+      #
+      # @return [Event::Dispatcher]
+      def run
+        event = @wait_time == 0 ? poll : peek(@wait_time)
+        
+        dispatch_event(event) unless event.nil?
+      end
+      
+      # Wait forever for an event.
+      #
+      # @return [Event::Base]
+      def poll
+        @application.adapter.poll_event
+      end
+      
+      # Wait a set amount of time for an event.
+      #
+      # @param [#to_i] milliseconds The amount of time to wait in milliseconds.
+      # @return [nil, Event::Base] The event, if handled.
+      def peek(milliseconds=100)
+        @application.adapter.peek_event(milliseconds.to_i)
+      end
+      
+      # Dispatch an event to the target or application, if the target is nil.
+      #
+      # @param [#to_sym] event The name of the event class to create an instance of or an event instance.
+      # @param [#to_hash, #to_h] options The options to pass through the middleware.
+      # @return [Event::Base] The dispatched event.
+      def dispatch_event(event, options={})
+        event = Event.new_from_name(event, options) if event.respond_to?(:to_sym)
+        raise TypeError, "event must be an Event::Base" unless event.is_a?(Event::Base)
+        
+        options = { dispatcher: self, event: event, dispatch_queue: [] }.merge(options.to_h)
+        
+        @middleware.each { |middleware| middleware.call(options) }
+        
+        options[:dispatch_queue].each(&:dispatch)
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/event/focus.rb

@@ -0,0 +1,14 @@
+if Kernel.respond_to?(:require)
+  require "cura/event/base"
+end
+
+module Cura
+  module Event
+    
+    # Dispatched when a component is focused.
+    class Focus < Base
+      
+    end
+    
+  end
+end

data/lib/cura/event/handler.rb

@@ -0,0 +1,74 @@
+if Kernel.respond_to?(:require)
+  require "cura/attributes/has_events"
+end
+
+module Cura
+  module Event
+    
+    # The event handler.
+    # Each {Cura::Component} as well as several other class's instances have an instance of this handler. 
+    # The handler can have multiple callbacks defined for an arbitrary event name.
+    class Handler
+      
+      # @param [Cura::Attributes::HasEvents] host The object this handler is attached to.
+      def initialize(host)
+        raise TypeError, "host must be a Cura::Attributes::HasEvents" unless host.is_a?(Cura::Attributes::HasEvents)
+        
+        @host = host
+        @callbacks = { default: [] }
+      end
+      
+      # Get the object this handler is attached to.
+      # 
+      # @return [Object]
+      attr_reader :host
+      
+      # The callbacks defined on this handler.
+      # Key is the event name and the value is an Array of Proc instances.
+      # 
+      # @return [Hash<Symbol,Array>]
+      attr_reader :callbacks
+      
+      # Add a callback to the event chain.
+      # The first registered callback will be the first one called (FIFO).
+      # If no event_name is given, the callback is registered to the `:default` name, which are called before all others.
+      def register(event_name=:default, *arguments, &block)
+        (@callbacks[event_name] ||= []) << { block: block, arguments: arguments }
+      end
+      
+      # Run all callbacks registered on this instance for the given event.
+      # The event object is given as a block argument to the callbacks.
+      # TODO: These should be able to break the callback chain by returning false in the callback (which would also break the delegation chain).
+      # TODO: The event should be delegated to the host's #parent if there are no callbacks registered for it, if it responds to #parent, and it's not nil.
+      def handle(event)
+        callbacks = @callbacks[:default] + @callbacks[event.class.name].to_a
+        
+        chain_broken = false
+        callbacks.each do |callback|
+          
+          result = host.instance_exec(event, *callback[:arguments], &callback[:block])
+          
+          # TODO: Optional event consumption
+          if result == false
+            # chain_broken = true # TODO TODO TODO TODO TODO 
+            
+            break
+          end
+          
+        end
+        
+        delegate_event(event) unless chain_broken
+      end
+      
+      protected
+      
+      # Propagate the event to the host's applicable #parent or #application.
+      # TODO: Why is the handler responsible for propagation? Should the component or a Event::Propagator be responsible?
+      def delegate_event(event)
+        host.parent.event_handler.handle(event) if host.respond_to?(:parent) && host.parent.respond_to?(:event_handler)
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/event/key_down.rb

@@ -0,0 +1,68 @@
+if Kernel.respond_to?(:require)
+  require "cura/event/base"
+end
+
+module Cura
+  module Event
+    
+    # Dispatched when a key's state changes from up to down.
+    class KeyDown < Base
+      
+      def initialize(attributes={})
+        @control = false
+        
+        super
+        
+        raise ArgumentError, "name must be set" if @name.nil?
+      end
+      
+      # Get whether the key was pressed while holding the control key.
+      #
+      # @return [Boolean]
+      def control?
+        @control
+      end
+      
+      # Get the key name.
+      #
+      # @return [Integer]
+      attr_reader :name
+      
+      # Get whether the key is printable.
+      #
+      # @return [Boolean]
+      def printable?
+        return false if @control
+        
+        Key.name_is_printable?(@name)
+      end
+      
+      # Get the printable character for the key.
+      #
+      # @return [nil, String]
+      def character
+        Key.character_from_name(@name)
+      end
+      
+      protected
+      
+      # Set if the key was pressed while holding the control key.
+      #
+      # @param [Boolean] value
+      # @return [Boolean]
+      def control=(value)
+        @control = !!value
+      end
+      
+      # Set the key name.
+      #
+      # @param [#to_sym] value
+      # @return [String]
+      def name=(value)
+        @name = value.to_sym
+      end
+      
+    end
+    
+  end
+end

data/lib/cura/event/middleware/aimer/base.rb

@@ -0,0 +1,38 @@
+if Kernel.respond_to?(:require)
+  require "cura/event/middleware/base"
+end
+
+module Cura
+  module Event
+    module Middleware
+      module Aimer
+        
+        # The base class for event middleware which set's a target, if needed.
+        class Base
+          
+          # Call this middleware.
+          #
+          # @param [#to_h] options
+          # @option options [Event::Dispatcher] :dispatcher
+          # @option options [Event::Base] :event
+          # @option options [Attributes::HasEvents] :target The optional target of the event.
+          def call(options={})
+            set_target(options) if should_aim?(options)
+          end
+          
+          protected
+          
+          def should_aim?(options={})
+            options[:event].target.nil?
+          end
+          
+          def set_target(_options={})
+            # Does nothing on purpose
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

data/lib/cura/event/middleware/aimer/dispatcher_target.rb

@@ -0,0 +1,24 @@
+if Kernel.respond_to?(:require)
+  require "cura/event/middleware/aimer/base"
+end
+
+module Cura
+  module Event
+    module Middleware
+      module Aimer
+        
+        # Sets the event's target to the dispatcher's target, if it isn't already set.
+        class DispatcherTarget < Base
+          
+          protected
+          
+          def set_target(options={})
+            options[:event].target ||= options[:dispatcher].target
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

data/lib/cura/event/middleware/aimer/mouse_focus.rb

@@ -0,0 +1,48 @@
+if Kernel.respond_to?(:require)
+  require "cura/event/mouse_button"
+  
+  require "cura/event/middleware/aimer/base"
+end
+
+module Cura
+  module Event
+    module Middleware
+      module Aimer
+        
+        # Sets the dispatcher's target to the component underneath the cursor on mouse button events.
+        class MouseFocus < Base
+          
+          protected
+          
+          def should_aim?(options={})
+            options[:event].is_a?(Event::MouseButton) && options[:event].down?
+          end
+          
+          def set_target(options={})
+            component = nearest_focusable_ancestor(top_most_component_at(options))
+            
+            options[:dispatcher].target = component unless options[:dispatcher].target == component
+          end
+          
+          # TODO: Some kind of hit tester class that initializes with a Window to get it's root element and determines
+          #       if a set of coordinates are within the bounds of which component in the view tree.
+          def top_most_component_at(options={})
+            # TODO: Focused window? Or some way of determining which window so use top_most_component_at with
+            window = options[:dispatcher].application.windows.first # TODO: Should be getting the screen coordinates from the event, not relevent to the window
+            window.children(true).reverse.find { |child| child.contains_coordinates?(x: options[:event].x, y: options[:event].y) }
+          end
+          
+          def nearest_focusable_ancestor(component)
+            return nil unless component.respond_to?(:focusable?)
+            return component if component.focusable?
+            return nil unless component.respond_to?(:parent)
+            
+            nearest_focusable_ancestor(component.parent)
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

data/lib/cura/event/middleware/aimer/target_option.rb

@@ -0,0 +1,38 @@
+if Kernel.respond_to?(:require)
+  require "cura/event/middleware/aimer/base"
+end
+
+module Cura
+  module Event
+    module Middleware
+      module Aimer
+        
+        # Sets the event's target to the component passed by an optional :target option.
+        class TargetOption < Base
+          
+          # Call this middleware.
+          #
+          # @param [#to_h] options
+          # @option options [Event::Dispatcher] :dispatcher
+          # @option options [Event::Base] :event
+          # @option options [Attributes::HasEvents] :target The optional target of the event.
+          def call(options={})
+            super # Only here for documentation
+          end
+          
+          protected
+          
+          def should_aim?(options={})
+            options.key?(:target)
+          end
+          
+          def set_target(options={})
+            options[:event].target = options[:target]
+          end
+          
+        end
+        
+      end
+    end
+  end
+end