tkwrapper 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6cf6fe96ebab8380076797dfe3f4ed9747d3f3709cc8d58e1bf1c012d28af572
+  data.tar.gz: b0956e96f04f7daf0b6d6f09317e7b2e73d010e866b57f678fa2fd7ba658fd16
+SHA512:
+  metadata.gz: 848528e93f0dabed494f7e234789edc0108b4460b11964bc661c9457aeabcf2a022565461d4ae3d566de853ad2e96ec06b4112c2abf9f1520912c999675c9bd1
+  data.tar.gz: 613ec39818df4edb5714f0eac7f3aac73c7b403ed0a5d2371103a2e5419ec0c8bc763a2ec068b12538e2476cd29f1e0f49622af3cbcdfa7c7a734edc783c5c62

data/lib/tk_extensions.rb

@@ -0,0 +1,49 @@
+require 'tk'
+require 'tkextlib/tile'
+
+module TkExtensions
+  # allow a Tk widget to have multiple bindings for the same event
+  module MultiBind
+    def bind(event, &callback)
+      @bindings ||= {}
+
+      unless @bindings[event]
+        @bindings[event] = []
+        super(event) { execute_all_bindings(event) }
+      end
+
+      @bindings[event].push(callback)
+    end
+
+    def execute_all_bindings(event)
+      @bindings[event].each(&:call)
+    end
+  end
+
+  module TkWidgets
+    # from several Tk widgets create subclasses, which include MultiBind
+    # the reason why we loop over strings and not the classes themselve is, that
+    # 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
+    ]
+    tk_class_names.each do |tk_class_name|
+      # extract last part of the name (e.g. Tk::Tile::Entry => Entry)
+      new_child_class_name = tk_class_name.match(/([^:]*)$/)[1]
+      # get the class from the class constant name
+      tk_class = const_get(tk_class_name)
+      # create a new child class of tk_class and have it include MultiBind, which
+      # overwrites the bind method of that class to allow for multiple bindings
+      new_child_class = Class.new(tk_class) { include(MultiBind) }
+      # make the new class known to the TkExtensions namespace to allow to use it
+      # by e.g. TkExtensions::Entry
+      const_set(new_child_class_name, new_child_class)
+    end
+  end
+end

data/lib/tkwrapper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+LIB_DIR = __dir__
+
+module TkWrapper end
+
+require_relative 'widgets/widgets'
+
+module TkWrapper
+  Widget = TkWrapper::Widgets::Base::Widget
+end

data/lib/util/hash_recursive.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Util
+  def self.merge_recursive!(*hashes)
+    hashes[0].merge!(*hashes[1..]) do |_key, old, new|
+      if old.is_a?(Hash) && new.is_a?(Hash)
+        merge_recursive!(old, new)
+      else
+        new
+      end
+    end
+  end
+
+  def self.each_recursive(hash, &block)
+    hash.each do |key, value|
+      next block.call(hash, key, value) unless value.is_a?(Hash)
+
+      block.call(hash, key, each_recursive(value, &block))
+    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)
+    end
+  end
+end

data/lib/util/virtual_methods.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# wraps some code of Tk to make it more object oriented, provide new
+# functionality and to ease usage
+module TkWrapper
+  # used to be abled to define virtual methods in a class which is extended by
+  # this module
+  module VirtualMethods
+    # error thrown, when a virtual method is called
+    class VirtualMethodCalledError < RuntimeError
+      def initialize(name)
+        super("Virtual function '#{name}' called.")
+      end
+    end
+
+    def virtual(method)
+      define_method(method) { raise VirtualMethodCalledError, method }
+    end
+  end
+end

data/lib/widgets/auto_resize_entry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+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)
+  end
+
+  def build(parent, configure: true)
+    super(parent, configure: configure)
+    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'
+    } } }
+  end
+
+  def create_dummy_label_with_same_size(&block)
+    label = 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
+  end
+
+  def resize
+    max_width = cell_bbox[2]
+    text_width = text_width_in_pixel
+    new_width = [[@min_width, text_width + @add_width].max, max_width].min
+    tk_widget.width = 0
+    tk_widget.grid(ipadx: new_width / 2.0)
+    @parent.tk_widget.update
+  end
+end

data/lib/widgets/base/base.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TkWrapper::Widgets::Base end
+
+require_relative 'widget'
+require_relative 'manager'
+require_relative 'configuration'

