kredki 0.1.0

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

@@ -0,0 +1,88 @@
+module Kredki
+  module Pads
+    # Module to include in layout class.
+    module Layout
+
+      # :section: LEVEL 2
+
+      def initialize x, y
+        @x = x
+        @y = y
+      end
+
+      def get_p cr, pc, sc
+        case cr
+        when Start
+          0
+        when Center
+          (pc - sc) * 0.5
+        when End
+          pc - sc
+        when Rational
+          cr * pc - sc * 0.5
+        when Proc
+          cr[pc, sc]
+        when Numeric
+          cr
+        else raise_ia cr
+        end
+      end
+
+      def get_x cr, pc, sc
+        get_p cr, pc, sc
+      end
+
+      def get_y cr, pc, sc
+        get_p cr, pc, sc
+      end
+
+      def arrange pad
+        csx = pad.clip_size_x
+        csy = pad.clip_size_y
+
+        lsx = lsy = 0
+        lx = csx
+        ly = csy
+        
+        pad.arranged_pads.each do |p1|
+          psy = p1.get_size_y csy
+          psx = p1.get_size_x csx, psy
+          p1.update_size psx, psy
+          px = p1.get_x csx, psx, (get_x @x, csx, psx)
+          py = p1.get_y csy, psy, (get_y @y, csy, psy)
+          p1.update_xy px, py
+          p1.update_margin
+          p1.arrange
+          if p1.layoutic
+            lx = [lx, px].min
+            ly = [ly, py].min
+            lsx = [lsx, psx].max
+            lsy = [lsy, psy].max
+          end
+        end
+
+        [lx, ly, lsx, lsy]
+      end
+
+      def fit_size_x pad
+        pad.pads_layoutic.map{|p1| p1.min_size_x }.max || 0
+      end
+
+      def fit_size_y pad
+        pad.pads_layoutic.map{|p1| p1.min_size_y }.max || 0
+      end
+
+      def get_size_x_rational p0, p0w, p1, r
+        r * p0w
+      end
+
+      def get_size_y_rational p0, p0h, p1, r
+        r * p0h
+      end
+    end#Layout
+  end#Pads
+end#Kredki
+
+require_relative "align"
+require_relative "x_way"
+require_relative "y_way"

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

@@ -0,0 +1,99 @@
+module Kredki
+  module Pads
+    module Layout
+      # A layout in which elements are positioned one next to another.
+      class Way
+        include Layout
+
+        # :section: LEVEL 2
+
+        def spans sp, pd, space
+          ad = 0
+          sd = 0
+          total_span = 0
+          sp.each do |span|
+            sd += span[1] if span[0] == 0
+            ad += span[1]
+            total_span += span[0]
+          end
+          return [[], 0] if sp.empty?
+          total_space = space * (sp.size - 1)
+          sd += total_space
+
+          rd = pd - sd
+          if total_span > 0 && rd > 0
+            nd = rd / total_span
+            rd = 0
+            sp.each do |span|
+              if span[0] > 0
+                od = nd * span[0]
+                if od > span[2]
+                  span[3] = span[2]
+                  rd += od - span[2]
+                elsif od < span[1]
+                  span[3] = span[1]
+                  rd += od - span[1]
+                else
+                  span[3] = od
+                end
+              end
+            end
+
+            loop do
+              if rd > 0
+                total_span = sp.map{|it| it[3] < it[2] ? it[0] : 0 }.sum
+                break if total_span == 0
+                nd = rd / total_span
+                rd = 0
+                sp.each do |span|
+                  if span[3] < span[2]
+                    od = nd * span[0] + span[3]
+                    if od > span[2]
+                      span[3] = span[2]
+                      rd += od - span[2]
+                    else
+                      span[3] = od
+                    end
+                  end
+                end
+              elsif rd < 0
+                total_span = sp.map{|it| it[3] > it[1] ? it[0] : 0 }.sum
+                break if total_span == 0
+                nd = rd / total_span
+                rd = 0
+                sp.each do |span|
+                  if span[3] > span[1]
+                    od = nd * span[0] + span[3]
+                    if od < span[1]
+                      span[3] = span[1]
+                      rd += od - span[1]
+                    else
+                      span[3] = od
+                    end
+                  end
+                end
+              else
+                break
+              end
+            end
+            
+            return [m = sp.map{|it| it[3] }, m.sum + total_space]
+          end
+          [sp.map{|it| it[3] }, ad + total_space]
+        end
+
+        def arrange_non_layoutic pad, csx, csy
+          psx = pad.get_size_x csx
+          psy = pad.get_size_y csy
+          pad.update_size psx, psy
+          px = pad.get_x csx, psx, (get_x @x, csx, psx)
+          py = pad.get_y csy, psy, (get_y @y, csy, psy)
+          pad.update_xy px, py
+          pad.update_margin
+          pad.arrange
+        end
+        
+      end#Way
+    end#Layout
+  end#Pads
+end#Kredki

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

