tk_component 0.1.0 → 0.1.1

data/lib/tk_component/builder/grid_map.rb

@@ -35,10 +35,10 @@ module TkComponent
       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
+        vw = weights[:y_flex]
+        @row_weights[row] = ((rw = @row_weights[row]).present? ? [rw, vw].max : vw) if vw
+        hw = weights[:x_flex]
+        @column_weights[col] = ((cw = @column_weights[col]).present? ? [cw, hw].max : hw) if hw
       end
 
       def row_indexes

data/lib/tk_component/builder/node.rb

@@ -1,16 +1,19 @@
 module TkComponent
   module Builder
 
-    TK_CMDS = %w(label entry button canvas text scale group).to_set.freeze
+    TK_CMDS = %w(label entry button radio_set radio_button canvas text scale group tree tree_node hscroll_bar vscroll_bar hpaned vpaned).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
+    EVENT_CMDS = %w(on_change on_mouse_down on_mouse_up on_mouse_drag on_mouse_wheel on_click on_select on_item_open on_event).to_set.freeze
     TOKENS = (TK_CMDS + LAYOUT_CMDS + EVENT_CMDS).freeze
 
+    LAYOUT_OPTIONS = %i(column row rowspan columnspan sticky x_flex y_flex)
+
     class Node
       attr_accessor :name
       attr_accessor :options
       attr_accessor :sub_nodes
       attr_accessor :grid
+      attr_accessor :weights
       attr_accessor :grid_map
       attr_accessor :event_handlers
       attr_accessor :tk_item
@@ -29,14 +32,14 @@ module TkComponent
         @name = name
         @options = options.with_indifferent_access
         @sub_nodes = []
-        @grid = {}
+        @grid = {}.with_indifferent_access
+        @weights = {}.with_indifferent_access
         @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
@@ -44,10 +47,12 @@ module TkComponent
       end
 
       def insert_component(component_class, parent_component, options = {}, &block)
-        c_node = node_from_command(:frame, &block)
+        layout_options = options.slice(*LAYOUT_OPTIONS)
+        c_node = node_from_command(:frame, layout_options, &block)
         comp = component_class.new(options.merge(parent: parent_component, parent_node: c_node))
         comp.generate(parent_component, options)
         parent_component.add_child(comp)
+        comp
       end
 
       def add_event_handler(name, lambda, options = {})
@@ -61,9 +66,25 @@ module TkComponent
         sub_nodes.each do |n|
           n.build(self, parent_component)
         end
+        apply_grid
+        built
+      end
+
+      def apply_grid
         self.tk_item.apply_internal_grid(grid_map)
       end
 
+      def built
+        self.tk_item.built
+      end
+
+      def rebuilt
+      end
+
+      def remove
+        self.tk_item.remove
+      end
+
       def prepare_option_events(component)
         option_events = options.extract!(*EVENT_CMDS)
         option_events.each do |k, v|
@@ -74,6 +95,7 @@ module TkComponent
       end
 
       def prepare_grid
+        self.grid_map = GridMap.new
         return unless self.sub_nodes.any?
         current_row = -1
         current_col = -1
@@ -90,13 +112,15 @@ module TkComponent
             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
+            n.grid = {}.with_indifferent_access if n.grid.nil?
+            n.grid.merge!(n.options.extract!(:column, :row, :rowspan, :columnspan, :sticky))
+            n.grid.merge!(column: current_col, row: current_row)
+            rowspan = n.grid[:rowspan] || 1
+            columnspan = n.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.weights = {}.with_indifferent_access if n.weights.nil?
+            n.weights.merge!(n.options.extract!(:x_flex, :y_flex))
+            grid_map.set_weights(current_row, current_col, n.weights)
             n.prepare_grid
             final_sub_nodes << n
           end

data/lib/tk_component/builder/tk_item.rb

@@ -11,34 +11,43 @@ module TkComponent
       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)
+        @native_item = create_native_item(parent_item.native_item, name, options, grid, event_handlers)
         apply_options(options)
         set_grid(grid)
         set_event_handlers(event_handlers)
       end
 
-      def apply_options(options)
+      def create_native_item(parent_native_item, name, options = {}, grid = {}, event_handlers = [])
+        native_item_class(parent_native_item, name, options, grid, event_handlers).new(parent_native_item)
+      end
+
+      def native_item_class(parent_native_item, name, options = {}, grid = {}, event_handlers = [])
+        tk_class = TK_CLASSES[name.to_sym]
+        raise "Don't know how to create #{name}" unless tk_class.present?
+        return tk_class
+      end
+
+      def remove
+        @native_item.destroy
+      end
+
+      def apply_options(options, to_item = self.native_item)
         options.each do |k,v|
