tkwrapper 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a31665aae98cd470f88451d45cd6332030c8fe874e18faa1040bcd42103d9ace
-  data.tar.gz: 93f428a63f6bf0832bf91accfdec1f14715cbfc6de2e9055f29b4cb146da0bf7
+  metadata.gz: 957efe49807e9800759aa22439bc99f5ea4ef0ec620bc7ea0b7d549474839a7a
+  data.tar.gz: f654e23817c14ce6e59d67e7893f55c33c9168686faf66cbf0a96f955f4e7c6e
 SHA512:
-  metadata.gz: 461b4344678f1d7a374ad6d1d01ffbab5c4865a9c513457c7145b21e9582e9d0922d3666a93adf6ed8f57428c6485b8e693694438db1966a7967c01c0ae6e3fc
-  data.tar.gz: f0a8d152e7aac88206454340c2fbce7e605117a85e2dc0cd550bffc4db9e49d09dd21b4610e52e19a87dc6313ce37b98c9a4bc4e8c44bf033b3f84fe41289833
+  metadata.gz: 4891b05ca78bff3d2119b6b4d8ba0be178836d1cdd7475e07ddc3be19100d766e0ca0d9878d4afc9be330ffbf3ea008914d4f4432b0e3eff2df8cc02534b74f4
+  data.tar.gz: 3ece495be24159cefde0ca65899c3022b181a3bb0d92e40727a9cbc2ca4494d376504a58313190a94fbf4dc8751949873753ec1c2313d9db4cc28fb29174a466

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_widget(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_widgets(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,10 +4,10 @@ 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: [])
+  def initialize(config: {}, childs: [], id: nil)
     @min_width = config[:min_width] || 0
     @add_width = config[:add_width] || 0
-    super(config: config, childs: childs)
+    super(config: config, childs: childs, id: id)
   end
 
   def build(parent, configure: true)
@@ -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]
+    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/manager.rb

@@ -1,62 +1,40 @@
 # 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
-    @configuration_matchers = { regex: {}, map: {} }
-    @modification_matchers = { regex: {}, map: {} }
+    @configurations = ComparatorItemStore.new
+    @modifications = ComparatorItemStore.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
+
+    configurations.each { |mat, cfg| add_configuration(mat, cfg) }
+  end
 
-    configs.each { |mat, cfg| add_matcher(mat, cfg, @configuration_matchers) }
+  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)
-      )
-    end
-  end
-
-  def items_from_map(key, container)
-    (container[:map][key] || []).map { |item| [item, nil] } || []
-  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
-  end
-
-  def add_matcher(matcher, item, container)
-    if matcher.is_a?(Regexp)
-      (container[:regex][matcher] ||= []).push(item)
-    else
-      (container[:map][matcher] ||= []).push(item)
+    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
 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

@@ -3,14 +3,22 @@
 require 'tk'
 
 require "#{LIB_DIR}/tk_extensions"
+require "#{LIB_DIR}/util/tk/font"
+require "#{LIB_DIR}/util/tk/cell"
+require "#{LIB_DIR}/util/tk/finder"
 
 require_relative 'base'
 
 class TkWrapper::Widgets::Base::Widget
+  extend Forwardable
   include TkExtensions
+  include Enumerable
+
+  def_delegator :@finder, :find_widget, :find
+  def_delegator :@finder, :find_all_widgets, :find_all
 
   attr_accessor :config
-  attr_reader :parent, :childs
+  attr_reader :parent, :ids, :cell, :childs
 
   def tk_class() end
 
@@ -26,22 +34,34 @@ class TkWrapper::Widgets::Base::Widget
     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 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 initialize(config: {}, childs: [], id: nil)
+    @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]
+    @ids = []
+    add_ids(id)
+    add_ids(config[:id])
+  end
+
+  def add_ids(ids)
+    return unless ids
+
+    ids = [ids] unless ids.is_a?(Array)
+    @ids.concat(ids)
   end
 
   def create_tk_widget(parent)
@@ -63,6 +83,7 @@ class TkWrapper::Widgets::Base::Widget
   def build(parent, configure: true)
     @parent = parent
     tk_widget # creates the widget if possible and not yet created
+    @font = TkWrapper::Util::Tk::Font.new(tk_widget)
     self.configure if configure
     manager.execute_modifications(self)
     @childs.each { |child| child.build(self) }
@@ -79,65 +100,21 @@ class TkWrapper::Widgets::Base::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)
+  def modify(matchers, &callback)
+    items = find_all(matchers)
 
-      nodes_to_scan = node.childs + nodes_to_scan
-    end
+    callback.call(items)
   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)
+  def modify_each(matchers, &callback)
+    items = find_all(matchers)
 
-      nodes_to_scan = node.childs + nodes_to_scan
-    end
-
-    found_nodes
-  end
-end
+    return unless items
 
-# 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?
+    with_match = items[0].is_a?(Array)
 
-    container = container.parent
+    items.each do |item|
+      with_match ? callback.call(item[0], item[1]) : callback.call(item)
+    end
   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(config: {}, childs: [], id: nil)
+    super(config: config, childs: childs, id: id)
     @childs.map! { |row| row.is_a?(Array) ? row : [row] }
     configure_cells_for_grid
     @childs.flatten! && @childs.select! { |cell| cell.is_a?(Widget) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tkwrapper
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.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