tk_component 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0588f1482fd807ba8c250d1e3098f2a0271bda795a0264fba9ccdced638cbdb5'
+  data.tar.gz: 2360a3b2cb6bb52aa9ae17815d3f345782da42f1f563c357d35685f13153d468
+SHA512:
+  metadata.gz: 89b625e7097f5109bc4fbf903c098284c857ec6aece46fadb9f2d598004191ee9a5825010e05bd86342a515cea97f6b342d9d6f619f61f33d24ff93b192b5620
+  data.tar.gz: a647f65cc892c511cc5d6bd693b4d6865a3355b5839add9cd7c8fd1acde6e7a30ba0a5e73f2b456f32e3005b45ca025cf589a568a401d3607db94eaa3437b1bf

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.3
+before_install: gem install bundler -v 1.16.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at jes@josepegea.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in tk_component.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    tk_component (0.1.0)
+      activesupport (~> 6.0.3)
+      tk (~> 0.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.0.3.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.4.4)
+    i18n (1.8.5)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.2)
+    rake (10.5.0)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+    thread_safe (0.3.6)
+    tk (0.3.0)
+    tzinfo (1.2.8)
+      thread_safe (~> 0.1)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  tk_component!
+
+BUNDLED WITH
+   1.16.6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# TkComponent
+
+TkComponent allows you to create desktop UIs using a component structure taking advantadge of TK, the UI toolkit created for TCL and used by Python in TkInter
+
+Still very much a work in progress.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tk_component'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tk_component
+
+## Usage
+
+TODO: Nothing written yet.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/josepegea/tk_component. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the TkComponent project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/josepegea/tk_component/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tk_component"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/tk_component.rb

@@ -0,0 +1,6 @@
+require "tk_component/version"
+require "active_support/all"
+
+require_relative 'tk_component/base'
+require_relative 'tk_component/window'
+require_relative 'tk_component/builder'

data/lib/tk_component/base.rb

@@ -0,0 +1,67 @@
+require 'tk'
+require 'tkextlib/tile'
+
+module TkComponent
+  class Base
+
+    attr_accessor :tk_item
+    attr_accessor :parent
+    attr_accessor :parent_node
+    attr_accessor :children
+    attr_accessor :node
+
+    def initialize(options = {})
+      @parent = options[:parent]
+      @parent_node = options[:parent_node]
+      @children = []
+    end
+
+    def parse_component(parent_component, options = {})
+      raise "You need to provide a block" unless block_given?
+      @node = Builder::Node.new(:top, options)
+      yield(@node)
+      binding.pry if @node.sub_nodes.size != 1
+      raise "Components need to have a single root node" unless @node.sub_nodes.size == 1
+      @node.prepare_option_events(self)
+      @node.prepare_grid
+      @node = @node.sub_nodes.first # Get rid of the dummy top node
+    end
+
+    def build(parent_component)
+      @node.build(@parent_node, parent_component)
+      component_did_build
+      children.each do |c|
+        c.build(self)
+      end
+    end
+
+    def regenerate
+      old_node = @node
+      generate(parent)
+      rebuild(old_node)
+      children.each do |c|
+        c.regenerate
+      end
+    end
+
+    def rebuild(old_node)
+      build(parent)
+    end
+
+    def name
+      self.class.name
+    end
+
+    def emit(event_name)
+      TkComponent::Builder::Event.emit('ParamChanged', parent_node.native_item, self.object_id)
+    end
+
+    def component_did_build
+    end
+
+    def add_child(child)
+      binding.pry if children.nil?
+      children << child
+    end
+  end
+end

data/lib/tk_component/builder.rb

@@ -0,0 +1,5 @@
+require_relative 'builder/node'
+require_relative 'builder/grid_map'
+require_relative 'builder/event'
+require_relative 'builder/event_handler'
+require_relative 'builder/tk_item'

data/lib/tk_component/builder/event.rb