data/lib/widgets/base/configuration.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "#{LIB_DIR}/util/hash_recursive.rb"
+
+require_relative 'base'
+
+class TkWrapper::Widgets::Base::Configuration
+  attr_accessor :config
+
+  GRID_SPECIAL_VALUES = {
+    onecell: {
+      weights: { rows: [1], cols: [1] }
+    },
+    fullcell: {
+      column: 0, row: 0, sticky: 'nsew'
+    },
+    default: {
+      weights: { rows: [1], cols: [1] },
+      column: 0, row: 0, sticky: 'nsew'
+    }
+  }.freeze
+
+  NON_TK_OPTIONS = %i[id tk_class tearoff weights menu].freeze
+
+  def initialize(config)
+    @config = parse!(config)
+  end
+
+  def merge!(*configurations)
+    configurations = configurations.map do |configuration|
+      next configuration.config if configuration.is_a?(self.class)
+
+      parse!(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)
+
+    @config[key]
+  end
+
+  def []=(key, value)
+    key = key.to_sym
+    @config[key] = parse_value(key, value)
+  end
+
+  def parse_value(key, value)
+    case key
+    when :grid
+      parse_grid_value(value)
+    else
+      value
+    end
+  end
+
+  def parse_grid_value(value)
+    return GRID_SPECIAL_VALUES[value] if value.is_a?(Symbol)
+
+    value
+  end
+
+  def grid(only_tk_options: false)
+    return @config[:grid] unless only_tk_options
+
+    @config[:grid].reject { |option, _| NON_TK_OPTIONS.include?(option) }
+  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
+      end
+
+      tk_widget[option] = value
+    end
+
+    configure_weights(tk_widget)
+  end
+
+  def configure_weights(tk_widget)
+    return unless (weights = @config.dig(:grid, :weights))
+
+    (weights[:rows] || []).each_with_index do |weight, index|
+      TkGrid.rowconfigure(tk_widget, index, weight: weight)
+    end
+
+    (weights[:cols] || []).each_with_index do |weight, index|
+      TkGrid.columnconfigure(tk_widget, index, weight: weight)
+    end
+  end
+
+  def configure_tearoff
+    return if (tearoff = @config[:tearoff]).nil?
+
+    TkOption.add '*tearOff', (tearoff ? 1 : 0)
+  end
+
+  def merge_global_configurations(manager, widget)
+    merge!(*manager.configurations(widget))
+  end
+end

data/lib/widgets/base/manager.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# manages widgets and their global configurations
+class TkWrapper::Widgets::Base::Manager
+  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

data/lib/widgets/base/widget.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'tk'
+
+require "#{LIB_DIR}/tk_extensions"
+
+require_relative 'base'
+
+class TkWrapper::Widgets::Base::Widget
+  include TkExtensions
+
+  attr_accessor :config
+  attr_reader :parent, :childs
+
+  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: [])
+    @config = TkWrapper::Widgets::Base::Configuration.new(config)
+    @childs = childs.is_a?(Array) ? childs : [childs]
+    @id = config[:id]
+  end
+
+  def create_tk_widget(parent)
+    tk_class = @config[:tk_class] || self.tk_class
+
+    return unless tk_class
+
+    parent&.tk_widget ? tk_class.new(parent.tk_widget) : tk_class.new
+  end
+
+  # if parent is provided and self has no tk_class, the tk_widget of the
+  # parent is returned, if parent is not nil
+  def tk_widget(parent = @parent)
+    return @tk_widget if @tk_widget
+
+    (@tk_widget = create_tk_widget(parent)) || parent&.tk_widget
+  end
+
+  def build(parent, configure: true)
+    @parent = parent
+    tk_widget # creates the widget if possible and not yet created
+    self.configure if configure
+    manager.execute_modifications(self)
+    @childs.each { |child| child.build(self) }
+  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
+    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
+  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/widgets.rb

@@ -0,0 +1,31 @@
+# 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

data/lib/widgets/entry.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class TkWrapper::Widgets::Entry < TkWrapper::Widgets::Base::Widget
+  def tk_class
+    TkWidgets::Entry
+  end
+end

data/lib/widgets/frame.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class TkWrapper::Widgets::Frame < TkWrapper::Widgets::Base::Widget
+  def tk_class
+    TkWidgets::Frame
+  end
+end

