glimmer 0.8.2 → 0.9.0

data/lib/glimmer/swt/tree_proxy.rb

@@ -1,120 +0,0 @@
-require 'glimmer/swt/widget_proxy'
-
-module Glimmer
-  module SWT
-    class TreeProxy < Glimmer::SWT::WidgetProxy
-      include Glimmer
-      
-      attr_reader :tree_editor, :tree_editor_text_proxy
-      attr_accessor :tree_properties
-      
-      def initialize(underscored_widget_name, parent, args)
-        super
-        @tree_editor = TreeEditor.new(swt_widget)
-        @tree_editor.horizontalAlignment = SWTProxy[:left]
-        @tree_editor.grabHorizontal = true
-        @tree_editor.minimumHeight = 20
-      end
-    
-      # Performs depth first search for tree items matching block condition
-      # If no condition block is passed, returns all tree items
-      # Returns a Java TreeItem array to easily set as selection on org.eclipse.swt.Tree if needed
-      def depth_first_search(&condition)
-        found = []
-        recursive_depth_first_search(swt_widget.getItems.first, found, &condition)
-        found.to_java(TreeItem)
-      end
-      
-      # Returns all tree items including descendants
-      def all_tree_items
-        depth_first_search
-      end
-
-      def widget_property_listener_installers
-        super.merge({
-          Java::OrgEclipseSwtWidgets::Tree => {
-            selection: lambda do |observer|
-              on_widget_selected { |selection_event|
-                observer.call(@swt_widget.getSelection)
-              }
-            end
-          },        
-        })
-      end
-      
-      def edit_in_progress?
-        !!@edit_in_progress
-      end
-      
-      def edit_selected_tree_item(before_write: nil, after_write: nil, after_cancel: nil)
-        edit_tree_item(swt_widget.getSelection.first, before_write: before_write, after_write: after_write, after_cancel: after_cancel)
-      end
-            
-      def edit_tree_item(tree_item, before_write: nil, after_write: nil, after_cancel: nil)
-        return if tree_item.nil?
-        content {
-          @tree_editor_text_proxy = text {
-            focus true
-            text tree_item.getText
-            action_taken = false
-            cancel = lambda {
-              @tree_editor_text_proxy.swt_widget.dispose
-              @tree_editor_text_proxy = nil
-              after_cancel&.call
-              @edit_in_progress = false
-            }
-            action = lambda { |event|
-              if !action_taken && !@edit_in_progress
-                action_taken = true
-                @edit_in_progress = true
-                new_text = @tree_editor_text_proxy.swt_widget.getText
-                if new_text == tree_item.getText
-                  cancel.call
-                else
-                  before_write&.call
-                  tree_item.setText(new_text)
-                  model = tree_item.getData
-                  model.send("#{tree_properties[:text]}=", new_text) # makes tree update itself, so must search for selected tree item again
-                  edited_tree_item = depth_first_search { |ti| ti.getData == model }.first
-                  swt_widget.showItem(edited_tree_item)
-                  @tree_editor_text_proxy.swt_widget.dispose
-                  @tree_editor_text_proxy = nil
-                  after_write&.call(edited_tree_item)
-                  @edit_in_progress = false
-                end
-              end
-            }
-            on_focus_lost(&action)
-            on_key_pressed { |key_event|
-              if key_event.keyCode == swt(:cr)
-                action.call(key_event)
-              elsif key_event.keyCode == swt(:esc)
-                cancel.call
-              end
-            }
-          }
-          @tree_editor_text_proxy.swt_widget.selectAll
-        }
-        @tree_editor.setEditor(@tree_editor_text_proxy.swt_widget, tree_item)
-      end
-      
-      private
-
-      def recursive_depth_first_search(tree_item, found, &condition)
-        return if tree_item.nil?
-        found << tree_item if condition.nil? || condition.call(tree_item)
-        tree_item.getItems.each do |child_tree_item|
-          recursive_depth_first_search(child_tree_item, found, &condition)
-        end
-      end
-      
-      def property_type_converters
-        super.merge({
-          selection: lambda do |value|
-            depth_first_search {|ti| ti.getData == value}
-          end,
-        })
-      end
-    end
-  end
-end

