glimmer 0.5.11 → 0.6.0

data/lib/glimmer/dsl/expression.rb

@@ -1,4 +1,6 @@
 require 'glimmer/error'
+require 'glimmer/swt/widget_proxy'
+require 'glimmer/ui/custom_widget'
 
 module Glimmer
   module DSL
@@ -10,6 +12,12 @@ module Glimmer
     # english versino of Ruby's boolean operations. This allows easy DSL-like
     # readability of the rules, and easy tagging with pd when troubleshooting.
     class Expression
+      class << self
+        def dsl
+          @dsl ||= name.split(/::/)[-2].downcase.to_sym
+        end
+      end
+
       # Checks if it can interpret parameters (subclass must override)
       def can_interpret?(parent, keyword, *args, &block)
         raise Error, "#can_interpret? must be implemented by an Expression subclass"
@@ -29,7 +37,7 @@ module Glimmer
 
       # Checks if parent object is a widget
       def widget?(parent)
-        parent.is_a?(SWT::WidgetProxy) or parent.is_a?(UI::CustomWidget)
+        parent.is_a?(Glimmer::SWT::WidgetProxy) or parent.is_a?(Glimmer::UI::CustomWidget)
       end
 
       # Checks if object is a Symbol or a String
@@ -39,6 +47,3 @@ module Glimmer
     end
   end
 end
-
-require 'glimmer/swt/widget_proxy'
-require 'glimmer/ui/custom_widget'

data/lib/glimmer/dsl/static_expression.rb

@@ -1,4 +1,6 @@
 require 'glimmer/error'
+require 'glimmer/dsl/engine'
+require 'glimmer/dsl/expression'
 require 'glimmer/swt/widget_proxy'
 require 'glimmer/ui/custom_widget'
 
@@ -12,20 +14,18 @@ module Glimmer
     # (not needed if it only checks for keyword)
     #
     # StaticExpression subclasses must define `#interpret`.
+    # 
+    # The direct parent namespace of a StaticExpression subclass must match the DSL name (case-insensitive)
+    # (e.g. Glimmer::DSL::SWT::WidgetExpression has a DSL of :swt)
     class StaticExpression < Expression
-      def self.inherited(base)
-        keyword = base.name.split(/::/).last.sub(/Expression$/, '').underscore
-        static_expression = base.new
-        Glimmer.define_method(keyword) do |*args, &block|
-          parent = Glimmer::DSL::Engine.current_parent
-          if !static_expression.can_interpret?(parent, keyword, *args, &block)
-            raise Error, "Invalid use of Glimmer keyword #{keyword} with args #{args} under parent #{parent}"
-          else
-            Glimmer.logger&.debug "#{base.name} will handle expression keyword #{keyword}"
-            static_expression.interpret(parent, keyword, *args, &block).tap do |ui_object|
-              Glimmer::DSL::Engine.add_content(ui_object, static_expression, &block) unless block.nil?
-            end
-          end
+      class << self  
+        def inherited(base)
+          Glimmer::DSL::Engine.add_static_expression(base.new)
+          super
+        end
+
+        def keyword
+          @keyword ||= name.split(/::/).last.sub(/Expression$/, '').underscore
         end
       end
 

data/lib/glimmer/dsl/swt/async_exec_expression.rb

@@ -0,0 +1,14 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/swt/exec_expression'
+
+module Glimmer
+  module DSL
+    module SWT  
+      # Asynchronously executes code block against the SWT Event Loop
+      # to manipulate SWT UI objects on the UI thread safely
+      class AsyncExecExpression < StaticExpression
+        include ExecExpression
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/bind_expression.rb

@@ -0,0 +1,37 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/data_binding/model_binding'
+
+module Glimmer
+  module DSL
+    module SWT
+      # Responsible for setting up the return value of the bind keyword (command symbol)
+      # as a ModelBinding. It is then used by another command handler like
+      # DataBindingCommandHandler for text and selection properties on Text and Spinner
+      # or TableItemsDataBindingCommandHandler for items in a Table
+      class BindExpression < StaticExpression
+        def can_interpret?(parent, keyword, *args, &block)
+          (
+            keyword == 'bind' and
+              (
+                (
+                  (args.size == 2) and
+                    textual?(args[1])
+                ) ||
+                  (
+                    (args.size == 3) and
+                      textual?(args[1]) and
+                      (args[2].is_a?(Hash))
+                  )
+              )
+          )
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          binding_options = args[2] || {}
+          binding_options[:on_read] = binding_options.delete(:on_read) || binding_options.delete('on_read') || block
+          DataBinding::ModelBinding.new(args[0], args[1].to_s, binding_options)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/color_expression.rb

