glimmer 0.8.2 → 0.9.4

data/lib/glimmer/swt/color_proxy.rb

@@ -1,53 +0,0 @@
-require 'glimmer/swt/swt_proxy'
-require 'glimmer/swt/display_proxy'
-
-module Glimmer
-  module SWT
-    # Proxy for org.eclipse.swt.graphics.Color
-    #
-    # Invoking `#swt_color` returns the SWT color object wrapped by this proxy
-    #
-    # Follows the Proxy Design Pattern
-    class ColorProxy
-      include_package 'org.eclipse.swt.graphics'
-
-      # Initializes a proxy for an SWT Color object
-      #
-      # Takes a standard color single argument, rgba 3 args, or rgba 4 args
-      #
-      # A standard color is a string/symbol representing one of the
-      # SWT.COLOR_*** constants like SWT.COLOR_RED, but in underscored string
-      # format (e.g :color_red).
-      # Glimmer can also accept standard color names without the color_ prefix,
-      # and it will automatically figure out the SWT.COLOR_*** constant
-      # (e.g. :red)
-      #
-      # rgb is 3 arguments representing Red, Green, Blue numeric values
-      #
-      # rgba is 4 arguments representing Red, Green, Blue, and Alpha numeric values
-      #
-      def initialize(*args)
-        @args = args
-      end
-
-      def swt_color
-        unless @swt_color
-          case @args.size
-          when 1
-            if @args.first.is_a?(String) || @args.first.is_a?(Symbol)
-              standard_color = @args.first
-              standard_color = "color_#{standard_color}".to_sym unless standard_color.to_s.downcase.include?('color_')
-              @swt_color = DisplayProxy.instance.swt_display.getSystemColor(SWTProxy[standard_color])
-            else
-              @swt_color = @args.first
-            end
-          when 3..4
-            red, green, blue, alpha = @args
-            @swt_color = Color.new(DisplayProxy.instance.swt_display, *[red, green, blue, alpha].compact)
-          end
-        end
-        @swt_color
-      end
-    end
-  end
-end

data/lib/glimmer/swt/display_proxy.rb

@@ -1,88 +0,0 @@
-require 'glimmer/swt/widget_listener_proxy'
-
-module Glimmer
-  module SWT
-    # Proxy for org.eclipse.swt.widgets.Display
-    #
-    # Maintains a singleton instance since SWT only supports
-    # a single active display at a time.
-    #
-    # Supports SWT Display's very useful asyncExec and syncExec methods
-    # to support proper multi-threaded manipulation of SWT UI objects
-    #
-    # Invoking `#swt_display` returns the SWT Display object wrapped by this proxy
-    #
-    # Follows the Proxy Design Pattern
-    class DisplayProxy
-      include_package 'org.eclipse.swt.widgets'
-
-      OBSERVED_MENU_ITEMS = ['about', 'preferences']
-
-      class << self
-        # Returns singleton instance
-        def instance(*args)
-          if @instance.nil? || @instance.swt_display.isDisposed
-            @instance = new(*args)
-          end
-          @instance
-        end
-      end
-
-      # SWT Display object wrapped
-      attr_reader :swt_display
-
-      def initialize(*args)
-        @swt_display = Display.new(*args)
-      end
-
-      def dispose
-        @swt_display.dispose
-      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)
-      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_/, '')
-          SWTProxy.has_constant?(constant_name)
-        elsif observation_request.start_with?('on_')
-          event_name = observation_request.sub(/^on_/, '')
-          OBSERVED_MENU_ITEMS.include?(event_name)
-        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_name = observation_request.sub(/^on_/, '')
-          if OBSERVED_MENU_ITEMS.include?(event_name)
-            if OS.mac?
-              system_menu = 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
-          end
-        end
-      end
-
-      def add_swt_event_listener(swt_constant, &block)
-        event_type = SWTProxy[swt_constant]
-        @swt_display.addFilter(event_type, &block)
-        #WidgetListenerProxy.new(@swt_display.getListeners(event_type).last)
-      end
-    end
-  end
-end

data/lib/glimmer/swt/font_proxy.rb

