glimmer 0.4.9 → 0.5.0

data/lib/glimmer/{shine.rb → data_binding/shine.rb}

@@ -8,8 +8,8 @@
 #   alias original_compare <=>
 #
 #   def <=>(other)
-#     if (self[0].class.name == "GWidget")
-#       add_contents(self[0]) {
+#     if (self[0].class.name == "WidgetProxy")
+#       content(self[0]) {
 #         if (other.size == 2)
 #           eval("#{self[1]} bind (other[0], other[1])")
 #         elsif (other.size == 3)

data/lib/glimmer/{swt → data_binding}/table_items_binding.rb

@@ -1,14 +1,14 @@
-require_relative 'observable_array'
-require_relative 'observable_model'
-require_relative 'observable'
-require_relative 'observer'
+require 'glimmer/data_binding/observable_array'
+require 'glimmer/data_binding/observable_model'
+require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/observer'
+require 'glimmer/swt/swt_proxy'
 
 module Glimmer
-  module SWT
+  module DataBinding
     class TableItemsBinding
-      include Glimmer
-      include Observable
-      include Observer
+      include DataBinding::Observable
+      include DataBinding::Observer
       include_package 'org.eclipse.swt'
       include_package 'org.eclipse.swt.widgets'
 
@@ -23,6 +23,7 @@ module Glimmer
           unregister_all_observables
         end
       end
+
       def call(model_collection=nil)
         if model_collection and model_collection.is_a?(Array)
           observe(model_collection, @column_properties)
@@ -30,16 +31,16 @@ module Glimmer
         end
         populate_table(@model_collection, @table, @column_properties)
       end
+
       def populate_table(model_collection, parent, column_properties)
-        parent.widget.removeAll
+        parent.swt_widget.removeAll
         model_collection.each do |model|
-          table_item = TableItem.new(parent.widget, GSWT[:none])
+          table_item = TableItem.new(parent.swt_widget, SWT::SWTProxy[:none])
           for index in 0..(column_properties.size-1)
             table_item.setText(index, model.send(column_properties[index]).to_s)
           end
         end
       end
-
     end
   end
 end

data/lib/glimmer/{swt → data_binding}/tree_items_binding.rb

@@ -1,14 +1,15 @@
-require_relative 'observable_array'
-require_relative 'observable_model'
-require_relative 'observable'
-require_relative 'observer'
+require 'glimmer/data_binding/observable_array'
+require 'glimmer/data_binding/observable_model'
+require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/observer'
+require 'glimmer/swt/swt_proxy'
 
 module Glimmer
-  module SWT
+  module DataBinding
     class TreeItemsBinding
-      include Glimmer
-      include Observable
-      include Observer
+      include DataBinding::Observable
+      include DataBinding::Observer
+
       include_package 'org.eclipse.swt'
       include_package 'org.eclipse.swt.widgets'
 
@@ -23,6 +24,7 @@ module Glimmer
           unregister_all_observables
         end
       end
+
       def call(model_tree_root_node=nil)
         if model_tree_root_node and model_tree_root_node.respond_to?(@tree_properties[:children])
           observe(model_tree_root_node, @tree_properties[:text])
@@ -31,19 +33,20 @@ module Glimmer
         end
         populate_tree(@model_tree_root_node, @tree, @tree_properties)
       end
+
       def populate_tree(model_tree_root_node, parent, tree_properties)
-        parent.widget.removeAll
-        populate_tree_node(model_tree_root_node, parent.widget, tree_properties)
+        parent.swt_widget.removeAll
+        populate_tree_node(model_tree_root_node, parent.swt_widget, tree_properties)
       end
+
       def populate_tree_node(model_tree_node, parent, tree_properties)
