tkwrapper 1.1.2 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42d786c8eda480c18150ef9b6c3e67fc04c14d2c9ec70a037907dee5a9273264
-  data.tar.gz: b669a2881c794270a80da8332a55393c90a7bb3115273b5c28fc5681fb43faf5
+  metadata.gz: abffb1cc7ae4efaf8b26ebdd49acca56837989829713473f21971f8a5f5a9063
+  data.tar.gz: 1e659e3049a41d4aff307f700ac27cc86d014ec844134aa65bc7bd20c2f692db
 SHA512:
-  metadata.gz: 1c583155569bc2adf08a5177c35e123e45a69c997ecb3aa70d78841ab4418406a7daa83277c7efe7654585c77932b58094a4bace040d5c9555de30e4e493c9b0
-  data.tar.gz: 63cb56447bc90a44a86251cfc5ef4507a5482063abb2f24a906610d6d23c3ba8cb341bf64a34ae027577ffbf6bb47ab4935e88a7ab56198e39b44e7f2d0cb890
+  metadata.gz: efbad85fe488198ff115feac31872163da0da8b796ef0a21babf33d21976e14da0f809a93a502cbfc0f9225e4446e30c1b567680af2b3c7e7eae862cf0b5f64b
+  data.tar.gz: 7d0addd32901d46c6d0175219ee83dd4478f699bc05ec7804f0a76dac02b1950a11f7a22dafa494996961bc8f25582c1f6be4f36c3cf19c9b3a3e5050cb0df9f

data/lib/tkwrapper.rb

@@ -2,10 +2,16 @@
 
 LIB_DIR = __dir__
 
-module TkWrapper end
+module TkWrapper
+  module Util
+    module Tk
+    end
+  end
+end
 
 require_relative 'widgets/widgets'
 
 module TkWrapper
+  Manager = TkWrapper::Widgets::Base::Manager
   Widget = TkWrapper::Widgets::Base::Widget
 end

data/lib/util/tk/cell.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'tk'
+
+class TkWrapper::Util::Tk::Cell
+  def initialize(widget)
+    @widget = widget
+  end
+
+  # returns the bounding box of the tk_widget
+  def bbox
+    return unless (container = container_parent)
+
+    grid_info = TkGrid.info(@widget.tk_widget)
+    start_col = grid_info['column']
+    end_col = start_col + grid_info['columnspan'] - 1
+    start_row = grid_info['row']
+    end_row = start_row + grid_info['rowspan'] - 1
+
+    TkGrid.bbox(container.tk_widget, start_col, start_row, end_col, end_row)
+  end
+
+  private
+
+  # the first parent, which contains a tk_widget, which is really different
+  # from self.tk_widget
+  def container_parent
+    container = @widget.parent
+    while container.tk_widget == @widget.tk_widget
+      return unless container.parent # not in a grid?
+
+      container = container.parent
+    end
+    container
+  end
+end

data/lib/util/tk/finder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "#{LIB_DIR}/widgets/base/manager"
+require "#{LIB_DIR}/widgets/base/matcher"
+require "#{LIB_DIR}/widgets/base/matches"
+
+class TkWrapper::Util::Tk::Finder
+  Match   = TkWrapper::Widgets::Base::Match
+  Matcher = TkWrapper::Widgets::Base::Matcher
+  Matches = TkWrapper::Widgets::Base::Matches
+
+  def initialize(widgets: nil, lookup: nil)
+    @lookup = lookup
+    @widgets = widgets
+  end
+
+  def iter(comparators, widgets = @widgets, lookup = @lookup)
+    Enumerator.new do |y|
+      comparators = each_widget_lookup_match(lookup, comparators) { |m| y << m }
+      each_widget_comparator_match(widgets, comparators) { |m| y << m }
+    end
+  end
+
+  def find(comparators, widgets = @widgets, lookup = @lookup)
+    iter(comparators, widgets, lookup, &:itself).first
+  end
+
+  def find_all(comparators, widgets = @widgets, lookup = @lookup)
+    it = iter(comparators, widgets, lookup, &:itself)
+    it.each_with_object(Matches.new) { |match, matches| matches.push(match) }
+  end
+
+  private
+
+  def create_value_matchers(comparators)
+    comparators = [comparators] unless comparators.is_a?(Array)
+    comparators.map { |comparator| Matcher.new(comparator: comparator) }
+  end
+
+  def each_widget_lookup_match(lookup, comparators, &block)
+    return comparators unless lookup
+
+    comparators.filter do |comparator|
+      next true unless [String, Symbol].include?(comparator.class)
+
+      (lookup[comparator] || []).each do |widget|
+        block.call(Match.new(comparator, widget: widget))
+      end
+
+      false
+    end
+  end
+
+  def each_widget_comparator_match(widgets, comparators, &block)
+    matchers = create_value_matchers(comparators)
+
+    widgets.each do |widget|
+      widget.ids.each do |id|
+        matchers.each do |matcher|
+          (match = matcher.match(id, widget)) && block.call(match)
+        end
+      end
+    end
+  end
+end

