tkwrapper 1.2.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a31665aae98cd470f88451d45cd6332030c8fe874e18faa1040bcd42103d9ace
-  data.tar.gz: 93f428a63f6bf0832bf91accfdec1f14715cbfc6de2e9055f29b4cb146da0bf7
+  metadata.gz: 25ebb6c8831b18ae3b55f4d98896cc5cf824d628fd4bc245b6fc1ed9fd8c5ef0
+  data.tar.gz: b90ca62d87faa02e1a07f5f1145e175d55dfcfeacd71782c709a484038701dfc
 SHA512:
-  metadata.gz: 461b4344678f1d7a374ad6d1d01ffbab5c4865a9c513457c7145b21e9582e9d0922d3666a93adf6ed8f57428c6485b8e693694438db1966a7967c01c0ae6e3fc
-  data.tar.gz: f0a8d152e7aac88206454340c2fbce7e605117a85e2dc0cd550bffc4db9e49d09dd21b4610e52e19a87dc6313ce37b98c9a4bc4e8c44bf033b3f84fe41289833
+  metadata.gz: b4d1820254e60b3d9ce4be52a8875b0acbda213dac7aa200352d794ff1146611e84ac1f9bb16589f6fa6d61ba3b65468c940cf27d965ead1e3913fbc5b1cce7e
+  data.tar.gz: fd00a3c5ae1c29aa66762f554a43223a5ce32ef538c340a8549ba56fb12853743f80ae90862aac30f99383be61497fe1744bbb85e7ca7ef1e83d32785e4f5133

data/lib/tk_extensions.rb

@@ -26,12 +26,13 @@ module TkExtensions
     # the class names may be aliases (e.g. Tk::Tile::Entry is an alias for
     # Tk::Tile::TEntry)
     tk_class_names = [
-      'TkRoot',          # becomes TkExtensions::TkRoot
-      'TkText',          # becomes TkExtensions::TkText
-      'TkMenu',          # becomes TkExtensions::TkMenu
-      'Tk::Tile::Entry', # becomes TkExtensions::Entry
-      'Tk::Tile::Frame', # becomes TkExtensions::Frame
-      'Tk::Tile::Label'  # becomes TkExtensions::Label
+      'TkRoot',           # becomes TkExtensions::TkWidgets::TkRoot
+      'TkText',           # becomes TkExtensions::TkWidgets::TkText
+      'TkMenu',           # becomes TkExtensions::TkWidgets::TkMenu
+      'Tk::Tile::Entry',  # becomes TkExtensions::TkWidgets::Entry
+      'Tk::Tile::Frame',  # becomes TkExtensions::TkWidgets::Frame
+      'Tk::Tile::Label',  # becomes TkExtensions::TkWidgets::Label
+      'Tk::Tile::Button'  # becomes TkExtensions::TkWidgets::Button
     ]
     tk_class_names.each do |tk_class_name|
       # extract last part of the name (e.g. Tk::Tile::Entry => Entry)

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,37 @@
+# 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
+
+    container.tk_widget.update
+    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,66 @@
+# 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)
+    comparators = [comparators] unless comparators.is_a?(Array)
+    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.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|
+      ids = widget.ids.empty? ? [nil] : widget.ids
+      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,14 +4,14 @@ 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[:min_width] || 0
-    @add_width = config[: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 }
@@ -26,43 +26,9 @@ class TkWrapper::Widgets::AutoResizeEntry < TkWrapper::Widgets::Entry
     tk_widget.textvariable.value
   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'
-    } } }
-  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 = 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
-  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

@@ -21,7 +21,7 @@ class TkWrapper::Widgets::Base::Configuration
   }.freeze
 
   NON_TK_OPTIONS = %i[
-    id tk_class tearoff weights menu min_width add_width
+    tk_class tearoff weights menu min_width add_width
   ].freeze
 
   def initialize(config)
@@ -77,17 +77,23 @@ class TkWrapper::Widgets::Base::Configuration
     @config[:grid].reject { |option, _| NON_TK_OPTIONS.include?(option) }
   end
 
+  def configure_grid(tk_widget)
+    grid = grid(only_tk_options: true)
+    return if grid.empty?
+
+    tk_widget.grid(grid)
+  end
+
   def configure_tk_widget(tk_widget)
     @config.each do |option, value|
       next if NON_TK_OPTIONS.include?(option)
 
-      if option == :grid
-        grid = grid(only_tk_options: true)
-        next if grid.empty?
-        next tk_widget.grid(grid) if option == :grid
+      case option
+      when :grid  then configure_grid(tk_widget)
+      when :pack  then tk_widget.pack(value)
+      when :place then tk_widget.place(value)
+      else             tk_widget[option] = value
       end
-
-      tk_widget[option] = value
     end
 
     configure_weights(tk_widget)
@@ -112,6 +118,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,62 +1,56 @@
 # 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
-    @configuration_matchers = { regex: {}, map: {} }
-    @modification_matchers = { regex: {}, map: {} }
+    @configurations = ComparatorItemStore.new
+    @modifications = ComparatorItemStore.new
+    @widgets = WidgetStore.new
   end
 
-  def add_configurations(matcher = nil, config = nil, **configs)
-    add_matcher(matcher, config, @configuration_matchers) if config
+  def add_configurations(matcher = nil, configuration = nil, **configurations)
+    add_configuration(matcher, configuration) if configuration
 
