glimmer 0.4.9 → 0.5.0

data/lib/glimmer/dsl/tree_properties_expression.rb

@@ -0,0 +1,24 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/data_binding/model_binding'
+require 'glimmer/data_binding/tree_items_binding'
+
+module Glimmer
+  module DSL
+    # Responsible for providing a readable keyword (command symbol) to capture
+    # and return tree properties for use in TreeItemsDataBindingCommandHandler
+    class TreePropertiesExpression < StaticExpression
+      include_package 'org.eclipse.swt.widgets'
+
+      def can_interpret?(parent, keyword, *args, &block)
+        keyword == "tree_properties" and
+          block.nil? and
+          widget?(parent) and
+          parent.swt_widget.is_a?(Tree)
+      end
+
+      def interpret(parent, keyword, *args, &block)
+        args
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/widget_expression.rb

@@ -0,0 +1,26 @@
+require 'glimmer'
+require 'glimmer/dsl/expression'
+require 'glimmer/dsl/parent_expression'
+
+module Glimmer
+  module DSL
+    class WidgetExpression < Expression
+      include ParentExpression
+      
+      EXCLUDED_KEYWORDS = %w[shell display tab_item]
+
+      def can_interpret?(parent, keyword, *args, &block)
+        !EXCLUDED_KEYWORDS.include?(keyword) and
+          widget?(parent) and
+          SWT::WidgetProxy.widget_exists?(keyword)
+      end
+
+      def interpret(parent, keyword, *args, &block)
+        Glimmer.logger.debug "widget styles are: " + args.inspect
+        SWT::WidgetProxy.new(keyword, parent, args)
+      end
+    end
+  end
+end
+
+require 'glimmer/swt/widget_proxy'

data/lib/glimmer/dsl/widget_listener_expression.rb

@@ -0,0 +1,27 @@
+require 'glimmer/dsl/expression'
+
+module Glimmer
+  module DSL
+    class WidgetListenerExpression < Expression
+      include_package 'org.eclipse.swt.widgets'
+
+      def can_interpret?(parent, keyword, *args, &block)
+        Glimmer.logger.debug "keyword starts with on_: #{keyword.start_with?('on_')}"
+        return unless keyword.start_with?('on_')
+        Glimmer.logger.debug "block exists?: #{!block.nil?}"
+        return unless !block.nil?
+        widget_parentage = widget?(parent)
+        Glimmer.logger.debug "parent is a widget: #{widget_parentage}"
+        return unless widget_parentage
+        Glimmer.logger.debug "args are empty?: #{args.empty?}"
+        return unless args.empty?
+        result = parent.can_handle_observation_request?(keyword)
+        Glimmer.logger.debug "can add listener? #{result}"
+      end
+
+      def interpret(parent, keyword, *args, &block)
+        parent.handle_observation_request(keyword, &block)
+      end
+    end
+  end
+end

data/lib/glimmer/error.rb

@@ -0,0 +1,6 @@
+module Glimmer
+  # Represents Glimmer errors that occur due to invalid use of Glimmer
+  # without handing control flow back to original method_missing
+  class Error < RuntimeError
+  end
+end

data/lib/glimmer/invalid_keyword_error.rb

@@ -0,0 +1,6 @@
+module Glimmer
+  # Represents Glimmer errors that occur due to invalid use of Glimmer
+  # without handing control flow back to original method_missing
+  class InvalidKeywordError < RuntimeError
+  end
+end

data/lib/glimmer/launcher.rb

@@ -4,17 +4,21 @@ module Glimmer
   class Launcher
     OPERATING_SYSTEMS_SUPPORTED = ["mac", "windows", "linux"]
     TEXT_USAGE = <<-MULTILINE
-  Usage: glimmer application.rb
+  Usage: glimmer [[-jruby-option]...] application.rb [[application2.rb]...]
 
-  Runs a Glimmer application using JRuby, automatically preloading
+  Runs Glimmer applications using JRuby, automatically preloading
   the glimmer ruby gem and SWT jar dependency.
 
-  Example: glimmer hello_world.rb
-  This runs the Glimmer application hello_world.rb
+  Optionally, JRuby options may be passed in.
+
+  Example: glimmer samples/hello_world.rb
+  This runs the Glimmer application samples/hello_world.rb
     MULTILINE
     GLIMMER_LIB_LOCAL = File.expand_path(File.join(__FILE__, '..', '..', 'glimmer.rb'))
     GLIMMER_LIB_GEM = 'glimmer'
 
+    @@mutex = Mutex.new
+
     class << self
       def platform_os
         OPERATING_SYSTEMS_SUPPORTED.detect {|os| OS.send("#{os}?")}
@@ -32,40 +36,52 @@ module Glimmer
         "#{jruby_os_specific_options} -J-classpath \"#{swt_jar_file}\""
       end
 