@@ -0,0 +1,97 @@
+module TkComponent
+  module Builder
+    class Event
+      attr_accessor :name
+      attr_accessor :sender
+      attr_accessor :button_index
+      attr_accessor :key_code
+      attr_accessor :key_string
+      attr_accessor :mouse_x
+      attr_accessor :mouse_y
+      attr_accessor :root_mouse_x
+      attr_accessor :root_mouse_y
+      attr_accessor :mouse_wheel_delta
+      attr_accessor :data
+
+      EVENT_ATTRS = "%x %y %X %Y %b %D %A %k %d"
+
+      def initialize(name, sender)
+        @name = name.to_sym
+        @sender = sender
+      end
+
+      def self.emit(name, source, data)
+        Tk.event_generate(source, "<#{name}>", data: data)
+      end
+
+      def self.bind_command(name, sender, options, lambda)
+        sender.native_item.command do
+          event = self.new(name, sender)
+          lambda.call(event)
+        end
+      end
+
+      def self.bind_variable(name, sender, options, lambda)
+        handler = proc do
+          event = self.new(name, sender)
+          lambda.call(event)
+        end
+        sender.tk_variable.trace('write', handler)
+      end
+
+      def self.bind_event(name, sender, options, lambda, pre_lambda = nil, post_lambda = nil)
+        event_string = self.event_string_for(name, options)
+        handler = proc do |x, y, rx, ry, bi, mw, ks, kc, data|
+          event = self.new(name, sender)
+          event.mouse_x = x
+          event.mouse_y = y
+          event.root_mouse_x = rx
+          event.root_mouse_y = ry
+          event.button_index = bi
+          event.mouse_wheel_delta = mw
+          event.key_string = ks
+          event.key_code = kc
+          event.data = data
+          # The pre_lambda returns true if it wants to prevent the event from firing
+          return if pre_lambda.present? && pre_lambda.call(event)
+          lambda.call(event)
+          post_lambda.call(event) if post_lambda.present?
+        end
+        sender.native_item.bind(event_string, handler, EVENT_ATTRS)
+      end
+
+      def data_object
+        @data_object ||= begin
+                           ObjectSpace._id2ref(self.data.to_i)
+                         rescue
+                           nil
+                         end
+      end
+
+      private
+
+      def self.event_string_for(name, options)
+        event_name = self.resolve_event_alias(name).to_s.camelize
+        event_prefix = ''
+        if button = options[:button]
+          event_prefix << "B#{button}"
+        end
+        event_name = event_prefix + '-' + event_name if event_prefix.present?
+        event_name
+      end
+
+      EVENT_ALIASES = {
+        mouse_drag: :motion,
+        mouse_down: :button_press,
+        mouse_up: :button_release
+      }
+
+      def self.resolve_event_alias(name)
+        if (found = EVENT_ALIASES[name])
+          name = found
+        end
+        name
+      end
+    end
+  end
+end

data/lib/tk_component/builder/event_handler.rb

@@ -0,0 +1,15 @@
+module TkComponent
+  module Builder
+    class EventHandler
+      attr_accessor :name
+      attr_accessor :lambda
+      attr_accessor :options
+
+      def initialize(name, lambda, options = {})
+        @name = name.to_sym
+        @lambda = lambda
+        @options = options
+      end
+    end
+  end
+end

data/lib/tk_component/builder/grid_map.rb

@@ -0,0 +1,73 @@
+module TkComponent
+  module Builder
+    class GridMap
+      def initialize
+        @rows = []
+        @row_weights = []
+        @column_weights = []
+      end
+
+      def get(row, col)
+        return nil if row >= @rows.size
+        return nil if (cols = @rows[row]).nil? || col >= cols.size
+        cols[col]
+      end
+
+      def set(row, col, val)
+        @rows[row] = [] if row > @rows.size || @rows[row].nil?
+        @rows[row][col] = val
+      end
+
+      def fill(row, col, rowspan, columnspan, val)
+        for r in (row .. row + rowspan - 1) do
+          for c in (col .. col + columnspan - 1) do
+            set(r, c, val)
+          end
+        end
+      end
+
+      def row_weight(row)
+        @row_weights[row] || 0
+      end
+
+      def column_weight(col)
+        @column_weights[col] || 0
+      end
+
+      def set_weights(row, col, weights = {})
+        hw = weights[:h_weight]
+        @row_weights[row] = ((rw = @row_weights[row]).present? ? [rw, hw].max : hw) if hw
+        vw = weights[:v_weight]
+        @column_weights[col] = ((cw = @column_weights[col]).present? ? [cw, vw].max : vw) if vw
+      end
+
+      def row_indexes
+        used_indexes(@rows)
+      end
+
+      def column_indexes
+        @rows.reduce([]) { |accum, r| accum += used_indexes(r) }.uniq
+      end
+
+      def get_next_cell(current_row, current_col, going_down)
+        if going_down
+          while get(current_row, current_col) do current_row += 1 end
+        else
+          while get(current_row, current_col) do current_col += 1 end
+        end
+        [current_row, current_col]
+      end
+
+      def to_s
+        @rows.to_s
+      end
+
+      private
+
+      def used_indexes(array)
+        return [] if array.nil?
+        array.map.with_index { |o, i| o.present? ? i : nil }.compact
+      end
+    end
+  end
+end