-    configs.each { |mat, cfg| add_matcher(mat, cfg, @configuration_matchers) }
+    configurations.each { |mat, cfg| add_configuration(mat, cfg) }
+  end
+
+  def add_configuration(comparator, configuration)
+    @configurations.push(comparator, configuration)
   end
 
   def add_modification(matcher, &callback)
-    add_matcher(matcher, callback, @modification_matchers)
+    @modifications.push(matcher, callback)
   end
 
   def configurations(widget)
-    configs = find_matching_items(widget.ids, @configuration_matchers)
-    configs.map { |config| config[0] }
+    config_list = @configurations.items_and_matches_for_widget(widget)
+    config_list.map { |configs| configs[:items] }.flatten(1)
   end
 
   def execute_modifications(widget)
-    callbacks = find_matching_items(widget.ids, @modification_matchers)
-    callbacks.each do |callback|
-      callback, match = callback
-      match ? callback.call(widget, match) : callback.call(widget)
-    end
-  end
-
-  private
-
-  def find_matching_items(keys, container)
-    keys.each_with_object([]) do |key, items|
-      items.concat(
-        items_from_map(key, container),
-        items_by_regex(key, container)
-      )
+    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 items_from_map(key, container)
-    (container[:map][key] || []).map { |item| [item, nil] } || []
+  def configure(widget)
+    widget.config.merge(*configurations(widget))
   end
 
-  def items_by_regex(key, container)
-    container[:regex].each_with_object([]) do |(matcher, items), merged_items|
-      match = matcher.match(key)
-      merged_items.concat(items.map { |item| [item, match] }) if match
-    end
+  def tk_widget(id)
+    @widgets[id].tk_widget
   end
 
-  def add_matcher(matcher, item, container)
-    if matcher.is_a?(Regexp)
-      (container[:regex][matcher] ||= []).push(item)
-    else
-      (container[:map][matcher] ||= []).push(item)
-    end
-  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,47 +1,30 @@
-# 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'
+require_relative 'window_info'
 
 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, :winfo
 
   def tk_class() end
 
-  def self.manager
-    @manager ||= TkWrapper::Widgets::Base::Manager.new
-  end
-
-  def self.config(matcher = nil, configuration = nil, **configurations)
-    manager.add_configurations(matcher, configuration, **configurations)
-  end
-
-  def self.modify(matcher, &callback)
-    manager.add_modification(matcher, &callback)
-  end
-
-  def ids
-    case @id
-    when Array then @id
-    when nil then   []
-    else            [@id]
-    end
-  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)
+    @winfo = TkWrapper::Widgets::Base::WindowInfo.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)
@@ -49,7 +32,7 @@ class TkWrapper::Widgets::Base::Widget
 
     return unless tk_class
 
-    parent&.tk_widget ? tk_class.new(parent.tk_widget) : tk_class.new
+    tk_class.new(parent&.tk_widget)
   end
 
   # if parent is provided and self has no tk_class, the tk_widget of the
@@ -60,84 +43,38 @@ class TkWrapper::Widgets::Base::Widget
     (@tk_widget = create_tk_widget(parent)) || parent&.tk_widget
   end
 
-  def build(parent, configure: true)
+  def build_childs
+    @childs.each { |child| child.build(self, manager: @manager) }
+  end
+
+  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)
+    build_childs
   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)
-    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
+  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_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, manager: @manager)
   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,38 @@
+# 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
+    (@lookup[nil] ||= []).push(widget) if widget.ids.empty?
+  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/base/window_info.rb

@@ -0,0 +1,13 @@
+class TkWrapper::Widgets::Base::WindowInfo
+  def initialize(widget)
+    @widget = widget
+  end
+
+  def method_missing(name, *args)
+    if @widget.tk_widget.respond_to?("winfo_#{name}")
+      @widget.tk_widget.send("winfo_#{name}", *args)
+    else
+      super
+    end
+  end
+end

data/lib/widgets/button.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class TkWrapper::Widgets::Button < TkWrapper::Widgets::Base::Widget
+  def tk_class
+    TkWidgets::Button
+  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

data/lib/widgets/mount_point.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class TkWrapper::Widgets::MountPoint < TkWrapper::Widgets::Base::Widget
+  def initialize(**args)
+    super(**args)
+  end
+
+  def build_childs(skip: true)
+    super() unless skip
+  end
+
+  def mount=(childs)
+    mount(childs)
+  end
+
+  def mount(childs = nil)
+    if childs
+      @childs = childs.is_a?(Array) ? childs : [childs]
+    end
+    @childs.each do |child|
+      child.config.merge(@config)
+    end
+    build_childs(skip: false)
+  end
+end

data/lib/widgets/widgets.rb

@@ -12,3 +12,5 @@ require_relative 'text'
 require_relative 'entry'
 require_relative 'auto_resize_entry'
 require_relative 'grid'
+require_relative 'mount_point'
+require_relative 'button'

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tkwrapper
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Benjamin Schnitzler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
-dependencies: []
+date: 2021-12-20 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,18 +33,29 @@ 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/base/window_info.rb
+- lib/widgets/button.rb
 - lib/widgets/entry.rb
 - lib/widgets/frame.rb
 - lib/widgets/grid.rb
 - lib/widgets/label.rb
 - lib/widgets/menu.rb
+- lib/widgets/mount_point.rb
 - lib/widgets/root.rb
 - lib/widgets/text.rb
 - lib/widgets/widgets.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