kredki 0.1.0

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

@@ -0,0 +1,140 @@
+module Kredki
+  module Pads
+    # Item group member.
+    class Item < RectanglePad
+
+      # Get whether is pressed.
+      def pressed keyboard_in = nil
+        keyboard_in = self.keyboard_in if keyboard_in.nil?
+        pin_top :primary or (
+          keyboard_in and (
+            Kredki.keyboard.pressed? :space or
+            Kredki.keyboard.pressed? :enter
+          )
+        )
+      end
+
+      # 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
+
+      # Create and attach select event reaction.
+      def on_select ...
+        on(SelectEvent, ...)
+      end
+
+      # See #on_select.
+      def on_select= param
+        on_select do: param
+      end
+
+      # Set a feature recognized by its class.
+      def << feature
+        case feature
+        when String
+          find(TextPad)&.set feature or default_text feature
+          self.subject ||= feature
+          self
+        else
+          super
+        end
+      end
+      
+      # :section: LEVEL 2
+
+      class SelectEvent < Event
+        def param
+          target.subject
+        end
+      end
+
+      def sketch
+        super
+
+        set_keyboardy true
+        set_layout :xsc
+        set_suit :gray
+        set_size Fit, 24
+        set_margin_x 4
+      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
+          set opacity: 3/4r
+          area.set fill: color
+        else
+          set opacity: 1r
+          area.set fill: pin_in ? color.darken : keyboard_in ? color.lighten : color
+        end
+      end
+
+      def behavior
+        super
+
+        on_mouse_click :primary do |e|
+          report_selected e
+        end
+
+        behavior_on_key
+
+        on_select do |e|
+          e.close if in_disabled
+        end
+      end
+
+      def behavior_on_key
+        on_key :space, :enter do |e|
+          report_selected e
+          e.close
+        end
+      end
+
+      def report_selected e
+        report SelectEvent.new(e), lower_iterator.to_a.reverse
+      end
+
+      def mouse_enter e
+        lower&.mouse_enter self
+      end
+
+      def min_size_x
+        fit_size_x
+      end
+
+      def default_text text
+        put TextPad, text, mousy: false
+      end
+    end#Item
+  end#Pads
+end#Kredki

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

@@ -0,0 +1,44 @@
+require_relative 'item_y'
+
+module Kredki
+  module Pads
+    # Group of items.
+    class ItemGroup < Service
+
+      # Add new item.
+      def item!(...)
+        put(ItemY, __method__, ...)
+      end
+      
+      # :section: LEVEL 2
+
+      def mouse_enter pad
+        pad.keyboard_request if find_upper(Item){|it| it.keyboard_in } != pad
+      end
+
+      def focus_next
+        items = each(Item).to_a 
+        index = items.index{|it| it.keyboard_in } || -1
+        return items[index] if index >= items.length - 1
+        item = (index + 1..items.length - 1).lazy.map{|i| items[i] }.find{|it| !it.in_disabled }
+        return items[index] if !item
+        focus item
+      end
+
+      def focus_previous
+        items = each(Item).to_a 
+        index = items.index{|it| it.keyboard_in } || 1
+        return items[index] if index <= 0
+        item = (0..index - 1).lazy.map{|i| items[index - 1 - i]}.find{|it| !it.in_disabled }
+        return items[index] if !item
+        focus item
+      end
+
+      def focus item
+        item&.keyboard_request
+        item
+      end
+
+    end#ItemGroup
+  end#Pads
+end

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

@@ -0,0 +1,22 @@
+module Kredki
+  module Pads
+    # Part of X axis aligned item group.
+    class ItemX < Item
+      # :section: LEVEL 2
+
+      def behavior
+        super
+
+        on_key_press :left do |e|
+          lower.focus_previous&.request_vision
+          e.close
+        end
+
+        on_key_press :right do |e|
+          lower.focus_next&.request_vision
+          e.close
+        end
+      end
+    end#ItemX
+  end#Pads
+end#Kredki

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

