glimmer-dsl-opal 0.1.0 → 0.5.1

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

@@ -0,0 +1,143 @@
+# Copyright (c) 2020 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/ui/custom_widget'
+
+module Glimmer
+  module SWT
+    module Custom
+      # A custom widget rendering a group of radios generated via data-binding
+      class RadioGroup
+        include Glimmer::UI::CustomWidget
+        
+        body {
+          composite # just an empty composite to hold radios upon data-binding `selection`
+        }
+        
+        def items=(text_array)
+          selection_value = selection
+          @items = Array[*text_array]
+          build_radios
+        end
+        
+        def items
+          @items || []
+        end
+        
+        def selection=(text)
+          radios.count.times do |index|
+            radio = radios[index]
+            item = items[index]
+            radio.selection = item == text
+          end
+        end
+        
+        def selection
+          selection_value = radios[selection_index]&.text unless selection_index == -1
+          selection_value.to_s
+        end
+        
+        def selection_index=(index)
+          self.selection=(items[index])
+        end
+        alias select selection_index=
+        
+        def selection_index
+          radios.index(radios.detect(&:selection)) || -1
+        end
+        
+        def radios
+          @radios ||= []
+        end
+        
+        def observation_request_to_event_mapping
+          # TODO method might not be needed
+          {
+            'on_widget_selected' => {
+              event: 'change'
+            },
+          }
+        end
+        
+        def can_handle_observation_request?(observation_request)
+          radios.first&.can_handle_observation_request?(observation_request) || super(observation_request)
+        end
+        
+        def handle_observation_request(observation_request, &block)
+          observation_requests << [observation_request, block]
+          delegate_observation_request_to_radios(observation_request, &block)
+          super
+        end
+        
+        def delegate_observation_request_to_radios(observation_request, &block)
+          if observation_request != 'on_widget_disposed'
+            radios.count.times do |index|
+            radio = radios[index]
+            radio.handle_observation_request(observation_request, &block) if radio.can_handle_observation_request?(observation_request)
+            end
+          end
+        end
+        
+        def observation_requests
+          @observation_requests ||= Set.new
+        end
+        
+        def has_attribute?(attribute_name, *args)
+          @radios.to_a.map do |widget_proxy|
+            return true if widget_proxy.has_attribute?(attribute_name, *args)
+          end
+          super
+        end
+         
+        def set_attribute(attribute_name, *args)
+          excluded_attributes = ['selection']
+          unless excluded_attributes.include?(attribute_name.to_s)
+            @radios.to_a.each do |widget_proxy|
+              widget_proxy.set_attribute(attribute_name, *args) if widget_proxy.has_attribute?(attribute_name, *args)
+            end
+          end
+          super
+        end
+        
+        private
+        
+        def build_radios
+          current_selection = selection
+          @radios = []
+          items.each do |item|
+            body_root.content {
+              radios << radio { |radio_proxy|
+                text item
+                on_widget_selected {
+                  self.selection = items[radios.index(radio_proxy)]
+                }
+              }
+            }
+          end
+          observation_requests.to_a.each do |observation_request, block|
+            delegate_observation_request_to_radios(observation_request, &block)
+          end
+          self.selection = current_selection
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/swt/display_proxy.rb

@@ -0,0 +1,79 @@
+module Glimmer
+  module SWT
+    class DisplayProxy < WidgetProxy
+      class << self
+        def instance
+          @instance ||= new
+        end
+      end
+      
+      def initialize
+        # Do not call super
+      end
+      
+      def path
+        "html body"
+      end
+
+      # Root element representing widget. Must be overridden by subclasses if different from div
+      def element
+        'body'
+      end
+      
+      def listener_dom_element
+        Document
+      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
+        end
+        Async::Task.new(&executer)
+      end
+      # sync_exec kept for API compatibility reasons
+      alias sync_exec async_exec
+      
+      def observation_request_to_event_mapping
+        {
+          'on_swt_keydown' => [
+            {
+              event: 'keypress',
+              event_handler: -> (event_listener) {
+                -> (event) {
+                  event.singleton_class.define_method(:character) do
+                    which || key_code
+                  end
+                  event_listener.call(event)
+                }
+              }
+            },
+            {
+              event: 'keydown',
+              event_handler: -> (event_listener) {
+                -> (event) {
+                  event.singleton_class.define_method(:character) do
+                    which || key_code
+                  end
+                  event_listener.call(event) if event.key_code != 13 && (event.key_code == 127 || event.key_code <= 31)
+                }
+              }
+            }          
+          ]
+        }
+      end      
+      
+      def shells
+        @shells ||= []
+      end
+    end
+  end
+end

data/lib/glimmer/swt/fill_layout_proxy.rb

