kredki 0.1.0

data/lib/kredki/pads/pane.rb

@@ -0,0 +1,267 @@
+require_relative 'service/service_filter'
+
+module Kredki
+  module Pads
+    # Pane of Pads module.
+    class Pane < Kredki::Pane
+      include ServiceFilter
+      
+      # Add new layer.
+      def layer! ...
+        put(Layer, __method__, ...)
+      end
+
+      # Match self with +filter+.
+      def =~ filter
+        case filter
+        when nil
+          true
+        when Module, Proc
+          filter === self
+        when Array
+          filter.all?{|it| self =~ it }
+        when Hash
+          filter.all?{|key, value| respond_to? key and value === send(key) }
+        else
+          raise "Unsupported =~ (#{filter} : #{filter.class})"
+        end
+      end
+
+      # Get lower services iterator - empty because Pane is always the lowest.
+      def lower_iterator include_self = false
+        []
+      end
+
+      class << self
+        attr_accessor :sketch_layer
+
+        # Define custom base layer for this Pane subclass.
+        def layer! &block
+          self.sketch_layer = Class.new Layer
+          sketch_layer.define_method :sketch do
+            super()
+            pane.sketch_layer_block self, &block
+          end
+        end
+      end
+
+      # :section: LEVEL 2
+
+      self.sketch_layer = Layer
+
+      def initialize *a, **ka
+        super()
+        
+        @event_queue = EventQueue.new
+        @services = []
+        @mouse_stale = false
+        @sketch_a = a
+        @sketch_ka = ka
+      end
+
+      def sketch_layer_block layer, &block
+        layer.instance_exec *@sketch_a, **@sketch_ka, &block
+        @sketch_a = @sketch_ka = nil
+      end
+
+      def sketch
+        super
+        
+        put(self.class.sketch_layer).keyboard_request
+      end
+
+      def behavior
+        super
+        on_mouse_move do: method(:mouse_move_event)
+        on_mouse_enter do: method(:mouse_enter_event)
+        on_mouse_leave do: method(:mouse_leave_event)
+        on_mouse_press do: method(:mouse_event)
+        on_mouse_release do: method(:mouse_event)
+        on_mouse_scroll do: method(:mouse_event)
+        on_drop do: method(:mouse_event)
+        on_key_press do: method(:keyboard_event)
+        on_key_release do: method(:keyboard_event)
+        on_text_input do: method(:keyboard_event)
+        on_joystick_press do: method(:joystick_event)
+        on_joystick_release do: method(:joystick_event)
+        on_joystick_move do: method(:joystick_event)
+        on_joystick_switch do: method(:joystick_event)
+      end
+
+      def context_service
+        super
+        @services.last
+      end
+
+      def resize_event event
+        super
+        sx, sy = event.size
+        @services.each do |it|
+          it.update_xy 0, 0
+          it.set_size sx, sy
+          it.update_size sx, sy
+        end
+      end
+
+      attr_accessor :mouse_stale
+
+      def event_queue
+        @event_queue
+      end
+
+      def layer
+        @services.last
+      end
+
+      def lower
+        nil
+      end
+
+      def lower_pad
+        nil
+      end
+
+      def area_size_x
+        window.size[0]
+      end
+
+      def area_size_y
+        window.size[1]
+      end
+
+      def area_size
+        window.size
+      end
+
+      def clip_size_x
+        window.size[0]
+      end
+
+      def clip_size_y
+        window.size[1]
+      end
+
+      def clip_size
+        window.size
+      end
+
+      def tick ms
+        super
+        arrange
+      end
+
+      def arrange
+        update_mouse_location if @services.count(&:arrange) > 0 || @mouse_stale
+      end
+
+      def pad_tree
+        @services.map{|it| [it, it.pad_tree] }.to_h
+      end
+
+      def mouse_event event
+        arrange
+        @services.reverse_each do |layer|
+          event.target = nil
+          event = layer.mouse_event event
+          @event_queue.process
+        end
+      end
+
+      def mouse_move_event event
+        update_mouse_location event
+      end
+
+      def mouse_enter_event event
+        update_mouse_location
+      end
+
+      def mouse_leave_event event
+        update_mouse_location
+      end
+
+      def update_mouse_location event = nil
+        event ||= PositionEvent.new *window.mouse_xy
+        xy = event.xy
+        cursor = nil
+        @services.reverse_each do |layer|
+          if event.closed?
+            layer.clear_mouse_location xy
+          else
+            event = layer.update_mouse_location event
+            cursor ||= layer.layer_mouse_cursor
+          end
+          @event_queue.process
+        end
+        Kredki.mouse.set_cursor cursor
+        @mouse_stale = false
+      end
+
+      def keyboard_event event
+        @services.reverse_each.find do |layer|
+          event.target = nil
+          layer.keyboard_event event
+          @event_queue.process
+          event.closed?
+        end
+      end
+
+      def joystick_event event
+        @services.reverse_each.find do |layer|
+          event.target = nil
+          layer.joystick_event event
+          @event_queue.process
+          event.closed?
+        end
+      end
+
+      def put subject, *a, at: nil, **ka, &b
+        case subject
+        when Class
+          put subject.new, *a, at: at, **ka, &b
+        else
+          layer = subject
+          put_layer layer, at if at != false
+          layer.set *a, **ka, &b
+          layer
+        end
+      end
+
+      def put_layer layer, at = nil
+        layer.pad_attach self, at
+        case at
+        when Integer
+          paint_state = put_paint layer.scene, false
+          @services.insert at, pad
+        when Layer
+          paint_state = put_paint layer.scene, false, at.scene
+          @services.insert @services.index(at), layer
+        else
+          paint_state = put_paint layer.scene, false
+          @services << layer
+        end
+        layer.sketch_service
+        sx, sy = window.size
+        layer.update_xy 0, 0
+        layer.set_size sx, sy
+        layer.update_size sx, sy
+        layer&.break_layout
+        @mouse_stale = true
+        layer
+      end
+
+      def layers
+        @services
+      end
+
+      def delete_upper upper
+        @services.delete upper
+        @mouse_stale = true
+      end
+
+      def delete_pad pad, transfer = false
+        @services.delete pad
+        @mouse_stale = true
+      end
+    end
+  end
+end

