simple_tk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 688f0fe3a07729c95ffe968c6d1bb55a846ef7d9
+  data.tar.gz: b96b21a78f9c6244bc66cb07018c5f356c003473
+SHA512:
+  metadata.gz: 524e8e9e20024a885938ea049b292c04a393c5ebbfe7acdcc1600d1fc5a3f48ac313a257a858cee2ae287f95a2fe72b939411338f2bc2545417493ddb55f5de1
+  data.tar.gz: 656d163a645705cf9964754a7c96a510d75de50616c190a38b21ff06887817ecbd0cf9cd2e5df00cf27674d639a5232c60d00c7e390ba3e37e9d0ec591bb15a4

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.14.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in simple_tk.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Beau Barker
+
+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,84 @@
+# SimpleTk
+
+I wanted a really simple GUI library for Ruby.  Not because I think Ruby should be used for GUI
+applications, but because I think it should be able to tbe used for GUI applications.
+
+Really I wanted something to make a quick configuration app using an existing Ruby gem I had 
+written. I started out with a simple console app, but I decided I wanted something even simpler
+for the eventual day when somebody else has to use it.
+
+So I searched.  First I found Shoes.  Which would be acceptable except Shoes 3 does not have a gem
+and Shoes 4 requires JRuby.  Ok moving on, we have several other libraries that interface with other
+libraries.  And then Tk, which is from the Ruby code base.  So time to learn Tk, which turns out has
+a lot of repeated steps and code.  Well that's easy enough to correct.  I wrote a quick wrapper and
+built my config app.
+
+I extracted that wrapper and built it up to support more than just labels, entries, and buttons.
+This gem is the end result of that action.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'simple_tk'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simple_tk
+
+## Usage
+
+You can build windows using either a block passed to a window constructor or by calling the methods
+on the created window.  Call `SimpleTk.run` to run your application.  You can use `SimpleTk.alert` and 
+`SimpleTk.ask` for basic message boxes.  In all cases, the Tk library is available if you need more 
+advanced options.
+
+```ruby
+require 'simple_tk'
+  
+win = SimpleTk::Window.new(title: "My Program", window_geometry: "400x300") do
+  add_label :label1, "Hello World!", :column => 0, :row => 0
+  add_frame(:frame1, :column => 0, :row => 1) do
+    add_button(:btn1, "Button 1", :position => [ 0, 0 ]) do
+      SimpleTk.alert "You clicked Button 1!"
+    end
+    add_button :btn2,
+        "Button 2",
+        :position => { x: 1, y: 0 },
+        :command => ->{ SimpleTk.alert "You clicked Button 2!" }
+  end
+end
+  
+win.add_label :label2, "Goodby World!", :column => 0, :row => 2
+  
+win.config_column 0, weight: 1
+  
+(0..win.row_count).each do |row|
+  win.config_row row, weight: 1
+end
+  
+# Use the Tk 'bind' method on the :btn2 object.  
+win.object[:frame1].object[:btn2].bind("3") do
+  SimpleTk.alert "You right-clicked on Button 2!"  
+end
+  
+SimpleTk.run
+```
+
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/barkerest/simple_tk.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "simple_tk"
+
+# 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/simple_tk/errors.rb

@@ -0,0 +1,16 @@
+
+module SimpleTk
+  ##
+  # A general error from the SimpleTk library.
+  class SimpleTkError < StandardError
+
+  end
+
+  ##
+  # A duplicate name was used.
+  class DuplicateNameError < SimpleTkError
+
+  end
+
+
+end

data/lib/simple_tk/get_set_helper.rb