data/lib/tk_component/builder/node.rb

@@ -0,0 +1,140 @@
+module TkComponent
+  module Builder
+
+    TK_CMDS = %w(label entry button canvas text scale group).to_set.freeze
+    LAYOUT_CMDS = %w(frame hframe vframe row cell).to_set.freeze
+    EVENT_CMDS = %w(on_change on_mouse_down on_mouse_up on_mouse_drag on_mouse_wheel on_click on_event).to_set.freeze
+    TOKENS = (TK_CMDS + LAYOUT_CMDS + EVENT_CMDS).freeze
+
+    class Node
+      attr_accessor :name
+      attr_accessor :options
+      attr_accessor :sub_nodes
+      attr_accessor :grid
+      attr_accessor :grid_map
+      attr_accessor :event_handlers
+      attr_accessor :tk_item
+
+      delegate :value, to: :tk_item
+      delegate :"value=", to: :tk_item
+      delegate :update_value, to: :tk_item
+      delegate :i_value, to: :tk_item
+      delegate :f_value, to: :tk_item
+      delegate :s_value, to: :tk_item
+      delegate :from, to: :tk_item
+      delegate :to, to: :tk_item
+      delegate :native_item, to: :tk_item
+
+      def initialize(name, options = {})
+        @name = name
+        @options = options.with_indifferent_access
+        @sub_nodes = []
+        @grid = {}
+        @grid_map = GridMap.new
+        @event_handlers = []
+        @tk_item = nil
+      end
+
+      def short(level = 0)
+        puts(" " * level + " #{@name}")
+        @sub_nodes.each do |n|
+          n.short(level + 4)
+        end
+        nil
+      end
+
+      def insert_component(component_class, parent_component, options = {}, &block)
+        c_node = node_from_command(:frame, &block)
+        comp = component_class.new(options.merge(parent: parent_component, parent_node: c_node))
+        comp.generate(parent_component, options)
+        parent_component.add_child(comp)
+      end
+
+      def add_event_handler(name, lambda, options = {})
+        event_handlers << EventHandler.new(name, lambda, options)
+      end
+
+      def build(parent_node, parent_component)
+        parent_item = parent_node.present? ? parent_node.tk_item : parent_component.tk_item
+        self.tk_item = TkItem.create(parent_item, name, options, grid, event_handlers)
+        parent_component.tk_item = self.tk_item if parent_component.tk_item.nil?
+        sub_nodes.each do |n|
+          n.build(self, parent_component)
+        end
+        self.tk_item.apply_internal_grid(grid_map)
+      end
+
+      def prepare_option_events(component)
+        option_events = options.extract!(*EVENT_CMDS)
+        option_events.each do |k, v|
+          event_proc = v.is_a?(Proc) ? v : proc { |e| component.public_send(v, e) }
+          node_from_command(k, event_proc)
+        end
+        sub_nodes.each { |n| n.prepare_option_events(component) }
+      end
+
+      def prepare_grid
+        return unless self.sub_nodes.any?
+        current_row = -1
+        current_col = -1
+        final_sub_nodes = []
+        going_down = going_down?
+        while (n = sub_nodes.shift) do
+          if n.row?
+            current_row += 1
+            current_col = 0
+            sub_nodes.unshift(*n.sub_nodes)
+          else
+            # Set the initial row and cols if no row was specified
+            current_row = 0 if current_row < 0
+            current_col = 0 if current_col < 0
+            current_row, current_col = grid_map.get_next_cell(current_row, current_col, going_down)
+            binding.pry if n.options.nil?
+            grid = n.options.extract!(:column, :row, :rowspan, :columnspan, :sticky)
+            n.grid = grid.merge(column: current_col, row: current_row)
+            rowspan = grid[:rowspan] || 1
+            columnspan = grid[:columnspan] || 1
+            grid_map.fill(current_row, current_col, rowspan, columnspan, true)
+            weights = n.options.extract!(:h_weight, :v_weight)
+            grid_map.set_weights(current_row, current_col, weights)
+            n.prepare_grid
+            final_sub_nodes << n
+          end
+        end
+        self.sub_nodes = final_sub_nodes
+      end
+
+      def method_missing(method_name, *args, &block)
+        if method_name.to_s.match(/(.*)\?/)
+          return name.to_s == $1
+        end
+        if TOKENS.include?(method_name.to_s)
+          return node_from_command(method_name, *args, &block)
+        end
+        super
+      end
+
+      def node_from_command(method_name, *args, &block)
+        if method_name.to_s == 'on_event'
+          args[0] = "<#{args[0]}>"
+          add_event_handler(*args)
+        elsif method_name.to_s.match(/^on_(.*)/)
+          add_event_handler($1, *args)
+        else
+          builder = self.class.new(method_name, *args)
+          yield(builder) if block_given?
+          add_node(builder)
+          return builder
+        end
+      end
+
+      def going_down?
+        vframe?
+      end
+
+      def add_node(node)
+        sub_nodes << node
+      end
+    end
+  end
+end

