glimmer-dsl-swt 4.18.3.0 → 4.18.3.5

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

@@ -77,7 +77,7 @@ module Glimmer
           composite.layout = GridLayout.new if composite.get_layout.nil?
         end,
         canvas: lambda do |canvas|
-          canvas.layout = nil unless canvas.get_layout.nil?
+          canvas.layout = nil if canvas.respond_to?('layout=') && !canvas.get_layout.nil?
         end,
         scrolled_composite: lambda do |scrolled_composite|
           scrolled_composite.expand_horizontal = true
@@ -547,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)
@@ -663,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)
@@ -696,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

@@ -77,7 +77,17 @@ module Glimmer
         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
@@ -138,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)
@@ -147,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_proxy = @parent = parent
+        @parent_proxy = @parent&.get_data('proxy') if @parent.respond_to?(:get_data) && @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
@@ -242,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
@@ -287,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

data/samples/elaborate/tetris.rb

@@ -25,60 +25,88 @@ require_relative 'tetris/model/game'
 
 require_relative 'tetris/view/playfield'
 require_relative 'tetris/view/score_lane'
-require_relative 'tetris/view/game_over_dialog'
+require_relative 'tetris/view/high_score_dialog'
+require_relative 'tetris/view/tetris_menu_bar'
 
 class Tetris
   include Glimmer::UI::CustomShell
   
   BLOCK_SIZE = 25
-  PLAYFIELD_WIDTH = 10
-  PLAYFIELD_HEIGHT = 20
-  PREVIEW_PLAYFIELD_WIDTH = 4
-  PREVIEW_PLAYFIELD_HEIGHT = 2
+  FONT_NAME = 'Menlo'
+  FONT_TITLE_HEIGHT = 32
+  FONT_TITLE_STYLE = :bold
+  BEVEL_CONSTANT = 20
+  
+  option :playfield_width, default: Model::Game::PLAYFIELD_WIDTH
+  option :playfield_height, default: Model::Game::PLAYFIELD_HEIGHT
+  
+  attr_reader :game
   
   before_body {
+    @mutex = Mutex.new
+    @game = Model::Game.new(playfield_width, playfield_height)
+        
+    @game.configure_beeper do
+      display.beep
+    end
+    
+    Display.app_name = 'Glimmer Tetris'
     display {
-      on_swt_keydown { |key_event|
+      @keyboard_listener = on_swt_keydown { |key_event|
         case key_event.keyCode
-        when swt(:arrow_down)
-          Model::Game.current_tetromino.down
-        when swt(:arrow_left)
-          Model::Game.current_tetromino.left
-        when swt(:arrow_right)
-          Model::Game.current_tetromino.right
-        when swt(:shift)
+        when swt(:arrow_down), 's'.bytes.first
+          game.down!
+        when swt(:arrow_up)
+          case game.up_arrow_action
+          when :instant_down
+            game.down!(instant: true)
+          when :rotate_right
+            game.rotate!(:right)
+          when :rotate_left
+            game.rotate!(:left)
+          end
+        when swt(:arrow_left), 'a'.bytes.first
+          game.left!
+        when swt(:arrow_right), 'd'.bytes.first
+          game.right!
+        when swt(:shift), swt(:alt)
           if key_event.keyLocation == swt(:right) # right shift key
-            Model::Game.current_tetromino.rotate(:right)
+            game.rotate!(:right)
           elsif key_event.keyLocation == swt(:left) # left shift key
-            Model::Game.current_tetromino.rotate(:left)
+            game.rotate!(:left)
           end
-        when 'd'.bytes.first, swt(:arrow_up)
-          Model::Game.current_tetromino.rotate(:right)
-        when 'a'.bytes.first
-          Model::Game.current_tetromino.rotate(:left)
+        when swt(:ctrl)
+          game.rotate!(:left)
         end
       }
+      
+      # if running in app mode, set the Mac app about dialog (ignored in platforms)
+      @about_observer = on_about {
+        show_about_dialog
+      }
+      
+      @quit_observer = on_quit {
+        exit(0)
+      }
     }
-    
-    Model::Game.configure_beeper do
-      display.beep
-    end
   }
   
   after_body {
-    Model::Game.start
-    
-    Thread.new {
-      loop {
-        sleep(Model::Game.delay)
-        sync_exec {
-          unless Model::Game.game_over?
-            Model::Game.current_tetromino.down
-            game_over_dialog(parent_shell: body_root).open if Model::Game.current_tetromino.row <= 0 && Model::Game.current_tetromino.stopped?
-          end
-        }
-      }
-    }
+    @game_over_observer = observe(@game, :game_over) do |game_over|
+      if game_over
+        show_high_score_dialog
+      else
+        start_moving_tetrominos_down
+      end
+    end
+    @show_high_scores_observer = observe(@game, :show_high_scores) do |show_high_scores|
+      if show_high_scores
+        show_high_score_dialog
+      else
+        @high_score_dialog.close unless @high_score_dialog.nil? || @high_score_dialog.disposed? || !@high_score_dialog.visible?
+      end
+    end
+    @game.start!
   }
   
   body {
@@ -92,15 +120,91 @@ class Tetris
       }
       
       text 'Glimmer Tetris'
-      background :gray
-            
-      playfield(game_playfield: Model::Game.playfield, playfield_width: PLAYFIELD_WIDTH, playfield_height: PLAYFIELD_HEIGHT, block_size: BLOCK_SIZE)
-      
-      score_lane(block_size: BLOCK_SIZE) {
-        layout_data(:fill, :fill, false, true)
+      minimum_size 475, 500
+      image tetris_icon
+
+      tetris_menu_bar(game: game)
+
+      playfield(game_playfield: game.playfield, playfield_width: playfield_width, playfield_height: playfield_height, block_size: BLOCK_SIZE)
+
+      score_lane(game: game, block_size: BLOCK_SIZE) {
+        layout_data(:fill, :fill, true, true)
+      }
+
+      on_widget_disposed {
+        deregister_observers
       }
     }
   }
