glimmer-dsl-swt 0.1.0

data/lib/glimmer/swt/message_box_proxy.rb

@@ -0,0 +1,48 @@
+require 'glimmer/swt/swt_proxy'
+require 'glimmer/swt/widget_proxy'
+require 'glimmer/swt/display_proxy'
+require 'glimmer/swt/shell_proxy'
+
+module Glimmer
+  module SWT
+    # Proxy for org.eclipse.swt.widgets.Shell
+    #
+    # Follows the Proxy Design Pattern
+    class MessageBoxProxy
+      include_package 'org.eclipse.swt.widgets'
+      
+      attr_reader :swt_widget
+      
+      def initialize(parent, style)
+        parent = parent.swt_widget if parent.respond_to?(:swt_widget) && parent.swt_widget.is_a?(Shell)
+        @swt_widget = MessageBox.new(parent, style)
+      end
+      
+      def open
+        @swt_widget.open
+      end
+      
+      # TODO refactor the following methods to put in a JavaBean mixin or somethin (perhaps contribute to OSS project too)
+      
+      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
+      
+      def has_attribute?(attribute_name, *args)
+        @swt_widget.respond_to?(attribute_setter(attribute_name), args)
+      end
+
+      def set_attribute(attribute_name, *args)
+        @swt_widget.send(attribute_setter(attribute_name), *args) unless @swt_widget.send(attribute_getter(attribute_name)) == args.first
+      end
+
+      def get_attribute(attribute_name)
+        @swt_widget.send(attribute_getter(attribute_name))
+      end      
+    end
+  end
+end

data/lib/glimmer/swt/packages.rb

@@ -0,0 +1,13 @@
+module Glimmer
+  module SWT
+    # This contains Java imports of SWT Java packages
+    module Packages
+      include_package 'org.eclipse.swt'
+      include_package 'org.eclipse.swt.widgets'
+      include_package 'org.eclipse.swt.layout'
+      include_package 'org.eclipse.swt.graphics'
+      include_package 'org.eclipse.swt.browser'
+      include_package 'org.eclipse.swt.custom'
+    end
+  end
+end

data/lib/glimmer/swt/shell_proxy.rb

