glimmer-dsl-opal 0.10.0 → 0.12.0

data/lib/glimmer/dsl/opal/shine_data_binding_expression.rb

@@ -0,0 +1,49 @@
+# Copyright (c) 2020-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/dsl/expression'
+require 'glimmer/data_binding/model_binding'
+require 'glimmer/swt/table_proxy'
+require 'glimmer/data_binding/shine'
+
+module Glimmer
+  module DSL
+    module Opal
+      class ShineDataBindingExpression < Expression
+        def can_interpret?(parent, keyword, *args, &block)
+          args.size == 0 and
+            block.nil? and
+            (
+              (parent.respond_to?(:set_attribute) and parent.respond_to?(keyword)) or
+              (parent.is_a?(Glimmer::SWT::TableProxy)) # TODO support tree element
+            )
+            # TODO support canvas elements
+#             and
+#             !(parent.respond_to?(:swt_widget) && parent.swt_widget.class == org.eclipse.swt.widgets.Canvas && keyword == 'image')
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::DataBinding::Shine.new(parent, keyword)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/opal/table_items_data_binding_expression.rb

@@ -12,10 +12,10 @@ module Glimmer
           keyword == "items" and
             block.nil? and
             parent.is_a?(Glimmer::SWT::TableProxy) and
-            args.size == 2 and
+            args.size.between?(1, 2) and
             args[0].is_a?(DataBinding::ModelBinding) and
             args[0].evaluate_property.is_a?(Array) and
-            args[1].is_a?(Array)
+            (args[1].nil? or args[1].is_a?(Array))
         end
   
         def interpret(parent, keyword, *args, &block)

data/lib/glimmer/dsl/opal/widget_expression.rb

@@ -20,7 +20,7 @@ module Glimmer
           Glimmer::SWT::WidgetProxy.for(keyword, parent, args, block)
         end
         
-        def add_content(parent, &block)
+        def add_content(parent, keyword, *args, &block)
           if parent.rendered? || parent.skip_content_on_render_blocks?
             super(parent, &block)
             parent.post_add_content

data/lib/glimmer/swt/combo_proxy.rb

@@ -6,6 +6,7 @@ module Glimmer
     class ComboProxy < WidgetProxy
       include Glimmer::DataBinding::ObservableElement
       attr_reader :text, :items
+      attr_accessor :selection # virtual attribute just to pass the shine data-binding test (TODO THINK OF A BETTER WAY OF HANDLING THIS)
       
       def initialize(parent, args, block)
         super(parent, args, block)

data/lib/glimmer/swt/composite_proxy.rb

@@ -4,8 +4,6 @@ require 'glimmer/swt/widget_proxy'
 module Glimmer
   module SWT
     class CompositeProxy < WidgetProxy
-      attr_reader :layout
-      
       def initialize(parent, args, block)
         super(parent, args, block)
         @layout = default_layout
@@ -27,9 +25,27 @@ module Glimmer
       def layout=(the_layout)
         @layout = the_layout
       end
+      alias set_layout layout=
+      alias setLayout layout=
       
+      def get_layout
+        @layout
+      end
+      alias getLayout get_layout #TODO consider pregenerating these aliases with an easy method in the future
+
+      def pack(*args)
+        # No Op (just a shim) TODO consider if it should be implemented
+      end
+      
+      def layout​(changed = nil, all = nil)
+        # TODO implement layout(changed = nil, all = nil) just as per SWT API
+        @layout&.layout(self, changed)
+      end
+            
     end
     
+    CanvasProxy = CompositeProxy # TODO implement fully eventually
+    
   end
   
 end

data/lib/glimmer/swt/dialog_proxy.rb

@@ -63,14 +63,12 @@ module Glimmer
         i = 0
         @parent = parent
         @parent = nil if parent.is_a?(LatestShellProxy)
-        @parent ||= DisplayProxy.instance.shells.last || ShellProxy.new([])
+        @parent ||= DisplayProxy.instance.shells.detect(&:open?) || ShellProxy.new([])
         @args = args
         @block = block
         @children = Set.new
         @enabled = true
-#         on_widget_selected {
-#           hide
-#         }
+        DisplayProxy.instance.opened_dialogs.last&.suspend_event_handling
         DisplayProxy.instance.dialogs << self
         @parent.post_initialize_child(self)
       end
@@ -84,35 +82,39 @@ module Glimmer
         end
       end
     
+      def open?
+        @open
+      end
+      
       def open
