glimmer-dsl-swt 0.1.0

data/lib/glimmer/swt/color_proxy.rb

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

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

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

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

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

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