@@ -0,0 +1,79 @@
+module SimpleTk
+  ##
+  # A helper class to make hash instance variables more accessible.
+  class GetSetHelper
+
+    ##
+    # Creates a helper for a specific hash in a parent object.
+    #
+    # This helper does not support adding items to the connected hash.
+    #
+    # Parameters:
+    # parent::
+    #     The parent object this helper accesses.
+    # hash_ivar::
+    #     The name (as a symbol) of the instance variable in the parent object to access.
+    #     (eg - :@data)
+    # auto_symbol::
+    #     Should names be converted to symbols in the accessors, defaults to true.
+    # getter::
+    #     The method or proc to call when getting a value.
+    #     If this is a Symbol then it defines the method name of the retrieved value to call.
+    #     If this is a Proc then it will be called with the retrieved value as an argument.
+    #     If this is nil then the retrieved value is returned.
+    # setter::
+    #     The method or proc to call when setting a value.
+    #     If this is a Symbol then it defines the method name of the retrieved value to call with the new value.
+    #     If this ia a Proc then it will be called with the retrieved value and the new value as arguments.
+    #     If this is nil then the hash value is replaced with the new value.
+    #
+    #   GetSetHelper.new(my_obj, :@data)
+    #   GetSetHelper.new(my_obj, :@data, true, :value, :value=)
+    #   GetSetHelper.new(my_obj, :@data, true, ->(v){ v.value }, ->(i,v){ i.value = v })
+    def initialize(parent, hash_ivar, auto_symbol = true, getter = nil, setter = nil)
+      @parent = parent
+      @hash_ivar = hash_ivar
+      @auto_symbol = auto_symbol
+      @getter = getter
+      @setter = setter
+    end
+
+    ##
+    # Gets the value for the given name.
+    def [](name)
+      name = name.to_sym if @auto_symbol
+      h = @parent.instance_variable_get(@hash_ivar)
+      if h.include?(name)
+        v = h[name]
+        if @getter.is_a?(Symbol)
+          v.send @getter
+        elsif @getter.is_a?(Proc)
+          @getter.call v
+        else
+          v
+        end
+      else
+        raise IndexError
+      end
+    end
+
+    ##
+    # Sets the value for the given name.
+    def []=(name, value)
+      name = name.to_sym if @auto_symbol
+      h = @parent.instance_variable_get(@hash_ivar)
+      if h.include?(name)
+        if @setter.is_a?(Symbol)
+          h[name].send @setter, value
+        elsif @setter.is_a?(Proc)
+          @setter.call h[name], value
+        else
+          h[name] = value
+        end
+      else
+        raise IndexError
+      end
+    end
+
+  end
+end

data/lib/simple_tk/version.rb

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

data/lib/simple_tk/widget_helpers.rb

@@ -0,0 +1,30 @@
+
+module SimpleTk
+
+  ##
+  # Provides :disable, :disabled?, and :enable methods to widgets.
+  module DisableHelpers
+
+    ##
+    # Disables this widget.
+    def disable
+      self.state('disabled')
+    end
+
+    ##
+    # Is this widget disabled?
+    def disabled?
+      self.instate('disabled')
+    end
+
+    ##
+    # Enables this widget.
+    def enable
+      self.state('!disabled')
+    end
+
+  end
+
+
+
+end

data/lib/simple_tk/window.rb

