glimmer-dsl-swt 0.2.4 → 0.5.0

data/lib/glimmer/swt/display_proxy.rb

@@ -33,26 +33,24 @@ module Glimmer
 
       def initialize(*args)
         @swt_display = Display.new(*args)
+        @swt_display.set_data('proxy', self)
       end
 
-      def dispose
-        @swt_display.dispose
+      def method_missing(method, *args, &block)
+        swt_display.send(method, *args, &block)
+      rescue => e
+        Glimmer::Config.logger.debug {"Neither DisplayProxy nor #{swt_display.class.name} can handle the method ##{method}"}
+        super
       end
-
-      # Executes code block asynchronously with respect to SWT UI thread
-      def async_exec(&block)
-        @swt_display.asyncExec(&block)
-      end
-
-      # Executes code block synchronously with respect to SWT UI thread
-      def sync_exec(&block)
-        @swt_display.syncExec(&block)
+      
+      def respond_to?(method, *args, &block)
+        super || swt_display.respond_to?(method, *args, &block)
       end
 
       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_/, '')
+        if observation_request.start_with?('on_swt_')
+          constant_name = observation_request.sub(/^on_swt_/, '')
           SWTProxy.has_constant?(constant_name)
         elsif observation_request.start_with?('on_')
           event_name = observation_request.sub(/^on_/, '')
@@ -63,8 +61,8 @@ module Glimmer
       end
 
       def handle_observation_request(observation_request, &block)
-        if observation_request.start_with?('on_event_')
-          constant_name = observation_request.sub(/^on_event_/, '')
+        if observation_request.start_with?('on_swt_')
+          constant_name = observation_request.sub(/^on_swt_/, '')
           add_swt_event_listener(constant_name, &block)
         elsif observation_request.start_with?('on_')
           event_name = observation_request.sub(/^on_/, '')

data/lib/glimmer/swt/layout_data_proxy.rb

@@ -31,7 +31,7 @@ module Glimmer
         begin
           @swt_layout_data = swt_layout_data_class.new(*args)
         rescue => e
-          Glimmer::Config.logger&.debug "#{e.message}\n#{e.backtrace.join("\n")}"
+          Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
           @swt_layout_data = args.first if args.count == 1
         end
         @widget_proxy.swt_widget.setLayoutData(@swt_layout_data)

data/lib/glimmer/swt/layout_proxy.rb

@@ -34,8 +34,8 @@ module Glimmer
           end
           swt_layout_class
         rescue => e
-          Glimmer::Config.logger&.debug e.message
-          # Glimmer::Config.logger&.debug "#{e.message}\n#{e.backtrace.join("\n")}"
+          Glimmer::Config.logger.debug {e.message}
+          # Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
           raise e
         end
       end

data/lib/glimmer/swt/message_box_proxy.rb

@@ -15,11 +15,13 @@ module Glimmer
       
       def initialize(parent, style)
         parent = parent.swt_widget if parent.respond_to?(:swt_widget) && parent.swt_widget.is_a?(Shell)
+        @temporary_parent = parent = Glimmer::SWT::ShellProxy.new.swt_widget if parent.nil?
         @swt_widget = MessageBox.new(parent, style)
       end
       
       def open
         @swt_widget.open
+        @temporary_parent&.dispose
       end
       
       # TODO refactor the following methods to put in a JavaBean mixin or somethin (perhaps contribute to OSS project too)

data/lib/glimmer/swt/shell_proxy.rb

@@ -40,9 +40,10 @@ module Glimmer
           end
           args = args.compact
           @swt_widget = Shell.new(*args)
+          @swt_widget.set_data('proxy', self)
           @swt_widget.setLayout(FillLayout.new)
           @swt_widget.setMinimumSize(WIDTH_MIN, HEIGHT_MIN)
-          on_event_show do
+          on_swt_show do
             Thread.new do      
               sleep(0.25)
               async_exec do
@@ -83,10 +84,6 @@ module Glimmer
         @swt_widget.setVisible(false)
       end
 
-      def close
-        @swt_widget.close
-      end
-
       def visible?
         @swt_widget.isDisposed ? false : @swt_widget.isVisible
       end
@@ -130,7 +127,11 @@ module Glimmer
       # This method is not needed except in rare circumstances where there is a need to start the SWT Event Loop before opening the shell.
       def start_event_loop
         until @swt_widget.isDisposed
-          @display.sleep unless @display.readAndDispatch
+          begin
+            @display.sleep unless @display.readAndDispatch
+          rescue => e
+            Glimmer::Config.logger.debug {e.full_message}
+          end
         end
       end
 