@@ -0,0 +1,152 @@
+require 'glimmer/swt/swt_proxy'
+require 'glimmer/swt/widget_proxy'
+require 'glimmer/swt/display_proxy'
+require 'glimmer/swt/swt_proxy'
+
+module Glimmer
+  module SWT
+    # Proxy for org.eclipse.swt.widgets.Shell
+    #
+    # Follows the Proxy Design Pattern
+    class ShellProxy < WidgetProxy
+      include_package 'org.eclipse.swt.widgets'
+      include_package 'org.eclipse.swt.layout'
+
+      WIDTH_MIN = 130
+      HEIGHT_MIN = 0
+
+      attr_reader :opened_before
+      alias opened_before? opened_before
+
+      # Instantiates ShellProxy with same arguments expected by SWT Shell
+      # if swt_widget keyword arg was passed, then it is assumed the shell has already been instantiated
+      # and the proxy wraps it instead of creating a new one.
+      def initialize(*args, swt_widget: nil)
+        if swt_widget
+          @swt_widget = swt_widget
+        else
+          if args.first.is_a?(ShellProxy)
+            args[0] = args[0].swt_widget
+          end
+          style_args = args.select {|arg| arg.is_a?(Symbol) || arg.is_a?(String)}
+          if style_args.any?
+            style_arg_start_index = args.index(style_args.first)
+            style_arg_last_index = args.index(style_args.last)
+            args[style_arg_start_index..style_arg_last_index] = SWTProxy[style_args]
+          end
+          if args.first.nil? || (!args.first.is_a?(Display) && !args.first.is_a?(Shell))
+            @display = DisplayProxy.instance.swt_display
+            args = [@display] + args
+          end
+          args = args.compact
+          @swt_widget = Shell.new(*args)
+          @swt_widget.setLayout(FillLayout.new)
+          @swt_widget.setMinimumSize(WIDTH_MIN, HEIGHT_MIN)
+          on_event_show do
+            Thread.new do      
+              sleep(0.25)
+              async_exec do
+                @swt_widget.setActive unless @swt_widget.isDisposed
+              end
+            end
+          end
+        end
+        @display ||= @swt_widget.getDisplay
+      end
+
+      # Centers shell within monitor it is in
+      def center
+        primary_monitor = @display.getPrimaryMonitor()
+        monitor_bounds = primary_monitor.getBounds()
+        shell_bounds = @swt_widget.getBounds()
+        location_x = monitor_bounds.x + (monitor_bounds.width - shell_bounds.width) / 2
+        location_y = monitor_bounds.y + (monitor_bounds.height - shell_bounds.height) / 2
+        @swt_widget.setLocation(location_x, location_y)
+      end
+
+      # Opens shell and starts SWT's UI thread event loop
+      def open
+        if @opened_before
+          @swt_widget.setVisible(true)
+          # notify_observers('visible')
+        else
+          @opened_before = true
+          @swt_widget.pack
+          center
+          @swt_widget.open
+          start_event_loop
+        end
+      end
+      alias show open
+
+      def hide
+        @swt_widget.setVisible(false)
+      end
+
+      def close
+        @swt_widget.close
+      end
+
+      def visible?
+        @swt_widget.isDisposed ? false : @swt_widget.isVisible
+      end
+
+      # Setting to true opens/shows shell. Setting to false hides the shell.
+      def visible=(visibility)
+        visibility ? show : hide
+      end
+
+      def pack
+        @swt_widget.pack
+      end
+
+      def pack_same_size
+        bounds = @swt_widget.getBounds
+        if OS.mac?
+          @swt_widget.pack
+          @swt_widget.setBounds(bounds)
+        elsif OS.windows? || OS::Underlying.windows?
+          minimum_size = @swt_widget.getMinimumSize
+          @swt_widget.setMinimumSize(bounds.width, bounds.height)
+          listener = on_control_resized { @swt_widget.setBounds(bounds) }
+          @swt_widget.pack
+          @swt_widget.removeControlListener(listener.swt_listener)
+          @swt_widget.setMinimumSize(minimum_size)
+        elsif OS.linux?          
+          @swt_widget.layout(true, true)
+          @swt_widget.setBounds(bounds)
+        end
+      end
+
+      def content(&block)
+        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::ShellExpression.new, &block)
+      end
+
+      # (happens as part of `#open`)
+      # Starts SWT Event Loop.
+      #
+      # You may learn more about the SWT Event Loop here:
+      # https://help.eclipse.org/2019-12/nftopic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/widgets/Display.html
+      # 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
+        end
+      end
+
+      def add_observer(observer, property_name)
+        case property_name.to_s
+        when 'visible?' #TODO see if you must handle non-? version and/or move elsewhere
+          visibility_notifier = proc do
+            observer.call(visible?)
+          end
+          on_event_show(&visibility_notifier)
+          on_event_hide(&visibility_notifier)
+          on_event_close(&visibility_notifier)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/swt/swt_proxy.rb