@@ -0,0 +1,667 @@
+require 'simple_tk/errors'
+require 'simple_tk/get_set_helper'
+require 'simple_tk/widget_helpers'
+
+require 'tk'
+
+module SimpleTk
+  ##
+  # A class representing a window that all the other controls get piled into.
+  #
+  # We use the "grid" layout manager.  Each widget gets assigned to the grid
+  # using specific column and row settings.
+  #
+  # To simplify things the Window class allows either "free" mode or "flow"
+  # mode placement.  In "free" mode, you must specify the :column and :row
+  # option for each widget you add.  In "flow" mode, the :column and :row
+  # are computed for you automatically.
+  #
+  # There are multiple ways to give the Window the grid coordinates for the
+  # new widget.
+  #
+  # You can explicitly set the :column, :row, :columnspan, and :rowspan options.
+  # The :col option is equivalent to :column and the :colspan option is equivalent
+  # to the :columnspan option.  The :columnspan and :rowspan options default to
+  # a value of 1 if you do not specify them.
+  #   add_label :xyz, 'XYZ', :column => 1, :row => 2, :columnspan => 1, :rowspan => 1
+  #   add_label :xyz, 'XYZ', :col => 1, :row => 2, :colspan => 1, :rowspan => 1
+  #
+  # You can also set the :position option.  The :pos option is equivalent to the
+  # :position option.  The argument to this option is either an Array or a Hash.
+  # If an Array is specified, it should have either 2 or 4 values.
+  class Window
+
+    ##
+    # Allows you to get or set the linked object for this window.
+    #
+    # A linked object can be used to provide command callbacks.
+    attr_accessor :linked_object
+
+    ##
+    # Creates a new window.
+    #
+    # Some valid options:
+    # title::
+    #     The title to put on the window.
+    #     Defaults to "My Application".
+    # parent::
+    #     The parent window for this window.
+    #     Use your main window for any popup windows you create.
+    #     Defaults to nil.
+    # padding::
+    #     The padding for the content frame.
+    #     This can be a single value to have the same padding all around.
+    #     It can also be two numbers to specify horizontal and vertical padding.
+    #     If you specify four numbers, they are for left, top, right, and bottom padding.
+    #     Defaults to "3".
+    # sticky::
+    #     The stickiness for the content frame.
+    #     This defaults to "nsew" and most likely you don't want to change it, but the
+    #     option is available.
+    #
+    # Window options can be prefixed with 'window_' or put into a hash under a 'window' option.
+    #   SimpleTk::Window.new(window: { geometry: '300x300' })
+    #   SimpleTk::Window.new(window_geometry: '300x300')
+    #
+    # Any options not listed above or explicitly assigned to the window are applied to the
+    # content frame.
+    #
+    # If you provide a block it will be executed in the scope of the window.
+    def initialize(options = {}, &block)
+      @stkw_object_list = {}
+      @stkw_var_list    = {}
+
+      options = {
+          title: 'My Application',
+          padding: '3',
+          sticky: 'nsew'
+      }.merge(options.inject({}) { |m,(k,v)| m[k.to_sym] = v; m})
+
+      title = options.delete(:title) || 'My Application'
+      parent = options.delete(:parent)
+      is_frame = options.delete(:stk___frame)
+
+      win_opt, options = split_window_content_options(options)
+
+      @stkw_object_list[:stk___root] =
+          if is_frame
+            parent
+          elsif parent
+            TkToplevel.new(parent)
+          else
+            TkRoot.new
+          end
+
+      unless is_frame
+        root.title title
+        TkGrid.columnconfigure root, 0, weight: 1
+        TkGrid.rowconfigure root, 0, weight: 1
+        apply_options root, win_opt
+      end
+
+      @stkw_object_list[:stk___content] = Tk::Tile::Frame.new(root)
+      apply_options content, options
+
+      @stkw_config = {
+          placement: :free,
+          row_start: -1,
+          col_start: -1,
+          col_count: -1,
+          cur_col: -1,
+          cur_row: -1,
+          base_opt: { },
+          max_col: 0,
+          max_row: 0
+      }
+
+      if block_given?
+        instance_eval &block
+      end
+    end
+
+    ##
+    # Gets the number of columns in use.
+    def column_count
+      @stkw_config[:max_col]
+    end
+
+    ##
+    # Gets the number of rows in use.
+    def row_count
+      @stkw_config[:max_row]
+    end
+
+    ##
+    # Allows you to configure the grid options for all cells in a column.
+    def config_column(col, options = {})
+      TkGrid.columnconfigure content, col, options
+    end
+
+    ##
+    # Allows you to configure the grid options for all cells in a row.
+    def config_row(row, options = {})
+      TkGrid.rowconfigure content, row, options
+    end
+
+    ##
+    # Gets all of the children on this window.
+    def children
+      TkWinfo.children(content)
+    end
+
+    ##
+    # Gets objects from the window.
+    def object
+      @object_helper ||= SimpleTk::GetSetHelper.new(self, :@stkw_object_list, true, nil, ->(i,v) {  } )
+    end
+
+    ##
+    # Gets or sets variable values for this window.
+    def var
+      @var_helper ||= SimpleTk::GetSetHelper.new(self, :@stkw_var_list, true, :value, :value=)
+    end
+
+    ##
+    # Binds a method or Proc to a window event.
+    #
+    # event::
+    #     The event to bind to (eg - "1", "Return", "Shift-2")
+    # proc::
+    #     A predefined proc to bind to the event, only used if no block is provided.
+    #
+    # If a block is provided it will be bound, otherwise the +proc+ argument is looked at.
+    # If the proc argument specifies a Proc it will be bound.  If the proc argument is a Symbol
+    # and the Window or +linked_object+ responds to the proc, then the method from the Window
+    # or +linked_object+ will be bound.
+    def on(event, proc = nil, &block)
+      cmd = get_command proc, &block
+      root.bind(event) { cmd.call }
+    end
+
+    ##
+    # Adds a new label to the window.
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # label_text::
+    #     The text to put in the label.
+    #     If this is a Symbol, then a variable will be created with this value as its name.
+    #     Otherwise the label will be given the string value as a static label.
+    # options::
+    #     Options for the label.  Common options are :column, :row, and :sticky.
+    def add_label(name, label_text, options = {})
+      add_widget Tk::Tile::Label, name, label_text, options
+    end
+
+    ##
+    # Adds a new image to the window.
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # image_path::
+    #     The path to the image, can be relative or absolute.
+    # options::
+    #     Options for the image.  Common options are :column, :row, and :sticky.
+    def add_image(name, image_path, options = {})
+      image = TkPhotoImage.new(file: image_path)
+      add_widget Tk::Tile::Label, name, nil, options.merge(image: image)
+    end
+
+    ##
+    # Adds a new button to the window.
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # label_text::
+    #     The text to put in the button.
+    #     If this is a Symbol, then a variable will be created with this value as its name.
+    #     Otherwise the button will be given the string value as a static label.
+    # options::
+    #     Options for the button.  Common options are :column, :row, :sticky, and :command.
+    #
+    # If a block is provided, it will be used for the button command.  Otherwise the :command option
+    # will be used.  This can be a Proc or Symbol.  If it is a Symbol it should reference a method in
+    # the current Window object or in the +linked_object+.
+    #
+    # If no block or proc is provided, a default proc that prints to $stderr is created.
+    def add_button(name, label_text, options = {}, &block)
+      options = options.dup
+      proc = get_command(options.delete(:command), &block) || ->{ $stderr.puts "Button '#{name}' does nothing when clicked." }
+      add_widget Tk::Tile::Button, name, label_text, options, &proc
+    end
+
+    ##
+    # Adds a new image button to the window.
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # image_path::
+    #     The path to the image, can be relative or absolute.
+    # options::
+    #     Options for the image button.  Common options are :column, :row, :sticky, and :command.
+    #
+    # If a block is provided, it will be used for the button command.  Otherwise the :command option
+    # will be used.  This can be a Proc or Symbol.  If it is a Symbol it should reference a method in
+    # the current Window object or in the +linked_object+.
+    #
+    # If no block or proc is provided, a default proc that prints to $stderr is created.
+    def add_image_button(name, image_path, options = {}, &block)
+      options = options.dup
+      image = TkPhotoImage.new(file: image_path)
+      proc = get_command(options.delete(:command), &block) || ->{ $stderr.puts "Button '#{name}' does nothing when clicked." }
+      add_widget Tk::Tile::Button, name, nil, options.merge(image: image), &proc
+    end
+
+    ##
+    # Adds a new text box to the window.
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # options::
+    #     Options for the text box.  Common options are :column, :row, :sticky, :width, :value, and :password.
+    #
+    # Accepts a block or command the same as a button. Unlike the button there is no default proc assigned.
+    # The proc, if specified, will be called for each keypress.  It should return 1 (success) or 0 (failure).
+    def add_text_box(name, options = {}, &block)
+      options = options.dup
+      if options.delete(:password)
+        options[:show] = '*'
+      end
+      proc = get_command(options.delete(:command), &block)
+      item = add_widget Tk::Tile::Entry, name, nil, options.merge(create_var: :textvariable)
+      # FIXME: Should the command be processed for validation or bound to a specific event?
+      if proc
+        item.send :validate, 'key'
+        item.send(:validatecommand) { proc.call }
+      end
+      item
+    end
+
+    ##
+    # Adds a new check box to the window
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # label_text::
+    #     The text to put in the button.
+    #     If this is a Symbol, then a variable will be created with this value as its name.
+    #     Otherwise the button will be given the string value as a static label.
+    # options::
+    #     Options for the check box.  Common options are :column, :row, :sticky, and :value.
+    #
+    # Accepts a block or command the same as a button.  Unlike a button there is no default proc assigned.
+    def add_check_box(name, label_text, options = {}, &block)
+      options = options.dup
+      proc = get_command(options.delete(:command), &block)
+      add_widget Tk::Tile::Checkbutton, name, label_text, options.merge(create_var: :variable), &proc
+    end
+
+    ##
+    # Adds a new image check box to the window
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # image_path::
+    #     The path to the image, can be relative or absolute.
+    # options::
+    #     Options for the check box.  Common options are :column, :row, :sticky, and :value.
+    #
+    # Accepts a block or command the same as a button.  Unlike a button there is no default proc assigned.
+    def add_image_check_box(name, image_path, options = {}, &block)
+      options = options.dup
+      image = TkPhotoImage.new(file: image_path)
+      proc = get_command(options.delete(:command), &block)
+      add_widget Tk::Tile::Checkbutton, name, nil, options.merge(image: image, create_var: :variable), &proc
+    end
+
+    ##
+    # Adds a new radio button to the window.
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # group::
+    #     The name of the variable this radio button uses.
+    # label_text::
+    #     The text to put in the button.
+    #     If this is a Symbol, then a variable will be created with this value as its name.
+    #     Otherwise the button will be given the string value as a static label.
+    # options::
+    #     Options for the check box.  Common options are :column, :row, :sticky, :value, and :selected.
+    #
+    # Accepts a block or command the same as a button.  Unlike a button there is no default proc assigned.
+    def add_radio_button(name, group, label_text, options = {}, &block)
+      raise ArgumentError, 'group cannot be blank' if group.to_s.strip == ''
+      options               = options.dup
+      group                 = group.to_sym
+      @stkw_var_list[group] ||= TkVariable.new
+      options[:variable]    = @stkw_var_list[group]
+      options[:value]       ||= name.to_s.strip
+      if options.delete(:selected)
+        @stkw_var_list[group] = options[:value]
+      end
+      proc = get_command(options.delete(:command), &block)
+      add_widget Tk::Tile::Radiobutton, name, label_text, options, &proc
+    end
+
+    ##
+    # Adds a new radio button to the window.
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # group::
+    #     The name of the variable this radio button uses.
+    # image_path::
+    #     The path to the image, can be relative or absolute.
+    # options::
+    #     Options for the check box.  Common options are :column, :row, :sticky, :value, and :selected.
+    #
+    # Accepts a block or command the same as a button.  Unlike a button there is no default proc assigned.
+    def add_image_radio_button(name, group, image_path, options = {}, &block)
+      raise ArgumentError, 'group cannot be blank' if group.to_s.strip == ''
+      options               = options.dup
+      group                 = group.to_sym
+      @stkw_var_list[group] ||= TkVariable.new
+      options[:variable]    = @stkw_var_list[group]
+      options[:value]       ||= name.to_s.strip
+      if options.delete(:selected)
+        @stkw_var_list[group] = options[:value]
+      end
+      proc = get_command(options.delete(:command), &block)
+      image = TkPhotoImage.new(file: image_path)
+      add_widget Tk::Tile::Radiobutton, name, nil, options.merge(image: image), &proc
+    end
+
+    ##
+    # Adds a new combo box to the window.
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # options::
+    #     Options for the check box.  Common options are :column, :row, :sticky, :value, and :values.
+    #
+    # The :values option will define the items in the combo box, the :value option sets the selected option if set.
+    #
+    # Accepts a block or command the same as a button.  Unlike a button there is no default proc assigned.
+    def add_combo_box(name, options = {}, &block)
+      options = options.dup
+      proc = get_command(options.delete(:command), &block)
+      item = add_widget TK::Tile::Combobox, name, nil, options.merge(create_var: :textvariable)
+      if proc
+        item.bind('<ComboboxSelected>') { proc.call }
+      end
+      item
+    end
+
+    ##
+    # Adds a new frame to the window.
+    #
+    # name::
+    #     A unique label for this item, cannot be nil.
+    # options::
+    #     Options for the frame.  Common options are :column, :row, and :padding.
+    #
+    # A frame can be used as a sub-window.  The returned object has all of the same methods as a Window
+    # so you can add other widgets to it and use it as a grid within the parent grid.
+    #
+    # If you provide a block, it will be executed in the scope of the frame.
+    def add_frame(name, options = {}, &block)
+      name = name.to_sym
+      raise DuplicateNameError if @stkw_object_list.include?(name)
+      options                 = fix_position(options.dup)
+      @stkw_object_list[name] = SimpleTk::Window.new(options.merge(parent: content, stk___frame: true), &block)
+    end
+
+    ##
+    # Sets the placement mode for this window.
+    #
+    # mode::
+    #     This can be either :free or :flow.
+    #     The default mode for a new window is :free.
+    #     Frames do not inherit this setting from the parent window.
+    #     In free placement mode, you must provide the :column and :row for every widget.
+    #     In flow placement mode, you must not provide the :column or :row for any widget.
+    #     Flow placement will add each widget to the next column moving to the next row as
+    #     needed.
+    # options::
+    #     Options are ignored in free placement mode.
+    #     In flow placement mode, you must provide :first_column, :first_row, and either
+    #     :last_column or :column_count.  If you specify both :last_column and :column_count
+    #     then :last_column will be used.  The :first_column and :first_row must be greater
+    #     than or equal to zero.  The :last_column can be equal to the first column but
+    #     the computed :column_count must be at least 1.
+    def set_placement_mode(mode, options = {})
+      raise ArgumentError, 'mode must be :free or :flow' unless [ :free, :flow ].include?(mode)
+      if mode == :flow
+        first_col = options[:first_column]
+        col_count =
+            if (val = options[:last_column])
+              val - first_col + 1
+            elsif (val = options[:column_count])
+              val
+            else
+              nil
+            end
+        first_row = options[:first_row]
+        raise ArgumentError, ':first_column must be provided for flow placement' unless first_col
+        raise ArgumentError, ':first_row must be provided for flow placement' unless first_row
+        raise ArgumentError, ':last_column or :column_count must be provided for flow placement' unless col_count
+        raise ArgumentError, ':first_column must be >= 0' unless first_col >= 0
+        raise ArgumentError, ':first_row must be >= 0' unless first_row >= 0
+        raise ArgumentError, ':column_count must be > 0' unless col_count > 0
+
+        @stkw_config.merge!(
+            placement: :flow,
+            col_start: first_col,
+            row_start: first_row,
+            col_count: col_count,
+            cur_row:   first_row,
+            cur_col:   first_col
+        )
+      elsif mode == :free
+        @stkw_config.merge!(
+            placement: :free,
+            col_start: -1,
+            row_start: -1,
+            col_count: -1,
+            cur_row: -1,
+            cur_col: -1
+        )
+      end
+    end
+
+    ##
+    # Executes a block with the specified options preset.
+    def with_options(options = {}, &block)
+      return unless block
+      backup_options          = @stkw_config[:base_opt]
+      @stkw_config[:base_opt] = @stkw_config[:base_opt].merge(options)
+      begin
+        instance_eval &block
+      ensure
+        @stkw_config[:base_opt] = backup_options
+      end
+    end
+
+    private
+
+    def root
+      @stkw_object_list[:stk___root]
+    end
+
+    def content
+      @stkw_object_list[:stk___content]
+    end
+
+    def fix_position(options)
+      col = options.delete(:column) || options.delete(:col)
+      row = options.delete(:row)
+      width = options.delete(:columnspan) || options.delete(:colspan) || options.delete(:columns) || 1
+      height = options.delete(:rowspan) || options.delete(:rows) || 1
+      pos = options.delete(:position) || options.delete(:pos)
+      skip = options.delete(:skip)
+
+      if pos.is_a?(Array)
+        col = pos[0] || col
+        row = pos[1] || row
+        width = pos[2] || width
+        height = pos[3] || height
+      elsif pos.is_a?(Hash)
+        col = pos[:column] || pos[:col] || pos[:x] || col
+        row = pos[:row] || pos[:y] || row
+        width = pos[:width] || pos[:w] || pos[:columnspan] || pos[:colspan] || width
+        height = pos[:height] || pos[:h] || pos[:rowspan] || height
+      end
+
+      if @stkw_config[:placement] == :free
+        raise ArgumentError, ':column must be set for free placement mode' unless col
+        raise ArgumentError, ':row must be set for free placement mode' unless row
+        raise ArgumentError, ':skip must not be set for free placement mode' if skip
+      elsif @stkw_config[:placement] == :flow
+        raise ArgumentError, ':column cannot be set for flow placement mode' if col
+        raise ArgumentError, ':row cannot be set for flow placement mode' if row
+        raise ArgumentError, ":columnspan cannot be more than #{@stkw_config[:col_count]} in flow placement mode" if width > @stkw_config[:col_count]
+        raise ArgumentError, ':rowspan cannot be more than 1 in flow placement mode' if height > 1
+
+        # skip cells if the user requested it.
+        if skip
+          @stkw_config[:cur_col] += skip
+          while @stkw_config[:cur_col] >= @stkw_config[:col_start] + @stkw_config[:col_count]
+            @stkw_config[:cur_row] += 1
+            @stkw_config[:cur_col] -= @stkw_config[:col_count]
+          end
+        end
+
+        if width > @stkw_config[:col_count] - @stkw_config[:cur_col] + 1
+          @stkw_config[:cur_row] += 1
+          @stkw_config[:cur_col] = @stkw_config[:col_start]
+        end
+        col                    = @stkw_config[:cur_col]
+        row                    = @stkw_config[:cur_row]
+        @stkw_config[:cur_col] += width
+        if @stkw_config[:cur_col] >= @stkw_config[:col_start] + @stkw_config[:col_count]
+          @stkw_config[:cur_col] = @stkw_config[:col_start]
+          @stkw_config[:cur_row] += 1
+        end
+      end
+
+      options[:column] = col
+      options[:row] = row
+      options[:columnspan] = width
+      options[:rowspan] = height
+
+      end_col                = options[:column] + options[:columnspan] - 1
+      end_row                = options[:row] + options[:rowspan] - 1
+
+      # track the columns and rows.
+      @stkw_config[:max_col] = end_col if end_col > @stkw_config[:max_col]
+      @stkw_config[:max_row] = end_row if end_row > @stkw_config[:max_row]
+
+      options
+    end
+
+    def add_widget(klass, name, label_text, options = {}, &block)
+      raise ArgumentError, 'name cannot be blank' if name.to_s.strip == ''
+      name = name.to_sym
+      raise DuplicateNameError if @stkw_object_list.include?(name)
+      options = options.dup
+      cmd = get_command options.delete(:command), &block
+      if cmd
+        options[:command] = cmd
+      end
+
+      options = fix_position(options)
+
+      if (attrib = options.delete(:create_var))
+        @stkw_var_list[name] ||= TkVariable.new
+        if attrib.is_a?(Symbol)
+          options[attrib] = @stkw_var_list[name]
+        end
+        init_val = options.delete(:value)
+        var[name] = init_val if init_val
+      end
+
+      @stkw_object_list[name] = klass.new(content)
+      if label_text
+        set_text @stkw_object_list[name], label_text
+      end
+      apply_options @stkw_object_list[name], options
+
+      # add disable, disabled?, and enable methods.
+      @stkw_object_list[name].extend SimpleTk::DisableHelpers
+
+      # return the object after creation
+      @stkw_object_list[name]
+    end
+
+    def get_command(proc, &block)
+      if block
+        block
+      elsif proc.is_a?(Proc)
+        proc
+      elsif proc.is_a?(Symbol) && self.respond_to?(proc, true)
+        self.method(proc)
+      elsif linked_object && proc.is_a?(Symbol) && linked_object.respond_to?(proc, true)
+        linked_object.method(proc)
+      else
+        nil
+      end
+    end
+
+    def set_text(object, label_text)
+      if label_text.is_a?(Symbol)
+        @stkw_var_list[label_text] ||= TkVariable.new
+        object.textvariable @stkw_var_list[label_text]
+      else
+        object.text label_text
+      end
+    end
+
+    def apply_options(object, options)
+      widget_opt, grid_opt = split_widget_grid_options(options)
+      widget_opt.each do |key,val|
+        if val.is_a?(Proc)
+          object.send key, &val
+        else
+          object.send key, val
+        end
+      end
+      object.grid(grid_opt) unless grid_opt.empty?
+    end
+
+    def split_widget_grid_options(options)
+      wopt = options.dup
+      gopt = {}
+
+      [
+          :row, :column, :columnspan, :rowspan,
+          :padx, :pady, :ipadx, :ipady,
+          :sticky,
+      ].each do |attr|
+        val = wopt.delete(attr)
+        if val
+          gopt[attr] = val
+        end
+      end
+
+      [ wopt, gopt ]
+    end
+
+    def split_window_content_options(options)
+      options = options.dup
+      wopt = options.delete(:window) || { }
+      copt = { }
+
+      options.each do |k,v|
+        ks = k.to_s
+        if ks =~ /^window_/
+          wopt[ks[7..-1].to_sym] = v
+        else
+          copt[k] = v
+        end
+      end
+
+      [ wopt, copt ]
+    end
+
+  end
+end