@@ -1,72 +0,0 @@
-require 'glimmer/error'
-require 'glimmer/swt/swt_proxy'
-require 'glimmer/swt/display_proxy'
-
-module Glimmer
-  module SWT
-    # Proxy for org.eclipse.swt.graphics.Font
-    #
-    # This class is meant to be used with WidgetProxy to manipulate
-    # an SWT widget font.
-    #
-    # It is not meant to create new SWT fonts form scratch without
-    # a widget proxy.
-    #
-    # Invoking `#swt_font` returns the SWT Font object wrapped by this proxy
-    #
-    # Follows the Proxy Design Pattern
-    class FontProxy
-      ERROR_INVALID_FONT_STYLE = " is an invalid font style! Valid values are :normal, :bold, and :italic"
-      FONT_STYLES = [:normal, :bold, :italic]
-
-      include_package 'org.eclipse.swt.graphics'
-
-      attr_reader :widget_proxy, :swt_font
-
-      # Builds a new font proxy from passed in widget_proxy and font_properties hash,
-      #
-      # It begins with existing SWT widget font and amends it with font properties.
-      #
-      # Font properties consist of: :name, :height, and :style (one needed minimum)
-      #
-      # Style (:style value) can only be one of FontProxy::FONT_STYLES values:
-      # that is :normal, :bold, or :italic
-      def initialize(widget_proxy, font_properties)
-        @widget_proxy = widget_proxy
-        detect_invalid_font_property(font_properties)
-        font_properties[:style] = SWTProxy[*font_properties[:style]]
-        font_data_args = [:name, :height, :style].map do |font_property_name|
-          font_properties[font_property_name] || send(font_property_name)
-        end
-        font_datum = FontData.new(*font_data_args)
-        @swt_font = Font.new(DisplayProxy.instance.swt_display, font_datum)
-      end
-
-      def name
-        font_datum.getName
-      end
-
-      def height
-        font_datum.getHeight
-      end
-
-      def style
-        font_datum.getStyle
-      end
-
-      private
-
-      def font_datum
-        @font_datum ||= @widget_proxy.swt_widget.getFont.getFontData[0]
-      end
-
-      def detect_invalid_font_property(font_properties)
-        [font_properties[:style]].flatten.select do |style|
-          style.is_a?(Symbol) || style.is_a?(String)
-        end.each do |style|
-          raise Error, style.to_s + ERROR_INVALID_FONT_STYLE if !FONT_STYLES.include?(style.to_sym)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/swt/layout_data_proxy.rb

