glimmer 0.3.5 → 0.4.0

data/lib/glimmer/command_handlers/data_binding_command_handler.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + "/../command_handler"
+require File.dirname(__FILE__) + "/models/g_widget"
+require File.dirname(__FILE__) + "/models/observable_model"
+require File.dirname(__FILE__) + "/models/model_binding"
+require File.dirname(__FILE__) + "/models/widget_binding"
+
+module Glimmer
+  # 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 DataBindingCommandHandler
+    extend Glimmer
+    include CommandHandler
+
+    include_package 'org.eclipse.swt.widgets'
+
+    @@widget_data_binders = {
+      Java::OrgEclipseSwtWidgets::Text => {
+        :text => Proc.new do |g_widget, model_binding|
+          add_contents(g_widget) {
+            on_modify_text { |modify_event|
+              model_binding.call(g_widget.widget.getText)
+            }
+          }
+        end,
+      },
+      Java::OrgEclipseSwtWidgets::Button => {
+        :selection => Proc.new do |g_widget, model_binding|
+          add_contents(g_widget) {
+            on_widget_selected { |selection_event|
+              model_binding.call(g_widget.widget.getSelection)
+            }
+          }
+        end
+      },
+      Java::OrgEclipseSwtWidgets::Spinner => {
+        :selection => Proc.new do |g_widget, model_binding|
+          add_contents(g_widget) {
+            on_widget_selected { |selection_event|
+              model_binding.call(g_widget.widget.getSelection)
+            }
+          }
+        end
+      }
+    }
+
+    def can_handle?(parent, command_symbol, *args, &block)
+      (parent.is_a?(GWidget) and
+      args.size == 1 and
+      args[0].is_a?(ModelBinding))
+    end
+
+    def do_handle(parent, command_symbol, *args, &block)
+      model_binding = args[0]
+      widget_binding_parameters = [parent, command_symbol.to_s]
+      widget_binding = WidgetBinding.new(*widget_binding_parameters)
+      widget_binding.call(model_binding.evaluate_property)
+      widget_binding.observe(model_binding)
+      widget_data_binder_map = @@widget_data_binders[parent.widget.class]
+      widget_data_binder = widget_data_binder_map[command_symbol.to_s.to_sym] if widget_data_binder_map
+      widget_data_binder.call(parent, model_binding) if widget_data_binder
+    end
+
+  end
+end

data/lib/glimmer/command_handlers/display_command_handler.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/../command_handler"
+require File.dirname(__FILE__) + "/models/g_display"
+
+module Glimmer
+  class DisplayCommandHandler
+    include CommandHandler
+
+    def can_handle?(parent, command_symbol, *args, &block)
+      command_symbol.to_s == "display"
+    end
+
+    def do_handle(parent, command_symbol, *args, &block)
+      GDisplay.instance(*args)
+    end
+  end
+end

data/lib/glimmer/command_handlers/list_selection_data_binding_command_handler.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + "/../command_handler"
+require File.dirname(__FILE__) + "/models/g_widget"
+require File.dirname(__FILE__) + "/models/list_selection_binding"
+
+module Glimmer
+  class ListSelectionDataBindingCommandHandler
+    include CommandHandler
+    include Glimmer
+
+    include_package 'org.eclipse.swt.widgets'
+
+    def can_handle?(parent, command_symbol, *args, &block)
+      parent.is_a?(GWidget) and
+      parent.widget.is_a?(List) and
+      command_symbol.to_s == "selection" and
+      args.size == 1 and
+      args[0].is_a?(ModelBinding) and
+      args[0].evaluate_options_property.is_a?(Array) and
+      block == nil
+    end
+
+    def do_handle(parent, command_symbol, *args, &block)
+      model_binding = args[0]
+      widget_binding = 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 handlers
+      widget_binding.observe(model, model_binding.options_property_name)
+
+      property_type = :string
+      property_type = :array if parent.has_style?(:multi)
+      list_selection_binding = 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)
+
+      add_contents(parent) {
+        on_widget_selected {
+          model_binding.call(list_selection_binding.evaluate_property)
+        }
+      }
+    end
+
+  end
+end

data/lib/glimmer/command_handlers/models/g_color.rb

