glimmer 0.3.5 → 0.4.0

data/lib/command_handler.rb

@@ -1,8 +0,0 @@
-module CommandHandler
-  def can_handle?(parent, command_symbol, *args, &block)
-    raise "must be implemented by a class"
-  end
-  def do_handle(parent, command_symbol, *args, &block) 
-    raise "must be implemented by a class"
-  end
-end

data/lib/command_handler_chain_factory.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + "/command_handler_chain_link"
-
-class CommandHandlerChainFactory
-  @@dsls = {}
-
-  def self.def_dsl(dsl, *command_handler_array)
-    @@last_chain_link = nil
-    @@chain = nil
-    command_handler_array.each do |command_handler|
-      Glimmer.logger.debug "Loading #{command_handler.class.to_s}..."
-      chain_link = CommandHandlerChainLink.new(command_handler)
-      @@last_chain_link.chain_to(chain_link) if @@last_chain_link
-      @@last_chain_link = chain_link
-      @@chain = chain_link unless @@chain
-    end
-    @@dsls[dsl] = {
-      :last_chain_link => @@last_chain_link,
-      :chain => @@chain
-    }
-  end
-
-  def self.select_dsl(dsl)
-    @@last_chain_link = @@dsls[dsl][:last_chain_link]
-    @@chain = @@dsls[dsl][:chain]
-  end
-
-  def self.chain
-    @@chain
-  end
-end

data/lib/command_handler_chain_link.rb

@@ -1,19 +0,0 @@
-class CommandHandlerChainLink
-  def initialize(command_handler)
-    @command_handler = command_handler
-  end
-  def chain_to(next_chain_link)
-    @next_chain_link = next_chain_link
-  end
-  def handle(parent, command_symbol, *args, &block)
-    if (@command_handler.can_handle?(parent, command_symbol, *args, &block))
-      Glimmer.logger.debug "#{@command_handler.class.to_s} will handle command: #{command_symbol} with arguments #{args}"
-      return @command_handler.do_handle(parent, command_symbol, *args, &block)
-    elsif @next_chain_link
-      return @next_chain_link.handle(parent, command_symbol, *args, &block)
-    else
-      Glimmer.logger.debug "Command: #{command_symbol} cannot be handled!"
-      return nil
-    end
-  end
-end

data/lib/command_handlers/bind_command_handler.rb

@@ -1,49 +0,0 @@
-require File.dirname(__FILE__) + "/../command_handler"
-require File.dirname(__FILE__) + "/models/r_widget"
-require File.dirname(__FILE__) + "/models/model_binding"
-
-# 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 BindCommandHandler
-  include CommandHandler
-
-  include_package 'org.eclipse.swt.widgets'
-
-  def can_handle?(parent, command_symbol, *args, &block)
-    (
-      parent.is_a?(RWidget) and
-      command_symbol.to_s == "bind" and
-      (
-        (
-          (args.size == 2) and
-          (
-            args[1].is_a?(Symbol) or
-            args[1].is_a?(String)
-          )
-        ) or
-        (
-          (args.size == 3) and
-          (args[1].is_a?(Symbol) or args[1].is_a?(String)) and
-          (args[2].is_a?(Symbol) or args[2].is_a?(String) or args[2].is_a?(Hash))
-        ) or
-        (
-          (args.size == 4) and
-          (args[1].is_a?(Symbol) or args[1].is_a?(String)) and
-          (args[2].is_a?(Symbol) or args[2].is_a?(String)) and
-          (args[3].is_a?(Hash))
-        )
-      ) and
-      block == nil
-    )
-  end
-
-  def do_handle(parent, command_symbol, *args, &block)
-    property_type = args[2] if (args.size == 3) && !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)
-    ModelBinding.new(args[0], args[1].to_s, property_type, binding_options)
-  end
-
-end

data/lib/command_handlers/color_command_handler.rb

@@ -1,24 +0,0 @@
-require_relative '../command_handler'
-require_relative 'models/r_color'
-
-class ColorCommandHandler
-  include CommandHandler
-
-  include_package 'org.eclipse.swt.widgets'
-
-  def can_handle?(parent, command_symbol, *args, &block)
-      ['rgba', 'rgb'].include?(command_symbol.to_s) and
-      (3..5).include?(args.count)
-  end
-
-  def do_handle(parent, command_symbol, *args, &block)
-    if args.first.is_a?(Display)
-      display = args.delete_at(0)
-    elsif parent.is_a?(RWidget)
-      display = parent.widget.display
-    else
-      display = nil
-    end
-    RColor.new(display, *args)
-  end
-end