data/lib/kredki/pads/portal_layer.rb

@@ -0,0 +1,94 @@
+module Kredki
+  module Pads
+    # A layer which translates all mouse pointer events.
+    class PortalLayer < Layer
+
+      # :section: LEVEL 2
+
+      module PortalMouseEvent
+        def x
+          @x
+        end
+
+        def y
+          @y
+        end
+
+        def xy
+          [@x, @y]
+        end
+
+        def param
+          xy
+        end
+
+        def initialize x, y, ...
+          super(nil, ...)
+          @x = x
+          @y = y
+        end
+      end
+
+      class PortalMousePointerMoveEvent < MousePointerMoveEvent
+        include PortalMouseEvent
+      end
+
+      module PortalMouseButtonEvent
+        include PortalMouseEvent
+    
+        def button
+          @source.button
+        end
+    
+        def code
+          @source.code
+        end
+    
+        def param
+          @source.param
+        end
+      end
+      
+      class PortalMouseButtonPressEvent < MouseButtonPressEvent
+        include PortalMouseButtonEvent
+      end
+      
+      class PortalMouseButtonReleaseEvent < MouseButtonReleaseEvent
+        include PortalMouseButtonEvent
+      end
+    
+      attr_accessor :entry
+      attr_accessor :exit
+
+      def mouse_event event
+        case event
+        when MouseButtonPressEvent
+          PortalMouseButtonPressEvent.new *translated_xy(event.xy), event
+        when MouseButtonReleaseEvent
+          PortalMouseButtonReleaseEvent.new *translated_xy(event.xy), event
+        else
+          event
+        end
+      end
+
+      def translated_xy xy
+        lx, ly = pane.translate *xy, @entry
+        @exit.translate lx * @exit.area_size_x / @entry.area_size_x, ly * @exit.area_size_y / @entry.area_size_y
+      end
+
+      def update_mouse_location event
+        xy = event.xy
+
+        @entry.layer.arrange
+        @mouse_pads, last_mouse_pads = [], @mouse_pads
+        @entry.layer.point_pads *xy, @mouse_pads
+        if @mouse_pads.last != @entry
+          pad_detach
+          return event
+        end
+        PortalMousePointerMoveEvent.new *translated_xy(event.xy), event
+      end
+
+    end
+  end
+end