data/lib/util/tk/font.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'tk'
+require 'forwardable'
+
+require_relative 'tk'
+
+class TkWrapper::Util::Tk::Font
+  def initialize(tk_widget)
+    @tk_widget = tk_widget
+  end
+
+  %i[family size weight slant underline overstrike].each do |option|
+    define_method("#{option}=") do |value, **args|
+      load unless @config
+      args[:update] ||= false
+      @config[option] = value
+      update if args[:update]
+    end
+
+    define_method(option) do
+      load unless @config
+      @config[option]
+    end
+  end
+
+  def with_update(&block)
+    block.call(self)
+    update
+  end
+
+  def method_missing(method, *args)
+    if TkFont.respond_to?(method)
+      TkFont.send(method, @tk_widget.font, *args)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, *)
+    TkFont.respond_to?(method) || super
+  end
+
+  def load
+    @config = TkFont.actual(@tk_widget.font).to_h.transform_keys(&:to_sym)
+  end
+
+  def update
+    @tk_widget.font = TkFont.new(@config)
+  end
+end

data/lib/util/tk/tk.rb

@@ -0,0 +1,8 @@
+module TkWrapper
+  module Util
+    module Tk
+    end
+  end
+end
+
+require_relative 'font'

data/lib/widgets/auto_resize_entry.rb

@@ -4,57 +4,31 @@ class TkWrapper::Widgets::AutoResizeEntry < TkWrapper::Widgets::Entry
   # auto resizes on user input, only works if in the grid geometry manager of tk
   attr_accessor :min_width, :add_width
 
-  def initialize(config: {}, childs: [])
-    @min_width = config.delete(:min_width) || 0
-    @add_width = config.delete(:add_width) || 0
-    super(config: config, childs: childs)
+  def initialize(**args)
+    @min_width = args.dig(:config, :min_width) || 0
+    @add_width = args.dig(:config, :add_width) || 0
+    super(**args)
   end
 
-  def build(parent, configure: true)
-    super(parent, configure: configure)
+  def build(parent, **args)
+    super(parent, **args)
     parent.tk_widget.bind('Configure') { resize }
     tk_widget.textvariable = TkVariable.new unless tk_widget.textvariable
     tk_widget.textvariable.trace('write') { resize }
     resize
   end
 
-  def config_for_dummy_label
-    grid_info = TkGrid.info(tk_widget)
-    { config: { grid: {
-      row: grid_info['row'],
-      column: grid_info['column'],
-      columnspan: grid_info['columnspan'],
-      sticky: 'nw'
-    } } }
+  def value=(value)
+    tk_widget.textvariable.value = value
   end
 
-  def create_dummy_label_with_same_size(&block)
-    label = TkWrapper::Widgets::Label.new(**config_for_dummy_label)
-    label.build(@parent)
-    label.tk_widget.text = tk_widget.textvariable.value
-    label.tk_widget.lower
-    result = block.call(label)
-    label.tk_widget.destroy
-    result
-  end
-
-  def text_width_in_pixel
-    create_dummy_label_with_same_size do |label|
-      @parent.tk_widget.update
-      label.tk_widget.winfo_width
-    end
-  end
-
-  def textwidth_and_maxwidth_in_pixel
-    create_dummy_frame_with_same_size_label do |frame, label|
-      { text_width: label.tk_widget.winfo_width,
-        max_width: frame.tk_widget.winfo_width }
-    end
+  def value
+    tk_widget.textvariable.value
   end
 
   def resize
