glimmer-dsl-opal 0.27.0 → 0.28.3

data/lib/glimmer/swt/custom/shape/text.rb

@@ -0,0 +1,114 @@
+# 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/swt/custom/shape'
+require 'glimmer/swt/swt_proxy'
+require 'glimmer/swt/display_proxy'
+require 'glimmer/swt/color_proxy'
+# require 'glimmer/swt/transform_proxy'
+
+module Glimmer
+  module SWT
+    module Custom
+      class Shape
+        class Text < Shape
+          def parameter_names
+            if text_parameter_names.size == @args.size
+              @parameter_names = text_parameter_names
+            elsif text_transparent_parameter_names.size == @args.size
+              @parameter_names = text_transparent_parameter_names
+            elsif text_flags_parameter_names.size == @args.size
+              @parameter_names = text_flags_parameter_names
+            end
+            @parameter_names || text_parameter_names
+          end
+          
+          def possible_parameter_names
+            # TODO refactor and improve this method through meta-programming (and share across other shapes)
+            (text_parameter_names + text_transparent_parameter_names + text_flags_parameter_names).uniq
+          end
+          
+          def text_parameter_names
+            [:string, :x, :y]
+          end
+          
+          def text_transparent_parameter_names
+            [:string, :x, :y, :is_transparent]
+          end
+          
+          def text_flags_parameter_names
+            [:string, :x, :y, :flags]
+          end
+          
+          def set_parameter_attribute(attribute_name, *args)
+            if @parameter_names.to_a.map(&:to_s).include?(attribute_name.to_s)
+              super(attribute_name, *args)
+              build_dom
+              reattach(dom_element)
+              return
+            end
+            if text_parameter_names.map(&:to_s).include?(attribute_name.to_s)
+              @parameter_names = text_parameter_names
+            elsif text_transparent_parameter_names.map(&:to_s).include?(attribute_name.to_s)
+              @parameter_names = text_transparent_parameter_names
+            elsif text_flags_parameter_names.map(&:to_s).include?(attribute_name.to_s)
+              @parameter_names = text_flags_parameter_names
+            end
+            super(attribute_name, *args)
+          end
+          
+          def reattach(old_element)
+            old_element.attr('x', Element[@dom].attr('x'))
+            old_element.attr('y', Element[@dom].attr('y'))
+            old_element.text(Element[@dom].html)
+          end
+          
+          def background=(value)
+            # TODO override background= to fill a rectangle containing text, matching its size
+            # For now, disable background when foreground is not set
+            super(value) unless foreground.nil?
+          end
+        
+          def foreground=(value)
+            super(value)
+            self.background = value
+          end
+
+          def element
+            'text'
+          end
+          
+          def dom
+            shape_id = id
+            shape_class = name
+            @dom ||= xml {
+              tag(:_name => 'text', id: shape_id, class: shape_class, x: @args[1], y: @args[2]) {
+                @args[0]
+              }
+            }.to_s
+          end
+          
+        end
+        String = Text
+      end
+    end
+  end
+end

data/lib/glimmer/swt/custom/shape.rb