@@ -1,84 +0,0 @@
-require 'glimmer'
-require 'glimmer/swt/swt_proxy'
-
-module Glimmer
-  module SWT
-    # Generic proxy for all SWT layout data objects, such as GridData & RowData
-    #
-    # This class is meant to be used with an existing WidgetProxy
-    # as it figures out the right SWT layout data class name
-    # by convention from the parent SWT widget layout class name
-    #
-    # The convention is:
-    # - Start with the parent widget layout package/class name (e.g. org.eclipse.swt.layout.RowLayout)
-    # - Replace the word "Layout" with "Data" in the class name
-    #
-    # Examples of figuring out SWT layout data class:
-    # - org.eclipse.swt.layout.RowData for org.eclipse.swt.layout.RowLayout
-    # - org.eclipse.swt.layout.GridData for org.eclipse.swt.layout.GridLayout
-    #
-    # Follows the Proxy Design Pattern
-    class LayoutDataProxy
-      include_package 'org.eclipse.swt.layout'
-
-      attr_reader :widget_proxy
-      attr_reader :swt_layout_data
-
-      # Inititalizes with owning widget proxy and layout data arguments
-      def initialize(widget_proxy, args)
-        @widget_proxy = widget_proxy
-        args = SWTProxy.constantify_args(args)
-        begin
-          @swt_layout_data = swt_layout_data_class.new(*args)
-        rescue => e
-          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)
-      end
-
-      # This figures out the right SWT layout data class name
-      # by convention from the parent SWT widget layout class name
-      #
-      # Supports layout data classes in and out of basic SWT library
-      #
-      # The convention is:
-      # - Start with the parent widget layout package/class name (e.g. org.eclipse.swt.layout.RowLayout)
-      # - Replace the word "Layout" with "Data" in the class name
-      #
-      # Examples of figuring out SWT layout data class:
-      # - org.eclipse.swt.layout.RowData for org.eclipse.swt.layout.RowLayout
-      # - org.eclipse.swt.layout.GridData for org.eclipse.swt.layout.GridLayout
-      #
-      def swt_layout_data_class
-        parent_layout_class_name = @widget_proxy.swt_widget.getParent.getLayout.class.name
-        layout_data_class_name = parent_layout_class_name.sub(/Layout$/, 'Data')
-        eval(layout_data_class_name)
-      end
-
-      def has_attribute?(attribute_name, *args)
-        @swt_layout_data.respond_to?(attribute_setter(attribute_name), args)
-      end
-
-      def set_attribute(attribute_name, *args)
-        args = SWTProxy.constantify_args(args)
-        if args.first != @swt_layout_data.send(attribute_getter(attribute_name))
-          @swt_layout_data.send(attribute_setter(attribute_name), *args)
-          @widget_proxy.swt_widget.getShell.pack
-        end
-      end
-
-      def get_attribute(attribute_name)
-        @swt_layout_data.send(attribute_getter(attribute_name))
-      end
-
-      def attribute_setter(attribute_name)
-        "#{attribute_name.to_s.camelcase(:lower)}="
-      end
-
-      def attribute_getter(attribute_name)
-        "#{attribute_name.to_s.camelcase(:lower)}"
-      end
-    end
-  end
-end

data/lib/glimmer/swt/layout_proxy.rb

@@ -1,82 +0,0 @@
-require 'glimmer'
-require 'glimmer/swt/swt_proxy'
-
-module Glimmer
-  module SWT
-    # Proxy for org.eclipse.swt.widgets.Layout
-    #
-    # This is meant to be used with a WidgetProxy where it will
-    # set the layout in the SWT widget upon instantiation.
-    #
-    # Follows the Proxy Design Pattern
-    class LayoutProxy
-      attr_reader :widget_proxy, :swt_layout
-
-      class << self
-        include_package 'org.eclipse.swt.layout'
-        include_package 'org.eclipse.swt.widgets'
-
-        def layout_exists?(underscored_layout_name)
-          begin
-            swt_layout_class_for(underscored_layout_name)
-            true
-          rescue NameError => e
-            false
-          end
-        end
-
-        # This supports layouts in and out of basic SWT library
-        def swt_layout_class_for(underscored_layout_name)
-          swt_layout_name = underscored_layout_name.camelcase(:upper)
-          swt_layout_class = eval(swt_layout_name)
-          unless swt_layout_class.ancestors.include?(Layout)
-            raise NameError, "Class #{swt_layout_class} matching #{underscored_layout_name} is not a subclass of org.eclipse.swt.widgets.Layout"
-          end
-          swt_layout_class
-        rescue => e
-          Glimmer::Config.logger&.debug e.message
-          # Glimmer::Config.logger&.debug "#{e.message}\n#{e.backtrace.join("\n")}"
-          raise e
-        end
-      end
-
-      def initialize(underscored_layout_name, widget_proxy, args)
-        @underscored_layout_name = underscored_layout_name
-        @widget_proxy = widget_proxy
-        args = SWTProxy.constantify_args(args)
-        @swt_layout = self.class.swt_layout_class_for(underscored_layout_name).new(*args)
-        @widget_proxy.swt_widget.setLayout(@swt_layout)
-      end
-
-      def has_attribute?(attribute_name, *args)
-        @swt_layout.respond_to?(attribute_setter(attribute_name), args)
-      end
-
-      def set_attribute(attribute_name, *args)
-        apply_property_type_converters(attribute_name, args)
-        if args.first != @swt_layout.send(attribute_getter(attribute_name))
-          @swt_layout.send(attribute_setter(attribute_name), *args)
-          @widget_proxy.swt_widget.getShell.pack
-        end
-      end
-
-      def get_attribute(attribute_name)
-        @swt_layout.send(attribute_getter(attribute_name))
-      end
-
-      def apply_property_type_converters(attribute_name, args)
-        if args.count == 1 && SWTProxy.has_constant?(args.first)
-          args[0] = SWTProxy.constant(args.first)
-        end
-      end
-
-      def attribute_setter(attribute_name)
-        "#{attribute_name.to_s.camelcase(:lower)}="
-      end
-
-      def attribute_getter(attribute_name)
-        "#{attribute_name.to_s.camelcase(:lower)}"
-      end
-    end
-  end
-end

