glimmer-dsl-tk 0.0.24 → 0.0.28

data/lib/glimmer/tk/text_proxy.rb

@@ -0,0 +1,350 @@
+# Copyright (c) 2020-2021 Andy Maleh
+#
+# 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.
+
+require 'glimmer/tk/widget_proxy'
+
+module Glimmer
+  module Tk
+    # Proxy for Tk::Text
+    #
+    # Follows the Proxy Design Pattern
+    class TextProxy < WidgetProxy
+      def handle_listener(listener_name, &listener)
+        listener_name = listener_name.to_s.downcase
+        case listener_name
+        when '<<modified>>', '<modified>', 'modified'
+          modified_listener = Proc.new do |*args|
+            listener.call(*args)
+            @tk.modified = false
+          end
+          bind('<Modified>', modified_listener)
+        when '<<selection>>', '<selection>', 'selection'
+          bind('<Selection>', listener)
+        else
+          super
+        end
+      end
+    
+      def text=(value)
+        if value != @text
+          if @text && value.start_with?(@text)
+            insert('end', value[@text.size..-1])
+          else
+            delete('1.0', 'end')
+            insert('end', value)
+          end
+          @text = value
+        end
+      end
+      
+      def text
+        @text = get("1.0", 'end')
+      end
+      
+      def add_selection_format(option, value)
+        process_selection_ranges { |range_start, range_end| add_format(range_start, range_end, option, value) }
+      end
+      
+      def remove_selection_format(option, value)
+        process_selection_ranges { |range_start, range_end| remove_format(range_start, range_end, option, value) }
+      end
+      
+      def toggle_selection_format(option, value)
+        process_selection_ranges { |range_start, range_end| toggle_format(range_start, range_end, option, value) }
+      end
+      
+      def add_selection_font_format(option, value)
+        process_selection_ranges { |range_start, range_end| add_font_format(range_start, range_end, option, value) }
+      end
+      
+      def remove_selection_font_format(option, value)
+        process_selection_ranges { |range_start, range_end| remove_font_format(range_start, range_end, option, value) }
+      end
+      
+      def toggle_selection_font_format(option, value)
+        process_selection_ranges { |range_start, range_end| toggle_font_format(range_start, range_end, option, value) }
+      end
+      
+      def process_selection_ranges(&processor)
+        @tk.tag_ranges('sel').each do |region|
+          range_start = region.first
+          range_end = region.last
+          processor.call(range_start, range_end)
+        end
+      end
+      
+      def applied_format?(region_start, region_end, option, value)
+        !applied_format_tags(region_start, region_end, option, value).empty?
+      end
+      
+      def applied_format_tags(region_start, region_end, option, value)
+        tag_names = @tk.tag_names - ['sel']
+        
+        tag_names.select do |tag_name|
+          @tk.tag_ranges(tag_name).any? do |range|
+            if text_index_less_than_or_equal_to_other_text_index?(range.first, region_start) && text_index_greater_than_or_equal_to_other_text_index?(range.last, region_end)
+              @tk.tag_cget(tag_name, option) == value
+            end
+          end
+        end
+      end
+            
+      def add_format(region_start, region_end, option, value)
+        @@tag_number = 0 unless defined?(@@tag_number)
+        tag = "tag#{@@tag_number += 1}"
+        @tk.tag_configure(tag, {option => value})
+        @tk.tag_add(tag, region_start, region_end)
+        tag
+      end
+      
+      def remove_format(region_start, region_end, option, value)
+        partial_intersection_option_applied_tags = tag_names.select do |tag_name|
+          @tk.tag_ranges(tag_name).any? do |range|
+            if range.first.to_f.between?(region_start.to_f, region_end.to_f) or
+               range.last.to_f.between?(region_start.to_f, region_end.to_f) or
+               (text_index_less_than_or_equal_to_other_text_index?(range.first, region_start) && text_index_greater_than_or_equal_to_other_text_index?(range.last, region_end))
+              @tk.tag_cget(tag_name, option) == value
+            end
+          end
+        end
+        
+        partial_intersection_option_applied_tags.each do |tag_name|
+          @tk.tag_remove(tag_name, region_start, region_end)
+        end
+        
+        nil
+      end
+      
+      # toggles option/value tag (removes if already applied)
+      def toggle_format(region_start, region_end, option, value)
+        if applied_format?(region_start, region_end, option, value)
+          remove_format(region_start, region_end, option, value)
+        else
+          add_format(region_start, region_end, option, value)
+        end
+      end
+           
+      # TODO Algorithm for font option formatting
+      # for a region, grab all the latest tags for each subregion as well as the widget font for subregions without a tag
+      # for each part of the region covered by a tag, augment its font with new font option (or remove if that is what is needed)
+      # Once add and remove are implemented, implement toggle
+      # Also, there is a need for a method that checks if a font option value applies to an entire region (to decide which way to toggle with toggle method)
+      def applied_font_format?(region_start, region_end, font_option, value)
+        applied_font_format_tags_and_regions(region_start, region_end).all? do |tag, region_start, region_end|
+          if tag.nil?
+            @tk.font.send(font_option) == value
+          else
+            @tk.tag_cget(tag, 'font').send(font_option) == value
+          end
+        end
+      end
+
+      def applied_font_format_tags_and_regions(region_start, region_end)
+        lines = text.split("\n")
+        tags_and_regions = []
+        all_tag_names = @tk.tag_names - ['sel']
+        (region_start.to_i..region_end.to_i).each do |line_number|
+          start_character_index = 0
+          start_character_index = region_start.to_s.split('.').last.to_i if line_number == region_start.to_i
+          end_character_index = lines[line_number - 1].size
+          end_character_index = region_end.to_s.split('.').last.to_i if line_number == region_end.to_i
+          (start_character_index...end_character_index).each do |character_index|
+            text_index = "#{line_number}.#{character_index}"
+            # TODO reimplement the following using @tk.tag_names without arg since passing an arg seems broken and returns inaccurate results
+            region_tag = all_tag_names.reverse.find do |tag|
+              @tk.tag_cget(tag, 'font') && @tk.tag_ranges(tag).any? do |range_start, range_end|
+                text_index_less_than_or_equal_to_other_text_index?(range_start, text_index) && text_index_greater_than_or_equal_to_other_text_index?(range_end, text_index)
+              end
+            end
+            end_text_index = add_to_text_index(text_index, 1)
+            if tags_and_regions&.last && region_tag == tags_and_regions.last.first
+              tags_and_regions.last[2] = end_text_index
+            else
+              tags_and_regions << [region_tag, text_index, end_text_index]
+            end
+          end
+        end
+        tags_and_regions
+      end
+
+      def add_font_format(region_start, region_end, font_option, value)
+        applied_font_format_tags_and_regions(region_start, region_end).each do |tag, tag_region_start, tag_region_end|
+          if tag
+            bigger_region_tag = @tk.tag_ranges(tag).any? do |range_start, range_end|
+              text_index_less_than_other_text_index?(range_start, tag_region_start) || text_index_greater_than_other_text_index?(range_end, tag_region_end)
+            end
+            if bigger_region_tag
+              @tk.tag_ranges(tag).each do |range_start, range_end|
+                if text_index_less_than_other_text_index?(range_start, tag_region_start) && text_index_less_than_or_equal_to_other_text_index?(range_end, tag_region_end) && text_index_greater_than_or_equal_to_other_text_index?(range_end, tag_region_start)
+                  font = @tk.tag_cget(tag, 'font')
+                  remove_format(range_start, range_end, 'font', font)
+                  add_format(range_start, tag_region_start, 'font', font)
+                  font_clone = clone_font(font)
+                  font_clone.send("#{font_option}=", value)
+                  add_format(tag_region_start, tag_region_end, 'font', font_clone)
+                elsif text_index_greater_than_other_text_index?(range_end, tag_region_end) && text_index_greater_than_or_equal_to_other_text_index?(range_start, tag_region_start) && text_index_less_than_or_equal_to_other_text_index?(range_start, tag_region_end)
+                  font = @tk.tag_cget(tag, 'font')
+                  remove_format(range_start, range_end, 'font', font)
+                  add_format(tag_region_end, range_end, 'font', font)
+                  font_clone = clone_font(font)
+                  font_clone.send("#{font_option}=", value)
+                  add_format(tag_region_start, tag_region_end, 'font', font_clone)
+                elsif text_index_less_than_other_text_index?(range_start, tag_region_start) && text_index_greater_than_other_text_index?(range_end, tag_region_end)
+                  font = @tk.tag_cget(tag, 'font')
+                  remove_format(range_start, range_end, 'font', font)
+                  add_format(range_start, tag_region_start, 'font', font)
+                  remove_format(range_start, range_end, 'font', font)
+                  add_format(tag_region_end, range_end, 'font', font)
+                  font_clone = clone_font(font)
+                  font_clone.send("#{font_option}=", value)
+                  add_format(tag_region_start, tag_region_end, 'font', font_clone)
+                end
+              end
+            else
+              current_font = @tk.tag_cget(tag, 'font')
+              current_font.send("#{font_option}=", value)
+            end
+          else
+            add_format(tag_region_start, tag_region_end, 'font', default_font_attributes.merge(font_option => value))
+          end
+        end
+      end
+
+      def remove_font_format(region_start, region_end, font_option, value)
+        applied_font_format_tags_and_regions(region_start, region_end).each do |tag, tag_region_start, tag_region_end|
+          if tag
+            bigger_region_tag = @tk.tag_ranges(tag).any? do |range_start, range_end|
+              text_index_less_than_other_text_index?(range_start, tag_region_start) || text_index_greater_than_other_text_index?(range_end, tag_region_end)
+            end
+            if bigger_region_tag
+              @tk.tag_ranges(tag).each do |range_start, range_end|
+                if text_index_less_than_other_text_index?(range_start, tag_region_start) && text_index_less_than_or_equal_to_other_text_index?(range_end, tag_region_end) && text_index_greater_than_or_equal_to_other_text_index?(range_end, tag_region_start)
+                  font = @tk.tag_cget(tag, 'font')
+                  remove_format(range_start, range_end, 'font', font)
+                  add_format(range_start, subtract_from_text_index(tag_region_start, 1), 'font', font)
+                  font_clone = clone_font(font)
+                  font_clone.send("#{font_option}=", default_for_font_option(font_option))
+                  add_format(tag_region_start, tag_region_end, 'font', font_clone)
+                elsif text_index_greater_than_other_text_index?(range_end, tag_region_end) && text_index_greater_than_or_equal_to_other_text_index?(range_start, tag_region_start) && text_index_less_than_or_equal_to_other_text_index?(range_start, tag_region_end)
+                  font = @tk.tag_cget(tag, 'font')
+                  remove_format(range_start, range_end, 'font', font)
+                  add_format(add_to_text_index(tag_region_end, 1), range_end, 'font', font)
+                  font_clone = clone_font(font)
+                  font_clone.send("#{font_option}=", default_for_font_option(font_option))
+                  add_format(tag_region_start, tag_region_end, 'font', font_clone)
+                elsif text_index_less_than_other_text_index?(range_start, tag_region_start) && text_index_greater_than_other_text_index?(range_end, tag_region_end)
+                  font = @tk.tag_cget(tag, 'font')
+                  remove_format(range_start, range_end, 'font', font)
+                  add_format(range_start, subtract_from_text_index(tag_region_start, 1), 'font', font)
+                  remove_format(range_start, range_end, 'font', font)
+                  add_format(add_to_text_index(tag_region_end, 1), range_end, 'font', font)
+                  font_clone = clone_font(font)
+                  font_clone.send("#{font_option}=", default_for_font_option(font_option))
+                  add_format(tag_region_start, tag_region_end, 'font', font_clone)
+                end
+              end
+            else
+              current_font = @tk.tag_cget(tag, 'font')
+              current_font.send("#{font_option}=", default_for_font_option(font_option))
+            end
+          else
+            add_format(tag_region_start, tag_region_end, 'font', default_font_attributes.merge(font_option => default_for_font_option(font_option)))
+          end
+        end
+      end
+
+      # toggles option/value tag (removes if already applied)
+      def toggle_font_format(region_start, region_end, option, value)
+        if applied_font_format?(region_start, region_end, option, value)
+          remove_font_format(region_start, region_end, option, value)
+        else
+          add_font_format(region_start, region_end, option, value)
+        end
+      end
+      
+      def default_for_font_option(font_option)
+        @tk.font.send(font_option)
+      end
+      
+      def default_font_attributes
+        Hash[@tk.font.actual]
+      end
+      
+      def add_to_text_index(text_index, addition)
+        text_index_parts = text_index.split('.')
+        line = text_index_parts.first
+        char_index = text_index_parts.last
+        char_index = char_index.to_i + addition
+        "#{line}.#{char_index}"
+      end
+            
+      def subtract_from_text_index(text_index, subtraction)
+        add_to_text_index(text_index, -1 * subtraction)
+      end
+      
+      def text_index_less_than_other_text_index?(region1, region2)
+        region1_parts = region1.to_s.split('.')
+        region2_parts = region2.to_s.split('.')
+        return true if region1_parts.first.to_i < region2_parts.first.to_i
+        return false if region1_parts.first.to_i > region2_parts.first.to_i
+        region1_parts.last.to_i < region2_parts.last.to_i
+      end
+            
+      def text_index_less_than_or_equal_to_other_text_index?(region1, region2)
+        region1_parts = region1.to_s.split('.')
+        region2_parts = region2.to_s.split('.')
+        return true if region1_parts.first.to_i < region2_parts.first.to_i
+        return false if region1_parts.first.to_i > region2_parts.first.to_i
+        region1_parts.last.to_i <= region2_parts.last.to_i
+      end
+            
+      def text_index_greater_than_other_text_index?(region1, region2)
+        region1_parts = region1.to_s.split('.')
+        region2_parts = region2.to_s.split('.')
+        return true if region1_parts.first.to_i > region2_parts.first.to_i
+        return false if region1_parts.first.to_i < region2_parts.first.to_i
+        region1_parts.last.to_i > region2_parts.last.to_i
+      end
+            
+      def text_index_greater_than_or_equal_to_other_text_index?(region1, region2)
+        region1_parts = region1.to_s.split('.')
+        region2_parts = region2.to_s.split('.')
+        return true if region1_parts.first.to_i > region2_parts.first.to_i
+        return false if region1_parts.first.to_i < region2_parts.first.to_i
+        region1_parts.last.to_i >= region2_parts.last.to_i
+      end
+      
+      def clone_font(font)
+        ::TkFont.new(Hash[font.actual])
+      end
+      
+      private
+      
+      def initialize_defaults
+        super
+        self.font = {family: 'Courier New'}
+        self.wrap = 'none'
+        self.padx = 5
+        self.pady = 5
+      end
+    end
+  end
+end