-          apply_option(k, v)
+          apply_option(k, v, to_item)
         end
       end
 
-      def apply_option(option, value)
-        self.native_item.public_send(option, value)
+      def apply_option(option, value, to_item = self.native_item)
+        to_item.public_send(option, value)
       end
 
-      def set_grid(grid)
-        self.native_item.grid(grid)
+      def set_grid(grid, to_item = self.native_item)
+        to_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)
@@ -55,10 +64,17 @@ module TkComponent
           Event.bind_event(event_handler.name, self, event_handler.options, event_handler.lambda)
         end
       end
+
+      def built
+      end
+
+      def focus
+        self.native_item.focus
+      end
     end
 
     module ValueTyping
-      def apply_option(option, v)
+      def apply_option(option, v, to_item = self.native_item)
         case option.to_sym
         when :value
           self.value = v
@@ -90,15 +106,23 @@ module TkComponent
       attr_accessor :tk_variable
 
       def initialize(parent_item, name, options = {}, grid = {}, event_handlers = [])
-        @tk_variable = TkVariable.new
+        create_variable
         super
-        self.native_item.public_send(variable_name, @tk_variable)
+        apply_variable
       end
 
       def variable_name
         :variable
       end
 
+      def apply_variable
+        self.native_item&.public_send(variable_name, @tk_variable)
+      end
+
+      def create_variable
+        @tk_variable = TkVariable.new
+      end
+
       delegate :value, to: :tk_variable
       delegate :"value=", to: :tk_variable
     end
@@ -127,8 +151,83 @@ module TkComponent
       end
     end
 
+    class TkRadioSet < TkItemWithVariable
+      # The variable for the radio set is only to be used by radio buttons inside it
+      # Thus, we don't try to link it to the actual item
+      def apply_variable
+      end
+    end
+
+    class TkRadioButton < TkItemWithVariable
+      # We need to use the tk_variable created by the parent_item
+      # So we set it here and skip creation below
+      def initialize(parent_item, name, options = {}, grid = {}, event_handlers = [])
+        @tk_variable = parent_item.tk_variable
+        super
+      end
+
+      def create_variable
+      end
+
+      # It is unfortunate that native TK radio buttons use 'value' to
+      # spedify the value for each of them, colliding with the 'value'
+      # methods for our items with variables. Thus, we need to
+      # override the setting of the 'value' option to revert it to the
+      # default functionality
+      def apply_option(option, v, to_item = self.native_item)
+        case option.to_sym
+        when :value
+          to_item.public_send(option, v)
+        else
+          super
+        end
+      end
+    end
+
+    module Scrollable
+      ROOT_FRAME_OPTIONS = %i|width height relief borderwidth padx pady padding| + TkComponent::Builder::LAYOUT_OPTIONS
+
+      def initialize(parent_item, name, options = {}, grid = {}, event_handlers = [])
+        return super unless (s_options = options.delete(:scrollers)) && s_options.present? && s_options != 'none'
+        frame_item = TK_CLASSES[:frame].new(parent_item.native_item) # Containing frame
+        real_native_item = create_native_item(frame_item, name, options, grid, event_handlers)
+        f_options = options.extract!(*ROOT_FRAME_OPTIONS)
+        apply_options(f_options, frame_item) # Apply the applicable options to the enclosing frame
+        @native_item = real_native_item
+        apply_options(options, real_native_item)
+        set_grid(grid, frame_item)
+        real_native_item.grid( :column => 0, :row => 0, :sticky => 'nwes')
+        if s_options.include?('x')
+          h_scrollbar = TK_CLASSES[:hscroll_bar].new(frame_item)
+          h_scrollbar.orient('horizontal')
+          h_scrollbar.command proc { |*args| real_native_item.xview(*args) }
+          real_native_item['xscrollcommand'] = proc { |*args| h_scrollbar.set(*args) }
+          h_scrollbar.grid( :column => 0, :row => 1, :sticky => 'wes')
+        end
+        if s_options.include?('y')
+          v_scrollbar =  TK_CLASSES[:vscroll_bar].new(frame_item)
+          v_scrollbar.orient('vertical')
+          v_scrollbar.command proc { |*args| real_native_item.yview(*args) }
+          real_native_item['yscrollcommand'] = proc { |*args| v_scrollbar.set(*args) }
+          v_scrollbar.grid( :column => 1, :row => 0, :sticky => 'nse')
+        end
+        TkGrid.columnconfigure(frame_item, 0, :weight => 1)
+        TkGrid.columnconfigure(frame_item, 1, :weight => 0) if v_scrollbar.present?
+        TkGrid.rowconfigure(frame_item, 0, :weight => 1)
+        TkGrid.rowconfigure(frame_item, 1, :weight => 0) if h_scrollbar.present?
+        @native_item = real_native_item
+        set_event_handlers(event_handlers)
+      end
+
+      # We need to remove the parent native item, as it's the container we put in place initially
+      def remove
+        @native_item.winfo_parent.destroy
+      end
+    end
+
     class TkText < TkItem
       include ValueTyping