data/lib/glimmer/swt/widget_listener_proxy.rb

@@ -1,34 +0,0 @@
-module Glimmer
-  module SWT
-    # Proxy for widget listeners
-    #
-    # Follows the Proxy Design Pattern
-    class WidgetListenerProxy
-
-      attr_reader :swt_widget, :swt_listener, :widget_add_listener_method, :swt_listener_class, :swt_listener_method, :event_type, :swt_constant
-
-      def initialize(swt_widget:, swt_listener:, widget_add_listener_method: nil, swt_listener_class: nil, swt_listener_method: nil, event_type: nil, swt_constant: nil)
-        @swt_widget = swt_widget
-        @swt_listener = swt_listener
-        @widget_add_listener_method = widget_add_listener_method
-        @swt_listener_class = swt_listener_class
-        @swt_listener_method = swt_listener_method
-        @event_type = event_type
-        @swt_constant = swt_constant
-      end
-      
-      def widget_remove_listener_method
-        @widget_add_listener_method.sub('add', 'remove')
-      end      
-      
-      def unregister
-        # TODO consider renaming to deregister (and in Observer too)
-        if @event_type
-          @swt_widget.removeListener(@event_type, @swt_listener)
-        else
-          @swt_widget.send(widget_remove_listener_method, @swt_listener)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/swt/widget_proxy.rb