data/lib/glimmer/tk/widget_proxy.rb

@@ -34,7 +34,9 @@ module Glimmer
           begin
             class_name = "#{keyword.camelcase(:upper)}Proxy".to_sym
             Glimmer::Tk.const_get(class_name)
-          rescue
+          rescue => e
+            Glimmer::Config.logger.debug {"Unable to instantiate custom class name for #{keyword} ... defaulting to Glimmer::Tk::WidgetProxy"}
+            Glimmer::Config.logger.debug {e.full_message}
             Glimmer::Tk::WidgetProxy
           end
         end
@@ -54,13 +56,15 @@ module Glimmer
               tk_widget_class = eval(tk_widget_name)
               break
             rescue RuntimeError, SyntaxError, NameError => e
-              Glimmer::Config.logger.debug e.full_message
+              Glimmer::Config.logger.debug {e.full_message}
             end
           end
-          tk_widget_class
+          tk_widget_class if tk_widget_class.respond_to?(:new)
         end
       end
       
+      FONTS_PREDEFINED = %w[default text fixed menu heading caption small_caption icon tooltip]
+      
       attr_reader :parent_proxy, :tk, :args, :keyword, :children
 
       # Initializes a new Tk Widget
@@ -74,8 +78,8 @@ module Glimmer
         tk_widget_class = self.class.tk_widget_class_for(underscored_widget_name)
         @tk = tk_widget_class.new(@parent_proxy.tk, *args)
         # a common widget initializer
