tkwrapper 1.0.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adff2bad961cbadb878bb2abbe0a6fbc94ff538889b6460dedea974821743874
-  data.tar.gz: f2ef0b44bc561ebe718e68197348974d6c85973dfe9a2f95f73a8b30229c7450
+  metadata.gz: 81c1971220f794d1e17288aac5b75221393727be934288a4993a621c35b3282d
+  data.tar.gz: f2a841f6f3a6a7ee040c85fe0f2081234780bf1ff0bf4aeb70de9cf4c2a75055
 SHA512:
-  metadata.gz: '0032648213c0a318b02756bf63dbef4e6375f3af1554c94cb369c858a0ed2be7c2f17456493429e5f32ed62b65ad1710f63599d3ae98f1a585596f52ecc612c7'
-  data.tar.gz: 0c737c6ebe8f1d06ae6061f8666066663abb41ee4be1317be3e2701da815f892ede6fca30db77ddf17adff726e99f6ebdc765c6f33ceb57fdeb6d13e5dac7f34
+  metadata.gz: 22cf843324096411be2441088df910d723ecc353aa6b54dd64ba5703b2fcd47bec3c2424a38e910fefb187fdcf23ec60dd44640de3f0657a3cb2969e84da016c
+  data.tar.gz: acb296b0e78c570e7d80ba96d91c4ebf62ecfd1ce7c97fac088546d599e0468a23dafac325ee14ae9fa0d4d08a9c8c70e5972df849346a05d8e2ac3ee9fb1154

data/lib/tkwrapper.rb

@@ -7,5 +7,6 @@ module TkWrapper end
 require_relative 'widgets/widgets'
 
 module TkWrapper
+  Manager = TkWrapper::Widgets::Base::Manager
   Widget = TkWrapper::Widgets::Base::Widget
 end

data/lib/util/hash_recursive.rb

@@ -19,12 +19,9 @@ module Util
     end
   end
 
-  def self.recursive_transform_key_value!(hash, &block)
-    hash.transform_keys! do |key|
-      value = hash[key]
-      next recursive_transform_key_value!(value, &block) if value.is_a?(Hash)
-
-      block.call(key, value)
+  def self.clone_recursive(hash)
+    hash.transform_values do |value|
+      value.is_a?(Hash) ? clone_recursive(value) : value
     end
   end
 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,49 @@