@@ -0,0 +1,205 @@
+# 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/property_owner'
+require 'glimmer/swt/swt_proxy'
+require 'glimmer/swt/display_proxy'
+require 'glimmer/swt/color_proxy'
+require 'glimmer/swt/font_proxy'
+# require 'glimmer/swt/transform_proxy'
+require 'glimmer/swt/point'
+require 'glimmer/swt/rectangle'
+
+module Glimmer
+  module SWT
+    module Custom
+      # Represents a shape (graphics) to be drawn on a control/widget/canvas/display
+      # That is because Shape is drawn on a parent as graphics and doesn't have an SWT widget for itself
+      class Shape < WidgetProxy
+        include PropertyOwner
+        
+        class << self
+          def create(parent, keyword, args, &property_block)
+            potential_shape_class_name = keyword.to_s.camelcase(:upper).to_sym
+            if constants.include?(potential_shape_class_name)
+              const_get(potential_shape_class_name).new(parent, args, &property_block)
+            else
+              new(parent, args, &property_block)
+            end
+          end
+        
+          def valid?(parent, keyword, args, &block)
+            return true if keyword.to_s == 'shape'
+            keywords.include?(keyword.to_s)
+          end
+          
+          def keywords
+            constants.select do |constant|
+              constant_value = const_get(constant)
+              constant_value.respond_to?(:ancestors) && constant_value.ancestors.include?(Glimmer::SWT::Custom::Shape)
+            end.map {|constant| constant.to_s.underscore}
+          end
+          
+        end
+        
+        def background=(value)
+          value = ColorProxy.new(value) if value.is_a?(String) || value.is_a?(Symbol)
+          @background = value
+          dom_element.css('fill', background.to_css) unless background.nil?
+        end
+        
+        def foreground=(value)
+          value = ColorProxy.new(value) if value.is_a?(String) || value.is_a?(Symbol)
+          @foreground = value
+          dom_element.css('stroke', foreground.to_css) unless foreground.nil?
+          dom_element.css('fill', 'transparent') if background.nil?
+        end
+        
+        def post_add_content
+          # TODO avoid rendering unless args changed from initialize args (due to setting of piecemeal attributes)
+          render
+        end
+        
+        def render(custom_parent_dom_element: nil, brand_new: false)
+          super(custom_parent_dom_element: nil, brand_new: false)
+          self.background = background
+          self.foreground = foreground
+          self.font = font
+        end
+        
+        # parameter names for arguments to pass to SWT GC.xyz method for rendering shape (e.g. draw_image(image, x, y) yields :image, :x, :y parameter names)
+        def parameter_names
+          [:x, :y, :width, :height]
+        end
+        
+        # subclasses may override to specify location parameter names if different from x and y (e.g. all polygon points are location parameters)
+        # used in calculating movement changes
+        def location_parameter_names
+          [:x, :y]
+        end
+        
+        def possible_parameter_names
+          parameter_names
+        end
+        
+        def parameter_name?(attribute_name)
+          possible_parameter_names.map(&:to_s).include?(attribute_getter(attribute_name))
+        end
+        
+        def current_parameter_name?(attribute_name)
+          parameter_names.include?(attribute_name.to_s.to_sym)
+        end
+        
+        def parameter_index(attribute_name)
+          parameter_names.index(attribute_name.to_s.to_sym)
+        end
+        
+        def get_parameter_attribute(attribute_name)
+          @args[parameter_index(attribute_getter(attribute_name))]
+        end
+        
+        def set_parameter_attribute(attribute_name, *args)
+          @args[parameter_index(attribute_getter(attribute_name))] = args.size == 1 ? args.first : args
+        end
+        
+        def has_attribute?(attribute_name, *args)
+          parameter_name?(attribute_name) or
+            (respond_to?(attribute_name, super: true) and respond_to?(attribute_setter(attribute_name), super: true))
+        end
+        
+        def set_attribute(attribute_name, *args)
+          attribute_getter_name = attribute_getter(attribute_name)
+          attribute_setter_name = attribute_setter(attribute_name)
+          if parameter_name?(attribute_name)
+            return if attribute_getter_name == (args.size == 1 ? args.first : args)
+            set_parameter_attribute(attribute_getter_name, *args)
+          elsif (respond_to?(attribute_name, super: true) and respond_to?(attribute_setter_name, super: true))
+            return if self.send(attribute_getter_name) == (args.size == 1 ? args.first : args)
+            self.send(attribute_setter_name, *args)
+          end
+        end
+        
+        def get_attribute(attribute_name)
+          if parameter_name?(attribute_name)
+            arg_index = parameter_index(attribute_name)
+            @args[arg_index] if arg_index
+          elsif (respond_to?(attribute_name, super: true) and respond_to?(attribute_setter(attribute_name), super: true))
+            self.send(attribute_name)
+          end
+        end
+        
+        # TODO look why image is not working with the method_missing and respond_to? on shape
+        def method_missing(method_name, *args, &block)
+          if method_name.to_s.end_with?('=')
+            set_attribute(method_name, *args)
+          elsif has_attribute?(method_name) && args.empty?
+            get_attribute(method_name)
+          else # TODO support proxying calls to handle_observation_request for listeners just like WidgetProxy
+            super(method_name, *args, &block)
+          end
+        end
+
+        def respond_to?(method_name, *args, &block)
+          options = args.last if args.last.is_a?(Hash)
+          super_invocation = options && options[:super]
+          if !super_invocation && has_attribute?(method_name)
+            true
+          else
+            super(method_name, *args, &block)
+          end
+        end
+        
+        def attach(the_parent_dom_element)
+          the_parent_dom_element.html("#{the_parent_dom_element.html()}\n#{@dom}")
+        end
+        
+        def element
+          'g'
+        end
+        
+        def dom
+          shape_id = id
+          shape_class = name
+          @dom ||= xml {
+            g(id: shape_id, class: shape_class) {
+            }
+          }.to_s
+        end
+        
+        # TODO implement shape_at_location potentially with document.elementFromPoint(x, y);
+        
+      end
+      
+    end
+    
+  end
+  
+end
+
+require 'glimmer/swt/custom/shape/arc'
+require 'glimmer/swt/custom/shape/image'
+require 'glimmer/swt/custom/shape/line'
+require 'glimmer/swt/custom/shape/oval'
+require 'glimmer/swt/custom/shape/point'
+require 'glimmer/swt/custom/shape/polygon'
+require 'glimmer/swt/custom/shape/polyline'
+require 'glimmer/swt/custom/shape/rectangle'
+require 'glimmer/swt/custom/shape/text'