-        initialize_defaults
         @parent_proxy.post_initialize_child(self)
+        initialize_defaults
         post_add_content if @block.nil?
       end
       
@@ -104,6 +108,8 @@ module Glimmer
           @tk.send(attribute_setter(attribute), @tk.send(attribute))
           result = true
         rescue => e
+          Glimmer::Config.logger.debug { "No tk attribute setter for #{attribute}" }
+          Glimmer::Config.logger.debug { e.full_message }
           result = false
         end
         result
@@ -114,7 +120,8 @@ module Glimmer
           # TK Widget currently doesn't support respond_to? properly, so I have to resort to this trick for now
           @tk.send(attribute)
           true
-        rescue
+        rescue => e
+          Glimmer::Config.logger.debug { "No tk attribute getter setter for #{attribute}" }
           false
         end
       end
@@ -125,7 +132,8 @@ module Glimmer
           begin
             @tk.tile_instate(attribute)
             true
-          rescue
+          rescue => e
+            Glimmer::Config.logger.debug { "No tk state for #{attribute}" }
             false
           end
         else
@@ -144,45 +152,55 @@ module Glimmer
           tk_widget_has_attribute_getter_setter?(attribute) or
           has_state?(attribute) or
           has_attributes_attribute?(attribute) or
-          respond_to?(attribute_setter(attribute), args)
+          respond_to?(attribute_setter(attribute), args) or
+          respond_to?(attribute_setter(attribute), *args, super_only: true) or
+          respond_to?(attribute, *args, super_only: true)
       end
 
       def set_attribute(attribute, *args)