+  
+  def tetris_icon
+    icon_block_size = 64
+    icon_bevel_size = icon_block_size.to_f / 25.to_f
+    icon_bevel_pixel_size = 0.16*icon_block_size.to_f
+    icon_size = 8
+    icon_pixel_size = icon_block_size * icon_size
+    image(icon_pixel_size, icon_pixel_size) {
+      icon_size.times { |row|
+        icon_size.times { |column|
+          colored = row >= 1 && column.between?(1, 6)
+          color = colored ? color(([:white] + Model::Tetromino::LETTER_COLORS.values).sample) : color(:white)
+          x = column * icon_block_size
+          y = row * icon_block_size
+          rectangle(x, y, icon_block_size, icon_block_size, fill: true) {
+            background color
+          }
+          polygon(x, y, x + icon_block_size, y, x + icon_block_size - icon_bevel_pixel_size, y + icon_bevel_pixel_size, x + icon_bevel_pixel_size, y + icon_bevel_pixel_size, fill: true) {
+            background rgb(color.red + 4*BEVEL_CONSTANT, color.green + 4*BEVEL_CONSTANT, color.blue + 4*BEVEL_CONSTANT)
+          }
+          polygon(x + icon_block_size, y, x + icon_block_size - icon_bevel_pixel_size, y + icon_bevel_pixel_size, x + icon_block_size - icon_bevel_pixel_size, y + icon_block_size - icon_bevel_pixel_size, x + icon_block_size, y + icon_block_size, fill: true) {
+            background rgb(color.red - BEVEL_CONSTANT, color.green - BEVEL_CONSTANT, color.blue - BEVEL_CONSTANT)
+          }
+          polygon(x + icon_block_size, y + icon_block_size, x, y + icon_block_size, x + icon_bevel_pixel_size, y + icon_block_size - icon_bevel_pixel_size, x + icon_block_size - icon_bevel_pixel_size, y + icon_block_size - icon_bevel_pixel_size, fill: true) {
+            background rgb(color.red - 2*BEVEL_CONSTANT, color.green - 2*BEVEL_CONSTANT, color.blue - 2*BEVEL_CONSTANT)
+          }
+          polygon(x, y, x, y + icon_block_size, x + icon_bevel_pixel_size, y + icon_block_size - icon_bevel_pixel_size, x + icon_bevel_pixel_size, y + icon_bevel_pixel_size, fill: true) {
+            background rgb(color.red - BEVEL_CONSTANT, color.green - BEVEL_CONSTANT, color.blue - BEVEL_CONSTANT)
+          }
+        }
+      }
+    }
+  end
+  
+  def start_moving_tetrominos_down
+    Thread.new do
+      @mutex.synchronize do
+        loop do
+          time = Time.now
+          sleep @game.delay
+          break if @game.game_over? || body_root.disposed?
+          sync_exec {
+            @game.down! unless @game.paused?
+          }
+        end
+      end
+    end
+  end
+  
+  def show_high_score_dialog
+    return if @high_score_dialog&.visible?
+    @high_score_dialog = high_score_dialog(parent_shell: body_root, game: @game) if @high_score_dialog.nil? || @high_score_dialog.disposed?
+    @high_score_dialog.show
+  end
+  
+  def show_about_dialog
+    message_box {
+      text 'Glimmer Tetris'
+      message "Glimmer Tetris\n\nGlimmer DSL for SWT Sample\n\nCopyright (c) 2007-2021 Andy Maleh"
+    }.open
+  end
+  
+  def deregister_observers
+    @show_high_scores_observer&.deregister
+    @game_over_observer&.deregister
+    @keyboard_listener&.deregister
+    @about_observer&.deregister
+    @quit_observer&.deregister
+  end
 end
 
 Tetris.launch