@@ -0,0 +1,17 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/swt/color_proxy'
+require 'glimmer/swt/display_proxy'
+
+module Glimmer
+  module DSL
+    module SWT
+      class ColorExpression < StaticExpression
+        include_package 'org.eclipse.swt.widgets'
+  
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::SWT::ColorProxy.new(*args)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/column_properties_expression.rb

@@ -0,0 +1,24 @@
+require 'glimmer/dsl/static_expression'
+
+module Glimmer
+  module DSL
+    module SWT
+      # Responsible for providing a readable keyword (command symbol) to capture
+      # and return column properties for use in TreeItemsDataBindingCommandHandler
+      class ColumnPropertiesExpression < StaticExpression
+        include_package 'org.eclipse.swt.widgets'
+  
+        def can_interpret?(parent, keyword, *args, &block)
+          keyword == 'column_properties' and
+            block.nil? and
+            widget?(parent) and
+            parent.swt_widget.is_a?(Table)
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          args
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/combo_selection_data_binding_expression.rb

@@ -0,0 +1,42 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/data_binding/model_binding'
+require 'glimmer/data_binding/widget_binding'
+
+module Glimmer
+  module DSL
+    module SWT
+      class ComboSelectionDataBindingExpression < Expression
+        include_package 'org.eclipse.swt.widgets'
+  
+        def can_interpret?(parent, keyword, *args, &block)
+          keyword == 'selection' and
+            block.nil? and
+            widget?(parent) and
+            parent.swt_widget.is_a?(Combo) and
+            args.size == 1 and
+            args[0].is_a?(DataBinding::ModelBinding) and
+            args[0].evaluate_options_property.is_a?(Array)
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          model_binding = args[0]
+  
+          #TODO make this options observer dependent and all similar observers in widget specific data binding handlers
+          # TODO consider delegating some of this work
+          widget_binding = DataBinding::WidgetBinding.new(parent, 'items')
+          widget_binding.call(model_binding.evaluate_options_property)
+          model = model_binding.base_model
+          widget_binding.observe(model, model_binding.options_property_name)
+  
+          widget_binding = DataBinding::WidgetBinding.new(parent, 'text')
+          widget_binding.call(model_binding.evaluate_property)
+          widget_binding.observe(model, model_binding.property_name_expression)
+  
+          parent.on_widget_selected do
+            model_binding.call(widget_binding.evaluate_property)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/custom_widget_expression.rb

@@ -0,0 +1,36 @@
+require 'glimmer'
+require 'glimmer/dsl/expression'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/ui/custom_widget'
+require 'glimmer/ui/custom_shell'
+
+module Glimmer
+  module DSL
+    module SWT
+      class CustomWidgetExpression < Expression
+        include ParentExpression
+
+        def can_interpret?(parent, keyword, *args, &block)
+          custom_widget_class = UI::CustomWidget.for(keyword)
+          custom_widget_class and
+            (widget?(parent) or
+            custom_widget_class.ancestors.include?(UI::CustomShell))
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          UI::CustomWidget.for(keyword).new(parent, *args, options, &block)
+        end
+  
+        def add_content(parent, &block)
+          # TODO consider avoiding source_location
+          if block.source_location == parent.content&.__getobj__.source_location
+            parent.content.call(parent) unless parent.content.called?
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/data_binding_expression.rb

@@ -0,0 +1,34 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/data_binding/model_binding'
+require 'glimmer/data_binding/widget_binding'
+
+module Glimmer
+  module DSL
+    module SWT
+      # Responsible for wiring two-way data-binding for text and selection properties
+      # on Text, Button, and Spinner widgets.
+      # Does so by using the output of the bind(model, property) command in the form
+      # of a ModelBinding, which is then connected to an anonymous widget observer
+      # (aka widget_data_binder as per widget_data_binders array)
+      #
+      # Depends on BindCommandHandler
+      class DataBindingExpression < Expression
+        def can_interpret?(parent, keyword, *args, &block)
+          args.size == 1 and
+            args[0].is_a?(DataBinding::ModelBinding)
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          model_binding = args[0]
+          widget_binding_parameters = [parent, keyword]
+          widget_binding = DataBinding::WidgetBinding.new(*widget_binding_parameters)
+          widget_binding.call(model_binding.evaluate_property)
+          #TODO make this options observer dependent and all similar observers in widget specific data binding handlers
+          widget_binding.observe(model_binding)
+          # TODO simplify this logic and put it where it belongs
+          parent.add_observer(model_binding, keyword) if parent.respond_to?(:add_observer, [model_binding, keyword])
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/display_expression.rb