@@ -0,0 +1,119 @@
+require_relative 'way'
+
+module Kredki
+  module Pads
+    module Layout
+      # A layout in which elements are positioned one next to another, along the X axis.
+      class XWay < Way
+
+        # :section: LEVEL 2
+
+        def get_span pad, size_x, limit, lower_clip_size_x
+          case size_x
+          when Rational
+            case limit
+            when nil
+              [size_x, 0, Float::INFINITY, 0]
+            when Range
+              sxv = limit.begin&.then{|it| pad.get_size_x_value it, lower_clip_size_x, nil } || 0
+              limit_sxv = limit.end&.then{|it| pad.get_size_x_value it, lower_clip_size_x, nil } || Float::INFINITY
+              [size_x, sxv, limit_sxv, sxv]
+            else
+              limit_sxv = pad.get_size_x_value limit, lower_clip_size_x, nil
+              [size_x, 0, limit_sxv, 0]
+            end
+          when Auto
+            case limit
+            when nil
+              [1r, 0, Float::INFINITY, 0]
+            when Range
+              sxv = limit.begin&.then{|it| pad.get_size_x_value it, lower_clip_size_x, nil } || 0
+              limit_sxv = limit.end&.then{|it| pad.get_size_x_value it, lower_clip_size_x, nil } || Float::INFINITY
+              [1r, sxv, limit_sxv, sxv]
+            else
+              limit_sxv = pad.get_size_x_value limit, lower_clip_size_x, nil
+              [1r, 0, limit_sxv, 0]
+            end
+          else
+            sxv = pad.get_size_x_limited size_x, limit, lower_clip_size_x
+            [0, sxv, sxv, sxv]
+          end
+        end
+
+        def arrange pad
+          csx, csy = pad.clip_size
+          sp = pad.pads_layoutic.map{|it| get_span it, it.size_x, it.size_x_limit, csx }
+          measurement, sx = spans sp, csx, pad.spacer || 0
+          
+          pad.pads_layoutic.zip measurement do |p1, m|
+            psy = p1.get_size_y csy, m
+            p1.update_size m, psy
+          end
+
+          arrange_pads pad.arranged_pads, sx, csx, csy, pad.spacer || 0
+        end
+
+        def arrange_pads pads, sx, csx, csy, spacer
+          cx = case @x
+          when Start
+            0
+          when Center
+            (csx - sx) * 0.5
+          when End
+            csx - sx
+          when Rational 
+            csx * @x
+          when Proc
+            @x[csx, sx]
+          when Numeric
+            @x
+          else raise_ia @x
+          end
+          lx = lxm = ly = lym = 0
+          
+          pads.each do |p1|
+            if p1.layoutic
+              psx, psy, px, py = arrange_layoutic p1, csx, csy, cx
+              cx += psx + spacer
+              lx = [lx, px].min
+              ly = [ly, py].min
+              lxm = [lxm, px + psx].max
+              lym = [lym, py + psy].max
+            else
+              arrange_non_layoutic p1, csx, csy
+            end
+          end
+
+          [lx, ly, lxm - lx, lym - ly]
+        end
+
+        def arrange_layoutic pad, csx, csy, cx
+          psx, psy = pad.area_size
+          px = pad.get_x csx, psx, cx
+          py = pad.get_y csy, psy, (get_y @y, csy, psy)
+          pad.update_xy px, py
+          pad.update_margin
+          pad.arrange
+          [psx, psy, px, py]
+        end
+
+        def fit_size_x pad
+          spacer = pad.spacer || 0
+          pad.pads_layoutic.map{|p1| p1.min_size_x }.reduce{ _1 + spacer + _2 } || 0
+        end
+
+        def get_size_x_rational p0, psx, p1, r
+          index = p0.pads_layoutic.find_index{|it| it == p1 }
+          if index
+            sp = p0.pads_layoutic.map{|it| get_span it, it.size_x, it.size_x_limit, psx }
+            measurement, sx = spans sp, psx, p0.spacer || 0
+            measurement[index]
+          else
+            r * psx
+          end
+        end
+
+      end#XWay
+    end#Layout
+  end#Pads
+end#Kredki

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