data/lib/widgets/grid.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# classification of TkGrid
+class TkWrapper::Widgets::Grid < TkWrapper::Widgets::Base::Widget
+  attr_reader :parent, :matrix
+
+  def tk_class
+    TkWidgets::Frame
+  end
+
+  def initialize(config: {}, childs: [])
+    super(config: config, childs: childs)
+    @childs.map! { |row| row.is_a?(Array) ? row : [row] }
+    configure_cells_for_grid
+    @childs.flatten! && @childs.select! { |cell| cell.is_a?(Widget) }
+  end
+
+  def configure_cells_for_grid
+    @childs.each_with_index do |row, row_i|
+      row.each_with_index do |cell, col_i|
+        next unless cell.is_a?(Widget)
+
+        (cell.config[:grid] ||= {}).merge!({ row: row_i, column: col_i })
+
+        configure_colspan(cell, row_i, col_i)
+        configure_rowspan(cell, row_i, col_i)
+      end
+    end
+  end
+
+  def configure_colspan(cell, row_i, col_i)
+    cols_after_cell = @childs[row_i][(col_i + 1)..]
+    colspan = cols_after_cell.reduce(1) do |span, content|
+      content == :right ? span + 1 : (break span)
+    end
+    (cell.config[:grid] ||= {}).merge!({ columnspan: colspan })
+  end
+
+  def configure_rowspan(cell, row_i, col_i)
+    rows_after_cell = @childs[(row_i + 1)..]
+    rowspan = rows_after_cell.reduce(1) do |span, row|
+      row[col_i] == :bottom ? span + 1 : (break span)
+    end
+    (cell.config[:grid] ||= {}).merge!({ rowspan: rowspan })
+  end
+end

data/lib/widgets/label.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class TkWrapper::Widgets::Label < TkWrapper::Widgets::Base::Widget
+  def tk_class
+    TkWidgets::Label
+  end
+end

data/lib/widgets/menu.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class TkWrapper::Widgets::Menu < TkWrapper::Widgets::Base::Widget
+  def tk_class
+    TkWidgets::TkMenu
+  end
+
+  def build(parent)
+    super(parent)
+    parent.tk_widget['menu'] = tk_widget
+  end
+
+  class Cascade < TkWrapper::Widgets::Base::Widget
+    def tk_class
+      TkWidgets::TkMenu
+    end
+
+    def build(parent)
+      super(parent, configure: false)
+      @config[:menu] = tk_widget
+      parent.tk_widget.add :cascade, **@config.config
+    end
+  end
+
+  class Command < TkWrapper::Widgets::Base::Widget
+    def build(parent)
+      parent.tk_widget.add :command, **@config.config
+    end
+  end
+
+  def self.create(structure: [], config: {})
+    Menu.new(
+      config: config,
+      childs: structure.map { |entry| create_subentry(entry) }
+    )
+  end
+
+  def self.create_subentries(structure)
+    return [] unless structure && !structure.nil?
+
+    structure = [structure] unless structure.is_a?(Array)
+    structure.map { |entry| create_subentry(**entry) }
+  end
+
+  def self.create_subentry(entry)
+    case entry
+    in { config: config, structure: structure }
+      return Cascade.new config: config, childs: create_subentries(structure)
+    else
+      return Command.new config: entry
+    end
+  end
+end

data/lib/widgets/root.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class TkWrapper::Widgets::Root < TkWrapper::Widgets::Base::Widget
+  def initialize(**arguments)
+    super(**arguments)
+    build(nil)
+  end
+
+  def tk_class
+    TkWidgets::TkRoot
+  end
+end

data/lib/widgets/text.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class TkWrapper::Widgets::Text < TkWrapper::Widgets::Base::Widget
+  def tk_class
+    TkWidgets::TkText
+  end
+end

data/lib/widgets/widgets.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module TkWrapper::Widgets end
+
+require_relative 'base/base'
+
+require_relative 'root'
+require_relative 'frame'
+require_relative 'label'
+require_relative 'menu'
+require_relative 'text'
+require_relative 'entry'
+require_relative 'auto_resize_entry'
+require_relative 'grid'

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: tkwrapper
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Benjamin Schnitzler
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-12-12 00:00:00.000000000 Z
+dependencies: []
+description:
+email: reception@e.mail.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tk_extensions.rb
+- lib/tkwrapper.rb
+- lib/util/hash_recursive.rb
+- lib/util/virtual_methods.rb
+- lib/widgets/auto_resize_entry.rb
+- lib/widgets/base/base.rb
+- lib/widgets/base/configuration.rb
+- lib/widgets/base/manager.rb
+- lib/widgets/base/widget.rb
+- lib/widgets/base/widgets.rb
+- lib/widgets/entry.rb
+- lib/widgets/frame.rb
+- lib/widgets/grid.rb
+- lib/widgets/label.rb
+- lib/widgets/menu.rb
+- lib/widgets/root.rb
+- lib/widgets/text.rb
+- lib/widgets/widgets.rb
+homepage: https://github.com/bschnitz/tkwrapper
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.29
+signing_key:
+specification_version: 4
+summary: Extensions/Wrapper ruby Tk
+test_files: []