-        widget_custom_attribute = widget_custom_attribute_mapping[tk.class] && widget_custom_attribute_mapping[tk.class][attribute.to_s]
-        if respond_to?(attribute, super_only: true)
-          send(attribute, *args)
-        elsif respond_to?(attribute_setter(attribute), super_only: true)
-          send(attribute_setter(attribute), *args)
-        elsif widget_custom_attribute
-          widget_custom_attribute[:setter][:invoker].call(@tk, args)
-        elsif tk_widget_has_attribute_setter?(attribute)
-          unless args.size == 1 && @tk.send(attribute) == args.first
-            if args.size == 1
-              @tk.send(attribute_setter(attribute), *args)
+        begin
+          widget_custom_attribute = widget_custom_attribute_mapping[tk.class] && widget_custom_attribute_mapping[tk.class][attribute.to_s]
+          if respond_to?(attribute_setter(attribute), super_only: true)
+            send(attribute_setter(attribute), *args)
+          elsif respond_to?(attribute, super_only: true) && self.class.instance_method(attribute).parameters.size > 0
+            send(attribute, *args)
+          elsif widget_custom_attribute
+            widget_custom_attribute[:setter][:invoker].call(@tk, args)
+          elsif tk_widget_has_attribute_setter?(attribute)
+            unless args.size == 1 && @tk.send(attribute) == args.first
+              if args.size == 1
+                @tk.send(attribute_setter(attribute), *args)
+              else
+                @tk.send(attribute_setter(attribute), args)
+              end
+            end
+          elsif tk_widget_has_attribute_getter_setter?(attribute)
+            @tk.send(attribute, *args)
+          elsif has_state?(attribute)
+            attribute = attribute.sub(/=$/, '')
+            if !!args.first
+              @tk.tile_state(attribute)
             else