@@ -0,0 +1,31 @@
+require_relative 'item'
+
+module Kredki
+  module Pads
+    # Part of Y axis aligned item group.
+    class ItemY < Item
+      
+      # :section: LEVEL 2
+
+      def behavior
+        super
+
+        on_key_press :up do |e|
+          item = lower.focus_previous
+          if item
+            item.request_vision
+            e.close
+          end
+        end
+
+        on_key_press :down do |e|
+          item = lower.focus_next
+          if item
+            item.request_vision
+            e.close
+          end
+        end
+      end
+    end#ItemY
+  end#Pads
+end#Kredki

data/lib/kredki/pads/label.rb

@@ -0,0 +1,71 @@
+require_relative 'text/navigable_text_pad'
+require_relative 'portal_layer'
+
+module Kredki
+  module Pads
+    # Control with text transfering mouse events to related pad.
+    class Label < Pad
+
+      # Set selector for mouse events target.
+      def set_for new_for = @for
+        return send_bundle :set_for, yield(self.for) if block_given?
+        return if @for == new_for
+        @for = new_for
+        true
+      end
+
+      # See #set_for.
+      def for= param
+        send_bundle :set_for, param
+      end
+
+      # Get selector for mouse events target.
+      def for
+        @for
+      end
+
+      # Set a feature recognized by its class.
+      def << feature
+        case feature
+        when String
+          text?&.set feature or super
+          self.subject ||= feature
+        else
+          super
+        end
+      end
+      
+      # :section: LEVEL 2
+
+      def sketch
+        super
+
+        set_size Fit, 24
+        set_for proc{|it| it.lower_pad&.find{|it| it.keyboardy } }
+        set_keyboardy false
+        area.set_fill false
+      end
+
+      def for_pad
+        @for.call self
+      end
+
+      def behavior
+        super
+
+        on_mouse_enter do |event|
+          @portal_layer = pane.put PortalLayer
+          @portal_layer.entry = self
+          @portal_layer.exit = for_pad
+        end
+      end
+
+      def default_text text
+        put NavigableTextPad, :text!, text, size_y: 1r do
+          cursor.size_x = 0
+          set_mousy false
+        end
+      end
+    end
+  end
+end

data/lib/kredki/pads/layer.rb