@@ -0,0 +1,120 @@
+require_relative 'way'
+
+module Kredki
+  module Pads
+    module Layout
+      # A layout in which elements are positioned one next to another, along the Y axis.
+      class YWay < Way
+
+        # :section: LEVEL 2
+
+        def get_span pad, size_y, limit, lower_clip_size_y
+          case size_y
+          when Rational
+            case limit
+            when nil
+              [size_y, 0, Float::INFINITY, 0]
+            when Range
+              syv = limit.begin&.then{|it| pad.get_size_y_value it, lower_clip_size_y, nil } || 0
+              limit_syv = limit.end&.then{|it| pad.get_size_y_value it, lower_clip_size_y, nil } || Float::INFINITY
+              [size_y, syv, limit_syv, syv]
+            else
+              limit_syv = pad.get_size_y_value limit, lower_clip_size_y, nil
+              [size_y, 0, limit_syv, 0]
+            end
+          when Auto
+            case limit
+            when nil
+              [1r, 0, Float::INFINITY, 0]
+            when Range
+              syv = limit.begin&.then{|it| pad.get_size_y_value it, lower_clip_size_y, nil } || 0
+              limit_syv = limit.end&.then{|it| pad.get_size_y_value it, lower_clip_size_y, nil } || Float::INFINITY
+              [1r, syv, limit_syv, syv]
+            else
+              limit_syv = pad.get_size_y_value limit, lower_clip_size_y, nil
+              [1r, 0, limit_syv, 0]
+            end
+          else
+            syv = pad.get_size_y_limited size_y, limit, lower_clip_size_y
+            [0, syv, syv, syv]
+          end
+        end
+
+        def arrange pad
+          csx, csy = pad.clip_size
+          sp = pad.pads_layoutic.map{|it| get_span it, it.size_y, it.size_y_limit, csy }
+          measurement, sy = spans sp, csy, pad.spacer || 0
+          
+          pad.pads_layoutic.zip measurement do |p1, measured|
+            psx = p1.get_size_x csx, measured
+            p1.update_size psx, measured
+          end
+
+          arrange_pads pad.arranged_pads, sy, csx, csy, pad.spacer || 0
+        end
+
+        def arrange_pads pads, sy, csx, csy, spacer
+          cy = case @y
+          when Start
+            0
+          when Center
+            (csy - sy) * 0.5
+          when End
+            csy - sy
+          when Rational 
+            csy * @y
+          when Proc
+            @y[csy, sy]
+          when Numeric
+            @y
+          else raise_is @y
+          end
+
+          lx = lxm = ly = lym = 0
+
+          pads.each do |p1|
+            if p1.layoutic
+              psx, psy, px, py = arrange_layoutic p1, csx, csy, cy
+              cy += psy + spacer
+              lx = [lx, px].min
+              ly = [ly, py].min
+              lxm = [lxm, px + psx].max
+              lym = [lym, py + psy].max
+            else
+              arrange_non_layoutic p1, csx, csy
+            end
+          end
+          
+          [lx, ly, lxm - lx, lym - ly]
+        end
+
+        def arrange_layoutic pad, csx, csy, cy
+          asx, asy = pad.area_size
+          px = pad.get_x csx, asx, (get_x @x, csx, asx)
+          py = pad.get_y csy, asy, cy
+          pad.update_xy px, py
+          pad.update_margin
+          pad.arrange
+          [asx, asy, px, py]
+        end
+        
+        def fit_size_y pad
+          spacer = pad.spacer || 0
+          pad.pads_layoutic.map{|p1| p1.min_size_y }.reduce{ _1 + spacer + _2 } || 0
+        end
+
+        def get_size_y_rational p0, psy, p1, r
+          index = p0.pads_layoutic.find_index{|it| it == p1 }
+          if index
+            sp = p0.pads_layoutic.map{|it| get_span it, it.size_y, it.size_y_limit, psy }
+            measurement, sy = spans sp, psy, p0.spacer || 0
+            measurement[index]
+          else
+            r * psy
+          end
+        end
+
+      end#YWay
+    end#Layout
+  end#Pads
+end#Kredki

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