@@ -140,9 +141,9 @@ module Glimmer
           visibility_notifier = proc do
             observer.call(visible?)
           end
-          on_event_show(&visibility_notifier)
-          on_event_hide(&visibility_notifier)
-          on_event_close(&visibility_notifier)
+          on_swt_show(&visibility_notifier)
+          on_swt_hide(&visibility_notifier)
+          on_swt_close(&visibility_notifier)
         else
           super
         end

data/lib/glimmer/swt/style_constantizable.rb

@@ -61,12 +61,12 @@ module Glimmer
           negative ? ~bit_value : bit_value
         rescue => e
           begin
-#             Glimmer::Config.logger&.debug(e.full_message)
+#             Glimmer::Config.logger.debug {e.full_message}
             alternative_swt_constant_symbol = constant_source_class.constants.find {|c| c.to_s.upcase == swt_constant_symbol.to_s.upcase}
             bit_value = constant_source_class.const_get(alternative_swt_constant_symbol)
             negative ? ~bit_value : bit_value
           rescue => e
-#             Glimmer::Config.logger&.debug(e.full_message)
+#             Glimmer::Config.logger.debug {e.full_message}
             bit_value = extra_styles[swt_constant_symbol]
             if bit_value
               negative ? ~bit_value : bit_value

data/lib/glimmer/swt/table_column_proxy.rb

@@ -3,7 +3,7 @@ require 'glimmer/swt/widget_proxy'
 module Glimmer
   module SWT
     class TableColumnProxy < Glimmer::SWT::WidgetProxy    
-      attr_reader :no_sort, :sort_property
+      attr_reader :no_sort, :sort_property, :editor
       alias no_sort? no_sort
       attr_accessor :sort_block, :sort_by_block
       
@@ -16,7 +16,11 @@ module Glimmer
       end
       
       def sort_property=(args)
-        @sort_property = args.to_a.first
+        @sort_property = args unless args.empty?
+      end
+      
+      def editor=(args)
+        @editor = args
       end
       
     end

data/lib/glimmer/swt/table_proxy.rb

@@ -23,8 +23,8 @@ module Glimmer
         def find_table_item_and_column_index
           {}.tap do |result|
             if respond_to?(:x) && respond_to?(:y)
-              result[:table_item] = widget.getItems.detect do |ti|
-                result[:column_index] = widget.getColumnCount.times.to_a.detect do |ci|
+              result[:table_item] = widget.items.detect do |ti|
+                result[:column_index] = widget.column_count.times.to_a.detect do |ci|
                   ti.getBounds(ci).contains(x, y)
                 end
               end
@@ -33,7 +33,61 @@ module Glimmer
         end   
       end
       
-      attr_reader :table_editor, :table_editor_text_proxy, :sort_property, :sort_direction, :sort_block, :sort_type, :sort_by_block
+      class << self
+        def editors
+          @editors ||= {
+            text: {
+              widget_value_property: :text,
+              editor_gui: lambda do |args, model, property, table_proxy|
+                table_proxy.table_editor.minimumHeight = 20
+                table_editor_widget_proxy = text(*args) {
+                  text model.send(property)
+                  focus true
+                  on_focus_lost {
+                    table_proxy.finish_edit!
+                  }
+                  on_key_pressed { |key_event|
+                    if key_event.keyCode == swt(:cr)
+                      table_proxy.finish_edit!
+                    elsif key_event.keyCode == swt(:esc)
+                      table_proxy.cancel_edit!
+                    end
+                  }              
+                }
+                table_editor_widget_proxy.swt_widget.selectAll          
+                table_editor_widget_proxy
+              end,
+            },
+            combo: {
+              widget_value_property: :text,
+              editor_gui: lambda do |args, model, property, table_proxy|
+                table_proxy.table_editor.minimumHeight = 25
+                table_editor_widget_proxy = combo(*args) {
+                  items model.send("#{property}_options")
+                  text model.send(property)
+                  focus true
+                  on_focus_lost {
+                    table_proxy.finish_edit!
+                  }
+                  on_key_pressed { |key_event|
+                    if key_event.keyCode == swt(:cr)
+                      table_proxy.finish_edit!
+                    elsif key_event.keyCode == swt(:esc)
+                      table_proxy.cancel_edit!
+                    end
+                  }
+                  on_widget_selected {
+                    table_proxy.finish_edit!
+                  }
+                }
+                table_editor_widget_proxy
+              end,
+            }
+          }      
+        end
+      end
+      
+      attr_reader :table_editor, :table_editor_widget_proxy, :sort_property, :sort_direction, :sort_block, :sort_type, :sort_by_block, :additional_sort_properties, :editor
       attr_accessor :column_properties
       
       def initialize(underscored_widget_name, parent, args)