data/lib/glimmer/swt/image_proxy.rb

@@ -0,0 +1,29 @@
+module Glimmer
+  module SWT
+    # emulating org.eclipse.swt.graphics.Image
+    class ImageProxy
+      class << self
+        def create(*args, &content)
+          if args.size == 1 && args.first.is_a?(ImageProxy)
+            args.first
+          else
+            new(*args, &content)
+          end
+        end
+      end
+    
+      attr_reader :file_path, :width, :height
+      
+      def initialize(*args)
+        options = args.last.is_a?(Hash) ? args.last : {}
+        # TODO support a parent as a first argument before the file path
+        @file_path = args.first
+        @width = options[:width]
+        @height = options[:height]
+      end
+      
+      # TODO implement scale_to
+    end
+    # TODO alias as org.eclipse.swt.graphics.Image
+  end
+end

data/lib/glimmer/swt/menu_proxy.rb

@@ -198,6 +198,7 @@ module Glimmer
           # delay this till all children rendered (perhaps post_add_content block)
           parent_dom_element.css('position', 'relative')
           parent_dom_element.css('margin-top', '30px')
+          parent_dom_element.css('height', '114%')
           redraw
           `$(#{path}).menu({
             position: { my: "top", at: "bottom" },
@@ -222,7 +223,6 @@ module Glimmer
         @visible = value
         if @visible
           parent.menu_requested = true
-          parent.dom_element.css('position', 'relative')
           render
           dom_element.css('position', 'absolute')
           dom_element.css('left', parent.menu_x - parent.dom_element.offset.left)

data/lib/glimmer/swt/point.rb

@@ -1,5 +1,7 @@
 module Glimmer
   module SWT
+    # emulating org.eclipse.swt.graphics.Point
     Point = Struct.new(:x, :y)
+    # TODO alias as org.eclipse.swt.graphics.Point
   end
 end

data/lib/glimmer/swt/rectangle.rb

@@ -0,0 +1,7 @@
+module Glimmer
+  module SWT
+    # emulating org.eclipse.swt.graphics.Rectangle
+    Rectangle = Struct.new(:x, :y, :width, :height)
+    # TODO alias as org.eclipse.swt.graphics.Rectangle
+  end
+end

data/lib/glimmer/swt/widget_proxy.rb

@@ -30,7 +30,7 @@ module Glimmer
     class WidgetProxy
       include Glimmer
       include PropertyOwner
-      
+            
       Event = Struct.new(:widget, keyword_init: true)
     
       JS_KEY_CODE_TO_SWT_KEY_CODE_MAP = {
@@ -295,6 +295,7 @@ module Glimmer
       end
       
       def font=(value)
+        return if value.nil?
         @font = value.is_a?(FontProxy) ? value : FontProxy.new(self, value)
         dom_element.css('font-family', @font.name) unless @font.nil?
         dom_element.css('font-style', 'italic') if @font&.style == :italic || [@font&.style].flatten.compact.include?(:italic)
@@ -331,9 +332,10 @@ module Glimmer
         brand_new = @dom.nil? || old_element.empty? || brand_new
         build_dom(layout: !custom_parent_dom_element) # TODO handle custom parent layout by passing parent instead of parent dom element
         if brand_new
-          the_parent_dom_element.append(@dom) # TODO make a method attach to allow subclasses to override if needed
+          # TODO make a method attach to allow subclasses to override if needed
+          attach(the_parent_dom_element)
         else
-          old_element.replace_with(@dom)
+          reattach(old_element)
         end
         observation_requests&.each do |keyword, event_listener_set|
           event_listener_set.each do |event_listener|
@@ -347,6 +349,14 @@ module Glimmer
         content_on_render_blocks.each { |content_block| content(&content_block) } unless skip_content_on_render_blocks?
       end
       alias redraw render
+        
+      def attach(the_parent_dom_element)
+        the_parent_dom_element.append(@dom)
+      end
+        
+      def reattach(old_element)
+        old_element.replace_with(@dom)
+      end
       
       def content_on_render_blocks
         @content_on_render_blocks ||= []
@@ -367,7 +377,7 @@ module Glimmer
       def build_dom(layout: true)
         # TODO consider passing parent element instead and having table item include a table cell widget only for opal
         @dom = nil
-        @dom = dom
+        @dom = dom # TODO unify how to build dom for most widgets based on element, id, and name (class)
         @dom = @parent.get_layout.dom(@dom) if @parent.respond_to?(:layout) && @parent.get_layout
         @dom
       end
@@ -1143,6 +1153,7 @@ require 'glimmer/swt/combo_proxy'
 require 'glimmer/swt/c_combo_proxy'
 require 'glimmer/swt/checkbox_proxy'
 require 'glimmer/swt/composite_proxy'
+require 'glimmer/swt/canvas_proxy'
 require 'glimmer/swt/date_time_proxy'
 require 'glimmer/swt/group_proxy'
 require 'glimmer/swt/label_proxy'

data/lib/glimmer-dsl-opal/samples/elaborate/tetris/view/block.rb

@@ -25,10 +25,54 @@ class Tetris
       include Glimmer::UI::CustomWidget
   
       options :game_playfield, :block_size, :row, :column
+      
+      attr_accessor :bevel_pixel_size
+      
+      before_body do
+        self.bevel_pixel_size = 0.16*block_size.to_f
+      end
   
       body {
         canvas { |canvas_proxy|
           background <= [game_playfield[row][column], :color]
+          polygon(0, 0, block_size, 0, block_size - bevel_pixel_size, bevel_pixel_size, bevel_pixel_size, bevel_pixel_size) {
+            background <= [game_playfield[row][column], :color, on_read: ->(color_value) {
+              unless color_value.nil?
+                color = color(color_value)
+                rgb(color.red + 4*BEVEL_CONSTANT, color.green + 4*BEVEL_CONSTANT, color.blue + 4*BEVEL_CONSTANT)
+              end
+            }]
+          }
+          polygon(block_size, 0, block_size - bevel_pixel_size, bevel_pixel_size, block_size - bevel_pixel_size, block_size - bevel_pixel_size, block_size, block_size) {
+            background <= [game_playfield[row][column], :color, on_read: ->(color_value) {
+              unless color_value.nil?
+                color = color(color_value)
+                rgb(color.red - BEVEL_CONSTANT, color.green - BEVEL_CONSTANT, color.blue - BEVEL_CONSTANT)
+              end
+            }]
+          }
+          polygon(block_size, block_size, 0, block_size, bevel_pixel_size, block_size - bevel_pixel_size, block_size - bevel_pixel_size, block_size - bevel_pixel_size) {
+            background <= [game_playfield[row][column], :color, on_read: ->(color_value) {
+              unless color_value.nil?
+                color = color(color_value)
+                rgb(color.red - 2*BEVEL_CONSTANT, color.green - 2*BEVEL_CONSTANT, color.blue - 2*BEVEL_CONSTANT)
+              end
+            }]
+          }
+          polygon(0, 0, 0, block_size, bevel_pixel_size, block_size - bevel_pixel_size, bevel_pixel_size, bevel_pixel_size) {
+            background <= [game_playfield[row][column], :color, on_read: ->(color_value) {
+              unless color_value.nil?
+                color = color(color_value)
+                rgb(color.red - BEVEL_CONSTANT, color.green - BEVEL_CONSTANT, color.blue - BEVEL_CONSTANT)
+              end
+            }]
+          }
+          rectangle(0, 0, block_size, block_size) {
+            foreground <= [game_playfield[row][column], :color, on_read: ->(color_value) {
+              color_value == Model::Block::COLOR_CLEAR ? :gray : color_value
+            }]
+          }
+          
         }
       }
     end