@@ -0,0 +1,106 @@
+require 'glimmer/error'
+
+module Glimmer
+  module SWT # TODO Consider making this the class below to ease calling it
+    # Proxy for org.eclipse.swt.SWT
+    #
+    # Follows the Proxy Design Pattern
+    class SWTProxy
+      class << self
+        java_import 'org.eclipse.swt.SWT'
+
+        ERROR_INVALID_STYLE = " is an invalid SWT style! Please choose a style from org.eclipse.swt.SWT class constants."
+        REGEX_SYMBOL_NEGATIVITY = /^([^!]+)(!)?$/
+
+        # Gets SWT constants as if calling SWT::CONSTANT where constant is
+        # passed in as a lower case symbol
+        def [](*symbols)
+          symbols = symbols.first if symbols.size == 1 && symbols.first.is_a?(Array)
+          result = symbols.compact.map do |symbol|
+            constant(symbol).tap do |constant_value|
+              raise Error, symbol.to_s + ERROR_INVALID_STYLE unless constant_value.is_a?(Integer)
+            end
+          end.reduce do |output, constant_value|
+            if constant_value < 0
+              output & constant_value
+            else
+              output | constant_value
+            end
+          end
+          result.nil? ? SWT::NONE : result
+        end
+
+        # Returns SWT style integer value for passed in symbol or allows
+        # passed in object to pass through (e.g. Integer). This makes is convenient
+        # to use symbols or actual SWT style integers in Glimmer
+        # Does not raise error for invalid values. Just lets them pass as is.
+        # (look into [] operator if you want an error raised on invalid values)
+        def constant(symbol)
+          return symbol unless symbol.is_a?(Symbol) || symbol.is_a?(String)
+          symbol_string, negative = extract_symbol_string_negativity(symbol)
+          swt_constant_symbol = symbol_string.downcase == symbol_string ? symbol_string.upcase.to_sym : symbol_string.to_sym
+          bit_value = SWT.const_get(swt_constant_symbol)
+          negative ? ~bit_value : bit_value
+        rescue => e
+          begin
+#             Glimmer::Config.logger&.debug(e.full_message)
+            alternative_swt_constant_symbol = SWT.constants.find {|c| c.to_s.upcase == swt_constant_symbol.to_s.upcase}
+            bit_value = SWT.const_get(alternative_swt_constant_symbol)
+            negative ? ~bit_value : bit_value
+          rescue => e
+#             Glimmer::Config.logger&.debug(e.full_message)
+            bit_value = Glimmer::SWT::SWTProxy::EXTRA_STYLES[swt_constant_symbol]
+            if bit_value
+              negative ? ~bit_value : bit_value
+            else
+              symbol
+            end
+          end
+        end
+
+        def extract_symbol_string_negativity(symbol)
+          if symbol.is_a?(Symbol) || symbol.is_a?(String)
+            symbol_negativity_match = symbol.to_s.match(REGEX_SYMBOL_NEGATIVITY)
+            symbol = symbol_negativity_match[1]
+            negative = !!symbol_negativity_match[2]
+            [symbol, negative]
+          else
+            negative = symbol < 0
+            [symbol, negative]
+          end
+         end
+
+        def negative?(symbol)
+          extract_symbol_string_negativity(symbol)[1]
+        end
+
+        def has_constant?(symbol)
+          return false unless symbol.is_a?(Symbol) || symbol.is_a?(String)
+          constant(symbol).is_a?(Integer)
+        end
+
+        def constantify_args(args)
+          args.map {|arg| constant(arg)}
+        end
+
+        # Deconstructs a style integer into symbols
+        # Useful for debugging
+        def deconstruct(integer)
+          SWT.constants.reduce([]) do |found, c|
+            constant_value = SWT.const_get(c) rescue -1
+            is_found = constant_value.is_a?(Integer) && (constant_value & integer) == constant_value
+            is_found ? found += [c] : found
+          end
+        end
+
+        def include?(swt_constant, *symbols)
+          swt_constant & self[symbols] == self[symbols]
+        end
+      end
+
+      EXTRA_STYLES = {
+        NO_RESIZE: self[:shell_trim, :resize!, :max!]
+      }
+    end
+  end
+end

data/lib/glimmer/swt/tab_item_proxy.rb

@@ -0,0 +1,65 @@
+require 'glimmer/swt/widget_proxy'
+
+module Glimmer
+  module SWT
+    # Proxy for org.eclipse.swt.widgets.TabItem
+    #
+    # Functions differently from other widget proxies.
+    #
+    # Glimmer instantiates an SWT Composite alongside the SWT TabItem
+    # and returns it for `#swt_widget` to allow adding widgets into it.
+    #
+    # In order to get the SWT TabItem object, one must call `#swt_tab_item`.
+    #
+    # Behind the scenes, this creates a tab item widget proxy separately from a composite that
+    # is set as the control of the tab item and `#swt_widget`.
+    #
+    # In order to retrieve the tab item widget proxy, one must call `#widget_proxy`
+    #
+    # Follows the Proxy Design Pattern
+    class TabItemProxy < WidgetProxy
+      include_package 'org.eclipse.swt.widgets'
+
+      attr_reader :widget_proxy, :swt_tab_item
+
+      def initialize(parent, style, &contents)
+        super("composite", parent, style, &contents)
+        @widget_proxy = SWT::WidgetProxy.new('tab_item', parent, style)
+        @swt_tab_item = @widget_proxy.swt_widget
+        @widget_proxy.swt_widget.control = self.swt_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)
+        attribute_name
+        if attribute_name.to_s == "text"
+          text_value = args[0]
+          @swt_tab_item.setText text_value
+        else
+          super(attribute_name, *args)
+        end
+      end
+
+      def get_attribute(attribute_name)
+        if attribute_name.to_s == "text"
+          @swt_tab_item.getText
+        else
+          super(attribute_name)
+        end
+      end
+      
+      def dispose
+        swt_tab_item.setControl(nil)
+        swt_widget.dispose
+        swt_tab_item.dispose
+      end
+    end
+  end
+end