@@ -46,13 +100,30 @@ module Glimmer
 
       def model_binding
         swt_widget.data
-      end      
+      end
       
       def sort_by_column(table_column_proxy)
         index = swt_widget.columns.to_a.index(table_column_proxy.swt_widget)
-        new_sort_property = table_column_proxy.sort_property || column_properties[index]
-        @sort_direction = @sort_direction.nil? || @sort_property != new_sort_property || @sort_direction == :descending ? :ascending : :descending
+        new_sort_property = table_column_proxy.sort_property || [column_properties[index]]
+        if new_sort_property.size == 1 && !additional_sort_properties.to_a.empty?
+          selected_additional_sort_properties = additional_sort_properties.clone
+          if selected_additional_sort_properties.include?(new_sort_property.first)
+            selected_additional_sort_properties.delete(new_sort_property.first)
+            new_sort_property += selected_additional_sort_properties
+          else
+            new_sort_property += additional_sort_properties
+          end
+        end
+        
+        @sort_direction = @sort_direction.nil? || @sort_property != new_sort_property || @sort_direction == :descending ? :ascending : :descending        
+        swt_widget.sort_direction = @sort_direction == :ascending ? SWTProxy[:up] : SWTProxy[:down]
+        
         @sort_property = new_sort_property
+        swt_widget.sort_column = table_column_proxy.swt_widget
+        
+        @sort_by_block = nil
+        @sort_block = nil
+        @sort_type = nil
         if table_column_proxy.sort_by_block
           @sort_by_block = table_column_proxy.sort_by_block
         elsif table_column_proxy.sort_block
@@ -64,43 +135,51 @@ module Glimmer
       end
       
       def detect_sort_type
-        @sort_type = String
+        @sort_type = sort_property.size.times.map { String }
         array = model_binding.evaluate_property
-        values = array.map { |object| object.send(sort_property) }
-        value_classes = values.map(&:class).uniq
-        if value_classes.size == 1
-          @sort_type = value_classes.first
-        elsif value_classes.include?(Integer)
-          @sort_type = Integer
-        elsif value_classes.include?(Float)
-          @sort_type = Float
+        sort_property.each_with_index do |a_sort_property, i|
+          values = array.map { |object| object.send(a_sort_property) }
+          value_classes = values.map(&:class).uniq
+          if value_classes.size == 1
+            @sort_type[i] = value_classes.first
+          elsif value_classes.include?(Integer)
+            @sort_type[i] = Integer
+          elsif value_classes.include?(Float)
+            @sort_type[i] = Float
+          end
         end
       end
       
+      def additional_sort_properties=(args)
+        @additional_sort_properties = args unless args.empty?
+      end
+      
+      def editor=(args)
+        @editor = args
+      end 
+      
       def sort
         return unless sort_property && (sort_type || sort_block || sort_by_block)
         array = model_binding.evaluate_property
         # Converting value to_s first to handle nil cases. Should work with numeric, boolean, and date fields
         if sort_block
-          sorted_array = array.sort do |object1, object2|
-            value1 = object1.send(sort_property)
-            value2 = object2.send(sort_property)
-            sort_block.call(value1, value2)
-          end
+          sorted_array = array.sort(&sort_block)
+        elsif sort_by_block
+          sorted_array = array.sort_by(&sort_by_block)          
         else
           sorted_array = array.sort_by do |object|
-            value = object.send(sort_property)
-            # handle nil and difficult to compare types gracefully
-            if sort_by_block
-              value = sort_by_block.call(value)
-            elsif sort_type == Integer
-              value = value.to_i
-            elsif sort_type == Float
-              value = value.to_f
-            elsif sort_type == String
-              value = value.to_s
+            sort_property.each_with_index.map do |a_sort_property, i|
+              value = object.send(a_sort_property)
+              # handle nil and difficult to compare types gracefully
+              if sort_type[i] == Integer
+                value = value.to_i
+              elsif sort_type[i] == Float
+                value = value.to_f
+              elsif sort_type[i] == String
+                value = value.to_s
+              end
+              value
             end
-            value
           end
         end
         sorted_array = sorted_array.reverse if sort_direction == :descending
@@ -131,6 +210,14 @@ module Glimmer
         })
       end
       
+      def post_initialize_child(table_column_proxy)
+        table_column_proxies << table_column_proxy
+      end
+      
+      def table_column_proxies
+        @table_column_proxies ||= []
+      end
+      
       # Indicates if table is in edit mode, thus displaying a text widget for a table item cell
       def edit_mode?
         !!@edit_mode