data/lib/glimmer/swt/menu_proxy.rb

@@ -1,101 +0,0 @@
-require 'glimmer/swt/widget_proxy'
-
-module Glimmer
-  module SWT
-    # Proxy for org.eclipse.swt.widgets.Menu
-    #
-    # Functions differently from other widget proxies.
-    #
-    # Glimmer automatically detects if this is a drop down menu
-    # or pop up menu from its parent if no SWT style is passed in.
-    #
-    # There are 3 possibilities:
-    # - SWT :bar style is passed in: Menu Bar
-    # - Parent is ShellProxy: Pop Up Menu (having style :pop_up)
-    # - Parent is another Menu: Drop Down Menu (having style :drop_down)
-    #
-    # In order to get the SWT Menu object, one must call `#swt_widget`.
-    #
-    # In the case of a Drop Down menu, this automatically creates an
-    # SWT MenuItem object with style :cascade
-    #
-    # In order to retrieve the menu item widget proxy, one must call `#menu_item_proxy`
-    #
-    # Follows the Proxy Design Pattern
-    class MenuProxy < WidgetProxy
-      include_package 'org.eclipse.swt.widgets'
-
-      attr_reader :menu_item_proxy, :swt_menu_item, :menu_parent
-
-      def initialize(parent, args)
-        index = args.delete(args.last) if args.last.is_a?(Numeric)
-        styles = args.map(&:to_sym)
-        if !styles.include?(:bar) && !parent.swt_widget.is_a?(Menu)
-          styles = styles.unshift(:pop_up)
-        end
-
-        swt_widget_class = self.class.swt_widget_class_for('menu')
-        if parent.swt_widget.is_a?(Menu)
-          @menu_item_proxy = SWT::WidgetProxy.new('menu_item', parent, [:cascade] + [index].compact)
-          @swt_menu_item = @menu_item_proxy.swt_widget
-          @swt_widget = swt_widget_class.new(@menu_item_proxy.swt_widget)
-          @swt_menu_item.setMenu(swt_widget)
-        elsif parent.swt_widget.is_a?(Shell)
-          @swt_widget = swt_widget_class.new(parent.swt_widget, style('menu', styles))
-        else
-          @swt_widget = swt_widget_class.new(parent.swt_widget)
-        end
-        DEFAULT_INITIALIZERS['menu']&.call(swt_widget)
-
-        if styles.include?(:bar)
-          parent.swt_widget.setMenuBar(swt_widget)
-        elsif styles.include?(:pop_up)
-          parent.swt_widget.setMenu(swt_widget)
-        end
-      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_menu_item.setText text_value
-        else
-          super(attribute_name, *args)
-        end
-      end
-
-      def get_attribute(attribute_name)
-        if attribute_name.to_s == "text"
-          @swt_menu_item.getText
-        else
-          super(attribute_name)
-        end
-      end
-      
-      def can_handle_observation_request?(observation_request, super_only: false)
-        super_result = super(observation_request)
-        if observation_request.start_with?('on_') && !super_result && !super_only
-          return menu_item_proxy.can_handle_observation_request?(observation_request)
-        else
-          super_result
-        end
-      end
-      
-      def handle_observation_request(observation_request, &block)
-        if can_handle_observation_request?(observation_request, super_only: true)
-          super
-        else
-          menu_item_proxy.handle_observation_request(observation_request, &block)
-        end
-      end      
-    end
-  end
-end