-      def launch(application, dev_mode = false, debug_mode = false)
-        glimmer_lib = GLIMMER_LIB_GEM
-        if dev_mode
-          glimmer_lib = GLIMMER_LIB_LOCAL
-          puts "[DEVELOPMENT MODE] (#{glimmer_lib})"
-        end
-        debug_option = ''
-        if debug_mode
-          debug_option = '--debug '
-          puts "[DEBUG MODE]"
+      def glimmer_lib
+        @@mutex.synchronize do
+          unless @glimmer_lib
+            @glimmer_lib = GLIMMER_LIB_GEM
+            glimmer_gem_listing = `jgem list #{GLIMMER_LIB_GEM}`
+            if !glimmer_gem_listing.include?(GLIMMER_LIB_GEM) && File.exists?(GLIMMER_LIB_LOCAL)
+              @glimmer_lib = GLIMMER_LIB_LOCAL
+              puts "[DEVELOPMENT MODE] (detected #{@glimmer_lib})"
+            end
+          end
         end
-        system "jruby #{debug_option}#{jruby_swt_options} -r #{glimmer_lib} -S #{application}"
+        @glimmer_lib
+      end
+
+      def launch(application, options = [])
+        options_string = options.join(' ') + ' ' if options.any?
+        system "jruby #{options_string}#{jruby_swt_options} -r #{glimmer_lib} -S #{application}"
       end
     end
 
     def initialize(options)
-      @dev_mode = !!options.delete('--dev')
-      @debug_mode = !!options.delete('--debug')
-      @application_path = options.first
+      @application_paths = options.select {|option| !option.start_with?('-')}
+      @application_paths.each do |application_path|
+        options.delete(application_path)
+      end
+      @options = options
     end
 
     def launch
-      if @application_path
-        launch_application
-      else
+      if @application_paths.empty?
         display_usage
+      else
+        launch_application
       end
     end
 
     private
 
     def launch_application
-      puts "Launching Glimmer Application: #{@application_path}" unless @application_path == 'irb'
-      self.class.launch(@application_path, @dev_mode, @debug_mode)
+      threads = @application_paths.map do |application_path|
+        puts "Launching Glimmer Application: #{application_path}" unless application_path.to_s.include?('irb')
+        Thread.new do
+          self.class.launch(application_path, @options)
+        end
+      end
+      threads.each(&:join)
     end
 
     def display_usage

data/lib/glimmer/swt/color_proxy.rb

@@ -0,0 +1,48 @@
+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'
+
+      attr_reader :swt_color
+
+      # 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)
+        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
+    end
+  end
+end

data/lib/glimmer/swt/display_proxy.rb

@@ -0,0 +1,49 @@
+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'
+
+      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
+    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,73 @@
+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.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)
+        @swt_layout_data.send(attribute_setter(attribute_name), *args)
+      end
+
+      def attribute_setter(attribute_name)
+        "#{attribute_name.to_s.camelcase(:lower)}="
+      end
+    end
+  end
+end

data/lib/glimmer/swt/{g_layout.rb → layout_proxy.rb}

@@ -1,18 +1,20 @@
-require_relative '../parent'
-require_relative 'g_swt'
+require 'glimmer'
+require 'glimmer/swt/swt_proxy'
 
 module Glimmer
   module SWT
-    class GLayout
-      include_package 'org.eclipse.swt.layout'
-
-      include Parent
-
-      attr_reader :composite
-      attr_reader :layout
+    # 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
@@ -23,44 +25,41 @@ module Glimmer
           end
         end
 
-        # This supports layouts in and out of basic SWT
+        # 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?(org.eclipse.swt.widgets.Layout)
+          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.logger.debug "#{e.message}\n#{e.backtrace.join("\n")}"
+          Glimmer.logger.debug e.message
+          # Glimmer.logger.debug "#{e.message}\n#{e.backtrace.join("\n")}"
           raise e
         end
       end
 
-      def initialize(underscored_layout_name, composite, args)
+      def initialize(underscored_layout_name, widget_proxy, args)
         @underscored_layout_name = underscored_layout_name
-        @composite = composite
-        args = GSWT.constantify_args(args)
-        @layout = self.class.swt_layout_class_for(underscored_layout_name).new(*args)
-        @composite.setLayout(@layout)
-      end
-
-      def process_block(block)
-        block.call(self)
+        @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)
-        @layout.respond_to?(attribute_setter(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)
-        @layout.send(attribute_setter(attribute_name), *args)
+        @swt_layout.send(attribute_setter(attribute_name), *args)
       end
 
       def apply_property_type_converters(attribute_name, args)
-        if args.count == 1 && GSWT.has_constant?(args.first)
-          args[0] = GSWT.constant(args.first)
+        if args.count == 1 && SWTProxy.has_constant?(args.first)
+          args[0] = SWTProxy.constant(args.first)
         end
       end