@@ -156,58 +243,62 @@ module Glimmer
             
       def edit_table_item(table_item, column_index, before_write: nil, after_write: nil, after_cancel: nil)
         return if table_item.nil?
+        model = table_item.data
+        property = column_properties[column_index]
         @cancel_edit&.call if @edit_mode
+        action_taken = false
         @edit_mode = true
-        content {
-          @table_editor_text_proxy = text {
-            focus true
-            text table_item.getText(column_index)
-            action_taken = false
-            @cancel_edit = lambda do
-              @cancel_in_progress = true
-              @table_editor_text_proxy&.swt_widget&.dispose
-              @table_editor_text_proxy = nil
-              after_cancel&.call
+        
+        editor_config = table_column_proxies[column_index].editor || editor
+        editor_config = editor_config.to_a
+        editor_widget_options = editor_config.last.is_a?(Hash) ? editor_config.last : {}
+        editor_widget_arg_last_index = editor_config.last.is_a?(Hash) ? -2 : -1
+        editor_widget = editor_config[0] || :text
+        editor_widget_args = editor_config[1..editor_widget_arg_last_index]
+        model_editing_property = editor_widget_options[:property] || property
+        widget_value_property = TableProxy::editors[editor_widget][:widget_value_property]
+        
+        @cancel_edit = lambda do |event=nil|
+          @cancel_in_progress = true
+          @table_editor_widget_proxy&.swt_widget&.dispose
+          @table_editor_widget_proxy = nil
+          after_cancel&.call
+          @edit_in_progress = false
+          @cancel_in_progress = false
+          @cancel_edit = nil
+          @edit_mode = false
+        end
+        
+        @finish_edit = lambda do |event=nil|
+          new_value = @table_editor_widget_proxy&.swt_widget&.send(widget_value_property)
+          if table_item.isDisposed
+            @cancel_edit.call
+          elsif new_value && !action_taken && !@edit_in_progress && !@cancel_in_progress
+            action_taken = true
+            @edit_in_progress = true
+            if new_value == model.send(model_editing_property)
+              @cancel_edit.call
+            else
+              before_write&.call
+              model.send("#{model_editing_property}=", new_value) # makes table update itself, so must search for selected table item again
+              # Table refresh happens here because of model update triggering observers, so must retrieve table item again
+              edited_table_item = search { |ti| ti.getData == model }.first
+              swt_widget.showItem(edited_table_item)
+              @table_editor_widget_proxy&.swt_widget&.dispose
+              @table_editor_widget_proxy = nil
+              after_write&.call(edited_table_item)              
               @edit_in_progress = false
-              @cancel_in_progress = false
-              @cancel_edit = nil
-              @edit_mode = false
             end
-            @finish_edit = lambda do |event=nil|
-              if table_item.isDisposed
-                @cancel_edit.call
-              elsif !action_taken && !@edit_in_progress && !@cancel_in_progress
-                action_taken = true
-                @edit_in_progress = true
-                new_text = @table_editor_text_proxy.swt_widget.getText
-                if new_text == table_item.getText(column_index)
-                  @cancel_edit.call
-                else
-                  before_write&.call
-                  table_item.setText(column_index, new_text)
-                  model = table_item.getData
-                  model.send("#{column_properties[column_index]}=", new_text) # makes table update itself, so must search for selected table item again
-                  edited_table_item = search { |ti| ti.getData == model }.first
-                  swt_widget.showItem(edited_table_item)
-                  @table_editor_text_proxy&.swt_widget&.dispose
-                  @table_editor_text_proxy = nil
-                  after_write&.call(edited_table_item)
-                  @edit_in_progress = false
-                end
-              end
-            end
-            on_focus_lost(&@finish_edit)
-            on_key_pressed { |key_event|
-              if key_event.keyCode == swt(:cr)
-                @finish_edit.call(key_event)
-              elsif key_event.keyCode == swt(:esc)
-                @cancel_edit.call
-              end
-            }
-          }
-          @table_editor_text_proxy.swt_widget.selectAll
+          end
+        end
+
+        content { 
+          @table_editor_widget_proxy = TableProxy::editors[editor_widget][:editor_gui].call(editor_widget_args, model, model_editing_property, self)
         }
-        @table_editor.setEditor(@table_editor_text_proxy.swt_widget, table_item, column_index)
+        @table_editor.setEditor(@table_editor_widget_proxy.swt_widget, table_item, column_index)
+      rescue => e
+        Glimmer::Config.logger.error {e.full_message}
+        raise e
       end
       
       def add_listener(underscored_listener_name, &block)