+      include Scrollable
 
       def value
         native_item.get('1.0', 'end')
@@ -138,6 +237,24 @@ module TkComponent
         native_item.replace('1.0', 'end', text)
       end
 
+      def selected_text
+        ranges = native_item.tag_ranges('sel')
+        return nil if ranges.empty?
+        native_item.get(ranges.first.first, ranges.first.last)
+      end
+
+      def current_line
+        native_item.get('insert linestart', 'insert lineend')
+      end
+
+      def append_text(text)
+        native_item.insert('end', text)
+      end
+
+      def select_range(from, to)
+        native_item.tag_add('sel', from, to)
+      end
+
       def set_event_handler(event_handler)
         case event_handler.name
         when :change
@@ -159,11 +276,214 @@ module TkComponent
       end
     end
 
+    class TkTree < TkItem
+      include Scrollable
+      @column_defs = []
+
+      def apply_options(options, to_item = self.native_item)
+        super
+        return unless @column_defs.present?
+        cols = @column_defs.map { |c| c[:key] }
+        to_item.columns(cols[1..-1].join(' ')) unless cols == ['#0']
+        @column_defs.each.with_index do |cd, idx|
+          key = idx == 0 ? '#0' : cd[:key]
+          column_conf = cd.slice(:width, :anchor)
+          to_item.column_configure(key, column_conf) unless column_conf.empty?
+          heading_conf = cd.slice(:text)
+          to_item.heading_configure(key, heading_conf) unless heading_conf.empty?
+        end
+      end
+
+      def apply_option(option, v, to_item = self.native_item)
+        case option.to_sym
+        when :column_defs
+          @column_defs = v
+        when :heading
+          @column_defs = [ { key: '#0', text: v } ]
+        else
+          super
+        end
+      end
+
+      def set_event_handler(event_handler)
+        case event_handler.name
+        when :select
+          Event.bind_event('<TreeviewSelect>', self, event_handler.options, event_handler.lambda)
+        when :item_open
+          Event.bind_event('<TreeviewOpen>', self, event_handler.options, event_handler.lambda)
+        else
+          super
+        end
+      end
+
+      def scroll_to_selection
+        scroll_to_item(@native_item.selection.first)
+      end
+
+      # Right now it only works well for non-nested trees
+      def scroll_to_item(tree_item)
+        return unless tree_item.present?
+        items = @native_item.children('')
+        rel_pos = items.index(tree_item).to_f / items.size.to_f
+        @native_item.after(200) { @native_item.yview_moveto(rel_pos) }
+      end
+    end
+
+    class TkTreeNode < TkItem
+      def initialize(parent_item, name, options = {}, grid = {}, event_handlers = [])
+        item_options = options.dup
+        parent_node = item_options.delete(:parent) || ''
+        parent_native_item = (parent_node == '' ? '' : parent_node.native_item)
+        at = item_options.delete(:at)
+        selected = item_options.delete(:selected)
+        @native_item = parent_item.native_item.insert(parent_native_item, at, item_options)
+        parent_item.native_item.selection_add(@native_item) if selected
+        set_event_handlers(event_handlers)
+      end
+    end
+
+    class ScrollBar < TkItem
+      def apply_option(option, v, to_item = self.native_item)
+        case option.to_sym
+        when :linked_to
+          @linked_to = v
+        else
+          super
+        end
+      end
+
+      def set_event_handler(event_handler)
+        case event_handler.name
+        when :change
+          Event.Event.bind_command(event_handler.name, self, event_handler.options, event_handler.lambda)
+        else
+          super
+        end
+      end
+
+      def apply_options(options, to_item = self.native_item)
+        options.merge!(orient: orient)
+        super
+      end
+
+      def set_event_handlers(event_handlers)
+        bind_linked_to
+        super
+      end
+
+      def bind_linked_to
+        return unless @linked_to.present?
+        items = @linked_to.is_a?(Array) ? @linked_to.map(&:native_item) : [ @linked_to.native_item ]
+        self.native_item.command proc { |*args|
+          items.each do |item|
+            item.send(scroll_command, *args)
+          end
+        }
+        items.each do |item|
+          item.send(linked_scroll_command, proc { |*args| self.native_item.send(linked_scroll_event, *args) })
+        end
+      end
+
+      def orient
+        raise "#{self.class.to_s} shouldn't be instantiated directly. Use 'H' or 'V' subclasses"
+      end
+
+      def scroll_command
+        raise "#{self.class.to_s} shouldn't be instantiated directly. Use 'H' or 'V' subclasses"
+      end
+
+      def linked_scroll_command
+        raise "#{self.class.to_s} shouldn't be instantiated directly. Use 'H' or 'V' subclasses"
+      end
+
+      def linked_scroll_event
+        raise "#{self.class.to_s} shouldn't be instantiated directly. Use 'H' or 'V' subclasses"
+      end
+    end
+
+    class HScrollbar < ScrollBar
+      def orient
+        'horizontal'
+      end
+
+      def scroll_command
+        :xview
+      end
+
+      def linked_scroll_command
+        :xscrollcommand
+      end
+
+      def linked_scroll_event
+        :set
+      end
+    end
+
+    class VScrollbar < ScrollBar
+      def orient
+        'vertical'
+      end
+
+      def scroll_command
+        :yview
+      end
+
+      def linked_scroll_command
+        :yscrollcommand
+      end
+
+      def linked_scroll_event
+        :set
+      end
+    end
+
+    class PanedWindow < TkItem
+      def create_native_item(parent_native_item, name, options = {}, grid = {}, event_handlers = [])
+        native_item_class(parent_native_item, name, options, grid, event_handlers).new(parent_native_item, orient: orient)
+      end
+
+      def built
+        # We need to synchronize children items to the panned window
+        added_panes = self.native_item.winfo_children - self.native_item.panes
+        removed_panes = self.native_item.panes - self.native_item.winfo_children
+        added_panes.each do |child|
+          self.native_item.add(child, weight: 1)
+        end
+        removed_panes.each do |child|
+          self.native_item.forget(child)
+        end
+      end
+
+      def orient
+        raise "#{self.class.to_s} shouldn't be instantiated directly. Use 'H' or 'V' subclasses"
+      end
+    end
+
+    class HPanedWindow < PanedWindow
+      def orient
+        'horizontal'
+      end
+    end
+
+    class VPanedWindow < PanedWindow
+      def orient
+        'vertical'
+      end
+    end
+
     class TkWindow < TkItem
       def initialize(parent_item, name, options = {}, grid = {}, event_handlers = [])