data/lib/kredki/pads/radio/group.rb

@@ -0,0 +1,45 @@
+require_relative 'item_button'
+require_relative 'item'
+
+module Kredki
+  module Pads
+    module Radio
+      # Group of radio items.
+      class Group < Service
+
+        # Add new radio item.
+        def item! ...
+          put(Item, __method__, ...)
+        end
+
+        # :section: LEVEL 2
+
+        def key event, item_button
+          case event.key.id
+          when :up
+            previous_item_button(item_button).keyboard_request
+            event.close
+          when :down
+            next_item_button(item_button).keyboard_request
+            event.close
+          end
+        end
+
+        def previous_item_button item_button
+          item_buttons = each_upper(ItemButton).to_a
+          item_buttons[item_buttons.index(item_button) - 1]
+        end
+
+        def next_item_button item_button
+          item_buttons = each_upper(ItemButton).to_a
+          item_buttons[(item_buttons.index(item_button) + 1) % item_buttons.size]
+        end
+
+        def update_selected item_button, selected
+          each_upper(ItemButton){|it| it.selected }.each{|it| it.update_selected false } if selected
+          item_button.update_selected selected
+        end
+      end#Group
+    end#Radio
+  end#Pads
+end#Kredki

data/lib/kredki/pads/radio/item.rb

@@ -0,0 +1,69 @@
+module Kredki
+  module Pads
+    module Radio
+      # Radio item.
+      class Item < SpacePad
+
+        # Set whether is selected.
+        def set_selected ...
+          @button.set_selected(...)
+        end
+
+        # See #set_selected.
+        def selected= param
+          @button.selected = param
+        end
+
+        # Get whether is selected.
+        def selected
+          @button.selected
+        end
+
+        # Set a feature recognized by its class.
+        def << feature
+          case feature
+          when String
+            find(Label)&.set feature or default_text feature
+            self.subject ||= feature
+          else
+            super
+          end
+        end
+
+        # :section: LEVEL 2
+
+        def initialize
+          super
+
+          @button = default_item_button
+        end
+
+        def attach lower, at: nil
+          pad_detach
+          pad_attach lower, at: at
+        end
+
+        def sketch
+          super
+
+          set_size_y Fit
+          set_spacer 8
+          set_layout :xsc
+        end
+
+        def repaint event = nil
+          set_opacity in_disabled ? 3/4r : 1r
+        end
+
+        def default_item_button
+          put ItemButton
+        end
+
+        def default_text text
+          put Label, text
+        end
+
+      end
+    end
+  end
+end

data/lib/kredki/pads/radio/item_button.rb