-        table_item = TreeItem.new(parent, GSWT[:none])
+        table_item = TreeItem.new(parent, SWT::SWTProxy[:none])
         table_item.setText((model_tree_node && model_tree_node.send(tree_properties[:text])).to_s)
         [model_tree_node && model_tree_node.send(tree_properties[:children])].flatten.to_a.compact.each do |child|
           observe(child, @tree_properties[:text])
           populate_tree_node(child, table_item, tree_properties)
         end
       end
-
     end
   end
 end

data/lib/glimmer/{swt → data_binding}/widget_binding.rb

@@ -1,8 +1,9 @@
+require 'glimmer'
 require_relative 'observable'
 require_relative 'observer'
 
 module Glimmer
-  module SWT
+  module DataBinding
     class WidgetBinding
       include Glimmer
       include Observable

data/lib/glimmer/dsl.rb

@@ -0,0 +1,26 @@
+require 'glimmer/dsl/engine'
+
+module Glimmer
+  # Glimmer DSL expression configuration module
+  #
+  # When DSL engine interprets an expression, it attempts to handle
+  # with expressions listed here in the order specified.
+  module DSL
+    # Every expression has a corresponding AbstractExpression subclass
+    # in glimmer/dsl
+    # TODO rename to dynamic_expressions in the future when supporting static expressions
+    Engine.dynamic_expressions = %w[
+      layout
+      widget_listener
+      combo_selection_data_binding
+      list_selection_data_binding
+      tree_items_data_binding
+      table_items_data_binding
+      data_binding
+      color
+      property
+      widget
+      custom_widget
+    ]
+  end
+end

data/lib/glimmer/dsl/async_exec_expression.rb

@@ -0,0 +1,12 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/exec_expression'
+
+module Glimmer
+  module DSL
+    # 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

data/lib/glimmer/dsl/bind_expression.rb

@@ -0,0 +1,44 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/data_binding/model_binding'
+
+module Glimmer
+  module DSL
+    # 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
+            block.nil? and
+            widget?(parent) and
+            (
+              (
+                (args.size == 2) and
+                  textual?(args[1])
+              ) ||
+                (
+                  (args.size == 3) and
+                    textual?(args[1]) and
+                    (textual?(args[2]) or args[2].is_a?(Hash))
+                ) ||
+                (
+                  (args.size == 4) and
+                    textual?(args[1]) and
+                    textual?(args[2]) and
+                    (args[3].is_a?(Hash))
+                )
+            )
+        )
+      end
+
+      def interpret(parent, keyword, *args, &block)
+        property_type = args[2] if (args.size == 3) and !args[2].is_a?(Hash)
+        binding_options = args[2] if args[2].is_a?(Hash)
+        binding_options = args[3] if args[3].is_a?(Hash)
+        DataBinding::ModelBinding.new(args[0], args[1].to_s, property_type, binding_options)
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/color_expression.rb

@@ -0,0 +1,28 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/swt/color_proxy'
+require 'glimmer/swt/display_proxy'
+
+# TODO consider turning static keywords like rgba/rgb into methods
+# Support color keyword
+
+module Glimmer
+  module DSL
+    class ColorExpression < Expression
+      include_package 'org.eclipse.swt.widgets'
+
+      def can_interpret?(parent, keyword, *args, &block)
+        ['color', 'rgba', 'rgb'].include?(keyword) and
+          (1..4).include?(args.count)
+      end
+
+      def interpret(parent, keyword, *args, &block)
+        if args.first.is_a?(Display) or args.first.nil?
+          display = args.delete_at(0)
+        else
+          display = SWT::DisplayProxy.instance.swt_display
+        end
+        SWT::ColorProxy.new(*args)
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/column_properties_expression.rb

@@ -0,0 +1,22 @@
+require 'glimmer/dsl/static_expression'
+
+module Glimmer
+  module DSL
+    # 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

data/lib/glimmer/dsl/combo_selection_data_binding_expression.rb

@@ -0,0 +1,40 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/data_binding/model_binding'
+require 'glimmer/data_binding/widget_binding'
+
+module Glimmer
+  module DSL
+    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

