glimmer-dsl-opal 0.4.0 → 0.5.0

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/grid_layout_proxy.rb

@@ -3,6 +3,15 @@ require 'glimmer/swt/layout_proxy'
 module Glimmer
   module SWT
     class GridLayoutProxy < LayoutProxy
+      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)
@@ -52,19 +61,21 @@ module Glimmer
       end
             
       def reapply
+        # TODO get rid of this method
         layout_css = <<~CSS
-          display: grid;
           grid-template-columns: #{'auto ' * @num_columns.to_i};
-          grid-template-rows: min-content;
           grid-row-gap: #{@vertical_spacing}px;
           grid-column-gap: #{@horizontal_spacing}px;
-          justify-content: start;
-          place-content: start;
-          align-items: stretch;
         CSS
-        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.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

data/lib/glimmer/swt/group_proxy.rb

@@ -0,0 +1,38 @@
+require 'glimmer/swt/widget_proxy'
+
+module Glimmer
+  module SWT
+    # Adapter for org.eclipse.swt.widgets.Group
+    #
+    # Follows Adapter Pattern
+    class GroupProxy < CompositeProxy
+      attr_reader :text
+      
+      def text=(value)
+        @text = value
+        if @text.nil?
+          legend_dom_element.add_class('hide')
+        else
+          legend_dom_element.remove_class('hide')
+        end
+        legend_dom_element.html(@text)
+      end
+      
+      def element
+        'fieldset'
+      end
+      
+      def legend_dom_element
+        dom_element.find('legend')
+      end
+      
+      def dom
+        @dom ||= html {
+          fieldset(id: id, class: name) {
+            legend(class: 'hide') { text }
+          }
+        }.to_s
+      end
+    end
+  end
+end

data/lib/glimmer/swt/label_proxy.rb

@@ -1,30 +1,50 @@
 require 'glimmer/swt/widget_proxy'
+# require 'glimmer/swt/image_proxy'
 
 module Glimmer
   module SWT
     class LabelProxy < WidgetProxy
-      attr_reader :text
+      attr_reader :text, :background_image, :image, :alignment
+      
+      def initialize(parent, args)
+        super(parent, args)
+        self.alignment = [:left, :center, :right].detect {|align| args.detect { |arg| SWTProxy[align] == arg } }
+      end
 
       def text=(value)
         @text = value
         dom_element.html(value)
       end
       
+      def background_image=(*image_options)
+        # TODO consider if there is a difference between background_image and image in label and to have one reuse the other
+        # TODO finish implementation
+#         @background_image = Glimmer::SWT::ImageProxy.create(*image_options)
+#         dom_element.css('background-image', @background_image.image_data.dom_element.src)
+      end
+      
+      def image=(*image_options)
+        # TODO finish implementation
+#         @image = Glimmer::SWT::ImageProxy.create(*image_options)
+#         dom_element.css('background-image', @image.image_data.dom_element.src)
+      end
+      
       def element
         'label'
       end
-      
-      def alignment
-        [:left, :center, :right].detect {|value| args.detect { |arg| SWTProxy[value] == arg } }
+
+      def alignment=(value)
+        # TODO consider storing swt value in the future instead
+        @alignment = value
+        dom_element.css('text-align', @alignment.to_s)
       end
       
-      def dom        
+      def dom
         label_text = @text
         label_id = id