data/lib/glimmer/swt/table_proxy.rb

@@ -0,0 +1,150 @@
+require 'glimmer/swt/widget_proxy'
+
+module Glimmer
+  module SWT
+    class TableProxy < Glimmer::SWT::WidgetProxy
+      include Glimmer
+      
+      module TableListenerEvent        
+        def table_item
+          table_item_and_column_index[:table_item]
+        end
+        
+        def column_index
+          table_item_and_column_index[:column_index]
+        end     
+        
+        private
+        
+        def table_item_and_column_index
+          @table_item_and_column_index ||= find_table_item_and_column_index
+        end
+        
+        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|
+                  ti.getBounds(ci).contains(x, y)
+                end
+              end
+            end
+          end
+        end   
+      end
+      
+      attr_reader :table_editor, :table_editor_text_proxy
+      attr_accessor :column_properties
+      
+      def initialize(underscored_widget_name, parent, args)
+        super
+        @table_editor = TableEditor.new(swt_widget)
+        @table_editor.horizontalAlignment = SWTProxy[:left]
+        @table_editor.grabHorizontal = true
+        @table_editor.minimumHeight = 20
+      end
+    
+      # Performs a search for table items matching block condition
+      # If no condition block is passed, returns all table items
+      # Returns a Java TableItem array to easily set as selection on org.eclipse.swt.Table if needed
+      def search(&condition)
+        swt_widget.getItems.select {|item| condition.nil? || condition.call(item)}.to_java(TableItem)
+      end
+      
+      # Returns all table items including descendants
+      def all_table_items
+        search
+      end
+
+      def widget_property_listener_installers
+        super.merge({
+          Java::OrgEclipseSwtWidgets::Table => {
+            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_table_item(column_index, before_write: nil, after_write: nil, after_cancel: nil)
+        edit_table_item(swt_widget.getSelection.first, column_index, before_write: before_write, after_write: after_write, after_cancel: after_cancel)
+      end
+            
+      def edit_table_item(table_item, column_index, before_write: nil, after_write: nil, after_cancel: nil)
+        return if table_item.nil?
+        content {
+          @table_editor_text_proxy = text {
+            focus true
+            text table_item.getText(column_index)
+            action_taken = false
+            cancel = lambda {
+              @table_editor_text_proxy.swt_widget.dispose
+              @table_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 = @table_editor_text_proxy.swt_widget.getText
+                if new_text == table_item.getText(column_index)
+                  cancel.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
+            }
+            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
+            }
+          }
+          @table_editor_text_proxy.swt_widget.selectAll
+        }
+        @table_editor.setEditor(@table_editor_text_proxy.swt_widget, table_item, column_index)
+      end
+      
+      def add_listener(underscored_listener_name, &block)
+        enhanced_block = lambda do |event|
+          event.extend(TableListenerEvent)
+          block.call(event)
+        end
+        super(underscored_listener_name, &enhanced_block)
+      end
+            
+      private
+
+      def property_type_converters
+        super.merge({
+          selection: lambda do |value|
+            if value.is_a?(Array)
+              search {|ti| value.include?(ti.getData) }
+            else
+              search {|ti| ti.getData == value}
+            end
+          end,
+        })
+      end
+    end
+  end
+end