-        @native_item = TkRoot.new { title options[:title] }
+        if (options.delete(:root))
+          @native_item = TkRoot.new { title options[:title] }
+        else
+          @native_item = TkToplevel.new { title options[:title] }
+        end
         apply_options(options)
       end
+
+      def focus
+        self.native_item.set_focus
+      end
     end
 
     TK_CLASSES = {
@@ -174,10 +494,17 @@ module TkComponent
       label: Tk::Tile::Label,
       entry: Tk::Tile::Entry,
       button: Tk::Tile::Button,
+      radio_set: Tk::Tile::Frame,
+      radio_button: Tk::Tile::RadioButton,
       canvas: Tk::Canvas,
       text: ::TkText,
       scale: Tk::Tile::Scale,
-      group: Tk::Tile::LabelFrame
+      group: Tk::Tile::LabelFrame,
+      tree: Tk::Tile::Treeview,
+      hscroll_bar: Tk::Tile::Scrollbar,
+      vscroll_bar: Tk::Tile::Scrollbar,
+      hpaned: Tk::Tile::Paned,
+      vpaned: Tk::Tile::Paned
     }
 
     ITEM_CLASSES = {
@@ -188,10 +515,19 @@ module TkComponent
       label: TkComponent::Builder::TkItem,
       entry: TkComponent::Builder::TkEntry,
       button: TkComponent::Builder::TkItem,
+      radio_set: TkComponent::Builder::TkRadioSet,
+      radio_button: TkComponent::Builder::TkRadioButton,
       canvas: TkComponent::Builder::TkItem,
       text: TkComponent::Builder::TkText,
       scale: TkComponent::Builder::TkScale,
-      group: TkComponent::Builder::TkItem
+      group: TkComponent::Builder::TkItem,
+      tree: TkComponent::Builder::TkTree,
+      tree_node: TkComponent::Builder::TkTreeNode,
+      hscroll_bar: TkComponent::Builder::HScrollbar,
+      vscroll_bar: TkComponent::Builder::VScrollbar,
+      hpaned: TkComponent::Builder::HPanedWindow,
+      vpaned: TkComponent::Builder::VPanedWindow
+
     }
   end
 end