data/lib/glimmer/dsl/custom_widget_expression.rb

@@ -0,0 +1,35 @@
+require 'glimmer'
+require 'glimmer/dsl/expression'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/ui/custom_widget'
+require 'glimmer/ui/custom_shell'
+require 'glimmer/ui/video' # this is interpreted here since it's a custom widget
+
+module Glimmer
+  module DSL
+    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 : {}
+        Glimmer.logger.debug "Custom widget #{keyword} styles are: [" + args.inspect + "] and options are: #{options}"
+        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

data/lib/glimmer/dsl/data_binding_expression.rb

@@ -0,0 +1,33 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/data_binding/model_binding'
+require 'glimmer/data_binding/widget_binding'
+
+module Glimmer
+  module DSL
+    # 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) and
+        widget?(parent)
+      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)
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/display_expression.rb

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

data/lib/glimmer/dsl/engine.rb

@@ -0,0 +1,80 @@
+require 'glimmer'
+Dir[File.expand_path('../*_expression.rb', __FILE__)].each {|f| require f}
+require 'glimmer/dsl/expression_handler'
+
+module Glimmer
+  module DSL
+    # Glimmer DSL Engine
+    #
+    # Follows Interpreter and Chain of Responsibility Design Patterns
+    #
+    # When DSL engine interprets an expression, it attempts to handle
+    # with ordered expression array specified via `.expressions=` method.
+    #
+    # TODO support auto-loading static_expressions in the future for expressions where
+    # the keyword does not vary dynamically. These static keywords are then
+    # predefined as methods in Glimmer instead of needing method_missing
+    class Engine
+      class << self
+        # Sets an ordered array of DSL expressions to support
+        #
+        # Every expression has an underscored name corresponding to an upper
+        # camelcase AbstractExpression subclass name in glimmer/dsl
+        #
+        # They are used in order following the Chain of Responsibility Design
+        # Pattern when interpretting a DSL expression
+        #
+        # TODO rename to dynamic_expressions in the future when supporting static expressions
+        def dynamic_expressions=(expression_names)
+          @dynamic_expression_chain_of_responsibility = expression_names.reverse.reduce(nil) do |last_expresion_handler, expression_name|
+            Glimmer.logger.debug "Loading #{expression_class_name(expression_name)}..."
+            expression = expression_class(expression_name).new
+            expression_handler = ExpressionHandler.new(expression)
+            expression_handler.next = last_expresion_handler if last_expresion_handler
+            expression_handler
+          end
+        end
+
+        def expression_class(expression_name)
+          DSL.const_get(expression_class_name(expression_name).to_sym)
+        end
+
+        def expression_class_name(expression_name)
+          "#{expression_name}_expression".camelcase(:upper)
+        end
+
+        # Interprets Glimmer DSL keyword, args, and block (e.g. shell(:no_resize) { ... })
+        def interpret(keyword, *args, &block)
+          keyword = keyword.to_s
+          expression = @dynamic_expression_chain_of_responsibility.handle(current_parent, keyword, *args, &block)
+          expression.interpret(current_parent, keyword, *args, &block).tap do |ui_object|
+            add_content(ui_object, expression, &block)
+          end
+        end
+
+        # Adds content block to parent UI object
+        #
+        # This allows evaluating parent UI object properties and children
+        #
+        # For example, a shell widget would get properties set and children added
+        def add_content(parent, expression, &block)
+          parent_stack.push(parent)
+          expression.add_content(parent, &block) if block_given?
+          parent_stack.pop
+        end
+
+        # Current parent while evaluating Glimmer DSL (nil if just started or done evaluatiing)
+        #
+        # Parents are maintained in a stack while evaluating Glimmer DSL
+        # to ensure properly ordered interpretation of DSL syntax
+        def current_parent
+          parent_stack.last
+        end
+
+        def parent_stack
+          @parent_stack ||= []
+        end
+      end
+    end
+  end
+end