glimmer-dsl-tk 0.0.1 → 0.0.6

data/lib/glimmer/tk/frame_proxy.rb

@@ -0,0 +1,42 @@
+# Copyright (c) 2020 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::Tile::Frame
+    #
+    # Follows the Proxy Design Pattern
+    class FrameProxy < WidgetProxy
+      attr_reader :tab_options
+      
+      def initialize(underscored_widget_name, parent_proxy, args)
+        if parent_proxy.is_a?(NotebookProxy)
+          @tab_options, args[0] = args[0].to_h.partition {|key, value| NotebookProxy::TAB_OPTIONS.include?(key.to_s)}
+          @tab_options = Hash[@tab_options]
+          args.delete_at(0) if args[0].to_a.empty?
+        end
+        super
+      end
+    end
+  end
+end

data/lib/glimmer/tk/label_proxy.rb

@@ -0,0 +1,40 @@
+# Copyright (c) 2020 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::Tile::TLabel
+    #
+    # Follows the Proxy Design Pattern
+    class LabelProxy < WidgetProxy
+      # TODO specify attribute setters
+#       def tk_widget_has_attribute_setter?(attribute)
+#         if ['anchor', 'justify'].include?(attribute.to_s)
+#           true
+#         else
+#           super
+#         end
+#       end    
+    end
+  end
+end

data/lib/glimmer/tk/list_proxy.rb

@@ -0,0 +1,60 @@
+# Copyright (c) 2020 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    
+    # Custom list widget implementation
+    class ListProxy < WidgetProxy
+      def initialize(underscored_widget_name, parent_proxy, args)
+        super('treeview', parent_proxy, args)
+        @tk.show = 'tree'
+      end
+      
+      def widget_custom_attribute_mapping
+        @widget_custom_attribute_mapping ||= {
+          ::Tk::Tile::Treeview => {
+            'items' => {
+              getter: {name: 'items', invoker: lambda { |widget, args| tk.children('').map(&:text) }},
+              setter: {name: 'items=', invoker: lambda { |widget, args| 
+                @tk.delete @tk.children('')
+                args.first.each do |child|
+                  @tk.insert('', 'end', :text => child)
+                end          
+              }},
+            },
+            'selection' => {
+              getter: {name: 'selection', invoker: lambda { |widget, args| @tk.selection.map(&:text) }},
+              setter: {name: 'selection=', invoker: lambda { |widget, args| 
+                selection_args = args.first.is_a?(Array) ? args.first : [args.first]
+                selection_items = selection_args.map do |arg|
+                  @tk.children('').detect {|item| item.text == arg}
+                end
+                @tk.selection_set(*selection_items)
+              }},
+            },
+          },
+        }
+      end
+    end
+  end
+end

data/lib/glimmer/tk/notebook_proxy.rb

@@ -0,0 +1,45 @@
+# Copyright (c) 2020 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::Tile::Notebook
+    #
+    # Follows the Proxy Design Pattern
+    class NotebookProxy < WidgetProxy
+      TAB_OPTIONS = ['state', 'sticky', 'padding', 'text', 'image', 'compound', 'underline']
+    
+      attr_reader :tab_proxies
+    
+      def initialize(*args)
+        @tab_proxies = []
+        super
+      end
+    
+      def post_initialize_child(child)
+        @tab_proxies << child
+        @tk.add child.tk, child.tab_options
+      end
+    end
+  end
+end

data/lib/glimmer/tk/root_proxy.rb

@@ -29,7 +29,7 @@ module Glimmer
     class RootProxy < WidgetProxy
 
       def initialize(*args)
-        @tk_widget = ::TkRoot.new
+        @tk = ::TkRoot.new
       end
 
       def open
@@ -37,7 +37,7 @@ module Glimmer
       end
 
       def content(&block)
-        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::RootExpression.new, &block)
+        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::Tk::RootExpression.new, &block)
       end
 
       # Starts Tk mainloop

data/lib/glimmer/tk/widget_proxy.rb

@@ -25,23 +25,67 @@ module Glimmer
     #
     # Follows the Proxy Design Pattern
     class WidgetProxy
-      attr_reader :parent_proxy, :tk_widget, :drag_source_proxy, :drop_target_proxy, :drag_source_style, :drag_source_transfer, :drop_target_transfer
+      attr_reader :parent_proxy, :tk, :args
 
       DEFAULT_INITIALIZERS = {
-        'label' => lambda do |label|
-          label.grid
+        'combobox' => lambda do |tk|
+          tk.textvariable = ::TkVariable.new          
+        end,
+        'label' => lambda do |tk|
+          tk.textvariable = ::TkVariable.new          
+        end,
+        'entry' => lambda do |tk|
+          tk.textvariable = ::TkVariable.new          
         end,
       }
       