@@ -0,0 +1,34 @@
+require_relative 'g_swt'
+
+module Glimmer
+  class GColor
+    attr_reader :display, :red, :green, :blue, :alpha
+
+    include_package 'org.eclipse.swt.graphics'
+
+    class << self
+      include_package 'org.eclipse.swt'
+
+      def for(display, standard_color)
+        display.getSystemColor(GSWT[standard_color])
+      end
+    end
+
+    def initialize(display, red, green, blue, alpha = nil)
+      @display = display
+      @red = red
+      @green = green
+      @blue = blue
+      @alpha = alpha
+    end
+
+    def color
+      @color ||= Color.new(@display, *[@red, @green, @blue, @alpha].compact)
+    end
+
+    def display=(a_display)
+      @display = a_display
+      @color = nil
+    end
+  end
+end

data/lib/glimmer/command_handlers/models/g_display.rb

@@ -0,0 +1,26 @@
+module Glimmer
+  # Wrapper around SWT Display
+  class GDisplay
+    include_package 'org.eclipse.swt.widgets'
+
+    class << self
+      def instance(*args)
+        if @instance.nil? || @instance.display.isDisposed
+          @instance = GDisplay.new(*args)
+        end
+        @instance
+      end
+    end
+
+    # SWT Display object wrapped
+    attr_reader :display
+
+    def initialize(*args)
+      @display = Display.new(*args)
+    end
+
+    def dispose
+      @display.dispose
+    end
+  end
+end

data/lib/glimmer/command_handlers/models/g_font.rb

@@ -0,0 +1,62 @@
+require_relative 'g_swt'
+
+module Glimmer
+  class GFont
+    include_package 'org.eclipse.swt.graphics'
+
+    extend Glimmer
+
+    attr_reader :g_widget
+    attr_accessor :display
+
+    class << self
+      def for(g_widget)
+        @instances ||= {}
+        unless @instances[g_widget]
+          @instances[g_widget] = new(g_widget)
+          add_contents(g_widget) {
+            on_widget_disposed { |dispose_event|
+              @instances.delete(g_widget)
+            }
+          }
+        end
+        @instances[g_widget]
+      end
+    end
+
+    def initialize(g_widget, display = nil)
+      @g_widget = g_widget
+      @display = display || @g_widget.widget.display
+    end
+
+    def g_widget=(a_widget)
+      @g_widget = a_widget
+      @font_datum = nil
+    end
+
+    def font_datum
+      @font_datum ||= @g_widget.widget.getFont.getFontData[0]
+    end
+
+    def name
+      font_datum.getName
+    end
+
+    def height
+      font_datum.getHeight
+    end
+
+    def style
+      font_datum.getStyle
+    end
+
+    def font(font_properties)
+      font_properties[:style] = GSWT[*font_properties[:style]]
+      font_data_args = [:name, :height, :style].map do |font_property_name|
+        font_properties[font_property_name] || send(font_property_name)
+      end
+      font_datum = FontData.new(*font_data_args)
+      Font.new(@display, font_datum)
+    end
+  end
+end

data/lib/glimmer/command_handlers/models/g_runnable.rb

@@ -0,0 +1,13 @@
+module Glimmer
+  class GRunnable
+    include java.lang.Runnable
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def run
+      @block.call
+    end
+  end
+end

data/lib/glimmer/command_handlers/models/g_shell.rb

@@ -0,0 +1,27 @@
+require_relative 'g_widget'
+require_relative 'g_display'
+
+module Glimmer
+  class GShell < GWidget
+    include_package 'org.eclipse.swt.layout'
+    include_package 'org.eclipse.swt.widgets'
+
+    attr_reader :display
+
+    def initialize(display = GDisplay.instance.display)
+      @display = display
+      @widget = Shell.new(@display)
+      @widget.setLayout(FillLayout.new)
+    end
+
+    def open
+      @widget.pack
+      @widget.open
+      until @widget.isDisposed
+        @display.sleep unless @display.readAndDispatch
+      end
+      @display.dispose
+    end
+
+  end
+end

data/lib/glimmer/command_handlers/models/g_swt.rb