-        label_style = "text-align: #{alignment};"
         label_class = name
         @dom ||= html {
-          label(id: label_id, style: label_style, class: label_class) {
+          label(id: label_id, class: label_class) {
             label_text
           }
         }.to_s

data/lib/glimmer/swt/layout_data_proxy.rb

@@ -14,68 +14,86 @@ module Glimmer
                   :vertical_indent, 
                   :grab_excess_horizontal_space,
                   :grab_excess_vertical_space,
+                  :width_hint,
                   :height_hint
     
       def initialize(parent, args)
         @parent = parent
         @args = args
-        # TODO spread args correctly
+        self.horizontal_alignment = @args[0] if @args[0]
+        self.vertical_alignment = @args[1] if @args[1]
+        self.grab_excess_horizontal_space = @args[2] if @args[2]
+        self.grab_excess_vertical_space = @args[3] if @args[3]
+        # TODO spread args correctly as per SWT LayoutData API
         # TODO avoid using reapply
-        reapply
+#         reapply
+      end
+
+      def width_hint=(width_hint)
+        @width_hint = width_hint
+        @parent.dom_element.css('width', "#{@width_hint}px")
+#         reapply
       end
 
       def height_hint=(height_hint)
         @height_hint = height_hint
-        # TODO
-        reapply
+        @parent.dom_element.css('height', "#{@height_hint}px")
+#         reapply
       end
 
       def horizontal_alignment=(horizontal_alignment)
         @horizontal_alignment = horizontal_alignment
+        return if @horizontal_alignment.nil?
+        if @horizontal_alignment == 'fill'
+          @parent.dom_element.css('width', '100%') if width_hint.nil?
+        else
+          @parent.dom_element.css('text-align', @horizontal_alignment)
+        end
         # TODO
-        reapply
+#         reapply
       end
       
       def vertical_alignment=(vertical_alignment)
         @vertical_alignment = vertical_alignment
         # TODO
-        reapply
+#         reapply
       end
       
       def horizontal_span=(value)
         @horizontal_span = value
         @parent.dom_element.css('grid-column-start', "span #{@horizontal_span}")
-        reapply
+#         reapply
       end
       
       def vertical_span=(value)
         @vertical_span = value
         @parent.dom_element.css('grid-row-start', "span #{@vertical_span}")
-        reapply
+#         reapply
       end
       
       def horizontal_indent=(value)
         @horizontal_indent = value
         @parent.dom_element.css('padding-left', @horizontal_indent)
-        reapply
+#         reapply
       end
       
       def vertical_indent=(value)
         @vertical_indent = value
         @parent.dom_element.css('padding-top', @vertical_indent)
-        reapply
+#         reapply
       end
       
       def grab_excess_horizontal_space=(grab_excess_horizontal_space)
         @grab_excess_horizontal_space = grab_excess_horizontal_space
-        # TODO
-        reapply
+        @parent.dom_element.css('width', "100%") if @grab_excess_horizontal_space && width_hint.nil?
+#         reapply
       end
 
       def grab_excess_vertical_space=(grab_excess_vertical_space)
         @grab_excess_vertical_space = grab_excess_vertical_space
+        @parent.dom_element.css('height', "100%") if @grab_excess_vertical_space && height_hint.nil?
         # TODO
-        reapply
+#         reapply
       end
 
       def reapply

data/lib/glimmer/swt/list_proxy.rb

@@ -6,7 +6,7 @@ module Glimmer
       ITEM_EMPTY = '_____'
       attr_reader :items, :selection
       
-      def initialize(parent, args)        
+      def initialize(parent, args)
         super(parent, args)
         @selection = []
       end
@@ -62,7 +62,7 @@ module Glimmer
                 if event.target.prop('nodeName') == 'LI'
                   selected_item = event.target.text
                   select(index_of(selected_item), event.meta_key)
-                  event_listener.call(event)              
+                  event_listener.call(event)
                 end
               }
             }

data/lib/glimmer/swt/radio_proxy.rb

@@ -0,0 +1,81 @@
+require 'glimmer/swt/widget_proxy'
+
+module Glimmer
+  module SWT
+    class RadioProxy < WidgetProxy
+      STYLE=<<~CSS
+        .radio {
+          display: inline;
+        }
+        .radio-label {
+          display: inline;
+        }
+        .radio-container {
+        }
+      CSS
+      
+      def text
+        label_dom_element.html
+      end
+      
+      def text=(value)
+        label_dom_element.html(value)
+      end
+      
+      def selection
+        dom_element.prop('checked')
+      end
+      
+      def selection=(value)
+        dom_element.prop('checked', value)
+      end
+      
+      def element
+        'input'
+      end
+      
+      def label_id
+        "#{id}-label"
+      end
+      
+      def label_name
+        "#{name}-label"
+      end
+      
+      def label_path
+        "#{parent_path} ##{label_id}"
+      end
+      
+      def label_dom_element
+        Document.find(label_path)
+      end
+      
+      def container_id
+        "#{id}-container"
+      end
+
+      def container_name
+        "#{name}-container"
+      end
+
+      def observation_request_to_event_mapping
+        {
+          'on_widget_selected' => {
+            event: 'change'
+          },
+        }
+      end
+      
+      def dom
+        @dom ||= html {
+          span(id: container_id, class: container_name) {
+            input(type: 'radio', id: id, class: name, name: parent&.id)
+            label(id: label_id, class: label_name, for: id) {
+              text
+            }
+          }
+        }.to_s
+      end
+    end
+  end
+end