@@ -0,0 +1,143 @@
+module Kredki
+  module Pads
+    module Radio
+      # Radio item button model.
+      class ItemButton < RectanglePad
+
+        # Set suit.
+        def set_suit *suit
+          return send_bundle :set_suit, yield(self.suit) if block_given?
+          suit = Util.uncover suit
+          return if @suit == suit && suit != :random
+          @suit = suit
+          repaint
+          true
+        end
+
+        # See #set_suit.
+        def suit= param
+          send_bundle :set_suit, param
+        end
+
+        # Get suit.
+        def suit
+          @suit
+        end
+        
+        # Set whether is selected.
+        def set_selected value = true
+          return if (c = selected) == (value = block_given? ? yield(c) : value == Not ? !c : value)
+          update_group_selected value
+        end
+
+        # See #set_selected.
+        def selected= param
+          send_bundle :set_selected, param
+        end
+
+        # Get whether is selected.
+        def selected
+          @selected
+        end
+
+        class SelectEvent < Event
+          def initialize value
+            @value = value
+          end
+
+          attr :value
+
+          def param
+            @target.subject
+          end
+        end
+
+        def on_select ...
+          on(SelectEvent, ...)
+        end
+
+        def on_select= param
+          on_select do: param
+        end
+
+        # :section: LEVEL 2
+
+        def initialize
+          super
+          
+          @check = default_check 
+        end
+
+        def sketch
+          super
+
+          set_area @scene.new_ellipse
+          set_keyboardy true
+          set_stroke_width 1
+          set_layout :zcc
+          set_size 16
+          set_margin 3
+          set_suit :gray
+        end
+
+        def presence
+          super
+
+          Event.each(
+            on_focus_enter,
+            on_focus_leave,
+            on_mouse_press,
+            on_mouse_release,
+            on_mouse_enter,
+            on_mouse_leave,
+            do: method(:repaint)
+          )
+        end
+
+        def repaint event = nil
+          color = Kredki.color @suit
+          if in_disabled
+            area.set fill: color
+            area.set stroke_fill: color.darken
+          else
+            area.set fill: pin_top ? color.darken : mouse_in ? color.lighten : color
+            area.set stroke_fill: keyboard_in ? :stroke_focus : color.darken
+          end
+        end
+
+        def behavior
+          super
+
+          Event.each on_mouse_click, on_key(:space, :enter) do |e|
+            report SelectEvent.new true if !selected
+          end
+
+          on_select early: true do |e|
+            e.close if in_disabled || set_selected(e.value).not
+          end
+
+          on_key_press do |e|
+            find_lower(Group).key e, self
+          end
+        end
+
+        def update_group_selected selected
+          find_lower(Group)&.update_selected self, selected or update_selected selected
+        end
+
+        def update_selected selected
+          @selected = selected
+          @check.set_scenic selected
+        end
+
+        def default_check
+          put ShapePad, mousy: false, keyboardy: false, fill: :text, size: 1r do
+            set_area @scene.new_ellipse
+            set_scenic false
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/kredki/pads/service/event_queue.rb

@@ -0,0 +1,79 @@
+module Kredki
+  # Responsible for the order in which events are reported.
+  class EventQueue
+
+    # :section: LEVEL 2
+
+    # The maximum number of reported events in one call, before EventQueue switch to loop safe mode.
+    EVENT_LOOP_SAFE_THRESHOLD = 500
+
+    def initialize
+      @stops = []
+      @stem = false
+      @i = -1
+    end
+
+    def inspect
+      "#{self.class}:#{object_id}"
+    end
+
+    def push event, stop, early = false, instant = false
+      if instant
+        @stops[@i += 1] = [stop, event, early]
+      else
+        @stops << [stop, event, early]
+      end
+      process if !@stem
+    end
+
+    def process
+      stem, @stem = @stem, true
+      (0..).each do |i|
+        @i = i
+        if i > EVENT_LOOP_SAFE_THRESHOLD
+          begin
+            return loop_safe_report i
+          ensure
+            @stops = []
+            @stem = stem
+            @i = -1
+          end
+        end
+        stop = @stops[i]
+        unless stop
+          @stops = []
+          @stem = stem
+          @i = -1
+          return
+        end
+        stop, event, early = *stop
+        stop.report event, early
+      end
+    end
+
+    private
+
+    class EventLoopError < Exception
+    end
+
+    def loop_error range
+      raise EventLoopError.new "#{@stops[range]}"
+    end
+
+    def loop_safe_report start = 0
+      proceed = {}
+      (start..).each do |i|
+        @i = i
+        return unless stop = @stops[i]
+        if j = proceed[stop]
+          loop_error j..i
+        else
+          proceed[stop] = i
+        end
+        stop, event, early = *stop
+        stop.report event, early
+      end
+    end
+
+  end
+end