+# frozen_string_literal: true
+
+require "#{LIB_DIR}/widgets/base/manager"
+require "#{LIB_DIR}/widgets/base/matcher"
+require_relative 'tk'
+
+class TkWrapper::Util::Tk::Finder
+  Matcher = TkWrapper::Widgets::Base::Matcher
+
+  def initialize(widgets: nil)
+    @widgets = widgets
+  end
+
+  def each_widget_match(widgets, matchers, &block)
+    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
+
+  def find(comparators, widgets = @widgets)
+    matchers = create_value_matchers(comparators)
+
+    each_widget_match(widgets, matchers) do |match|
+      return match.widget if match
+    end
+  end
+
+  def find_all(comparators, widgets = @widgets)
+    matchers = create_value_matchers(comparators)
+    matches = TkWrapper::Widgets::Base::Matches.new
+
+    each_widget_match(widgets, matchers) do |match|
+      matches.push(match)
+    end
+
+    matches
+  end
+
+  private
+
+  def create_value_matchers(comparators)
+    comparators = [comparators] unless comparators.is_a?(Array)
+    comparators.map { |comparator| Matcher.new(comparator: comparator) }
+  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[:config][:min_width] || 0
+    @add_width = args[: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]
+    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,41 @@
+# 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 push(key, *items)
+    if [String, Symbol].include?(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
+
+  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

@@ -5,7 +5,7 @@ require "#{LIB_DIR}/util/hash_recursive.rb"
 require_relative 'base'
 
 class TkWrapper::Widgets::Base::Configuration
-  attr_accessor :config
+  attr_reader :config
 
   GRID_SPECIAL_VALUES = {
     onecell: {
@@ -20,32 +20,24 @@ 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!(config)
+    @config = parse_and_clone(config)
   end
 
-  def merge!(*configurations)
+  def merge(*configurations)
     configurations = configurations.map do |configuration|
-      next configuration.config if configuration.is_a?(self.class)
+      configuration = configuration.config if configuration.is_a?(self.class)
 
-      parse!(configuration)
+      parse_and_clone(configuration)
     end
 
     Util.merge_recursive!(@config, *configurations)
   end
 
-  def parse!(config)
-    Util.each_recursive(config) do |hash, key, value|
-      next if value.is_a?(Hash)
-
-      hash[key] = parse_value(key, value)
-    end
-
-    config
-  end
-
   def [](key)
     key = key.to_sym
     return self.class.new(@config[key]) if @config[key].is_a?(Hash)
@@ -55,7 +47,13 @@ class TkWrapper::Widgets::Base::Configuration
 
   def []=(key, value)
     key = key.to_sym
-    @config[key] = parse_value(key, value)
+    @config[key] = parse_and_clone(value, key)
+  end
+
+  def parse_and_clone(value, key = nil)
+    return parse_value(key, value) unless value.is_a?(Hash)
+
+    value.each_with_object({}) { |(k, v), h| h[k] = parse_and_clone(v, k) }
   end
 
   def parse_value(key, value)
@@ -114,6 +112,8 @@ class TkWrapper::Widgets::Base::Configuration
   end
 
   def merge_global_configurations(manager, widget)
-    merge!(*manager.configurations(widget))
+    return unless manager
+
+    merge(*manager.configurations(widget))
   end
 end

data/lib/widgets/base/manager.rb

@@ -1,32 +1,47 @@
 # frozen_string_literal: true
 
-# manages widgets and their global configurations
+require_relative 'comparator_item_store'
+
 class TkWrapper::Widgets::Base::Manager
+  ComparatorItemStore = TkWrapper::Widgets::Base::ComparatorItemStore
+
   def initialize
-    @configurations = []
-    @modifications = []
+    @configurations = ComparatorItemStore.new
+    @modifications = ComparatorItemStore.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,34 @@
+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
+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,79 +41,33 @@ 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) }
+    @manager&.execute_modifications(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
+  def push(child)
+    @childs.push(child)
+    child.build(self)
   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
-  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/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) }
@@ -22,7 +22,7 @@ class TkWrapper::Widgets::Grid < TkWrapper::Widgets::Base::Widget
       row.each_with_index do |cell, col_i|
         next unless cell.is_a?(Widget)
 
-        (cell.config[:grid] ||= {}).merge!({ row: row_i, column: col_i })
+        cell.config.merge({ grid: { row: row_i, column: col_i } })
 
         configure_colspan(cell, row_i, col_i)
         configure_rowspan(cell, row_i, col_i)
@@ -35,7 +35,7 @@ class TkWrapper::Widgets::Grid < TkWrapper::Widgets::Base::Widget
     colspan = cols_after_cell.reduce(1) do |span, content|
       content == :right ? span + 1 : (break span)
     end
-    (cell.config[:grid] ||= {}).merge!({ columnspan: colspan })
+    cell.config.merge({ grid: { columnspan: colspan } })
   end
 
   def configure_rowspan(cell, row_i, col_i)
@@ -43,6 +43,6 @@ class TkWrapper::Widgets::Grid < TkWrapper::Widgets::Base::Widget
     rowspan = rows_after_cell.reduce(1) do |span, row|
       row[col_i] == :bottom ? span + 1 : (break span)
     end
-    (cell.config[:grid] ||= {}).merge!({ rowspan: rowspan })
+    cell.config.merge({ grid: { rowspan: rowspan } })
   end
 end

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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tkwrapper
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.4.0
 platform: ruby
 authors:
 - Benjamin Schnitzler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies: []
 description:
 email: reception@e.mail.de
@@ -19,13 +19,20 @@ 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/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