@@ -1,489 +0,0 @@
-require 'glimmer'
-require 'glimmer/swt/widget_listener_proxy'
-require 'glimmer/swt/color_proxy'
-require 'glimmer/swt/font_proxy'
-require 'glimmer/swt/swt_proxy'
-require 'glimmer/data_binding/observable_widget'
-
-# TODO refactor to make file smaller and extract sub-widget-proxies out of this
-
-module Glimmer
-  module SWT
-    # Proxy for SWT Widget objects
-    #
-    # Sets default SWT styles to widgets upon inititalizing as
-    # per DEFAULT_STYLES
-    #
-    # Also, auto-initializes widgets as per initializer blocks
-    # in DEFAULT_INITIALIZERS  (e.g. setting Composite default layout)
-    #
-    # Follows the Proxy Design Pattern
-    class WidgetProxy
-      include Packages
-      include DataBinding::ObservableWidget
-
-      DEFAULT_STYLES = {
-        "text"        => [:border],
-        "table"       => [:border],
-        "tree"       =>  [:virtual, :border, :h_scroll, :v_scroll],
-        "spinner"     => [:border],
-        "styled_text" => [:border],
-        "list"        => [:border, :v_scroll],
-        "button"      => [:push],
-        "menu_item"   => [:push],
-      }
-
-      DEFAULT_INITIALIZERS = {
-        "composite" => lambda do |composite|
-          composite.setLayout(GridLayout.new)
-        end,
-        "table" => lambda do |table|
-          table.setHeaderVisible(true)
-          table.setLinesVisible(true)
-        end,
-        "table_column" => lambda do |table_column|
-          table_column.setWidth(80)
-        end,
-        "group" => lambda do |group|
-          group.setLayout(GridLayout.new)
-        end,
-      }
-
-      attr_reader :swt_widget
-
-      # Initializes a new SWT Widget
-      #
-      # Styles is a comma separate list of symbols representing SWT styles in lower case
-      def initialize(underscored_widget_name, parent, args)
-        styles, extra_options = extract_args(underscored_widget_name, args)
-        swt_widget_class = self.class.swt_widget_class_for(underscored_widget_name)
-        @swt_widget = swt_widget_class.new(parent.swt_widget, style(underscored_widget_name, styles), *extra_options)
-        DEFAULT_INITIALIZERS[underscored_widget_name]&.call(@swt_widget)
-      end
-
-      def extract_args(underscored_widget_name, args)
-        @arg_extractor_mapping ||= {
-          'menu_item' => lambda do |args|
-            index = args.delete(args.last) if args.last.is_a?(Numeric)
-            extra_options = [index].compact
-            styles = args
-            [styles, extra_options]
-          end,
-        }
-        if @arg_extractor_mapping[underscored_widget_name]
-          @arg_extractor_mapping[underscored_widget_name].call(args)
-        else
-          [args, []]
-        end
-      end
-
-      def has_attribute?(attribute_name, *args)
-        widget_custom_attribute = widget_custom_attribute_mapping[attribute_name.to_s]
-        if widget_custom_attribute
-          @swt_widget.respond_to?(widget_custom_attribute[:setter][:name])
-        else
-          @swt_widget.respond_to?(attribute_setter(attribute_name), args)
-        end
-      end
-
-      def set_attribute(attribute_name, *args)
-        widget_custom_attribute = widget_custom_attribute_mapping[attribute_name.to_s]
-        if widget_custom_attribute
-          widget_custom_attribute[:setter][:invoker].call(@swt_widget, args)
-        else
-          apply_property_type_converters(attribute_name, args)
-          @swt_widget.send(attribute_setter(attribute_name), *args) unless @swt_widget.send(attribute_getter(attribute_name)) == args.first
-        end
-      end
-
-      def get_attribute(attribute_name)
-        widget_custom_attribute = widget_custom_attribute_mapping[attribute_name.to_s]
-        if widget_custom_attribute
-          @swt_widget.send(widget_custom_attribute[:getter][:name])
-        else
-          @swt_widget.send(attribute_getter(attribute_name))
-        end
-      end
-
-      def pack_same_size
-        bounds = @swt_widget.getBounds
-        listener = on_control_resized {
-          @swt_widget.setSize(bounds.width, bounds.height)
-          @swt_widget.setLocation(bounds.x, bounds.y)
-        }
-        if @swt_widget.is_a?(Composite)
-          @swt_widget.layout(true, true)
-        else
-          @swt_widget.pack(true)
-        end
-        @swt_widget.removeControlListener(listener.swt_listener)
-      end
-
-      def widget_property_listener_installers
-        @swt_widget_property_listener_installers ||= {
-          Java::OrgEclipseSwtWidgets::Control => {
-            :focus => lambda do |observer|
-              on_focus_gained { |focus_event|
-                observer.call(true)
-              }
-              on_focus_lost { |focus_event|
-                observer.call(false)
-              }
-            end,
-          },
-          Java::OrgEclipseSwtWidgets::Text => {
-            :text => lambda do |observer|
-              on_modify_text { |modify_event|
-                observer.call(@swt_widget.getText)
-              }
-            end,
-            :caret_position => lambda do |observer|
-              on_event_keydown { |event|
-                observer.call(@swt_widget.getCaretPosition)
-              }
-              on_event_keyup { |event|
-                observer.call(@swt_widget.getCaretPosition)
-              }
-              on_event_mousedown { |event|
-                observer.call(@swt_widget.getCaretPosition)
-              }
-              on_event_mouseup { |event|
-                observer.call(@swt_widget.getCaretPosition)
-              }
-            end,
-            :selection => lambda do |observer|
-              on_event_keydown { |event|
-                observer.call(@swt_widget.getSelection)
-              }
-              on_event_keyup { |event|
-                observer.call(@swt_widget.getSelection)
-              }
-              on_event_mousedown { |event|
-                observer.call(@swt_widget.getSelection)
-              }
-              on_event_mouseup { |event|
-                observer.call(@swt_widget.getSelection)
-              }
-            end,
-            :selection_count => lambda do |observer|
-              on_event_keydown { |event|
-                observer.call(@swt_widget.getSelectionCount)
-              }
-              on_event_keyup { |event|
-                observer.call(@swt_widget.getSelectionCount)
-              }
-              on_event_mousedown { |event|
-                observer.call(@swt_widget.getSelectionCount)
-              }
-              on_event_mouseup { |event|
-                observer.call(@swt_widget.getSelectionCount)
-              }
-            end,
-            :top_index => lambda do |observer|
-              @last_top_index = @swt_widget.getTopIndex
-              on_paint_control { |event|
-                if @swt_widget.getTopIndex != @last_top_index
-                  @last_top_index = @swt_widget.getTopIndex
-                  observer.call(@last_top_index)
-                end
-              }
-            end,
-          },
-          Java::OrgEclipseSwtCustom::StyledText => {
-            :text => lambda do |observer|
-              on_modify_text { |modify_event|
-                observer.call(@swt_widget.getText)
-              }
-            end,
-          },
-          Java::OrgEclipseSwtWidgets::Button => {
-            :selection => lambda do |observer|
-              on_widget_selected { |selection_event|
-                observer.call(@swt_widget.getSelection)
-              }
-            end
-          },
-          Java::OrgEclipseSwtWidgets::MenuItem => {
-            :selection => lambda do |observer|
-              on_widget_selected { |selection_event|
-                observer.call(@swt_widget.getSelection)
-              }
-            end
-          },
-          Java::OrgEclipseSwtWidgets::Spinner => {
-            :selection => lambda do |observer|
-              on_widget_selected { |selection_event|
-                observer.call(@swt_widget.getSelection)
-              }
-            end
-          },
-        }
-      end
-
-      def self.widget_exists?(underscored_widget_name)
-        !!swt_widget_class_for(underscored_widget_name)
-      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)
-          Glimmer::Config.logger&.debug("Class #{swt_widget_class} matching #{underscored_widget_name} is not a subclass of org.eclipse.swt.widgets.Widget")
-          return nil
-        end
-        swt_widget_class
-      rescue NameError => e
-        Glimmer::Config.logger&.debug e.message
-        # Glimmer::Config.logger&.debug("#{e.message}\n#{e.backtrace.join("\n")}")
-        nil
-      rescue => e
-        Glimmer::Config.logger&.debug e.message
-        # Glimmer::Config.logger&.debug("#{e.message}\n#{e.backtrace.join("\n")}")
-        nil
-      end
-
-      def async_exec(&block)
-        DisplayProxy.instance.async_exec(&block)
-      end
-
-      def sync_exec(&block)
-        DisplayProxy.instance.sync_exec(&block)
-      end
-
-      def has_style?(style)
-        (@swt_widget.style & SWTProxy[style]) == SWTProxy[style]
-      end
-
-      def dispose
-        @swt_widget.dispose
-      end
-
-      # TODO Consider renaming these methods as they are mainly used for data-binding
-
-      def can_add_observer?(property_name)
-        @swt_widget.class.ancestors.map {|ancestor| widget_property_listener_installers[ancestor]}.compact.map(&:keys).flatten.map(&:to_s).include?(property_name.to_s)
-      end
-
-      # Used for data-binding only. Consider renaming or improving to avoid the confusion it causes
-      def add_observer(observer, property_name)
-        property_listener_installers = @swt_widget.class.ancestors.map {|ancestor| widget_property_listener_installers[ancestor]}.compact
-        widget_listener_installers = property_listener_installers.map{|installer| installer[property_name.to_s.to_sym]}.compact if !property_listener_installers.empty?
-        widget_listener_installers.to_a.each do |widget_listener_installer|
-          widget_listener_installer.call(observer)
-        end
-      end
-
-      def remove_observer(observer, property_name)
-        # TODO consider implementing if remove_observer is needed (consumers can remove listener via SWT API)
-      end
-
-      # TODO eliminate duplication in the following methods perhaps by relying on exceptions
-
-      def can_handle_observation_request?(observation_request)
-        observation_request = observation_request.to_s
-        if observation_request.start_with?('on_event_')
-          constant_name = observation_request.sub(/^on_event_/, '')
-          SWTProxy.has_constant?(constant_name)
-        elsif observation_request.start_with?('on_')
-          event = observation_request.sub(/^on_/, '')
-          can_add_listener?(event)
-        else
-          false
-        end
-      end
-
-      def handle_observation_request(observation_request, &block)
-        if observation_request.start_with?('on_event_')
-          constant_name = observation_request.sub(/^on_event_/, '')
-          add_swt_event_listener(constant_name, &block)
-        elsif observation_request.start_with?('on_')
-          event = observation_request.sub(/^on_/, '')
-          add_listener(event, &block)
-        end
-      end
-
-      def content(&block)
-        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::WidgetExpression.new, &block)
-      end
-
-      private
-
-      def style(underscored_widget_name, styles)
-        styles = [styles].flatten.compact
-        styles.empty? ? default_style(underscored_widget_name) : SWTProxy[*styles]
-      end
-
-      def default_style(underscored_widget_name)
-        styles = DEFAULT_STYLES[underscored_widget_name] || [:none]
-        SWTProxy[styles]
-      end
-
-      def attribute_setter(attribute_name)
-        "set#{attribute_name.to_s.camelcase(:upper)}"
-      end
-
-      def attribute_getter(attribute_name)
-        "get#{attribute_name.to_s.camelcase(:upper)}"
-      end
-
-      # TODO refactor following methods to eliminate duplication
-      # perhaps consider relying on raising an exception to avoid checking first
-      # unless that gives obscure SWT errors
-      # Otherwise, consider caching results from can_add_lsitener and using them in
-      # add_listener knowing it will be called for sure afterwards
-
-      def can_add_listener?(underscored_listener_name)
-        !self.class.find_listener(@swt_widget.getClass, underscored_listener_name).empty?
-      end
-
-      def add_listener(underscored_listener_name, &block)
-        widget_add_listener_method, listener_class, listener_method = self.class.find_listener(@swt_widget.getClass, underscored_listener_name)        
-        widget_listener_proxy = nil
-        safe_block = lambda { |event| block.call(event) unless @swt_widget.isDisposed }
-        listener = listener_class.new(listener_method => safe_block)
-        @swt_widget.send(widget_add_listener_method, listener)
-        widget_listener_proxy = WidgetListenerProxy.new(swt_widget: @swt_widget, swt_listener: listener, widget_add_listener_method: widget_add_listener_method, swt_listener_class: listener_class, swt_listener_method: listener_method)
-      end
-
-      # Looks through SWT class add***Listener methods till it finds one for which
-      # the argument is a listener class that has an event method matching
-      # underscored_listener_name
-      def self.find_listener(swt_widget_class, underscored_listener_name)
-        @listeners ||= {}
-        listener_key = [swt_widget_class.name, underscored_listener_name]
-        unless @listeners.has_key?(listener_key)
-          listener_method_name = underscored_listener_name.camelcase(:lower)
-          swt_widget_class.getMethods.each do |widget_add_listener_method|
-            if widget_add_listener_method.getName.match(/add.*Listener/)
-              widget_add_listener_method.getParameterTypes.each do |listener_type|
-                listener_type.getMethods.each do |listener_method|
-                  if (listener_method.getName == listener_method_name)
-                    @listeners[listener_key] = [widget_add_listener_method.getName, listener_class(listener_type), listener_method.getName]
-                    return @listeners[listener_key]
-                  end
-                end
-              end
-            end
-          end
-          @listeners[listener_key] = []
-        end
-        @listeners[listener_key]
-      end
-
-      # Returns a Ruby class that implements listener type Java interface with ability to easily
-      # install a block that gets called upon calling a listener event method
-      def self.listener_class(listener_type)
-        @listener_classes ||= {}
-        listener_class_key = listener_type.name
-        unless @listener_classes.has_key?(listener_class_key)
-          @listener_classes[listener_class_key] = Class.new(Object).tap do |listener_class|
-            listener_class.send :include, (eval listener_type.name.sub("interface", ""))
-            listener_class.define_method('initialize') do |event_method_block_mapping|
-              @event_method_block_mapping = event_method_block_mapping
-            end
-            listener_type.getMethods.each do |event_method|
-              listener_class.define_method(event_method.getName) do |event|
-                @event_method_block_mapping[event_method.getName]&.call(event)
-              end
-            end
-          end
-        end
-        @listener_classes[listener_class_key]
-      end
-
-      def add_swt_event_listener(swt_constant, &block)
-        event_type = SWTProxy[swt_constant]
-        widget_listener_proxy = nil
-        safe_block = lambda { |event| block.call(event) unless @swt_widget.isDisposed }
-        @swt_widget.addListener(event_type, &safe_block)
-        widget_listener_proxy = WidgetListenerProxy.new(swt_widget: @swt_widget, swt_listener: @swt_widget.getListeners(event_type).last, event_type: event_type, swt_constant: swt_constant)
-      end
-
-      def widget_custom_attribute_mapping
-        @swt_widget_custom_attribute_mapping ||= {
-          'focus' => {
-            getter: {name: 'isFocusControl'},
-            setter: {name: 'setFocus', invoker: lambda { |widget, args| @swt_widget.setFocus if args.first }},
-          },
-          'caret_position' => {
-            getter: {name: 'getCaretPosition'},
-            setter: {name: 'setSelection', invoker: lambda { |widget, args| @swt_widget.setSelection(args.first) if args.first }},
-          },
-          'selection_count' => {
-            getter: {name: 'getSelectionCount'},
-            setter: {name: 'setSelection', invoker: lambda { |widget, args| @swt_widget.setSelection(@swt_widget.getCaretPosition, @swt_widget.getCaretPosition + args.first) if args.first }},
-          },
-        }
-      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?(ColorProxy)
-          g_color = args.first
-          args[0] = g_color.swt_color
-        end
-      end
-
-      def property_type_converters
-        color_converter = lambda do |value|
-          if value.is_a?(Symbol) || value.is_a?(String)
-            ColorProxy.new(value).swt_color
-          else
-            value
-          end
-        end
-        # TODO consider detecting type on widget method and automatically invoking right converter (e.g. :to_s for String, :to_i for Integer)
-        @property_type_converters ||= {
-          :background => color_converter,
-          :background_image => lambda do |value|
-            if value.is_a?(String)
-              if value.start_with?('uri:classloader')
-                value = value.sub(/^uri\:classloader\:\//, '')
-                object = java.lang.Object.new
-                value = object.java_class.resource_as_stream(value)
-                value = java.io.BufferedInputStream.new(value)
-              end
-              image_data = ImageData.new(value)
-              # TODO in the future, look into unregistering this listener when no longer needed
-              on_event_Resize do |resize_event|
-                new_image_data = image_data.scaledTo(@swt_widget.getSize.x, @swt_widget.getSize.y)
-                @swt_widget.getBackgroundImage&.dispose
-                @swt_widget.setBackgroundImage(Image.new(@swt_widget.getDisplay, new_image_data))
-              end
-              Image.new(@swt_widget.getDisplay, image_data)
-            else
-              value
-            end
-          end,
-          :foreground => color_converter,
-          :font => lambda do |value|
-            if value.is_a?(Hash)
-              font_properties = value
-              FontProxy.new(self, font_properties).swt_font
-            else
-              value
-            end
-          end,
-          :items => lambda do |value|
-            value.to_java :string
-          end,
-          :text => lambda do |value|
-            if swt_widget.is_a?(Browser)
-              value.to_s
-            else
-              value.to_s
-            end
-          end,
-          :visible => lambda do |value|
-            !!value
-          end,
-        }
-      end
-    end
-  end
-end