+      class << self
+        def create(keyword, parent, args)
+          widget_proxy_class(keyword).new(keyword, parent, args)
+        end
+        
+        def widget_proxy_class(keyword)
+          begin
+            class_name = "#{keyword.camelcase(:upper)}Proxy".to_sym
+            Glimmer::Tk.const_get(class_name)
+          rescue
+            Glimmer::Tk::WidgetProxy
+          end        
+        end
+        
+        # This supports widgets in and out of basic Tk
+        def tk_widget_class_for(underscored_widget_name)
+          tk_widget_class_basename = underscored_widget_name.camelcase(:upper)
+          potential_tk_widget_class_names = [
+            "::Tk::Tile::#{tk_widget_class_basename}", 
+            "::Tk::#{tk_widget_class_basename}", 
+            "::Tk#{tk_widget_class_basename}", 
+            "::Glimmer::Tk::#{tk_widget_class_basename}Proxy", 
+          ]
+          tk_widget_class = nil
+          potential_tk_widget_class_names.each do |tk_widget_name|
+            begin
+              tk_widget_class = eval(tk_widget_name)
+              break
+            rescue RuntimeError, SyntaxError, NameError => e
+              Glimmer::Config.logger.debug e.full_message
+            end            
+          end
+          tk_widget_class
+        end
+      end      
+      
       # Initializes a new Tk Widget
       #
       # Styles is a comma separate list of symbols representing Tk styles in lower case
-      def initialize(*init_args)
-        underscored_widget_name, parent, extra_options = init_args
-        @parent_proxy = parent
-        tk_widget_class = self.class.tk_widget_class_for(underscored_widget_name)
-        @tk_widget = tk_widget_class.new(@parent_proxy.tk_widget, *extra_options)
-        DEFAULT_INITIALIZERS[underscored_widget_name]&.call(@tk_widget)        
+      def initialize(underscored_widget_name, parent_proxy, args)
+        @parent_proxy = parent_proxy
+        @args = args
+        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
+        @tk.grid
+        DEFAULT_INITIALIZERS[underscored_widget_name]&.call(@tk)        
         @parent_proxy.post_initialize_child(self)
       end
       
@@ -59,24 +103,23 @@ module Glimmer
         !!tk_widget_class_for(underscored_widget_name)
       end
 
-      # This supports widgets in and out of basic Tk
-      def self.tk_widget_class_for(underscored_widget_name)
-        tk_widget_name = "::Tk::Tile::#{underscored_widget_name.camelcase(:upper)}"
-        tk_widget_class = eval(tk_widget_name)
-        tk_widget_class
-      rescue SyntaxError, NameError => e
-        puts e.full_message
-        nil
-      rescue => e
-        puts e.full_message
-        nil      
+      def tk_widget_has_attribute_setter?(attribute)
+        result = nil
+        begin     
+          # TK Widget currently doesn't support respond_to? properly, so I have to resort to this trick for now   
+          @tk.send(attribute_setter(attribute), @tk.send(attribute))
+          result = true
+        rescue => e
+          result = false
+        end
+        result      
       end
       
-      def tk_widget_has_attribute?(attribute_name)
+      def tk_widget_has_attribute_getter_setter?(attribute)
         result = nil
         begin     
           # TK Widget currently doesn't support respond_to? properly, so I have to resort to this trick for now   
-          @tk_widget.send(attribute_setter(attribute_name), @tk_widget.send(attribute_name))
+          @tk.send(attribute, @tk.send(attribute))
           result = true
         rescue => e
           result = false
@@ -84,40 +127,123 @@ module Glimmer
         result      
       end
       
-      def has_attribute?(attribute_name, *args)
-        tk_widget_has_attribute?(attribute_name) || respond_to?(attribute_setter(attribute_name), args)
+      def has_attribute?(attribute, *args)
+        (widget_custom_attribute_mapping[tk.class] && widget_custom_attribute_mapping[tk.class][attribute.to_s]) || 
+          tk_widget_has_attribute_setter?(attribute) || 
+          tk_widget_has_attribute_getter_setter?(attribute) || 
+          respond_to?(attribute_setter(attribute), args)
       end
 
-      def set_attribute(attribute_name, *args)
-        if tk_widget_has_attribute?(attribute_name)
-          @tk_widget.send(attribute_setter(attribute_name), *args) unless @tk_widget.send(attribute_name) == args.first
+      def set_attribute(attribute, *args)
+        widget_custom_attribute = widget_custom_attribute_mapping[tk.class] && widget_custom_attribute_mapping[tk.class][attribute.to_s]
+        if widget_custom_attribute
+          widget_custom_attribute[:setter][:invoker].call(@tk, args)
+        elsif tk_widget_has_attribute_setter?(attribute)
+          @tk.send(attribute_setter(attribute), *args) unless @tk.send(attribute) == args.first
+        elsif tk_widget_has_attribute_getter_setter?(attribute)
+          @tk.send(attribute, *args) unless @tk.send(attribute) == args.first
         else