data/lib/tk_component/builder/tk_item.rb

@@ -0,0 +1,197 @@
+module TkComponent
+  module Builder
+    class TkItem
+
+      attr_accessor :native_item
+
+      def self.create(parent_item, name, options = {}, grid = {}, event_handlers = [])
+        item_class = ITEM_CLASSES[name.to_sym]
+        raise "Don't know how to create #{name}" unless item_class
+        item_class.new(parent_item, name, options, grid, event_handlers)
+      end
+
+      def initialize(parent_item, name, options = {}, grid = {}, event_handlers = [])
+        tk_class = TK_CLASSES[name.to_sym]
+        raise "Don't know how to create #{name}" unless tk_class
+        @native_item = tk_class.new(parent_item.native_item)
+        apply_options(options)
+        set_grid(grid)
+        set_event_handlers(event_handlers)
+      end
+
+      def apply_options(options)
+        options.each do |k,v|
+          apply_option(k, v)
+        end
+      end
+
+      def apply_option(option, value)
+        self.native_item.public_send(option, value)
+      end
+
+      def set_grid(grid)
+        self.native_item.grid(grid)
+      end
+
+      def apply_internal_grid(grid_map)
+        puts(grid_map)
+        grid_map.column_indexes.each { |c| TkGrid.columnconfigure(self.native_item, c, weight: grid_map.column_weight(c)) }
+        grid_map.row_indexes.each { |r| TkGrid.rowconfigure(self.native_item, r, weight: grid_map.row_weight(r)) }
+        # grid_map.column_indexes.each { |c| TkGrid.columnconfigure(self.native_item, c, weight: 1) }
+        # grid_map.row_indexes.each { |r| TkGrid.rowconfigure(self.native_item, r, weight: 1) }
+      end
+
+      def set_event_handlers(event_handlers)
+        event_handlers.each { |eh| set_event_handler(eh) }
+      end
+
+      def set_event_handler(event_handler)
+        case event_handler.name
+        when :click
+          Event.bind_command(event_handler.name, self, event_handler.options, event_handler.lambda)
+        when :change
+          Event.bind_variable(event_handler.name, self, event_handler.options, event_handler.lambda)
+        else
+          Event.bind_event(event_handler.name, self, event_handler.options, event_handler.lambda)
+        end
+      end
+    end
+
+    module ValueTyping
+      def apply_option(option, v)
+        case option.to_sym
+        when :value
+          self.value = v
+        else
+          super
+        end
+      end
+
+      def update_value(v)
+        self.value = v if value.to_s != v.to_s
+      end
+
+      def i_value
+        value.to_i
+      end
+
+      def f_value
+        value.to_f
+      end
+
+      def s_value
+        value.to_s
+      end
+    end
+
+    class TkItemWithVariable < TkItem
+      include ValueTyping
+
+      attr_accessor :tk_variable
+
+      def initialize(parent_item, name, options = {}, grid = {}, event_handlers = [])
+        @tk_variable = TkVariable.new
+        super
+        self.native_item.public_send(variable_name, @tk_variable)
+      end
+
+      def variable_name
+        :variable
+      end
+
+      delegate :value, to: :tk_variable
+      delegate :"value=", to: :tk_variable
+    end
+
+    class TkEntry < TkItemWithVariable
+      def variable_name
+        :textvariable
+      end
+    end
+
+    class TkScale < TkItemWithVariable
+      def variable_name
+        :variable
+      end
+
+      delegate :from, to: :native_item
+      delegate :to, to: :native_item
+
+      def set_event_handler(event_handler)
+        case event_handler.name
+        when :change
+          Event.bind_command(event_handler.name, self, event_handler.options, event_handler.lambda)
+        else
+          super
+        end
+      end
+    end
+
+    class TkText < TkItem
+      include ValueTyping
+
+      def value
+        native_item.get('1.0', 'end')
+      end
+
+      def value=(text)
+        native_item.replace('1.0', 'end', text)
+      end
+
+      def set_event_handler(event_handler)
+        case event_handler.name
+        when :change
+          pre_lambda = ->(e) do
+            # Prevent the event if the text wasn't really modified
+            # This is because setting "modified = false" triggers
+            # the modification event itself, which makes not much sense.
+            e.sender.is_a?(self.class) && !e.sender.native_item.modified?
+          end
+          post_lambda = ->(e) do
+            if e.sender.is_a?(self.class)
+              e.sender.native_item.modified = false
+            end
+          end
+          Event.bind_event('<Modified>', self, event_handler.options, event_handler.lambda, pre_lambda, post_lambda)
+        else
+          super
+        end
+      end
+    end
+
+    class TkWindow < TkItem
+      def initialize(parent_item, name, options = {}, grid = {}, event_handlers = [])
+        @native_item = TkRoot.new { title options[:title] }
+        apply_options(options)
+      end
+    end
+
+    TK_CLASSES = {
+      root: TkRoot,
+      frame: Tk::Tile::Frame,
+      hframe: Tk::Tile::Frame,
+      vframe: Tk::Tile::Frame,
+      label: Tk::Tile::Label,
+      entry: Tk::Tile::Entry,
+      button: Tk::Tile::Button,
+      canvas: Tk::Canvas,
+      text: ::TkText,
+      scale: Tk::Tile::Scale,
+      group: Tk::Tile::LabelFrame
+    }
+
+    ITEM_CLASSES = {
+      root: TkComponent::Builder::TkWindow,
+      frame: TkComponent::Builder::TkItem,
+      hframe: TkComponent::Builder::TkItem,
+      vframe: TkComponent::Builder::TkItem,
+      label: TkComponent::Builder::TkItem,
+      entry: TkComponent::Builder::TkEntry,
+      button: TkComponent::Builder::TkItem,
+      canvas: TkComponent::Builder::TkItem,
+      text: TkComponent::Builder::TkText,
+      scale: TkComponent::Builder::TkScale,
+      group: TkComponent::Builder::TkItem
+    }
+  end
+end