@@ -0,0 +1,326 @@
+module Kredki
+  module Pads
+    # The Kredki::Pads::Pane child. Layers form a layer stack. Pads from higher layers are processed before pads from lower ones.
+    class Layer < RectanglePad
+
+      # Get repeated click counter value. The counter is reset when the next click occurs after a specified time interval, 
+      # or the click target is a different pad, or the click location is beyond a specified distance limit from the previous one.
+      def mouse_click_combo event = nil
+        return 0 if !@click_data
+        if !event || (
+          @click_data.pad == event.target && 
+          !event.target.drag_check(@click_data.xy, event.xy) && 
+          event.timestamp - @click_data.timestamp < 200000000
+        )
+        then
+          return @click_data.combo
+        end
+        return 0
+      end
+
+      # Detach from pane.
+      def detach transfer = false
+        unless transfer
+          update_keyboard_pad nil
+          @pin_data = nil
+          @click_data = nil
+        end
+        super
+      end
+
+      # Enable carry focus on tab event resolver.
+      def carry_focus_on_tab
+        on_key_press :tab do |event|
+          next_pad = layer.keyboard_pad&.then do |p0|
+            upper_pad_iterator(reverse: event.shift?, deep: true)
+              .lazy
+              .drop_while{|p1| p0 != p1 }
+              .drop(1)
+              .filter{|it| it.keyboardy && !it.in_disabled && it.displayed }
+              .first
+          end || upper_pad_iterator(reverse: event.shift?, deep: true)
+            .lazy
+            .filter{|it| it.keyboardy && !it.in_disabled && it.displayed }
+            .first
+          next_pad&.keyboard_request
+        end
+      end
+
+      # :section: LEVEL 2
+
+      class PinData
+        
+        def initialize pad, xy, button, drag
+          @pad = pad
+          @xy = xy
+          @button = button
+          @drag = drag
+        end
+
+        attr_accessor :pad
+        attr_accessor :xy
+        attr_accessor :button
+        attr_accessor :drag
+
+      end
+
+      class ClickData
+
+        def initialize pad, xy, timestamp, combo
+          @pad = pad
+          @xy = xy
+          @timestamp = timestamp
+          @combo = combo
+        end
+
+        attr_accessor :pad
+        attr_accessor :xy
+        attr_accessor :timestamp
+        attr_accessor :combo
+      end
+
+      def initialize
+        super
+        
+        @pin_data = nil
+        @keyboard_pads = []
+        @mouse_pads = []
+        @click_data = nil
+        @sketched = false
+      end
+
+      def sketch_service
+        return if @sketched
+        @sketched = true
+        super
+      end
+
+      def sketch
+        super
+
+        set_keyboardy
+        set_fill false
+      end
+
+      def behavior
+        super
+        
+        on_key_press early: true do |e|
+          @pressed_keys[e.param || e.code] = true
+        end
+
+        on_key_release early: true do |e|
+          if @pressed_keys[e.param || e.code]
+            @pressed_keys[e.param || e.code] = false
+            keyboard_event KeyClickEvent.new e
+          end
+        end
+
+        on_mouse_click early: true, do: method(:mouse_click)
+      end
+
+      def break_layout
+        @layout_broken = true
+      end
+
+      def arrange
+        return unless @layout_broken
+        update_margin
+        @pads_layout.arrange self
+        @layout_broken = false
+        true
+      end
+
+      def keyboard_pad
+        @keyboard_pads.last
+      end
+
+      def keyboard_event event
+        if !event.closed? && displayed && (kp = keyboard_pad)
+          event.target = kp
+          kp.report event
+        end
+      end
+
+      def update_keyboard_pad keyboard_pad = self
+        if !keyboard_pad
+          @keyboard_pads.each{|pad| pad.report FocusLeaveEvent.new, false }
+          @keyboard_pads = []
+        else
+          keyboard_pads = keyboard_pad.lower_pad_iterator.to_a.reverse
+          enter, no_change, leave = *Util.polarize(keyboard_pads, @keyboard_pads)
+          @keyboard_pads = keyboard_pads
+          leave.reverse_each{|it| it.report FocusLeaveEvent.new, false }
+          enter.reverse_each{|it| it.report FocusEnterEvent.new, false }
+        end
+        @pressed_keys = {}
+        true
+      end
+
+      def check_key_pressed key
+        !!@pressed_keys[key]
+      end
+
+      def joystick_event event
+        if !event.closed?
+          report event
+        end
+      end
+
+      def mouse_pad
+        @pin_data&.pad || @mouse_pads.last
+      end
+
+      def mouse_event e
+        if e.is_a? MouseButtonReleaseEvent
+          layer_mouse_release e
+        else
+          mouse_pad&.report e
+        end
+        e
+      end
+
+      def update_mouse_location event
+        xy = event.xy
+
+        if @pin_data
+          drag = @pin_data.drag || ((@pin_data.drag = layer_drag_check xy) && :start)
+          if drag
+            event = MousePointerDragEvent.new nil, event
+            event.button = @pin_data.button
+            event.start = true if drag == :start
+          end
+          @pin_data.pad.report event
+          return event
+        end
+
+        arrange
+        @mouse_pads, last_mouse_pads = [], @mouse_pads
+        point_pads *xy, @mouse_pads
+        enter, stay, leave = *Util.polarize(@mouse_pads, last_mouse_pads)
+        leave.reverse_each{|it| it.report MousePointerLeaveEvent.new(event), false }
+        enter.reverse_each{|it| it.report MousePointerEnterEvent.new(event), false }
+
+        @mouse_pads.last&.report event
+        event
+      end
+
+      def layer_mouse_release event
+        xy = event.xy
+
+        arrange
+        @mouse_pads, last_mouse_pads = [], @mouse_pads
+        point_pads *xy, @mouse_pads
+        enter, stay, leave = *Util.polarize(@mouse_pads, last_mouse_pads)
+        leave.reverse_each{|it| it.report MousePointerLeaveEvent.new(event), false }
+        enter.reverse_each{|it| it.report MousePointerEnterEvent.new(event), false }
+
+        if @pin_data
+          event.drag = @pin_data.drag
+          @pin_data.pad.report event
+        else
+          @mouse_pads.last&.report event
+        end
+        
+        event
+      end
+
+      def point_pads x, y, pads, force = false
+        if force || (mousy && displayed && include_point(x, y))
+          pads << self
+          x -= @clip_scene.x
+          y -= @clip_scene.y
+          return true if @pads.reverse_each.find{|it| it.point_pads x - it.area_x, y - it.area_y, pads }
+        end
+        return false
+      end
+
+      def clear_mouse_location xy
+        unless @mouse_pads.empty?
+          mouse_pads = @mouse_pads
+          @mouse_pads = []
+          mouse_pads.reverse_each{|it| it.report MousePointerLeaveEvent.new(nil, *xy), false }
+        end
+        @pin_data&.pad&.pin_dispose
+      end
+
+      def layer_mouse_cursor
+        if @pin_data
+          @pin_data.pad.mouse_cursor
+        else
+          @mouse_pads.reverse_each.find{|it| it.mouse_cursor }&.mouse_cursor
+        end
+      end
+
+      def mouse_press e
+        keyboard_request if keyboardy
+        pin_request e.xy, e.button.id
+      end
+
+      def mouse_release e
+        pin_dispose e.button.id
+        if !e.drag && include_point(e.x, e.y)
+          report MouseButtonClickEvent.new e
+        end
+      end
+
+      def mouse_click event
+        combo = mouse_click_combo(event) + 1
+        event.combo = combo
+        @click_data = ClickData.new event.target, event.xy, event.timestamp, combo
+      end
+
+      def layer_check_mouse_in pad
+        mouse_pad&.check_mouse_in pad
+      end
+
+      def pin_pad
+        @pin_data&.pad
+      end
+
+      def pin_xy
+        @pin_data&.xy
+      end
+
+      def pin_button
+        @pin_data&.button
+      end
+
+      def pin_check pad, button, top_only
+        return if button != @pin_data&.button
+        return @pin_data&.pad == pad if top_only
+        @pin_data&.pad&.in_pad pad
+      end
+      
+      def update_pin_pad pad, xy = nil, button = nil, drag = false
+        if pad
+          if !@pin_data || !@pin_data.button || @pin_data.button == button
+            @pin_data = PinData.new pad, xy, button, drag
+          else 
+            return false
+          end
+        else
+          @pin_data = nil
+          xy ||= window.mouse_xy
+          layer.update_mouse_location PositionEvent.new *xy
+        end
+        true
+      end      
+
+      def layer_drag_check xy
+        bxy = @pin_data&.xy and @pin_data.pad.drag_check bxy, xy
+      end
+
+      def update_lower lower, at = nil
+        return if @lower == lower
+        @lower = lower
+      end
+
+      def pad_attach lower, at = nil
+        return if @lower_pad == lower
+        @lower_pad = lower
+        @lower = lower if !@lower
+      end
+    end
+  end
+end

data/lib/kredki/pads/layout/align.rb

@@ -0,0 +1,10 @@
+module Kredki
+  module Pads
+    module Layout
+      # Pad layout where subpads are aligned to some point.
+      class Align
+        include Layout
+      end#Align
+    end#Layout
+  end#Pads
+end#Kredki