glimmer 0.8.2 → 0.9.0

data/lib/glimmer/swt/message_box_proxy.rb

@@ -1,48 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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