-        unless @init
-          dom_element.remove_class('hide')
-          dom_element.dialog({'auto_open' => false})
-          @init = true
-          dom_element.dialog('option', 'appendTo', parent.path)
-          dom_element.dialog('option', 'modal', true) # NOTE: Not Working! Doing manually below by relying on overlay in ShellProxy.
-          if DisplayProxy.instance.dialogs.size == 1 # only add for first dialog open
-            Element['.dialog-overlay'].remove_class('hide')
-          end
-          dom_element.dialog('option', 'closeOnEscape', true)
-          dom_element.dialog('option', 'draggable', true)
-          dom_element.dialog('option', 'width', 'auto')
-          dom_element.dialog('option', 'minHeight', 'none')
-          dom_element.on('dialogclose') do
-            unless @hiding
-              close
-            else
-              @hiding = false
+        owned_proc = Glimmer::Util::ProcTracker.new(owner: self, invoked_from: :open) {
+          shell.open(async: false) unless shell.open?
+          unless @init
+            dom_element.remove_class('hide')
+            dom_element.dialog('auto_open' => false)
+            @init = true
+            dom_element.dialog('option', 'appendTo', parent.path)
+            dom_element.dialog('option', 'modal', true) # NOTE: Not Working! Doing manually below by relying on overlay in ShellProxy.
+            unless DisplayProxy.instance.dialogs.any?(&:open?) # only add for first dialog open
+              Element['.dialog-overlay'].remove_class('hide')
+            end
+            dom_element.dialog('option', 'closeOnEscape', true)
+            dom_element.dialog('option', 'draggable', true)
+            dom_element.dialog('option', 'width', 'auto')
+            dom_element.dialog('option', 'minHeight', 'none')
+            dom_element.on('dialogclose') do
+              unless @hiding
+                close
+              else
+                @hiding = false
+              end
             end
+          else
+            dom_element.dialog('open')
           end
-        else
-          dom_element.dialog('open')
-        end
-        @open = true
-      end
-      
-      def open?
-        @open
+          @open = true
+        }
+        DisplayProxy.instance.async_exec(owned_proc)
       end
       
       def hide
@@ -128,12 +130,15 @@ module Glimmer
         @open = false
         @init = false
         Element['.dialog-overlay'].add_class('hide') unless DisplayProxy.instance.dialogs.any?(&:open?)
+        parent.children.delete(self)
+        shell.close if shell.children.empty?
         DisplayProxy.instance.dialogs.delete(self)
+        DisplayProxy.instance.opened_dialogs.last&.resume_event_handling
       end
       
       
       def content(&block)
-        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::Opal::DialogExpression.new, &block)
+        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::Opal::DialogExpression.new, 'dialog', &block)
       end
       
       def path
@@ -144,6 +149,16 @@ module Glimmer
         end
       end
       
+      def suspend_event_handling
+        super
+        Element["[aria-describedby=#{id}]"].css('z-index', 9)
+      end
+      
+      def resume_event_handling
+        super
+        Element["[aria-describedby=#{id}]"].css('z-index', 100)
+      end
+      
 #       def selector
 #         super + ' .close'
 #       end