-    max_width = cell_bbox[2]
-    text_width = text_width_in_pixel
+    max_width = [@cell.bbox[2], 0].max
+    text_width = @font.measure(value)
     new_width = [[@min_width, text_width + @add_width].max, max_width].min
     tk_widget.width = 0
     tk_widget.grid(ipadx: new_width / 2.0)

data/lib/widgets/base/base.rb

@@ -5,3 +5,4 @@ module TkWrapper::Widgets::Base end
 require_relative 'widget'
 require_relative 'manager'
 require_relative 'configuration'
+require_relative 'matches'

data/lib/widgets/base/comparator_item_store.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'matcher'
+
+class TkWrapper::Widgets::Base::ComparatorItemStore
+  Matcher = TkWrapper::Widgets::Base::Matcher
+
+  def initialize
+    @key_map = {}        # for fast lookup
+    @comparator_map = {} # for lookup using comparisons by Matcher class
+  end
+
+  def map_key?(key)
+    [String, Symbol].include?(key)
+  end
+
+  def push(key, *items)
+    if map_key?(key)
+      (@key_map[key] ||= []).concat(items)
+    else
+      (@comparator_map[key] ||= []).concat(items)
+    end
+  end
+
+  # returns [{items: [...], match: Match}, {items: [...]}, ...]
+  def items_and_matches_for_widget(widget)
+    widget.ids.reduce([]) do |items, id|
+      items + items_from_key_map(id) + items_from_comparator_map(id, widget)
+    end
+  end
+
+  def [](key)
+    items = map_key?(key) ? @key_map[key] : @comparator_map[key]
+    items&.length == 1 ? items.first : items
+  end
+
+  private
+
+  def items_from_key_map(id)
+    (items = @key_map[id]) ? [{ items: items }] : []
+  end
+
+  def items_from_comparator_map(id, widget)
+    matcher = Matcher.new(value: id)
+
+    @comparator_map.filter_map do |(comparator, items)|
+      (m = matcher.match(comparator, widget)) && { items: items, match: m }
+    end
+  end
+end

data/lib/widgets/base/configuration.rb

@@ -20,7 +20,9 @@ class TkWrapper::Widgets::Base::Configuration
     }
   }.freeze
 
-  NON_TK_OPTIONS = %i[id tk_class tearoff weights menu].freeze
+  NON_TK_OPTIONS = %i[
+    tk_class tearoff weights menu min_width add_width
+  ].freeze
 
   def initialize(config)
     @config = parse_and_clone(config)
@@ -110,6 +112,8 @@ class TkWrapper::Widgets::Base::Configuration
   end
 
   def merge_global_configurations(manager, widget)
+    return unless manager
+
     merge(*manager.configurations(widget))
   end
 end

data/lib/widgets/base/manager.rb

@@ -1,32 +1,52 @@
 # frozen_string_literal: true
 
-# manages widgets and their global configurations
+require_relative 'comparator_item_store'
+require_relative 'widget_store'
+
 class TkWrapper::Widgets::Base::Manager
+  ComparatorItemStore = TkWrapper::Widgets::Base::ComparatorItemStore
+  WidgetStore = TkWrapper::Widgets::Base::WidgetStore
+
+  attr_reader :widgets
+
   def initialize
-    @configurations = []
-    @modifications = []
+    @configurations = ComparatorItemStore.new
+    @modifications = ComparatorItemStore.new
+    @widgets = WidgetStore.new
+  end
+
+  def add_configurations(matcher = nil, configuration = nil, **configurations)
+    add_configuration(matcher, configuration) if configuration
+
+    configurations.each { |mat, cfg| add_configuration(mat, cfg) }
   end
 
-  def add_configuration(matcher, configuration)
-    @configurations.push([matcher, configuration])
+  def add_configuration(comparator, configuration)
+    @configurations.push(comparator, configuration)
   end
 
   def add_modification(matcher, &callback)
-    @modifications.push([matcher, callback])
+    @modifications.push(matcher, callback)
   end
 
   def configurations(widget)
-    @configurations.filter_map do |(matcher, config)|
-      config if widget.check_match(matcher)
-    end
+    config_list = @configurations.items_and_matches_for_widget(widget)
+    config_list.map { |configs| configs[:items] }.flatten(1)
   end
 
   def execute_modifications(widget)