@@ -0,0 +1,117 @@
+module Kredki
+  module Pads
+    module List
+      # List item model.
+      class Item < ItemY
+
+        # Set whether is selected.
+        def set_selected value = true, &block
+          return if (c = selected) == (value = block ? block[c] : value == Not ? !c : value)
+          @selected = value
+          repaint
+          true
+        end
+
+        # See #set_selected.
+        def selected= param
+          send_bundle :set_selected, param
+        end
+
+        # Get whether is selected.
+        def selected
+          @selected
+        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
+
+        # :section: LEVEL 2
+
+        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
+            area.set_stroke_width 0
+            area.set_stroke_fill color
+          else
+            set_opacity 1r
+            area.set_fill selected ? mouse_in ? Kredki.color(:text_selection).lighten : :text_selection : mouse_in ? color.lighten : color
+            if keyboard_in
+              area.set_stroke_width 1
+              area.set_stroke_fill :stroke_focus
+            else
+              area.set_stroke_width 0
+              area.set_stroke_fill color
+            end
+          end
+        end
+
+        def behavior
+          super
+
+          on_key_press :up do |e|
+            set_selected if e.shift?
+            item = lower.focus_previous
+            if item
+              item.set_selected if e.shift?
+              item.request_vision
+            end
+            e.close
+          end
+
+          on_key_press :down do |e|
+            set_selected if e.shift?
+            item = lower.focus_next
+            if item
+              item.set_selected if e.shift?
+              item.request_vision
+            end
+            e.close
+          end
+        end
+
+        def mouse_enter e
+        end
+
+        def mouse_press e
+          lower.select_up_to self if Kredki.keyboard.match shift: true
+          super
+        end
+
+      end#Item
+    end#List
+  end#Pads
+end#Kredki

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

@@ -0,0 +1,36 @@
+module Kredki
+  module Pads
+    module List
+      # Group of list items.
+      class ItemGroup < Pads::ItemGroup
+
+        # Add new item.
+        def item!(...)
+          put(Item, __method__, ...)
+        end
+
+        # Get all items.
+        def items
+          each_upper(Item).to_a
+        end
+
+        # Get selected items.
+        def selected_items
+          each_upper(Item, selected: true).to_a
+        end
+
+        # :section: LEVEL 2
+
+        def select_up_to pad
+          bound = 0
+          each_upper(Item).each do |it|
+            bound += 1 if it == pad
+            bound += 1 if it.keyboard_in
+            it.set_selected if bound > 0
+            break if bound > 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kredki/pads/list/pad.rb

@@ -0,0 +1,74 @@
+require_relative 'item_group'
+require_relative 'item'
+
+module Kredki
+  module Pads
+    module List
+      class Pad < RectanglePad
+        
+        # Add new item.
+        def item! *a, **ka, &b
+          @item_group.item! *a, size_x: 1r, **ka, &b
+        end
+        
+        # Create and attach select event reaction.
+        def on_select ...
+          on(Item::SelectEvent, ...)
+        end
+
+        # See #on_select.
+        def on_select= param
+          on_select do: param
+        end
+
+        # Get all items.
+        def items
+          @item_group.items
+        end
+
+        # Get selected items.
+        def selected_items
+          @item_group.selected_items
+        end
+
+        # :section: LEVEL 2
+
+        def initialize
+          super
+
+          @item_group = put ItemGroup
+        end
+
+        def sketch
+          super
+
+          set_keyboardy true
+          set_fill :gray
+          set_layout :yss
+          set_size_y Fit
+        end
+
+        def behavior
+          super
+
+          on Item::SelectEvent do |e|
+            item = e.target
+            kb = Kredki.keyboard
+            if kb.shift?
+              item.set_selected
+            elsif kb.ctrl?
+              item.set_selected Not
+            else
+              each_upper(Item).each{|it| it.set_selected it == item }
+            end
+          end
+
+          on_focus_leave do
+            each_upper(Item).each_set selected: false
+          end
+        end
+
+      end#Pad
+    end#List
+  end#Pads
+end#Kredki