-              @tk.send(attribute_setter(attribute), args)
+              @tk.tile_state("!#{attribute}")
             end
-          end
-        elsif tk_widget_has_attribute_getter_setter?(attribute)
-          @tk.send(attribute, *args)
-        elsif has_state?(attribute)
-          attribute = attribute.sub(/=$/, '')
-          if !!args.first
-            @tk.tile_state(attribute)
+          elsif has_attributes_attribute?(attribute)
+            attribute = attribute.sub(/=$/, '')
+            @tk.attributes(attribute, args.first)
           else
-            @tk.tile_state("!#{attribute}")
+            raise "#{self} cannot handle attribute #{attribute} with args #{args.inspect}"
           end
-        elsif has_attributes_attribute?(attribute)
-          attribute = attribute.sub(/=$/, '')
-          @tk.attributes(attribute, args.first)
-        else
-          send(attribute_setter(attribute), args)
+        rescue => e
+          Glimmer::Config.logger.debug {"Failed to set attribute #{attribute} with args #{args.inspect}. Attempting to set through style instead..."}
+          Glimmer::Config.logger.debug {e.full_message}
+          apply_style(attribute => args.first)
         end
       end
 
       def get_attribute(attribute)
         widget_custom_attribute = widget_custom_attribute_mapping[tk.class] && widget_custom_attribute_mapping[tk.class][attribute.to_s]