-    @modifications.each do |(matcher, callback)|
-      next unless (match = widget.check_match(matcher))
-
-      arguments = match.is_a?(MatchData) ? [widget, match] : [widget]
-      callback.call(*arguments)
+    item_list = @modifications.items_and_matches_for_widget(widget)
+    item_list.each do |items|
+      items[:items].each do |callback|
+        callback.call(widget, items[:match])
+      end
     end
   end
+
+  def configure(widget)
+    widget.config.merge(*configurations(widget))
+  end
+
+  alias modify add_modification
+  alias config add_configurations
 end

data/lib/widgets/base/match.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# single 'match' as part of a Matches object
+class TkWrapper::Widgets::Base::Match
+  attr_reader :key, :widget, :match
+
+  def initialize(value, cls: nil, match: nil, widget: nil)
+    @key = match&.[](0) || value
+    @widget = widget
+    @match = match
+    @cls = cls
+    @value = value
+  end
+
+  def tk_widget
+    @widget&.tk_widget
+  end
+end

data/lib/widgets/base/matcher.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "#{LIB_DIR}/widgets/base/match"
+
+class TkWrapper::Widgets::Base::Matcher
+  Match = TkWrapper::Widgets::Base::Match
+
+  def initialize(value: nil, comparator: nil)
+    @match_function = curry_match_function(value, comparator)
+  end
+
+  # args:
+  #   []                if widget and matcher were provided on initialization
+  #   [widget]          if matcher was provided on initialization
+  #   [matcher]         if widget was provided on initialization
+  #   [widget, matcher] if neither widget nor matcher were provided on initial.
+  def match(*args)
+    @match_function.call(*args)
+  end
+
+  private
+
+  def match_regex(value, comparator, widget)
+    (match = comparator.match(value)) &&
+      Match.new(value, match: match, widget: widget)
+  end
+
+  def match_string(value, comparator, widget)
+    value == comparator && Match.new(value, widget: widget)
+  end
+
+  def match_class(value, comparator, widget)
+    widget.is_a?(comparator) &&
+      Match.new(value, cls: comparator, widget: widget)
+  end
+
+  def match_f(value, comparator, widget)
+    case comparator
+    when String, Symbol then match_string(value, comparator, widget)
+    when Regexp         then match_regex(value, comparator, widget)
+    when Class          then match_class(value, comparator, widget)
+    when nil            then Match(value, { widget: widget })
+    else                     false
+    end
+  end
+
+  def curry_match_function(value, comparator)
+    if value && comparator
+      ->(widget)                        { match_f(value, comparator, widget) }
+    elsif value
+      ->(x_comparator, widget)          { match_f(value, x_comparator, widget) }
+    elsif comparator
+      ->(x_value, widget)               { match_f(x_value, comparator, widget) }
+    else
+      ->(x_value, x_comparator, widget) { match_f(x_value, x_comparator, widget) }
+    end
+  end
+end

data/lib/widgets/base/matches.rb

@@ -0,0 +1,38 @@
+require_relative 'match'
+
+# matches widgets against conditions and stores matching widgets and matches
+class TkWrapper::Widgets::Base::Matches
+  include Enumerable
+
+  def initialize
+    @matches = {}
+  end
+
+  def push(match)
+    (@matches[match.key] ||= []).push(match)
+  end
+
+  def concat(matches)
+    matches.each { |match| push(match) }
+  end
+
+  def each(&block)
+    @matches.each do |(key, matches_for_key)|
+      matches_for_key.each do |match|
+        block.call([match.widget, key, match.match, match])
+      end
+    end
+  end
+
+  def [](key)
+    case @matches[key].size
+    when 0 then nil
+    when 1 then @matches[key][0]
+    else        @matches[key]
+    end
+  end
+
+  def first
+    @matches.first&.[](1)
+  end
+end

data/lib/widgets/base/widget.rb

@@ -1,39 +1,28 @@
-# frozen_string_literal: true
-
-require 'tk'
-
+require "#{LIB_DIR}/util/tk/cell"
+require "#{LIB_DIR}/util/tk/finder"
 require "#{LIB_DIR}/tk_extensions"
 
 require_relative 'base'
 
 class TkWrapper::Widgets::Base::Widget
+  extend Forwardable
   include TkExtensions
+  include Enumerable
+
+  def_delegators :@finder, :find, :find_all
 
   attr_accessor :config