@@ -162,7 +177,7 @@ module Glimmer
  
       def dom
         @dom ||= html {
-          div(id: id, class: "#{name} hide", title: text) {
+          div(id: id, class: "#{name} modal hide", title: text) {
           }
         }.to_s
       end

data/lib/glimmer/swt/display_proxy.rb

@@ -1,3 +1,5 @@
+require 'glimmer/swt/widget_proxy'
+
 module Glimmer
   module SWT
     class DisplayProxy < WidgetProxy
@@ -5,6 +7,9 @@ module Glimmer
         def instance
           @instance ||= new
         end
+        
+        attr_accessor :open_custom_shells_in_current_window
+        alias open_custom_shells_in_current_window? open_custom_shells_in_current_window
       end
       
       def initialize
@@ -36,20 +41,46 @@ module Glimmer
         @dialogs ||= []
       end
       
+      def modals
+        message_boxes + dialogs
+      end
+      
+      def message_box_open?
+        message_boxes.any?(&:open?)
+      end
+      
+      def dialog_open?
+        dialogs.any?(&:open?)
+      end
+      
+      def opened_dialogs
+        dialogs.select(&:open?)
+      end
+      
+      def modal_open?
+        message_box_open? or dialog_open?
+      end
+      
       def render
         # No rendering as body is rendered as part of ShellProxy.. this class only serves as an SWT Display utility
       end
       
-      def async_exec(&block)
-        executer = lambda do
-          if Document.find('.modal').to_a.empty?
-            block.call
-          else
-            sleep(0.05)
-            Async::Task.new(&executer)
-          end
+      def beep
+        # TODO (simulate beep from SWT display flashing the screen and making a noise if possible)
+      end
+      
+      def async_exec(proc_tracker = nil, &block)
+        block = proc_tracker unless proc_tracker.nil?
+        queue = nil # general queue
+        if !proc_tracker.nil? && proc_tracker.invoked_from.to_s == 'open' && modal_open? &&
+           (
+             proc_tracker.owner.is_a?(MessageBoxProxy) ||
+             (dialog_open? && proc_tracker.owner.is_a?(DialogProxy) && opened_dialogs.last == WidgetProxy.widget_handling_listener&.dialog_ancestor)
+           )
+          queue = WidgetProxy.widget_handling_listener
         end
-        Async::Task.new(&executer)
+        return block.call if !modal_open?
+        schedule_async_exec(block, queue)
       end
       # sync_exec kept for API compatibility reasons
       alias sync_exec async_exec
@@ -64,7 +95,34 @@ module Glimmer
                   event.singleton_class.define_method(:character) do
                     which || key_code
                   end
+                  event.define_singleton_method(:keyCode) {event.which}
+                  event.define_singleton_method(:key_code, &event.method(:keyCode))
+                  event.define_singleton_method(:character) {event.which.chr}
+                  event.define_singleton_method(:stateMask) do
+                    state_mask = 0
+                    state_mask |= SWTProxy[:alt] if event.alt_key
+                    state_mask |= SWTProxy[:ctrl] if event.ctrl_key
+                    state_mask |= SWTProxy[:shift] if event.shift_key
+                    state_mask |= SWTProxy[:command] if event.meta_key
+                    state_mask
+                  end
+                  event.define_singleton_method(:state_mask, &event.method(:stateMask))
+                  doit = true
+                  event.define_singleton_method(:doit=) do |value|
+                    doit = value
+                  end
+                  event.define_singleton_method(:doit) { doit }
                   event_listener.call(event)
+                  
+                    # TODO Fix doit false, it's not stopping input
+                  unless doit
+                    event.prevent
+                    event.prevent_default
+                    event.stop_propagation
+                    event.stop_immediate_propagation
+                  end
+                  
+                  doit
                 }
               }
             },
@@ -75,13 +133,74 @@ module Glimmer
                   event.singleton_class.define_method(:character) do
                     which || key_code
                   end
+                  event.define_singleton_method(:keyCode) {event.which}
+                  event.define_singleton_method(:key_code, &event.method(:keyCode))
+                  event.define_singleton_method(:character) {event.which.chr}
+                  event.define_singleton_method(:stateMask) do
+                    state_mask = 0
+                    state_mask |= SWTProxy[:alt] if event.alt_key
+                    state_mask |= SWTProxy[:ctrl] if event.ctrl_key
+                    state_mask |= SWTProxy[:shift] if event.shift_key
+                    state_mask |= SWTProxy[:command] if event.meta_key
+                    state_mask
+                  end
+                  event.define_singleton_method(:state_mask, &event.method(:stateMask))
+                  doit = true
+                  event.define_singleton_method(:doit=) do |value|
+                    doit = value
+                  end
+                  event.define_singleton_method(:doit) { doit }
                   event_listener.call(event) if event.key_code != 13 && (event.key_code == 127 || event.key_code <= 31)
+                  
+                    # TODO Fix doit false, it's not stopping input
+                  unless doit
+                    event.prevent
+                    event.prevent_default
+                    event.stop_propagation
+                    event.stop_immediate_propagation
+                  end
+                  
+                  doit
                 }
               }
             }
           ]
         }
       end
