glimmer 0.7.8 → 0.9.1

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,170 +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
-      OBSERVED_MENU_ITEMS = ['about', 'preferences']
-
-      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
-        width = @swt_widget.getBounds.width
-        height = @swt_widget.getBounds.height
-        x = @swt_widget.getBounds.x
-        y = @swt_widget.getBounds.y
-        @swt_widget.pack
-        @swt_widget.setSize(width, height)
-        @swt_widget.setLocation(x, y)
-      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 can_handle_observation_request?(observation_request)
-        result = false
-        if observation_request.start_with?('on_')
-          event_name = observation_request.sub(/^on_/, '')
-          result = OBSERVED_MENU_ITEMS.include?(event_name)
-        end
-        result || super
-      end
-
-      def handle_observation_request(observation_request, &block)
-        if observation_request.start_with?('on_')
-          event_name = observation_request.sub(/^on_/, '')
-          if OBSERVED_MENU_ITEMS.include?(event_name)
-            if OS.mac?
-              system_menu = DisplayProxy.instance.swt_display.getSystemMenu
-              menu_item = system_menu.getItems.find {|menu_item| menu_item.getID == SWTProxy["ID_#{event_name.upcase}"]}
-              menu_item.addListener(SWTProxy[:Selection], &block)
-            end
-          else
-            super
-          end
-        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/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