-  attr_reader :parent, :childs
+  attr_reader :parent, :ids, :cell, :childs, :manager
 
   def tk_class() end
 
-  def self.manager
-    @manager ||= TkWrapper::Widgets::Base::Manager.new
-  end
-
-  def self.config(matcher, configuration)
-    manager.add_configuration(matcher, configuration)
-  end
-
-  def self.modify(matcher, &callback)
-    manager.add_modification(matcher, &callback)
-  end
-
-  def manager
-    TkWrapper::Widgets::Base::Widget.manager
-  end
-
-  def initialize(config: {}, childs: [])
+  def initialize(config: {}, childs: [], manager: nil, ids: [])
+    @cell = TkWrapper::Util::Tk::Cell.new(self)
+    @finder = TkWrapper::Util::Tk::Finder.new(widgets: self)
     @config = TkWrapper::Widgets::Base::Configuration.new(config)
     @childs = childs.is_a?(Array) ? childs : [childs]
-    @id = config[:id]
+    @manager = manager
+    @ids = ids.is_a?(Array) ? ids : [ids]
   end
 
   def create_tk_widget(parent)
@@ -52,84 +41,34 @@ class TkWrapper::Widgets::Base::Widget
     (@tk_widget = create_tk_widget(parent)) || parent&.tk_widget
   end
 
-  def build(parent, configure: true)
+  def build(parent, configure: true, manager: nil)
     @parent = parent
     tk_widget # creates the widget if possible and not yet created
+    @font = TkWrapper::Util::Tk::Font.new(tk_widget)
+    @manager ||= manager
+    @config.merge(*@manager.configurations(self)) if @manager
     self.configure if configure
-    manager.execute_modifications(self)
-    @childs.each { |child| child.build(self) }
-  end
-
-  def push(child)
-    @childs.push(child)
-    child.build(self)
+    @manager&.execute_modifications(self)
+    @manager&.widgets&.push(self)
+    @childs.each { |child| child.build(self, manager: @manager) }
   end
 
   def configure
-    @config.merge_global_configurations(manager, self)
     @config.configure_tk_widget(tk_widget)
     @config.configure_tearoff
   end
 
-  def check_match(matcher)
-    case matcher
-    when Regexp
-      matcher.match(@id)
-    when String, Symbol
-      matcher == @id
-    when nil
-      true
-    else
-      is_a?(matcher)
+  def each(&block)
+    nodes_to_walk = [self]
+    until nodes_to_walk.empty?
+      node = nodes_to_walk.pop
+      block.call(node)
+      nodes_to_walk = node.childs + nodes_to_walk
     end
   end
 
-  def find(matcher)
-    nodes_to_scan = [self]
-    until nodes_to_scan.empty?
-      node = nodes_to_scan.pop
-      return node if node.check_match(matcher)
-
-      nodes_to_scan = node.childs + nodes_to_scan
-    end
-  end
-
-  def find_all(matcher)
-    found_nodes = []
-    nodes_to_scan = [self]
-
-    until nodes_to_scan.empty?
-      node = nodes_to_scan.pop
-      found_nodes.push(node) if node.check_match(matcher)
-
-      nodes_to_scan = node.childs + nodes_to_scan
-    end
-
-    found_nodes
-  end
-end
-
-# the first parent, which contains a tk_widget, which is really different
-# from self.tk_widget
-def get_container_parent
-  container = @parent
-  while container.tk_widget == tk_widget
-    return unless container.parent # not in a grid?
-
-    container = container.parent
+  def push(child)
+    @childs.push(child)
+    child.build(self)
   end
-  container
-end
-
-# returns the bounding box of the tk_widget
-def cell_bbox
-  return unless (container = get_container_parent)
-
-  grid_info = TkGrid.info(tk_widget)
-  start_col = grid_info['column']
-  end_col = start_col + grid_info['columnspan'] - 1
-  start_row = grid_info['row']
-  end_row = start_row + grid_info['rowspan'] - 1
-
-  TkGrid.bbox(container.tk_widget, start_col, start_row, end_col, end_row)
 end

