glimmer-dsl-swt 4.18.2.4 → 4.18.3.3

data/lib/glimmer/swt/transform_proxy.rb

@@ -0,0 +1,109 @@
+# Copyright (c) 2007-2021 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'glimmer/swt/display_proxy'
+require 'glimmer/swt/properties'
+require 'glimmer/swt/custom/shape'
+
+module Glimmer
+  module SWT
+    # Proxy for org.eclipse.swt.graphics.Transform
+    #
+    # Follows the Proxy Design Pattern
+    class TransformProxy
+      include Properties
+      
+      include_package 'org.eclipse.swt.graphics'
+      include_package 'org.eclipse.swt.widgets'
+      
+      attr_reader :swt_transform, :parent
+      
+      def initialize(parent, *args, swt_transform: nil, multiply: false)
+        @parent = parent
+        @multiply = multiply
+        if swt_transform.nil?
+          if !args.first.is_a?(Display) && !args.first.is_a?(DisplayProxy)
+            args.prepend DisplayProxy.instance.swt_display
+          end
+          if args.first.is_a?(DisplayProxy)
+            args[0] = args[0].swt_display
+          end
+          if args.last.is_a?(TransformProxy)
+            args[-1] = args[-1].swt_transform
+          end
+          if args.last.nil? || args.last.is_a?(Transform)
+            @swt_transform = args.last
+            @parent&.set_attribute('transform', self)
+          else
+            @swt_transform = Transform.new(*args)
+          end
+        else
+          @swt_transform = swt_transform
+        end
+      end
+      
+      def post_add_content
+        if @multiply
+          @parent.multiply(@swt_transform)
+        else
+          @parent&.set_attribute('transform', self)
+        end
+      end
+      
+      def content(&block)
+        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::TransformExpression.new, &block)
+      end
+      
+      def has_attribute?(attribute_name, *args)
+        @swt_transform.respond_to?(attribute_name) || @swt_transform.respond_to?(attribute_setter(attribute_name))
+      end
+
+      def set_attribute(attribute_name, *args)
+        if @swt_transform.respond_to?(attribute_name)
+          @swt_transform.send(attribute_name, *args)
+        elsif @swt_transform.respond_to?(attribute_setter(attribute_name))
+          @swt_transform.send(attribute_setter(attribute_name), *args)
+        end
+      end
+
+      def get_attribute(attribute_name)
+        if @swt_transform.respond_to?(attribute_getter(attribute_name))
+          @swt_transform.send(attribute_getter(attribute_name))
+        else
+          @swt_transform.send(attribute_name)
+        end
+      end
+      
+      def method_missing(method_name, *args, &block)
+        result = @swt_transform.send(method_name, *args, &block)
+        result.nil? ? self : result
+      rescue => e
+        Glimmer::Config.logger.debug {"Neither MessageBoxProxy nor #{@swt_transform.class.name} can handle the method ##{method}"}
+        super
+      end
+      
+      def respond_to?(method, *args, &block)
+        super ||
+          @swt_transform.respond_to?(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/glimmer/swt/widget_listener_proxy.rb

@@ -26,10 +26,12 @@ module Glimmer
     # Follows the Proxy Design Pattern
     class WidgetListenerProxy
 
-      attr_reader :swt_widget, :swt_listener, :widget_add_listener_method, :swt_listener_class, :swt_listener_method, :event_type, :swt_constant
+      attr_reader :swt_widget, :swt_display, :swt_listener, :widget_add_listener_method, :swt_listener_class, :swt_listener_method, :event_type, :swt_constant
 
-      def initialize(swt_widget:, swt_listener:, widget_add_listener_method: nil, swt_listener_class: nil, swt_listener_method: nil, event_type: nil, swt_constant: nil)
+      def initialize(swt_widget:nil, swt_display:nil, swt_listener:, widget_add_listener_method: nil, swt_listener_class: nil, swt_listener_method: nil, event_type: nil, swt_constant: nil, filter: false)
         @swt_widget = swt_widget
+        @swt_display = swt_display
+        @filter = filter
         @swt_listener = swt_listener
         @widget_add_listener_method = widget_add_listener_method
         @swt_listener_class = swt_listener_class
@@ -42,14 +44,21 @@ module Glimmer
         @widget_add_listener_method.sub('add', 'remove')
       end
       
-      def unregister
-        # TODO consider renaming to deregister (and in Observer too)
-        if @event_type
+      def deregister
+        return if @swt_widget&.is_disposed || @swt_display&.is_disposed
+        if @swt_display
+          if @filter
+            @swt_display.removeFilter(@event_type, @swt_listener)
+          else
+            @swt_display.removeListener(@event_type, @swt_listener)
+          end
+        elsif @event_type
           @swt_widget.removeListener(@event_type, @swt_listener)
         else
           @swt_widget.send(widget_remove_listener_method, @swt_listener)
         end
       end
+      alias unregister deregister # TODO consider dropping unregister (and in Observer too)
     end
   end
 end

data/lib/glimmer/swt/widget_proxy.rb

@@ -497,26 +497,37 @@ module Glimmer
 
       # This supports widgets in and out of basic SWT
       def self.swt_widget_class_for(underscored_widget_name)
-        underscored_widget_name = KEYWORD_ALIASES[underscored_widget_name] if KEYWORD_ALIASES[underscored_widget_name]
-        swt_widget_name = underscored_widget_name.camelcase(:upper)
-        swt_widget_class = eval(swt_widget_name)
-        # TODO fix issue with not detecting DateTime because it's conflicting with the Ruby DateTime
-        unless swt_widget_class.ancestors.include?(org.eclipse.swt.widgets.Widget)
-          swt_widget_class = swt_widget_class_manual_entries[underscored_widget_name]
-          if swt_widget_class.nil?
-            Glimmer::Config.logger.debug {"Class #{swt_widget_class} matching #{underscored_widget_name} is not a subclass of org.eclipse.swt.widgets.Widget"}
-            return nil
+        # TODO clear memoization for a keyword if a custom widget was defined with that keyword
+        unless flyweight_swt_widget_classes.keys.include?(underscored_widget_name)
+          begin
+            underscored_widget_name = KEYWORD_ALIASES[underscored_widget_name] if KEYWORD_ALIASES[underscored_widget_name]
+            swt_widget_name = underscored_widget_name.camelcase(:upper)
+            swt_widget_class = eval(swt_widget_name)
+            # TODO fix issue with not detecting DateTime because it's conflicting with the Ruby DateTime
+            unless swt_widget_class.ancestors.include?(org.eclipse.swt.widgets.Widget)
+              swt_widget_class = swt_widget_class_manual_entries[underscored_widget_name]
+              if swt_widget_class.nil?
+                Glimmer::Config.logger.debug {"Class #{swt_widget_class} matching #{underscored_widget_name} is not a subclass of org.eclipse.swt.widgets.Widget"}
+                return nil
+              end
+            end
+            flyweight_swt_widget_classes[underscored_widget_name] = swt_widget_class
+          rescue SyntaxError, NameError => e
+            Glimmer::Config.logger.debug {e.full_message}
+            # Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
+            nil
+          rescue => e
+            Glimmer::Config.logger.debug {e.full_message}
+            # Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
+            nil
           end
         end
-        swt_widget_class
-      rescue SyntaxError, NameError => e
-        Glimmer::Config.logger.debug {e.full_message}
-        # Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
-        nil
-      rescue => e
-        Glimmer::Config.logger.debug {e.full_message}
-        # Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
-        nil
+        flyweight_swt_widget_classes[underscored_widget_name]
+      end
+      
+      # Flyweight Design Pattern memoization cache. Can be cleared if memory is needed.
+      def self.flyweight_swt_widget_classes
+        @flyweight_swt_widget_classes ||= {}
       end
 
       def async_exec(&block)
@@ -536,6 +547,10 @@ module Glimmer
         @swt_widget.dispose
       end
 
+      def disposed?
+        @swt_widget.isDisposed
+      end
+
       # TODO Consider renaming these methods as they are mainly used for data-binding
 
       def can_add_observer?(property_name)
@@ -652,7 +667,7 @@ module Glimmer
           can_handle_observation_request?(method) ||
           swt_widget.respond_to?(method, *args, &block)
       end
-
+      
       private
 
       def style(underscored_widget_name, styles)
@@ -685,7 +700,7 @@ module Glimmer
         safe_block = lambda { |*args| block.call(*args) unless @swt_widget.isDisposed }
         listener = listener_class.new(listener_method => safe_block)
         @swt_widget.send(widget_add_listener_method, listener)
-        widget_listener_proxy = WidgetListenerProxy.new(swt_widget: @swt_widget, swt_listener: listener, widget_add_listener_method: widget_add_listener_method, swt_listener_class: listener_class, swt_listener_method: listener_method)
+        WidgetListenerProxy.new(swt_widget: @swt_widget, swt_listener: listener, widget_add_listener_method: widget_add_listener_method, swt_listener_class: listener_class, swt_listener_method: listener_method)
       end
 
       # Looks through SWT class add***Listener methods till it finds one for which

data/lib/glimmer/ui/custom_shell.rb

@@ -28,15 +28,12 @@ module Glimmer
       include Glimmer::UI::CustomWidget
       
       class << self
-        attr_reader :custom_shell
+        attr_reader :launched_custom_shell
         
-        def launch
-          @custom_shell = send(self.name.underscore.gsub('::', '__'))
-          @custom_shell.open
-        end
-        
-        def shutdown
-          @custom_shell.close
+        def launch(*args, &content)
+          @launched_custom_shell = send(keyword, *args, &content) if @launched_custom_shell.nil? || @launched_custom_shell.disposed?
+          @launched_custom_shell.swt_widget.set_data('launched', true)
+          @launched_custom_shell.open
         end
       end
       
@@ -45,7 +42,7 @@ module Glimmer
         @swt_widget.set_data('custom_shell', self)
         raise Error, 'Invalid custom shell body root! Must be a shell or another custom shell.' unless body_root.swt_widget.is_a?(org.eclipse.swt.widgets.Shell)
       end
-
+      
       # Classes may override
       def open
         body_root.open
@@ -56,6 +53,7 @@ module Glimmer
         open
       end
 
+      # TODO consider using Forwardable instead
       def close
         body_root.close
       end
@@ -68,6 +66,10 @@ module Glimmer
         body_root.visible?
       end
 
+      def disposed?
+        swt_widget.is_disposed
+      end
+
       def center_within_display
         body_root.center_within_display
       end

data/lib/glimmer/ui/custom_widget.rb

@@ -34,39 +34,60 @@ module Glimmer
       include DataBinding::ObservableModel
 
       super_module_included do |klass|
+        # TODO clear memoization of WidgetProxy.swt_widget_class_for for a keyword if a custom widget was defined with that keyword
         klass.include(Glimmer) unless klass.name.include?('Glimmer::UI::CustomShell')
         Glimmer::UI::CustomWidget.add_custom_widget_namespaces_for(klass) unless klass.name.include?('Glimmer::UI::CustomShell')
       end
 
       class << self
         def for(underscored_custom_widget_name)
-          extracted_namespaces = underscored_custom_widget_name.
-            to_s.
-            split(/__/).map do |namespace|
-              namespace.camelcase(:upper)
-            end
-          custom_widget_namespaces.each do |base|
-            extracted_namespaces.reduce(base) do |result, namespace|
-              if !result.constants.include?(namespace)
-                namespace = result.constants.detect {|c| c.to_s.upcase == namespace.to_s.upcase } || namespace
-              end
-              begin
-                constant = result.const_get(namespace)
-                return constant if constant.ancestors.include?(Glimmer::UI::CustomWidget)
-                constant
-              rescue => e
-                # Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
-                result
+          unless flyweight_custom_widget_classes.keys.include?(underscored_custom_widget_name)
+            begin
+              extracted_namespaces = underscored_custom_widget_name.
+                to_s.
+                split(/__/).map do |namespace|
+                  namespace.camelcase(:upper)
+                end
+              custom_widget_namespaces.each do |base|
+                extracted_namespaces.reduce(base) do |result, namespace|
+                  if !result.constants.include?(namespace)
+                    namespace = result.constants.detect {|c| c.to_s.upcase == namespace.to_s.upcase } || namespace
+                  end
+                  begin
+                    flyweight_custom_widget_classes[underscored_custom_widget_name] = constant = result.const_get(namespace)
+                    return constant if constant.ancestors.include?(Glimmer::UI::CustomWidget)
+                    flyweight_custom_widget_classes[underscored_custom_widget_name] = constant
+                  rescue => e
+                    # Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
+                    flyweight_custom_widget_classes[underscored_custom_widget_name] = result
+                  end
+                end
               end
+              raise "#{underscored_custom_widget_name} has no custom widget class!"
+            rescue => e
+              Glimmer::Config.logger.debug {e.message}
+              Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
+              flyweight_custom_widget_classes[underscored_custom_widget_name] = nil
             end
           end
-          raise "#{underscored_custom_widget_name} has no custom widget class!"
-        rescue => e
-          Glimmer::Config.logger.debug {e.message}
-          Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
-          nil
+          flyweight_custom_widget_classes[underscored_custom_widget_name]
+        end
+        
+        # Flyweight Design Pattern memoization cache. Can be cleared if memory is needed.
+        def flyweight_custom_widget_classes
+          @flyweight_custom_widget_classes ||= {}
         end
- 
+        
+        # Returns keyword to use for this custom widget
+        def keyword
+          self.name.underscore.gsub('::', '__')
+        end
+        
+        # Returns shortcut keyword to use for this custom widget (keyword minus namespace)
+        def shortcut_keyword
+          self.name.underscore.gsub('::', '__').split('__').last
+        end
+        
         def add_custom_widget_namespaces_for(klass)
           Glimmer::UI::CustomWidget.namespaces_for_class(klass).drop(1).each do |namespace|
             Glimmer::UI::CustomWidget.custom_widget_namespaces << namespace
@@ -127,8 +148,7 @@ module Glimmer
         end
 
         def before_body(&block)
-          @before_body_blocks ||= []
-          @before_body_blocks << block
+          @before_body_block = block
         end
 
         def body(&block)
@@ -136,29 +156,27 @@ module Glimmer
         end
 
         def after_body(&block)
-          @after_body_blocks ||= []
-          @after_body_blocks << block
+          @after_body_block = block
         end
       end
 
       attr_reader :body_root, :swt_widget, :parent, :parent_proxy, :swt_style, :options
 
       def initialize(parent, *swt_constants, options, &content)
+        @parent = parent
+        @parent_proxy = @parent&.get_data('proxy')
         @swt_style = SWT::SWTProxy[*swt_constants]
         options ||= {}
         @options = self.class.options.merge(options)
         @content = Util::ProcTracker.new(content) if content
-        execute_hooks('before_body')
+        execute_hook('before_body')
         body_block = self.class.instance_variable_get("@body_block")
         raise Glimmer::Error, 'Invalid custom widget for having no body! Please define body block!' if body_block.nil?
         @body_root = instance_exec(&body_block)
         raise Glimmer::Error, 'Invalid custom widget for having an empty body! Please fill body block!' if @body_root.nil?
         @swt_widget = @body_root.swt_widget
         @swt_widget.set_data('custom_widget', self)
-        @parent = parent
-        @parent ||= @swt_widget.parent
-        @parent_proxy ||= @parent&.get_data('proxy')
-        execute_hooks('after_body')
+        execute_hook('after_body')
       end
       
       # Subclasses may override to perform post initialization work on an added child
@@ -231,10 +249,18 @@ module Glimmer
       def attribute_setter(attribute_name)
         "#{attribute_name}="
       end
+      
+      def disposed?
+        swt_widget.isDisposed
+      end
 
       def has_style?(style)
         (swt_style & SWT::SWTProxy[style]) == SWT::SWTProxy[style]
       end
+      
+      def pack(*args)
+        body_root.pack(*args)
+      end
 
       # TODO see if it is worth it to eliminate duplication of async_exec/sync_exec
       # delegation to DisplayProxy, via a module
@@ -276,13 +302,13 @@ module Glimmer
       
       private
 
-      def execute_hooks(hook_name)
-        self.class.instance_variable_get("@#{hook_name}_blocks")&.each do |hook_block|
-          temp_method_name = "#{hook_name}_block_#{hook_block.hash.abs}_#{(Time.now.to_f * 1_000_000).to_i}"
-          singleton_class.define_method(temp_method_name, &hook_block)
-          send(temp_method_name)
-          singleton_class.send(:remove_method, temp_method_name)
-        end
+      def execute_hook(hook_name)
+        hook_block = self.class.instance_variable_get("@#{hook_name}_block")
+        return if hook_block.nil?
+        temp_method_name = "#{hook_name}_block_#{hook_block.hash.abs}_#{(Time.now.to_f * 1_000_000).to_i}"
+        singleton_class.define_method(temp_method_name, &hook_block)
+        send(temp_method_name)
+        singleton_class.send(:remove_method, temp_method_name)
       end
     end
   end

data/samples/elaborate/meta_sample.rb

@@ -25,6 +25,24 @@ require 'etc'
 class Sample
   include Glimmer::DataBinding::ObservableModel
   
+  class << self
+    def glimmer_directory
+      File.expand_path('../../..', __FILE__)
+    end
+  
+    def user_glimmer_directory
+      File.join(Etc.getpwuid.dir, '.glimmer-dsl-swt')
+    end
+    
+    def ensure_user_glimmer_directory
+      unless @ensured_glimmer_directory
+        FileUtils.rm_rf(user_glimmer_directory)
+        FileUtils.cp_r(glimmer_directory, user_glimmer_directory)
+        @ensured_glimmer_directory = true
+      end
+    end
+  end
+
   attr_accessor :sample_directory, :file, :selected
   
   def initialize(file, sample_directory: )
@@ -59,25 +77,35 @@ class Sample
     File.basename(file) != 'meta_sample.rb'
   end
   alias launchable editable
+    
+  def file_relative_path
+    file.sub(self.class.glimmer_directory, '')
+  end
+  
+  def user_file
+    File.join(self.class.user_glimmer_directory, file_relative_path)
+  end
+    
+  def user_file_parent_directory
+    File.dirname(user_file)
+  end
   
+  def directory
+    file.sub(/\.rb/, '')
+  end
+    
   def launch(modified_code)
-    parent_directory = File.basename(File.dirname(file))
-    modified_file_parent_directory = File.join(Etc.getpwuid.dir, '.glimmer', 'samples', parent_directory)
-    launch_file = modified_file = File.join(modified_file_parent_directory, File.basename(file))
+    launch_file = user_file
     begin
-      FileUtils.mkdir_p(modified_file_parent_directory)
-      FileUtils.cp_r(file, modified_file_parent_directory)
-      FileUtils.cp_r(file.sub(/\.rb/, ''), modified_file_parent_directory) if File.exist?(file.sub(/\.rb/, ''))
-      File.write(modified_file, modified_code)
+      FileUtils.cp_r(file, user_file_parent_directory)
+      FileUtils.cp_r(directory, user_file_parent_directory) if File.exist?(directory)
+      File.write(user_file, modified_code)
     rescue => e
       puts 'Error writing sample modifications. Launching original sample.'
       puts e.full_message
       launch_file = file # load original file if failed to write changes
     end
     load(launch_file)
-  ensure
-    FileUtils.rm_rf(modified_file)
-    FileUtils.rm_rf(modified_file.sub(/\.rb/, ''))
   end
 end
 
@@ -162,17 +190,18 @@ class SampleDirectory
 end
 
 class MetaSampleApplication
-  include Glimmer
+  include Glimmer::UI::CustomShell
   
-  def initialize
+  before_body {
+    Sample.ensure_user_glimmer_directory
     selected_sample_directory = SampleDirectory.sample_directories.first
     selected_sample = selected_sample_directory.samples.first
     selected_sample_directory.selected_sample_name = selected_sample.name
-  end
-  
-  def launch
     Display.app_name = 'Glimmer Meta-Sample'
-    shell {
+  }
+  
+  body {
+    shell(:fill_screen) {
       minimum_size 1280, 768
       text 'Glimmer Meta-Sample (The Sample of Samples)'
       image File.expand_path('../../icons/scaffold_app.png', __dir__)
@@ -218,11 +247,8 @@ class MetaSampleApplication
               on_widget_selected {
                 begin
                   SampleDirectory.selected_sample.launch(@code_text.text)
-                rescue StandardError, SyntaxError => launch_error
-                  message_box {
-                    text 'Error Launching'
-                    message launch_error.full_message
-                  }.open
+                rescue LoadError, StandardError, SyntaxError => launch_error
+                  error_dialog(message: launch_error.full_message).open
                 end
               }
             }
@@ -243,10 +269,41 @@ class MetaSampleApplication
           editable bind(SampleDirectory, 'selected_sample.editable')
         }
         
-        weights 4, 9
+        weights 4, 11
+      }
+    }
+  }
+  
+  # Method-based error_dialog custom widget
+  def error_dialog(message:)
+    return if message.nil?
+    dialog(body_root) { |dialog_proxy|
+      row_layout(:vertical) {
+        center true
+      }
+      
+      text 'Error Launching'
+        
+      styled_text(:border, :h_scroll, :v_scroll) {
+        layout_data {
+          width body_root.bounds.width*0.75
+          height body_root.bounds.height*0.75
+        }
+        
+        text message
+        editable false
+        caret nil
+      }
+      
+      button {
+        text 'Close'
+        
+        on_widget_selected {
+          dialog_proxy.close
+        }
       }
-    }.open
+    }
   end
 end
 
-MetaSampleApplication.new.launch
+MetaSampleApplication.launch