data/lib/command_handlers/combo_selection_data_binding_command_handler.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + "/../command_handler"
-require File.dirname(__FILE__) + "/models/r_widget"
-
-class ComboSelectionDataBindingCommandHandler
-  include CommandHandler
-  include Glimmer
-
-  include_package 'org.eclipse.swt.widgets'
-
-  def can_handle?(parent, command_symbol, *args, &block)
-    parent.is_a?(RWidget) and
-    parent.widget.is_a?(Combo) 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.update(model_binding.evaluate_options_property)
-    model = model_binding.base_model
-    widget_binding.observe(model, model_binding.options_property_name)
-
-    widget_binding = WidgetBinding.new(parent, "text")
-    widget_binding.update(model_binding.evaluate_property)
-    widget_binding.observe(model, model_binding.property_name_expression)
-
-    add_contents(parent) {
-      on_widget_selected {
-        model_binding.update(widget_binding.evaluate_property)
-      }
-    }
-  end
-
-end

data/lib/command_handlers/data_binding_command_handler.rb

@@ -1,67 +0,0 @@
-require File.dirname(__FILE__) + "/../command_handler"
-require File.dirname(__FILE__) + "/models/r_widget"
-require File.dirname(__FILE__) + "/models/observable_model"
-require File.dirname(__FILE__) + "/models/model_binding"
-require File.dirname(__FILE__) + "/models/widget_binding"
-
-# 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 |rwidget, model_binding|
-        add_contents(rwidget) {
-          on_modify_text { |modify_event|
-            model_binding.update(rwidget.widget.getText)
-          }
-        }
-        end,
-      },
-      Java::OrgEclipseSwtWidgets::Button => {
-        :selection => Proc.new do |rwidget, model_binding|
-          add_contents(rwidget) {
-            on_widget_selected { |selection_event|
-              model_binding.update(rwidget.widget.getSelection)
-            }
-          }
-        end
-      },
-      Java::OrgEclipseSwtWidgets::Spinner => {
-        :selection => Proc.new do |rwidget, model_binding|
-          add_contents(rwidget) {
-            on_widget_selected { |selection_event|
-              model_binding.update(rwidget.widget.getSelection)
-            }
-          }
-        end
-      }
-    }
-
-    def can_handle?(parent, command_symbol, *args, &block)
-      (parent.is_a?(RWidget) 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.update(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

data/lib/command_handlers/list_selection_data_binding_command_handler.rb

@@ -1,43 +0,0 @@
-require File.dirname(__FILE__) + "/../command_handler"
-require File.dirname(__FILE__) + "/models/r_widget"
-require File.dirname(__FILE__) + "/models/list_selection_binding"
-
-class ListSelectionDataBindingCommandHandler
-  include CommandHandler
-  include Glimmer
-
-  include_package 'org.eclipse.swt.widgets'
-
-  def can_handle?(parent, command_symbol, *args, &block)
-    parent.is_a?(RWidget) 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.update(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.update(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.update(list_selection_binding.evaluate_property)
-      }
-    }
-  end
-
-end

data/lib/command_handlers/models/block_observer.rb

@@ -1,14 +0,0 @@
-require_relative 'observer'
-
-# Observer that takes an updater block to process updates
-class BlockObserver
-  include Observer
-
-  def initialize(&updater)
-    @updater = updater
-  end
-
-  def update(changed_value=nil)
-    @updater.call(changed_value)
-  end
-end

data/lib/command_handlers/models/list_selection_binding.rb

@@ -1,45 +0,0 @@
-require_relative 'observable'
-require_relative 'observer'
-
-# SWT List widget selection binding
-class ListSelectionBinding
-  include Glimmer
-  include Observable
-  include Observer
-
-  attr_reader :widget
-  @@property_type_updaters = {
-    :string => lambda { |widget, value| widget.widget.select(widget.widget.index_of(value.to_s)) },
-    :array => lambda { |widget, value| widget.widget.selection=((value or []).to_java :string) }
-  }
-  @@property_evaluators = {
-    :string => lambda do |selection_array|
-      return nil if selection_array.empty?
-      selection_array[0]
-     end,
-    :array => lambda do |selection_array|
-      selection_array
-    end
-  }
-  # Initialize with list widget and property_type
-  # property_type :string represents default list single selection
-  # property_type :array represents list multi selection
-  def initialize(widget, property_type)
-    property_type = :string if property_type.nil? or property_type == :undefined
-    @widget = widget
-    @property_type = property_type
-    add_contents(@widget) {
-      on_widget_disposed { |dispose_event|
-        unregister_all_observables
-      }
-    }
-  end
-  def update(value)
-    @@property_type_updaters[@property_type].call(@widget, value) unless evaluate_property == value
-  end
-  def evaluate_property
-    selection_array = @widget.widget.send("selection").to_a
-    property_value = @@property_evaluators[@property_type].call(selection_array)
-    return property_value
-  end
-end

data/lib/command_handlers/models/model_binding.rb

@@ -1,205 +0,0 @@
-require_relative 'observable'
-require_relative 'observer'
-require_relative 'block_observer'
-
-class ModelBinding
-  include Observable
-  include Observer
-
-  attr_reader :property_type, :binding_options
-  @@property_type_converters = {
-    :undefined => lambda { |value| value },
-    :fixnum => lambda { |value| value.to_i },
-    :array => lambda { |value| value.to_a }
-  }
-  def initialize(base_model, property_name_expression, property_type = :undefined, binding_options = nil)
-    property_type = :undefined if property_type.nil?
-    @base_model = base_model
-    @property_name_expression = property_name_expression
-    @property_type = property_type
-    @binding_options = binding_options || {}
-    if computed?
-      @computed_model_bindings = computed_by.map do |computed_by_property_expression|
-        self.class.new(base_model, computed_by_property_expression, :undefined, computed_binding_options)
-      end
-    end
-  end
-  def model
-    nested_property? ? nested_model : base_model
-  end
-  # e.g. person.address.state returns [person, person.address]
-  def nested_models
-    @nested_models = [base_model]
-    model_property_names.reduce(base_model) do |reduced_model, nested_model_property_name|
-      if reduced_model.nil?
-        nil
-      else
-        invoke_property_reader(reduced_model, nested_model_property_name).tap do |new_reduced_model|
-          @nested_models << new_reduced_model
-        end
-      end
-    end
-    @nested_models
-  end
-  def nested_model
-    nested_models.last
-  end
-  def base_model
-    @base_model
-  end
-  def property_name
-    nested_property? ? nested_property_name : property_name_expression
-  end
-  # All nested property names
-  # e.g. property name expression "address.state" gives ['address', 'state']
-  # If there are any indexed property names, this returns indexes as properties.
-  # e.g. property name expression "addresses[1].state" gives ['addresses', '[1]', 'state']
-  def nested_property_names
-    @nested_property_names ||= property_name_expression.split(".").map {|pne| pne.match(/([^\[]+)(\[[^\]]+\])?/).to_a.drop(1)}.flatten.compact
-  end
-  # Final nested property name
-  # e.g. property name expression "address.state" gives :state
-  def nested_property_name
-    nested_property_names.last
-  end
-  # Model representing nested property names
-  # e.g. property name expression "address.state" gives [:address]
-  def model_property_names
-    nested_property_names[0...-1]
-  end
-  def nested_property?
-    property_name_expression.match(/[.\[]/)
-  end
-  def property_name_expression
-    @property_name_expression
-  end
-  def computed?
-    !!computed_by
-  end
-  def computed_by
-    @binding_options[:computed_by]
-  end
-  def computed_binding_options
-    @binding_options.reject {|k,v| k == :computed_by}
-  end
-  def nested_property_observers_for(observer)
-    @nested_property_observers_collection ||= {}
-    unless @nested_property_observers_collection.has_key?(observer)
-      @nested_property_observers_collection[observer] = nested_property_names.reduce({}) do |output, property_name|
-        output.merge(
-          property_name => BlockObserver.new do |changed_value|
-            # Ensure reattaching observers when a higher level nested property is updated (e.g. person.address changes reattaches person.address.street observer)
-            add_observer(observer)
-            observer.update(evaluate_property)
-          end
-        )
-      end
-    end
-    # @nested_property_observers_collection[observer].keys.each_with_index do |property_name, i|
-    #   previous_property_name = nested_property_names[i-1]
-    #   previous_observer = @nested_property_observers_collection[observer][previous_property_name]
-    #   nested_property_observer = @nested_property_observers_collection[observer][property_name]
-    #   previous_observer.add_dependent(nested_property_observer) unless previous_observer.nil?
-    # end
-    # TODO remove this brainstorming
-    # person.addresses[1].streets[2].number
-    # person.addresses[1] = ...
-    @nested_property_observers_collection[observer]
-  end
-  def add_observer(observer)
-    if computed?
-      add_computed_observers(observer)
-    elsif nested_property?
-      add_nested_observers(observer)
-    else
-      observer.observe(model, property_name)
-      observer.add_dependent([self, nil] => [observer, model, property_name])
-    end
-  end
-  def remove_observer(observer)
-    if computed?
-      @computed_model_bindings.each do |computed_model_binding|
-        computed_observer_for(observer).unobserve(computed_model_binding)
-      end
-      @computed_observer_collection.delete(observer)
-    elsif nested_property?
-      nested_property_observers_for(observer).clear
-    else
-      observer.unobserve(model, property_name)
-    end
-  end
-  def computed_observer_for(observer)
-    @computed_observer_collection ||= {}
-    unless @computed_observer_collection.has_key?(observer)
-      @computed_observer_collection[observer] = BlockObserver.new do |changed_value|
-        observer.update(evaluate_property)
-      end
-    end
-    @computed_observer_collection[observer]
-  end
-  def add_computed_observers(observer)
-    @computed_model_bindings.each do |computed_model_binding|
-      computed_observer_for(observer).observe(computed_model_binding)
-      observer.add_dependent([self, nil] => [computed_observer_for(observer), computed_model_binding, nil])
-    end
-  end
-  def add_nested_observers(observer)
-    nested_property_observers = nested_property_observers_for(observer)
-    nested_models.zip(nested_property_names).each_with_index do |zip, i|
-      model, property_name = zip
-      nested_property_observer = nested_property_observers[property_name]
-      previous_index = i - 1
-      parent_model = previous_index.negative? ? self : nested_models[previous_index]
-      parent_property_name = previous_index.negative? ? nil : nested_property_names[previous_index]
-      parent_observer = previous_index.negative? ? observer : nested_property_observers[parent_property_name]
-      parent_property_name = nil if parent_property_name.to_s.start_with?('[')
-      unless model.nil?
-        if property_indexed?(property_name)
-          # TODO figure out a way to deal with this more uniformly
-          nested_property_observer.observe(model)
-          parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, nil])
-        else
-          nested_property_observer.observe(model, property_name)
-          parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, property_name])
-        end
-      end
-    end
-  end
-  def update(value)
-    return if model.nil?
-    converted_value = @@property_type_converters[@property_type].call(value)
-    invoke_property_writer(model, "#{property_name}=", converted_value) unless evaluate_property == converted_value
-  end
-  def evaluate_property
-    invoke_property_reader(model, property_name) unless model.nil?
-  end
-  def evaluate_options_property
-    model.send(options_property_name) unless model.nil?
-  end
-  def options_property_name
-    self.property_name + "_options"
-  end
-  def property_indexed?(property_expression)
-    property_expression.start_with?('[')
-  end
-  def invoke_property_reader(object, property_expression)
-    if property_indexed?(property_expression)
-      property_method = '[]'
-      property_argument = property_expression[1...-1]
-      property_argument = property_argument.to_i if property_argument.match(/\d+/)
-      object.send(property_method, property_argument)
-    else
-      object.send(property_expression)
-    end
-  end
-  def invoke_property_writer(object, property_expression, value)
-    if property_indexed?(property_expression)
-      property_method = '[]='
-      property_argument = property_expression[1...-2]
-      property_argument = property_argument.to_i if property_argument.match(/\d+/)
-      object.send(property_method, property_argument, value)
-    else
-      object.send(property_expression, value)
-    end
-  end
-end