data/lib/widgets/base/widget_store.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "#{LIB_DIR}/util/tk/finder"
+require_relative 'comparator_item_store'
+
+class TkWrapper::Widgets::Base::WidgetStore
+  extend Forwardable
+
+  def_delegators :@finder, :find, :find_all, :iter
+
+  def initialize
+    @lookup = {}
+    @finder = TkWrapper::Util::Tk::Finder.new(widgets: self, lookup: @lookup)
+  end
+
+  def push(widget)
+    widget.ids.each do |id|
+      (@lookup[id] ||= []).push(widget)
+    end
+  end
+
+  def each(&block)
+    @lookup.each_value do |widgets|
+      widgets.each { |widget| block.call(widget) }
+    end
+  end
+
+  def [](key)
+    @lookup[key].size == 1 ? @lookup[key].first : @lookup[key]
+  end
+
+  private
+
+  def map_key?(key)
+    [String, Symbol].include?(key)
+  end
+end

data/lib/widgets/grid.rb

@@ -10,8 +10,8 @@ class TkWrapper::Widgets::Grid < TkWrapper::Widgets::Base::Widget
     TkWidgets::Frame
   end
 
-  def initialize(config: {}, childs: [])
-    super(config: config, childs: childs)
+  def initialize(**arguments)
+    super(**arguments)
     @childs.map! { |row| row.is_a?(Array) ? row : [row] }
     configure_cells_for_grid
     @childs.flatten! && @childs.select! { |cell| cell.is_a?(Widget) }

data/lib/widgets/menu.rb

@@ -5,8 +5,8 @@ class TkWrapper::Widgets::Menu < TkWrapper::Widgets::Base::Widget
     TkWidgets::TkMenu
   end
 
-  def build(parent)
-    super(parent)
+  def build(parent, **args)
+    super(parent, **args)
     parent.tk_widget['menu'] = tk_widget
   end
 
@@ -15,15 +15,18 @@ class TkWrapper::Widgets::Menu < TkWrapper::Widgets::Base::Widget
       TkWidgets::TkMenu
     end
 
-    def build(parent)
-      super(parent, configure: false)
+    def build(parent, **args)
+      args[:configure] = false
+      super(parent, **args)
       @config[:menu] = tk_widget
       parent.tk_widget.add :cascade, **@config.config
     end
   end
 
   class Command < TkWrapper::Widgets::Base::Widget
-    def build(parent)
+    def build(parent, **args)
+      args[:configure] = false
+      super(parent, **args)
       parent.tk_widget.add :command, **@config.config
     end
   end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tkwrapper
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.5.0
 platform: ruby
 authors:
 - Benjamin Schnitzler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
-dependencies: []
+date: 2021-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 description:
 email: reception@e.mail.de
 executables: []
@@ -19,13 +33,21 @@ files:
 - lib/tk_extensions.rb
 - lib/tkwrapper.rb
 - lib/util/hash_recursive.rb
+- lib/util/tk/cell.rb
+- lib/util/tk/finder.rb
+- lib/util/tk/font.rb
+- lib/util/tk/tk.rb
 - lib/util/virtual_methods.rb
 - lib/widgets/auto_resize_entry.rb
 - lib/widgets/base/base.rb
+- lib/widgets/base/comparator_item_store.rb
 - lib/widgets/base/configuration.rb
 - lib/widgets/base/manager.rb
+- lib/widgets/base/match.rb
+- lib/widgets/base/matcher.rb
+- lib/widgets/base/matches.rb
 - lib/widgets/base/widget.rb
-- lib/widgets/base/widgets.rb
+- lib/widgets/base/widget_store.rb
 - lib/widgets/entry.rb
 - lib/widgets/frame.rb
 - lib/widgets/grid.rb

data/lib/widgets/base/widgets.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class TkWrapper::Widgets::Base::Widgets
-  def initialize
-    @configurations = []
-    @modifications = []
-  end
-
-  def add_configuration(matcher, configuration)
-    @configurations.push(matcher, configuration)
-  end
-
-  def add_modification(matcher, &callback)
-    @modifications.push(matcher, callback)
-  end
-
-  def configurations(widget)
-    @configurations.filter_map do |(matcher, config)|
-      config if widget.check_match(matcher)
-    end
-  end
-
-  def execute_modifications(widget)
-    @modifications.each do |(matcher, callback)|
-      next unless (match = widget.check_match(matcher))
-
-      arguments = match.is_a?(MatchData) ? [widget, match] : [widget]
-      callback.call(*arguments)
-    end
-  end
-end