data/lib/tk_component/version.rb

@@ -0,0 +1,3 @@
+module TkComponent
+  VERSION = "0.1.0"
+end

data/lib/tk_component/window.rb

@@ -0,0 +1,23 @@
+module TkComponent
+  class Window < Base
+    def initialize(options = {})
+      super
+      @tk_item = Builder::TkItem.create(nil, :root, options)
+    end
+
+    def name
+      "Window"
+    end
+
+    def place_root_component(component, options = {})
+      component.parent = self
+      component.generate(self)
+      component.build(self)
+      h_weight = options[:h_weight] || 1
+      v_weight = options[:v_weight] || 1
+      TkGrid.columnconfigure tk_item.native_item, 0, weight: h_weight
+      TkGrid.rowconfigure tk_item.native_item, 0, weight: v_weight
+      add_child(component)
+    end
+  end
+end

data/tk_component.gemspec

@@ -0,0 +1,45 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "tk_component/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "tk_component"
+  spec.version       = TkComponent::VERSION
+  spec.authors       = ["Josep Egea"]
+  spec.email         = ["jes@josepegea.com"]
+
+  spec.summary       = %q{Use TK from Ruby in a component oriented fashion }
+  spec.description   = %q{TkComponent allows you to create desktop UIs using a component structure taking advantadge of TK, the UI toolkit created for TCL and used by Python in TkInter }
+  spec.homepage      = "https://github.com/josepegea/tk_component"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/josepegea/tk_component"
+    spec.metadata["changelog_uri"] = "https://github.com/josepegea/tk_component/releases"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "tk", "~> 0.3.0"
+  spec.add_dependency "activesupport", "~> 6.0.3"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: tk_component
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Josep Egea
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 'TkComponent allows you to create desktop UIs using a component structure
+  taking advantadge of TK, the UI toolkit created for TCL and used by Python in TkInter '
+email:
+- jes@josepegea.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/tk_component.rb
+- lib/tk_component/base.rb
+- lib/tk_component/builder.rb
+- lib/tk_component/builder/event.rb
+- lib/tk_component/builder/event_handler.rb
+- lib/tk_component/builder/grid_map.rb
+- lib/tk_component/builder/node.rb
+- lib/tk_component/builder/tk_item.rb
+- lib/tk_component/version.rb
+- lib/tk_component/window.rb
+- tk_component.gemspec
+homepage: https://github.com/josepegea/tk_component
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/josepegea/tk_component
+  source_code_uri: https://github.com/josepegea/tk_component
+  changelog_uri: https://github.com/josepegea/tk_component/releases
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Use TK from Ruby in a component oriented fashion
+test_files: []