@@ -0,0 +1,84 @@
+require 'glimmer/swt/layout_proxy'
+
+module Glimmer
+  module SWT
+    class FillLayoutProxy < LayoutProxy
+      include Glimmer
+      
+      STYLE = <<~CSS
+        .fill-layout {
+          display: flex;
+        }
+        
+        .fill-layout > * {
+          width: 100%;
+          height: 100%;
+        }
+        
+        .fill-layout-horizontal {
+          flex-direction: row;
+        }
+        
+        .fill-layout-vertical {
+          flex-direction: column;
+        }
+      CSS
+    
+      attr_reader :type, :margin_width, :margin_height, :spacing
+    
+      def initialize(parent, args)
+        super(parent, args)
+        @type = @args.first || :horizontal
+        self.margin_width = 15
+        self.margin_height = 15
+        @parent.css_classes << 'fill-layout'
+        @parent.css_classes << (horizontal? ? 'fill-layout-horizontal' : 'fill-layout-vertical')
+        @parent.dom_element.add_class('fill-layout')
+        @parent.dom_element.add_class(horizontal? ? 'fill-layout-horizontal' : 'fill-layout-vertical')
+      end
+      
+      def horizontal?
+        @type == :horizontal
+      end
+
+      def vertical?
+        @type == :vertical
+      end
+
+      def margin_width=(pixels)
+        @margin_width = pixels
+        # Using padding for width since margin-right isn't getting respected with width 100%
+        @parent.dom_element.css('padding-left', @margin_width)
+        @parent.dom_element.css('padding-right', @margin_width)
+      end
+      
+      def margin_height=(pixels)
+        @margin_height = pixels
+        @parent.dom_element.css('padding-top', @margin_height)
+        @parent.dom_element.css('padding-bottom', @margin_height)
+      end
+      
+      def spacing=(spacing)
+        @spacing = spacing.to_i
+        # TODO implement changes to accomodate layout_data in the future
+        @parent.style_element.html css {
+          s("##{@parent.id} > *") {
+            if horizontal?
+              margin_right "#{@spacing}px"
+            elsif vertical?
+              margin_bottom "#{@spacing}px"
+            end
+          }          
+          s("##{@parent.id} > :last-child") {
+            if horizontal?
+              margin_right 0
+            elsif vertical?
+              margin_bottom 0
+            end
+          }
+        }.to_s
+      end
+      
+    end
+  end
+end

data/lib/glimmer/swt/font_proxy.rb

@@ -0,0 +1,79 @@
+# Copyright (c) 2020 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/error'
+
+module Glimmer
+  module SWT
+    # Proxy for org.eclipse.swt.graphics.Font
+    #
+    # This class can be optionally used with WidgetProxy to manipulate
+    # an SWT widget font (reusing its FontData but building a new Font)
+    #
+    # Otherwise, if no WidgetProxy is passed to constructor, it builds new FontData
+    #
+    # 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]
+
+      attr_reader :widget_proxy, :font_properties
+
+      # 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 = nil, font_properties)
+        @widget_proxy = widget_proxy
+        @font_properties = font_properties.symbolize_keys
+        detect_invalid_font_property(font_properties)
+      end
+
+      def name
+        font_properties[:name]
+      end
+
+      def height
+        font_properties[:height]
+      end
+
+      def style
+        font_properties[:style]
+      end
+
+      private
+
+      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/grid_layout_proxy.rb

@@ -3,18 +3,28 @@ require 'glimmer/swt/layout_proxy'
 module Glimmer
   module SWT
     class GridLayoutProxy < LayoutProxy
-      attr_reader :num_columns, :make_columns_equal_width, :horizontal_spacing, :vertical_spacing
+      STYLE = <<~CSS
+        .grid-layout {
+          display: grid;
+          grid-template-rows: min-content;
+          justify-content: start;
+          place-content: start;
+          align-items: stretch;      
+        }
+      CSS
+      attr_reader :num_columns, :make_columns_equal_width, :horizontal_spacing, :vertical_spacing, :margin_width, :margin_height
     
       def initialize(parent, args)
         super(parent, args)
-        @horizontal_spacing = 10
-        @vertical_spacing = 10
-        @num_columns = @args.first || 1        
+        self.horizontal_spacing = 10
+        self.vertical_spacing = 10
+        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
       end
@@ -36,6 +46,37 @@ module Glimmer
 #         @parent.add_css_class("vertical-spacing-#{@vertical_spacing}")
         reapply
       end
+      
+      def margin_width=(pixels)
+        @margin_width = pixels
+        # Using padding for width since margin-right isn't getting respected with width 100%
+        @parent.dom_element.css('padding-left', @margin_width)
+        @parent.dom_element.css('padding-right', @margin_width)
+      end
+      
+      def margin_height=(pixels)
+        @margin_height = pixels
+        @parent.dom_element.css('padding-top', @margin_height)
+        @parent.dom_element.css('padding-bottom', @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
+        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      
     end
   end
 end