@@ -0,0 +1,22 @@
+module Glimmer
+  class GSWT
+    class << self
+      java_import 'org.eclipse.swt.SWT'
+
+      # Gets SWT constants as if calling SWT::CONSTANT where constant is
+      # passed in as a lower case symbol
+      def [](*symbols)
+        symbols.compact.reduce(0) { |output, symbol| output | constant(symbol) }
+      end
+
+      def constant(symbol)
+        return symbol if symbol.is_a?(Integer)
+        swt_constant_symbol = symbol.to_s.upcase.to_sym
+        SWT.const_get(swt_constant_symbol)
+      rescue
+        swt_constant_symbol = SWT.constants.find {|c| c.to_s.upcase == swt_constant_symbol.to_s}
+        SWT.const_get(swt_constant_symbol)
+      end
+    end
+  end
+end

data/lib/glimmer/command_handlers/models/g_tab_item_composite.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/g_widget_listener"
+require File.dirname(__FILE__) + "/g_runnable"
+
+module Glimmer
+  class GTabItemComposite < GWidget
+    include_package 'org.eclipse.swt.widgets'
+
+    attr_reader :tab_item
+    def initialize(tab_item, parent, style, &contents)
+      super("composite", parent, style, &contents)
+      @tab_item = tab_item
+      @tab_item.widget.control = self.widget
+    end
+
+    def has_attribute?(attribute_name, *args)
+      if attribute_name.to_s == "text"
+        true
+      else
+        super(attribute_name, *args)
+      end
+    end
+
+    def set_attribute(attribute_name, *args)
+      if attribute_name.to_s == "text"
+        text_value = args[0]
+        @tab_item.widget.text = text_value
+      else
+        super(attribute_name, *args)
+      end
+    end
+
+  end
+end

data/lib/glimmer/command_handlers/models/g_widget.rb

