kredki 0.1.0

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

@@ -0,0 +1,248 @@
+require 'weakref'
+require_relative 'service_event_manager'
+require_relative 'service_inherited'
+require_relative 'service_filter'
+
+module Kredki
+  module Pads
+    # Base class of Pads tree nodes.
+    class Service
+      extend ServiceInherited
+      include ServiceFilter
+
+      # Get lower services.
+      def lower_iterator include_self = true
+        Enumerator.new do |e|
+          c = include_self ? self : lower
+          while c && !c.is(Pane)
+            e << c
+            c = c.lower
+          end
+        end
+      end
+
+      # Get service layer.
+      def layer
+        is Layer or find_lower Layer
+      end
+
+      # Get service pane.
+      def pane
+        layer&.lower_pad
+      end
+
+      # Get service window.
+      def window
+        pane&.window
+      end
+
+      # Get service application.
+      def app
+        window&.app
+      end
+
+      # Get whether +lower+ is lower service of +self+.
+      def in? lower
+        lower_iterator(false).include? lower
+      end
+
+      # Get whether +upper+ is upper service of +self+.
+      def include? upper
+        upper.in? self
+      end
+     
+      # Get lower service.
+      def lower
+        @lower
+      end
+
+      # Attach self to +lower+ service.
+      def attach lower, at: nil
+        raise "service loop detected" if find_lower self
+        detach true if @lower
+        lower&.put_service self, at: at
+      end
+
+      # Detach self.
+      def detach transfer = false
+        @lower&.delete_upper self
+        @lower = nil
+      end
+
+      def on event_type, early: false, always: false, do: nil, &block
+        @event_manager.manager event_type, block || binding.local_variable_get(:do), early, always
+      end
+
+      # Match self with +filter+.
+      def =~ filter
+        case filter
+        when nil
+          true
+        when Symbol
+          if filter.end_with? "?"
+            respond_to? filter and send filter
+          else
+            !!@tags[filter]
+          end
+        when Service
+          filter == self
+        when Module, Proc
+          filter === self
+        when Integer
+          pad_index == filter
+        when WeakRef
+          self =~ filter.__getobj__
+        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
+
+      # Set whether Pad is tagged with +tag+.
+      def set_tag tag, value = true
+        return if (c = self.tag tag) == (value = block_given? ? yield(c) : value == Not ? !c : value)
+        if value
+          @tags[tag] = true
+        else
+          @tags.delete tag
+        end
+        true
+      end
+
+      # See #set_tag.
+      def tag= param
+        send_bundle :set_tag, param
+      end
+
+      # Get whether Pad is tagged with +tag+.
+      def tag tag
+        @tags[tag]
+      end
+
+      # Get tags.
+      def tags
+        @tags.keys
+      end
+
+      # Create new job tree.
+      def job run = true, &block
+        job = AfterJob.new block, 0
+        job.run pane if run
+        job
+      end
+
+      # Set a feature recognized by its class.
+      def << feature
+        case feature
+        when Symbol
+          set_tag feature
+          # eval "#{feature} = WeakRef.new self" if feature.start_with? "$"
+          # lower&.instance_variable_set feature, self if feature.start_with? "@"
+        when Hash
+          set **feature
+        when Array
+          set *feature
+        when Proc
+          set &feature
+        else
+          raise "Unsupported << (#{feature} : #{feature.class})"
+        end
+        self
+      end
+
+      # :section: LEVEL 2
+
+      def initialize
+        super
+        @lower = nil
+        @tags = {}
+        @services = []
+        @event_manager = ServiceEventManager.new
+      end
+
+      def sketch_service
+        sketch
+      end
+
+      def sketch
+      end
+
+      def inspect
+        "#{self.class}:#{object_id}"
+      end
+
+      attr :services
+      attr :event_manager
+
+      def service_tree
+        @services.map{|it| [it, it.service_tree] }.to_h
+      end
+
+      def put service_class, *a, at: nil, **ka, &b
+        service = service_class.new
+        put_service service, at: at if at != false
+        service.sketch_service
+        service.set *a, **ka, &b
+        service
+      end
+
+      def put_service service, at: nil
+        service.update_lower self, at
+        case at
+        when Integer
+          @services.insert at, service
+        when Pad
+          @services.insert @services.index(at), service
+        else
+          @services << service
+        end
+        service
+      end
+
+      def service_index service
+        @services.index service
+      end
+
+      def delete_upper upper
+        @services.delete upper
+      end
+
+      def update_lower lower, at = nil
+        different_lower = @lower != lower
+        if different_lower
+          @lower = lower
+          c_set_lower at
+        end
+        different_lower
+      end
+
+      def c_set_lower at
+        @services.each{|it| it.update_lower self }
+      end
+
+      def lower_pad_detached
+        @services.each{ _1.lower_pad_detached }
+      end
+      
+      def report event, path = false, instant = false
+        event.target ||= self
+        event_queue = pane&.event_queue
+        return unless event_queue
+        if path
+          path.each do |it|
+            event_queue.push event, it.event_manager, true, instant
+          end
+          path.reverse_each do |it|
+            event_queue.push event, it.event_manager, false, instant
+          end
+        else
+          event_queue.push event, @event_manager, true, instant
+          event_queue.push event, @event_manager, false, instant
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Kredki
+  # Event manager for Service.
+  class ServiceEventManager
+
+    # :section: LEVEL 2
+
+    def initialize
+      @managers = {
+        true => {},
+        false => {},
+      }
+    end
+
+    def manager event_class, block, early, always
+      manager = (@managers[early][event_class] ||= EventManager.new)
+      block ? manager.attach(block, always:) : manager
+    end
+
+    def keyboard_manager event_class, keycodes, block, early, always
+      manager = (@managers[early][event_class] ||= KeyboardEventManager.new)[*keycodes]
+      block ? manager.attach(block, always:) : manager
+    end
+
+    def mouse_manager event_class, indexes, block, early, always
+      manager = (@managers[early][event_class] ||= MouseEventManager.new)[*indexes]
+      block ? manager.attach(block, always:) : manager
+    end
+    
+    def joystick_manager event_class, joystick, indexes, block, early, always
+      manager = (@managers[early][event_class] ||= JoystickEventManager.new)[joystick, indexes]
+      block ? manager.attach(block, always:) : manager
+    end
+
+    def report event, early
+      cl = event.class
+      manager = @managers[early]
+      while cl != Object
+        manager[cl]&.report event
+        cl = cl.superclass
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module Kredki
+  module Pads
+    # Module to include in service containers.
+    module ServiceFilter
+
+      def respond_to? name, include_all = false
+        name.end_with? "?" or super
+      end
+
+      def method_missing name, ...
+        if name.end_with? "?"
+          find_upper(name.to_s.tr("?", "!").to_sym, ...)
+        else
+          super
+        end
+      end
+
+      # Get self if it matches filters.
+      def is *filters, **ka, &block
+        return self if self =~ [*filters, ka, block]
+      end
+
+      # Find direct upper service matching filters.
+      def find *filters, last: false, **ka, &block
+        each(*filters, **ka, reverse: last, &block).first
+      end
+
+      # Find upper service matching filters.
+      def find_upper *filters, last: false, **ka, &block
+        each_upper(*filters, **ka, reverse: last, &block).first
+      end
+
+      # Find lower service matching filters.
+      def find_lower *filters, last: false, **ka, &block
+        each_lower(*filters, **ka, reverse: last, &block).first
+      end
+
+      # Get each direct lower service matching filters.
+      def each *filters, reverse: false, **ka, &block
+        upper_iterator deep: false, reverse:, filter: [*filters, ka, block]
+      end
+      
+      # Get each lower service matching filters.
+      def each_lower *filters, reverse: false, **ka, &block
+        lower_iterator(false).then{|it| reverse ? it.reverse_each : it }.filter{|it| it =~ [*filters, ka, block] }
+      end
+
+      # Get each upper service matching filters.
+      def each_upper *filters, reverse: false, **ka, &block
+        upper_iterator deep: true, reverse:, filter: [*filters, ka, block]
+      end
+            
+      # Get upper services iterator.
+      def upper_iterator enum = nil, reverse: false, deep: true, filter: nil
+        if enum
+          method = reverse ? :reverse_each : :each
+          case deep
+          when false
+            @services.send(method){|it| enum << it if it =~ filter }
+          when :first
+            @services.send method do |it|
+              enum << it if it =~ filter 
+              it.upper_iterator enum, reverse:, deep:, filter: ;
+            end
+          else
+            @services.send(method){|it| enum << it if it =~ filter }
+            @services.send(method){|it| it.upper_iterator enum, reverse:, deep:, filter: }
+          end
+          enum
+        else
+          Enumerator.new{|enum| upper_iterator enum, reverse:, deep:, filter: }
+        end
+      end
+
+      # Iterate over pad descedants.
+      def upper_pad_iterator enum = nil, reverse: false, deep: true
+        if enum
+          method = reverse ? :reverse_each : :each
+          case deep
+          when false
+            @pads.send(method){ enum << _1 }
+          when :first
+            @pads.send method do
+              enum << _1
+              _1.upper_pad_iterator enum, reverse:, deep:;
+            end
+          else
+            @pads.send(method){ enum << _1 }
+            @pads.send(method){ _1.upper_pad_iterator enum, reverse:, deep: }
+          end
+          enum
+        else
+          Enumerator.new{|enum| upper_pad_iterator enum, reverse:, deep: }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Kredki
+  module Pads
+    # Module extended in Kredki::Pads::Service and all inherited classes.
+    module ServiceInherited
+      def self.extended cl
+        cl.define_singleton_method :inherited do |cl1|
+          cl1.extend ServiceInherited
+        end
+      end
+
+      def method_missing name, ...
+        if name.end_with? "!"
+          define(name, ...)
+        else
+          super
+        end
+      end
+
+      def respond_to? name, all = false
+        name.end_with? "!" or super
+      end
+
+      # Define method.
+      def define name, klass = nil, &block
+        case klass
+        when Class
+          class_eval <<~xx
+            def #{name} ...
+              put(#{klass}, :#{name}, ...)
+            end
+          xx
+        when nil
+          if block.parameters.empty?
+            define_method name do |*a, **ka, &b|
+              instance_exec(&block).set *a, **ka, &b
+            end
+          else
+            define_method name do |*a, **ka, &b|
+              instance_exec(*a, **ka, &block).set &b
+            end
+          end
+        else raise_ia klass
+        end
+      end
+
+    end#ServiceInherited
+  end#Pads
+end#Kredki

data/lib/kredki/pads/setup.rb

@@ -0,0 +1,36 @@
+require_relative 'service/service_inherited'
+require_relative "layout/layout"
+
+module Kredki
+  module Pads
+
+    class << self
+      attr_accessor :layout_map
+
+      def layout! id, layout
+        @layout_map[id] = layout
+      end
+  
+      def layout param = nil
+        case param
+        in Layout
+          param
+        else
+          @layout_map[param] or raise "Unknown layout '#{param}'"
+        end
+      end
+
+      attr_accessor :config
+    end
+
+    self.layout_map = {}
+    self.config = "#{Kredki.dir}/stuff/config/pads_config.rb"
+
+    Auto = :auto
+    Fit = :fit
+    Ratio = :ratio
+    Start = :start
+    Center = :center
+    End = :end
+  end
+end

data/lib/kredki/pads/slider/slider.rb

@@ -0,0 +1,145 @@
+module Kredki
+  module Pads
+    # A base class for controls that allows you to set a value by dragging a handle.
+    class Slider < RectanglePad
+
+      class EditEvent < Event
+        def initialize value, ...
+          super(...)
+          @value = value
+        end
+
+        def value
+          @value
+        end
+
+        def param
+          value
+        end
+      end
+
+      # Set value.
+      def set_value value = @value
+        return send_bundle :set_value, yield(self.value) if block_given?
+        return if @value == value
+        @value = value
+        layer&.break_layout
+      end
+
+      # See #set_value.
+      def value= param
+        send_bundle :set_value, param
+      end
+
+      # Get value.
+      def value
+        @value
+      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 edit event reaction.
+      def on_edit ...
+        on(EditEvent, ...)
+      end
+
+      # See #on_edit.
+      def on_edit= param
+        on_edit do: param
+      end
+
+      # :section: LEVEL 2
+
+      def initialize
+        super
+
+        @value = 0.0
+        @c0 = 0
+        @handle = put RectanglePad, fill: :gray
+      end
+
+      attr :handle
+
+      def sketch
+        super
+
+        set_suit :gray
+      end
+
+      def presence
+        super
+
+        Event.each(
+          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
+          handle.area.set_fill color.darken
+        else
+          set_opacity 1r
+          handle.area.set_fill mouse_in ? color.lighten : color.darken
+        end
+      end
+
+      def behavior
+        super
+
+        on_mouse_scroll do |e|
+          v, y = Kredki.relative_scroll *e.xy
+          v = y if v.abs < y.abs
+          jump = 0.1
+          v = (@value - jump * v).clamp(0..1)
+          report EditEvent.new(v, e)
+          e.close
+        end
+
+        on_mouse_move do |e|
+          if e.drag?
+            process_drag e
+            e.close
+          end
+        end
+
+        on_edit early: true do |e|
+          e.close if in_disabled
+        end
+
+        on_edit do |e|
+          set_value e.value
+        end
+
+        @handle.on_mouse_press do |e|
+          @handle.start_drag e.xy, e.button.id
+          e.close
+        end
+      end
+    end
+  end
+end

data/lib/kredki/pads/slider/slider_x.rb

@@ -0,0 +1,41 @@
+module Kredki
+  module Pads
+    # A control that allows you to set a value by dragging a handle in X axis.
+    class SliderX < Slider
+
+      # :section: LEVEL 2
+
+      def process_drag e, speed = 1
+        hsx = @handle.area_size_x
+        max_x = area_size_x - hsx
+        @c0 = @handle.area_x if e.start?
+        start_x = layer.pin_xy[0]
+        x = [[0, @c0 + (e.x - start_x) * speed].max, max_x].min
+        report EditEvent.new(1.0 * x / max_x, e) if max_x > 0
+      end
+
+      def sketch
+        super
+
+        set_size_y 10
+      end
+
+      def behavior
+        super
+
+        on_mouse_press :primary do |e|
+          @handle.start_drag @handle.translate(@handle.area_size_x * 0.5, 0), :primary
+          e.close
+        end
+      end
+
+      def arrange request_size_x = nil
+        csx = clip_size_x
+        request_size_x ||= 3 * csx
+        size_x = (csx.to_f / request_size_x * csx).clamp 20, [csx - 20, 20].max
+        @handle.update_size size_x, area_size_y
+        @handle.update_xy ((csx - size_x) * @value.to_f.then{|it| it.nan? ? 0 : it.clamp(0..1) }).ceil, 0
+      end
+    end
+  end
+end

data/lib/kredki/pads/slider/slider_y.rb

@@ -0,0 +1,41 @@
+module Kredki
+  module Pads
+    # A control that allows you to set a value by dragging a handle in Y axis.
+    class SliderY < Slider
+
+      # :section: LEVEL 2
+
+      def process_drag e, speed = 1
+        hsy = @handle.area_size_y
+        max_y = area_size_y - hsy
+        @c0 = @handle.area_y if e.start?
+        start_y = layer.pin_xy[1]
+        y = [[0, @c0 + (e.y - start_y) * speed].max, max_y].min
+        report EditEvent.new(1.0 * y / max_y, e) if max_y > 0
+      end
+
+      def sketch
+        super
+
+        set_size_x 10
+      end
+
+      def behavior
+        super
+
+        on_mouse_press :primary do |e|
+          @handle.start_drag @handle.translate(0, @handle.area_size_x * 0.5), :primary
+          e.close
+        end
+      end
+
+      def arrange request_size_y = nil
+        csy = clip_size_y
+        request_size_y ||= 3 * csy
+        size_y = (csy.to_f / request_size_y * csy).clamp 20, [csy - 20, 20].max
+        @handle.update_size area_size_x, size_y
+        @handle.update_xy 0, ((csy - size_y) * @value.to_f.then{|it| it.nan? ? 0 : it.clamp(0..1) }).ceil
+      end
+    end
+  end
+end