-          send(attribute_setter(attribute_name), args)
+          send(attribute_setter(attribute), args)
         end
       end
 
-      def get_attribute(attribute_name)
-        @tk_widget.send(attribute_name)
-      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
+          widget_custom_attribute[:getter][:invoker].call(@tk, args)
+        elsif tk_widget_has_attribute_getter_setter?(attribute)
+          @tk.send(attribute)
+        else
+          send(attribute)
+        end
+      end
 
-      def attribute_setter(attribute_name)
-        "#{attribute_name}="
+      def attribute_setter(attribute)
+        "#{attribute}="
+      end
+      
+      def widget_custom_attribute_mapping
+        @widget_custom_attribute_mapping ||= {
+          ::Tk::Tile::TCombobox => {
+            'text' => {
+              getter: {name: 'text', invoker: lambda { |widget, args| @tk.textvariable&.value }},
+              setter: {name: 'text=', invoker: lambda { |widget, args| @tk.textvariable&.value = args.first }},
+            },
+          },
+          ::Tk::Tile::TLabel => {
+            'text' => {
+              getter: {name: 'text', invoker: lambda { |widget, args| @tk.textvariable&.value }},
+              setter: {name: 'text=', invoker: lambda { |widget, args| @tk.textvariable&.value = args.first }},
+            },
+          },
+          ::Tk::Tile::TEntry => {
+            'text' => {
+              getter: {name: 'text', invoker: lambda { |widget, args| @tk.textvariable&.value }},
+              setter: {name: 'text=', invoker: lambda { |widget, args| @tk.textvariable&.value = args.first unless @text_variable_edit }},
+            },
+          },
+        }
+      end
+      
+      def widget_attribute_listener_installers
+        @tk_widget_attribute_listener_installers ||= {
+          ::Tk::Tile::TCombobox => {
+            'text' => lambda do |observer|
+              if observer.is_a?(Glimmer::DataBinding::ModelBinding)
+                model = observer.model
+                options_model_property = observer.property_name + '_options'
+                @tk.values = model.send(options_model_property) if model.respond_to?(options_model_property)
+              end
+              @tk.bind('<ComboboxSelected>') {
+                observer.call(@tk.textvariable.value)
+              }
+            end,
+          },
+          ::Tk::Tile::TEntry => {
+            'text' => lambda do |observer|
+              tk.validate = 'key'
+              tk.validatecommand { |new_tk_variable|
+                @text_variable_edit = new_tk_variable.value != @tk.textvariable.value
+                if @text_variable_edit
+                  observer.call(new_tk_variable.value)
+                  @text_variable_edit = nil
+                  true
+                else
+                  false
+                end
+              }
+            end,
+          },
+        }
       end
+      
+      def add_observer(observer, attribute)
+        attribute_listener_installers = @tk.class.ancestors.map {|ancestor| widget_attribute_listener_installers[ancestor]}.compact
+        widget_listener_installers = attribute_listener_installers.map{|installer| installer[attribute.to_s]}.compact if !attribute_listener_installers.empty?
+        widget_listener_installers.to_a.first&.call(observer)
+      end      
 
       def content(&block)
         Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::Tk::WidgetExpression.new, &block)
       end
 
       def method_missing(method, *args, &block)
-        tk_widget.send(method, *args, &block)
+        method = method.to_s
+        if args.empty? && block.nil? && widget_custom_attribute_mapping[tk.class] && widget_custom_attribute_mapping[tk.class][method]
+          get_attribute(method)
+        elsif widget_custom_attribute_mapping[tk.class] && widget_custom_attribute_mapping[tk.class][method.sub(/=$/, '')] && method.end_with?('=') && block.nil?
+          set_attribute(method.sub(/=$/, ''), *args)
+        else
+          tk.send(method, *args, &block)
+        end
       rescue => e
-        Glimmer::Config.logger.debug {"Neither WidgetProxy nor #{tk_widget.class.name} can handle the method ##{method}"}
-        super
+        Glimmer::Config.logger.debug {"Neither WidgetProxy nor #{tk.class.name} can handle the method ##{method}"}
+        super(method.to_sym, *args, &block)
       end
       
       def respond_to?(method, *args, &block)
         super || 
-          tk_widget.respond_to?(method, *args, &block)
+          tk.respond_to?(method, *args, &block)
       end
     end
   end