@@ -0,0 +1,199 @@
+require_relative 'g_widget_listener'
+require_relative 'g_runnable'
+require_relative 'g_color'
+require_relative 'g_font'
+require_relative 'g_swt'
+
+module Glimmer
+  class GWidget
+    include_package 'org.eclipse.swt'
+    include_package 'org.eclipse.swt.widgets'
+    include_package 'org.eclipse.swt.layout'
+    include_package 'org.eclipse.swt.graphics'
+    include Parent
+
+    attr_reader :widget
+
+    #TODO externalize
+    @@default_styles = {
+      "text" => GSWT[:border],
+      "table" => GSWT[:border],
+      "spinner" => GSWT[:border],
+      "list" => GSWT[:border, :v_scroll],
+      "button" => GSWT[:push],
+    }
+
+    #TODO externalize
+    @@default_initializers = {
+      "composite" => Proc.new {|composite| composite.setLayout(GridLayout.new) },
+      "table" => Proc.new do |table|
+        table.setHeaderVisible(true)
+        table.setLinesVisible(true)
+      end,
+      "table_column" => Proc.new { |table_column| table_column.setWidth(80) },
+      "group" => Proc.new {|group| group.setLayout(GridLayout.new) },
+    }
+
+    #styles is a comma separate list of symbols representing SWT styles in lower case
+    def initialize(underscored_widget_name, parent, styles, &contents)
+      @widget = self.class.swt_widget_class_for(underscored_widget_name).new(parent, style(underscored_widget_name, styles))
+      @@default_initializers[underscored_widget_name].call(@widget) if @@default_initializers[underscored_widget_name]
+    end
+
+    def has_attribute?(attribute_name, *args)
+      @widget.respond_to?(attribute_setter(attribute_name), args)
+    end
+
+    def set_attribute(attribute_name, *args)
+      apply_property_type_converters(attribute_name, args)
+      @widget.send(attribute_setter(attribute_name), *args)
+    end
+
+    def property_type_converters
+      @property_type_converters ||= {
+        :text => Proc.new { |value| value.to_s },
+        :items => Proc.new { |value| value.to_java :string},
+        :visible => Proc.new { |value| !!value},
+        :font => Proc.new do |value|
+          if value.is_a?(Hash)
+            font_properties = value
+            GFont.for(self).font(font_properties)
+          else
+            value
+          end
+        end,
+      }
+    end
+
+    def apply_property_type_converters(attribute_name, args)
+      if args.count == 1
+        value = args.first
+        converter = property_type_converters[attribute_name.to_sym]
+        args[0] = converter.call(value) if converter
+      end
+      if args.count == 1 && (args.first.is_a?(Symbol) || args.first.is_a?(String)) && args.first.to_s.start_with?('color_')
+        standard_color = args.first
+        args[0] = GColor.for(widget.getDisplay, standard_color)
+      elsif args.count == 1 && args.first.is_a?(GColor)
+        g_color = args.first
+        g_color.display = widget.display if g_color.display.nil? || g_color.display != widget.display
+        args[0] = g_color.color
+      end
+    end
+
+    def self.widget_exists?(underscored_widget_name)
+      begin
+        swt_widget_class_for(underscored_widget_name)
+        true
+      rescue NameError
+        false
+      end
+    end
+
+    # This supports widgets in and out of basic SWT
+    def self.swt_widget_class_for(underscored_widget_name)
+      swt_widget_name = underscored_widget_name.camelcase(:upper)
+      swt_widget_class = eval(swt_widget_name)
+      unless swt_widget_class.ancestors.include?(org.eclipse.swt.widgets.Widget)
+        raise NameError, "Class #{swt_widget_class} matching #{underscored_widget_name} is not a subclass of org.eclipse.swt.widgets.Widget"
+      end
+      swt_widget_class
+    end
+
+    def widget_listener_exists?(underscored_listener_name)
+      listener_method_name = underscored_listener_name.listener_method_name(:lower)
+      @widget.getClass.getMethods.each do |widget_method|
+        if widget_method.getName.match(/add.*Listener/)
+          widget_method.getParameterTypes.each do |listener_type|
+            listener_type.getMethods.each do |listener_method|
+              if (listener_method.getName == listener_method_name)
+                return true
+              end
+            end
+          end
+        end
+      end
+      return false
+    end
+
+    def can_add_listener?(underscored_listener_name)
+      listener_method_name = underscored_listener_name.camelcase(:lower)
+      @widget.getClass.getMethods.each do |widget_method|
+        if widget_method.getName.match(/add.*Listener/)
+          widget_method.getParameterTypes.each do |listener_type|
+            listener_type.getMethods.each do |listener_method|
+              if (listener_method.getName == listener_method_name)
+                return true
+              end
+            end
+          end
+        end
+      end
+      return false
+    end
+
+    def add_listener(underscored_listener_name, &block)
+      listener_method_name = underscored_listener_name.camelcase(:lower)
+      @widget.getClass.getMethods.each do |widget_method|
+        if widget_method.getName.match(/add.*Listener/)
+          widget_method.getParameterTypes.each do |listener_type|
+            listener_type.getMethods.each do |listener_method|
+              if (listener_method.getName == listener_method_name)
+                listener_class = Class.new(Object)
+                listener_class.send :include, (eval listener_type.to_s.sub("interface", ""))
+                listener = listener_class.new
+                listener_type.getMethods.each do |t_method|
+                  eval "def listener.#{t_method.getName}(event) end"
+                end
+                def listener.block=(block)
+                  @block = block
+                end
+                listener.block=block
+                eval "def listener.#{listener_method.getName}(event) @block.call(event) if @block end"
+                @widget.send(widget_method.getName, listener)
+                return GWidgetListener.new(listener)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def process_block(block)
+      block.call(@widget)
+    end
+
+    def async_exec(&block)
+      @widget.getDisplay.asyncExec(GRunnable.new(&block))
+    end
+
+    def sync_exec(&block)
+      @widget.getDisplay.syncExec(GRunnable.new(&block))
+    end
+
+    def has_style?(style)
+      (widget.style & GSWT[style]) == GSWT[style]
+    end
+
+    def dispose
+      @widget.dispose
+    end
+
+    private
+
+    def style(underscored_widget_name, styles)
+      styles.empty? ? default_style(underscored_widget_name) : GSWT[*styles]
+    end
+
+    def default_style(underscored_widget_name)
+      style = @@default_styles[underscored_widget_name] if @@default_styles[underscored_widget_name]
+      style = GSWT[:none] unless style
+      style
+    end
+
+    def attribute_setter(attribute_name)
+      "set#{attribute_name.to_s.camelcase(:upper)}"
+    end
+
+  end
+end