-        if widget_custom_attribute
+        if respond_to?(attribute, super_only: true)
+          send(attribute)
+        elsif widget_custom_attribute
           widget_custom_attribute[:getter][:invoker].call(@tk, args)
         elsif tk_widget_has_attribute_getter_setter?(attribute)
           @tk.send(attribute)
@@ -201,6 +219,12 @@ module Glimmer
         "#{attribute}="
       end
       
+      def style=(styles)
+        styles.each do |attribute, value|
+          apply_style(attribute => value)
+        end
+      end
+      
       def grid(options = {})
         options = options.stringify_keys
         index_in_parent = @parent_proxy.children.index(self)
@@ -221,6 +245,25 @@ module Glimmer
         @tk.grid(options)
       end
       
+      def font=(value)
+        if (value.is_a?(Symbol) || value.is_a?(String)) && FONTS_PREDEFINED.include?(value.to_s.downcase)
+          @tk.font = "tk_#{value}_font".camelcase(:upper)
+        else
+          @tk.font = value.is_a?(TkFont) ? value : TkFont.new(value)
+        end
+      rescue => e
+        Glimmer::Config.logger.debug {"Failed to set attribute #{attribute} with args #{args.inspect}. Attempting to set through style instead..."}
+        Glimmer::Config.logger.debug {e.full_message}
+        apply_style({"font" => value})
+      end
+      
+      def apply_style(options)
+        @@style_number = 0 unless defined?(@@style_number)
+        style = "style#{@@style_number += 1}.#{@tk.class.name.split('::').last}"
+        ::Tk::Tile::Style.configure(style, options)
+        @tk.style = style
+      end
+      
       def widget_custom_attribute_mapping
         # TODO consider extracting to modules/subclasses
         @widget_custom_attribute_mapping ||= {
@@ -276,6 +319,12 @@ module Glimmer
               setter: {name: 'text=', invoker: lambda { |widget, args| @tk.textvariable&.value = args.first }},
             },
           },
+          ::Tk::Tile::TSpinbox => {
+            'text' => {
+              getter: {name: 'text', invoker: lambda { |widget, args| @tk.textvariable&.value }},
+              setter: {name: 'text=', invoker: lambda { |widget, args| @tk.textvariable&.value = args.first }},
+            },
+          },
           ::Tk::Root => {
             'text' => {
               getter: {name: 'text', invoker: lambda { |widget, args| @tk.title }},
@@ -309,11 +358,33 @@ module Glimmer
           },
           ::Tk::Tile::TEntry => {
             'text' => lambda do |observer|
-              tk.textvariable.trace('write') {
+              @tk.textvariable.trace('write') {
                 observer.call(@tk.textvariable.value)
               }
             end,
           },
+          ::Tk::Tile::TSpinbox => {
+            'text' => lambda do |observer|
+              @tk.command {
+                observer.call(@tk.textvariable&.value)
+              }
+              @tk.validate('key')
+              @tk.validatecommand { |validate_args|
+                observer.call(validate_args.value)
+                new_icursor = validate_args.index
+                new_icursor += validate_args.string.size if validate_args.action == 1
+                @tk.icursor = new_icursor
+                true
+              }
+            end,
+          },
+          ::Tk::Text => {
+            'text' => lambda do |observer|
+              handle_listener('modified') do
+                observer.call(text)
+              end
+            end,
+          },
           ::Tk::Tile::TRadiobutton => {
             'variable' => lambda do |observer|
               @tk.command {
@@ -384,7 +455,10 @@ module Glimmer
       private
       
       def initialize_defaults
-        grid unless @tk.is_a?(::Tk::Toplevel)
+        options = {}
+        options[:sticky] = 'nsew'
+        options[:column_weight] = 1 if @parent_proxy.children.count == 1
+        grid(options) unless @tk.is_a?(::Tk::Toplevel)
       end
     end
   end