@@ -0,0 +1,19 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/dsl/top_level_expression'
+require 'glimmer/swt/display_proxy'
+
+module Glimmer
+  module DSL
+    module SWT
+      class DisplayExpression < StaticExpression
+        include TopLevelExpression
+        include ParentExpression
+
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::SWT::DisplayProxy.instance(*args)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/dsl.rb

@@ -0,0 +1,26 @@
+require 'glimmer/dsl/engine'
+Dir[File.expand_path('../*_expression.rb', __FILE__)].each {|f| require f}
+
+# Glimmer DSL expression configuration module
+#
+# When DSL engine interprets an expression, it attempts to handle
+# with expressions listed here in the order specified.
+
+# Every expression has a corresponding Expression subclass
+# in glimmer/dsl
+
+Glimmer::DSL::Engine.add_dynamic_expressions(
+  Glimmer::DSL::SWT,
+  %w[
+    layout
+    widget_listener
+    combo_selection_data_binding
+    list_selection_data_binding
+    tree_items_data_binding
+    table_items_data_binding
+    data_binding
+    property
+    widget
+    custom_widget
+  ]
+)

data/lib/glimmer/dsl/swt/exec_expression.rb

@@ -0,0 +1,28 @@
+require 'glimmer/dsl/top_level_expression'
+require 'glimmer/swt/display_proxy'
+
+module Glimmer
+  module DSL
+    module SWT
+      # Mixin for common code in async_exec and sync_exec expressions
+      # Uses name in subclass to auto-derive exec_operation
+      module ExecExpression
+        include TopLevelExpression
+
+        def exec_operation
+          @exec_operation ||= self.class.name.split(/::/).last.sub(/Expression$/, '').underscore
+        end
+  
+        def can_interpret?(parent, keyword, *args, &block)
+          keyword == exec_operation and
+            block_given? and
+            args.empty?
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::SWT::DisplayProxy.instance.send(exec_operation, &block)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/layout_data_expression.rb

@@ -0,0 +1,25 @@
+require 'glimmer'
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/swt/layout_data_proxy'
+
+# TODO consider turning static keywords like layout_data into methods
+
+module Glimmer
+  module DSL
+    module SWT
+      class LayoutDataExpression < StaticExpression
+        include ParentExpression
+  
+        def can_interpret?(parent, keyword, *args, &block)
+          keyword == 'layout_data' and
+            widget?(parent)
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::SWT::LayoutDataProxy.new(parent, args)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/layout_expression.rb

@@ -0,0 +1,27 @@
+require 'glimmer'
+require 'glimmer/dsl/expression'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/swt/layout_proxy'
+
+module Glimmer
+  module DSL
+    module SWT
+      class LayoutExpression < Expression
+        include ParentExpression
+  
+        include_package 'org.eclipse.swt.widgets'
+  
+        def can_interpret?(parent, keyword, *args, &block)
+          keyword.to_s.end_with?('_layout') and
+            widget?(parent) and
+            parent.swt_widget.is_a?(Composite) and
+            Glimmer::SWT::LayoutProxy.layout_exists?(keyword.to_s)
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::SWT::LayoutProxy.new(keyword, parent, args)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/swt/list_selection_data_binding_expression.rb

@@ -0,0 +1,44 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/data_binding/model_binding'
+require 'glimmer/data_binding/widget_binding'
+require 'glimmer/data_binding/list_selection_binding'
+
+module Glimmer
+  module DSL
+    module SWT
+      class ListSelectionDataBindingExpression < Expression
+        include_package 'org.eclipse.swt.widgets'
+  
+        def can_interpret?(parent, keyword, *args, &block)
+          keyword == 'selection' and
+            block.nil? and
+            widget?(parent) and
+            parent.swt_widget.is_a?(List) and
+            args.size == 1 and
+            args[0].is_a?(DataBinding::ModelBinding) and
+            args[0].evaluate_options_property.is_a?(Array)
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          model_binding = args[0]
+          widget_binding = DataBinding::WidgetBinding.new(parent, 'items')
+          widget_binding.call(model_binding.evaluate_options_property)
+          model = model_binding.base_model
+          #TODO make this options observer dependent and all similar observers in widget specific data binding interpretrs
+          widget_binding.observe(model, model_binding.options_property_name)
+  
+          property_type = :string
+          property_type = :array if parent.has_style?(:multi)
+          list_selection_binding = DataBinding::ListSelectionBinding.new(parent, property_type)
+          list_selection_binding.call(model_binding.evaluate_property)
+          #TODO check if nested data binding works for list widget and other widgets that need custom data binding
+          list_selection_binding.observe(model, model_binding.property_name_expression)
+  
+          parent.on_widget_selected do
+            model_binding.call(list_selection_binding.evaluate_property)
+          end
+        end
+      end
+    end
+  end
+end