+      
+      private
+      
+      def async_exec_queues
+        @async_exec_queues ||= {}
+      end
+      
+      def async_exec_queue(widget_handling_listener = nil)
+        async_exec_queues[widget_handling_listener] ||= []
+      end
+      
+      def no_widget_handling_listener_work?
+        async_exec_queues.reject {|key, value| key.nil?}.values.reduce(:+).to_a.empty?
+      end
+      
+      def schedule_async_exec(block, queue)
+        async_exec_queue(queue).unshift(block)
+        
+        # TODO consider the need for locking to avoid race conditions (rare or impossible case)
+        if async_exec_queue(queue).size == 1
+          executer = lambda do
+            # queue could be a widget handling listener queue
+            # TODO see if there are more intricate cases of opening a dialog from a widget listener handler
+            if !message_box_open? && (!dialog_open? || queue&.dialog_ancestor == opened_dialogs.last) && ((!queue.nil? && async_exec_queues.keys.last == queue) || no_widget_handling_listener_work?)
+              block = async_exec_queue(queue).pop
+              block&.call
+              Async::Task.new(delay: 1, &executer) if async_exec_queue(queue).any?
+            else
+              Async::Task.new(delay: 100, &executer)
+            end
+          end
+          Async::Task.new(delay: 1, &executer)
+        end
+      end
     end
   end
 end

data/lib/glimmer/swt/grid_layout_proxy.rb

@@ -14,39 +14,46 @@ module Glimmer
       
       attr_reader :num_columns, :make_columns_equal_width, :horizontal_spacing, :vertical_spacing, :margin_width, :margin_height
     
-      def initialize(parent, args)
-        super(parent, args)
-        self.horizontal_spacing = 10
-        self.vertical_spacing = 10
-        self.margin_width = 15
-        self.margin_height = 15
-        self.num_columns = @args.first || 1
-        reapply
-      end
-
       def num_columns=(columns)
         @num_columns = columns
         # TODO do the following instead of reapply
 #         @parent.add_css_class("num-columns-#{@num_columns}")
-        reapply
+        # reinitialize # TODO reimplement without using reinitialize
+        layout_css = <<~CSS
+          grid-template-columns: #{'auto ' * @num_columns.to_i};
+          grid-row-gap: #{@vertical_spacing}px;
+          grid-column-gap: #{@horizontal_spacing}px;
+        CSS
+        if @parent.css_classes.include?('grid-layout')
+          layout_css.split(";").map(&:strip).map {|l| l.split(':').map(&:strip)}.each do |key, value|
+            @parent.dom_element.css(key, value) unless key.nil?
+          end
+          if @parent.is_a?(GroupProxy)
+            @parent.dom_element.find('legend').css('grid-column-start', "span #{@num_columns.to_i}")
+          end
+        else
+          layout_css.split(";").map(&:strip).map {|l| l.split(':').map(&:strip)}.each do |key, value|
+            @parent.dom_element.css(key, 'initial') unless key.nil?
+          end
+        end
       end
       
       def make_columns_equal_width=(equal_width)
         @make_columns_equal_width = equal_width
 #         @parent.add_css_class('make_columns_equal_width') if @make_columns_equal_width
-        reapply
+        # reinitialize # TODO reimplement without using reinitialize
       end
       
       def horizontal_spacing=(spacing)
         @horizontal_spacing = spacing
 #         @parent.add_css_class("horizontal-spacing-#{@horizontal_spacing}")
-        reapply
+        # reinitialize # TODO reimplement without using reinitialize
       end
 
       def vertical_spacing=(spacing)
         @vertical_spacing = spacing
 #         @parent.add_css_class("vertical-spacing-#{@vertical_spacing}")
-        reapply
+        # reinitialize # TODO reimplement without using reinitialize
       end
       
       def margin_width=(pixels)
@@ -66,25 +73,13 @@ module Glimmer
         @parent.dom_element.css('padding-bottom', effective_margin_height)
       end
             
-      def reapply
-        # TODO get rid of this method
-        layout_css = <<~CSS
-          grid-template-columns: #{'auto ' * @num_columns.to_i};
-          grid-row-gap: #{@vertical_spacing}px;
-          grid-column-gap: #{@horizontal_spacing}px;
-        CSS
-        if @parent.css_classes.include?('grid-layout')
-          layout_css.split(";").map(&:strip).map {|l| l.split(':').map(&:strip)}.each do |key, value|
-            @parent.dom_element.css(key, value) unless key.nil?
-          end
-          if @parent.is_a?(GroupProxy)
-            @parent.dom_element.find('legend').css('grid-column-start', "span #{@num_columns.to_i}")
-          end
-        else
-          layout_css.split(";").map(&:strip).map {|l| l.split(':').map(&:strip)}.each do |key, value|
-            @parent.dom_element.css(key, 'initial') unless key.nil?
-          end
-        end
+      def initialize(parent, args)
+        super(parent, args)
+        self.horizontal_spacing = 10
+        self.vertical_spacing = 10
+        self.margin_width = 15
+        self.margin_height = 15
+        self.num_columns = @args.first || 1
       end
     end
   end