data/lib/simple_tk.rb

@@ -0,0 +1,44 @@
+require 'simple_tk/version'
+require 'simple_tk/get_set_helper'
+require 'simple_tk/window'
+
+##
+# A real cheap wrapper around the Ruby Tk bindings.
+module SimpleTk
+
+  ##
+  # Runs the Tk application.
+  def self.run
+    Tk.mainloop
+  end
+
+  ##
+  # Creates a basic alert message box.
+  #
+  # message::
+  #     The message to display.
+  # icon::
+  #     The icon to display (one of :info, :error, :question, or :warning).
+  #
+  # Returns true.
+  def self.alert(message, icon = :info)
+    Tk::messageBox message: message, icon: icon.to_s
+    true
+  end
+
+  ##
+  # Creates a basic yes/no message box.
+  #
+  # message::
+  #     The message to display.
+  # icon::
+  #     The icon to display (one of :info, :error, :question, or :warning).
+  # ok_cancel::
+  #     Set to true to make the buttons OK and Cancel instead of Yes and No.
+  #
+  # Returns true for 'Yes' (or 'OK') or false for 'No' (or 'Cancel').
+  def self.ask(message, icon = :question, ok_cancel = false)
+    %w(ok yes).include?(Tk::messageBox(message: message, type: ok_cancel ? 'okcancel' : 'yesno', icon: icon))
+  end
+
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: simple_tk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Beau Barker
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- beau@barkerest.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/simple_tk.rb
+- lib/simple_tk/errors.rb
+- lib/simple_tk/get_set_helper.rb
+- lib/simple_tk/version.rb
+- lib/simple_tk/widget_helpers.rb
+- lib/simple_tk/window.rb
+homepage: http://www.barkerest.com/
+licenses:
+- MIT
+metadata: {}
+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.6.11
+signing_key: 
+specification_version: 4
+summary: A simple interface to the Ruby Tk bindings.
+test_files: []