glimmer-dsl-opal 0.6.1 → 0.7.0

data/lib/glimmer/data_binding/table_items_binding.rb

@@ -12,26 +12,32 @@ module Glimmer
       include DataBinding::Observer
 
       def initialize(parent, model_binding, column_properties)
-        @last_model_collection = nil
+        @last_populated_model_collection = nil
         @table = parent
         @model_binding = model_binding
         @column_properties = column_properties
-        if @table.respond_to?(:column_properties=)
-          @table.column_properties = @column_properties
-        ##else # assume custom widget
-        ##  @table.body_root.column_properties = @column_properties
-        end
-        call(@model_binding.evaluate_property)
-        model = model_binding.base_model
-        observe(model, model_binding.property_name_expression)
+        @table.data = @model_binding
         ##@table.on_widget_disposed do |dispose_event| # doesn't seem needed within Opal
         ##  unregister_all_observables
         ##end
+        if @table.respond_to?(:column_properties=)
+          @table.column_properties = @column_properties
+        else # assume custom widget
+         @table.body_root.column_properties = @column_properties
+        end
+        @table_observer_registration = observe(model_binding)
+        call
       end
 
       def call(new_model_collection=nil)
+        new_model_collection = @model_binding.evaluate_property # this ensures applying converters (e.g. :on_read)
+        table_cells = @table.items.map {|item| @table.column_properties.size.times.map {|i| item.get_text(i)} }
+        model_cells = new_model_collection.to_a.map {|m| @table.cells_for(m)}
+        return if table_cells == model_cells
         if new_model_collection and new_model_collection.is_a?(Array)
-          observe(new_model_collection, @column_properties)
+#           @table_items_observer_registration&.unobserve
+          @table_items_observer_registration = observe(new_model_collection, @column_properties)
+          add_dependent(@table_observer_registration => @table_items_observer_registration)
           @model_collection = new_model_collection
         end
         populate_table(@model_collection, @table, @column_properties)
@@ -39,8 +45,8 @@ module Glimmer
       end
       
       def populate_table(model_collection, parent, column_properties)
-        return if model_collection&.sort_by(&:hash) == @last_model_collection&.sort_by(&:hash)
-        @last_model_collection = model_collection
+        return if model_collection&.sort_by(&:hash) == @last_populated_model_collection&.sort_by(&:hash)
+        @last_populated_model_collection = model_collection
         # TODO improve performance
         selected_table_item_models = parent.selection.map(&:get_data)
         old_items = parent.items
@@ -55,16 +61,21 @@ module Glimmer
           table_item.id = old_item_ids_per_model[model.hash] if old_item_ids_per_model[model.hash]
         end
         selected_table_items = parent.search {|item| selected_table_item_models.include?(item.get_data) }
-        selected_table_items = [parent.items.first] if selected_table_items.empty? && !parent.items.empty?
-        parent.selection = selected_table_items unless selected_table_items.empty?
+        parent.selection = selected_table_items
         parent.redraw
       end
       
       def sort_table(model_collection, parent, column_properties)
-        return if model_collection == @last_model_collection
-        parent.items = parent.items.sort_by { |item| model_collection.index(item.get_data) }
-        @last_model_collection = model_collection
-      end      
+        return if model_collection == @last_sorted_model_collection
+        if model_collection == @last_populated_model_collection
+          # Reapply the last table sort. The model collection has just been populated since it diverged from what it was before
+          parent.sort!
+        else
+          # The model collection was sorted by the model, but beyond sorting, it did not change from the last populated model collection.
+          parent.items = parent.items.sort_by { |item| model_collection.index(item.get_data) }
+          @last_sorted_model_collection = @last_populated_model_collection = model_collection
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,41 @@
+# Copyright (c) 2007-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/dsl/expression'
+
+module Glimmer
+  module DSL
+    module Opal
+      class BlockPropertyExpression < Expression
+        def can_interpret?(parent, keyword, *args, &block)
+          block_given? and
+            args.size == 0 and
+            parent.respond_to?("#{keyword}_block=")
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          parent.send("#{keyword}_block=", block)
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -25,6 +25,7 @@ require 'glimmer/dsl/opal/custom_widget_expression'
 require 'glimmer/dsl/opal/swt_expression'
 require 'glimmer/dsl/opal/radio_group_selection_data_binding_expression'
 require 'glimmer/dsl/opal/checkbox_group_selection_data_binding_expression'
+require 'glimmer/dsl/opal/block_property_expression'
 
 module Glimmer
   module DSL
@@ -42,6 +43,7 @@ module Glimmer
          data_binding
          font
          layout
+         block_property
          property
          widget
        ]

data/lib/glimmer/swt/display_proxy.rb

@@ -24,6 +24,10 @@ module Glimmer
         Document
       end
       
+      def shells
+        @shells ||= []
+      end
+      
       def render
         # No rendering as body is rendered as part of ShellProxy.. this class only serves as an SWT Display utility
       end

data/lib/glimmer/swt/message_box_proxy.rb

@@ -1,4 +1,5 @@
 require 'glimmer/swt/widget_proxy'
+require 'glimmer/swt/display_proxy'
 
 module Glimmer
   module SWT
@@ -7,7 +8,7 @@ module Glimmer
       
       def initialize(parent, args, block)
         i = 0
-        @parent = parent
+        @parent = parent || DisplayProxy.instance.shells.first
         @args = args
         @block = block
         @children = Set.new

data/lib/glimmer/swt/property_owner.rb

@@ -7,7 +7,7 @@ module Glimmer
       end
     
       def set_attribute(attribute_name, *args)
-        send(attribute_setter(attribute_name), *args) unless send(attribute_getter(attribute_name)) == args.first
+        send(attribute_setter(attribute_name), *args) unless args.size == 1 && send(attribute_getter(attribute_name)) == args.first
       end
       
       def attribute_setter(attribute_name)
@@ -16,7 +16,7 @@ module Glimmer
       
       def attribute_getter(attribute_name)
         attribute_name.to_s.underscore
-      end      
+      end
     end
   end
 end

data/lib/glimmer/swt/shell_proxy.rb

@@ -21,6 +21,7 @@ module Glimmer
         @layout.margin_width = 0
         @layout.margin_height = 0
         self.minimum_size = Point.new(WIDTH_MIN, HEIGHT_MIN)
+        DisplayProxy.instance.shells << self
       end
       
       def element
@@ -207,6 +208,7 @@ module Glimmer
         body_class = ([name] + css_classes.to_a).join(' ')
         @dom ||= html {
           div(id: body_id, class: body_class) {
+            # TODO support the idea of dynamic CSS building on close of shell that adds only as much CSS as needed for widgets that were mentioned
             style(class: 'common-style') {
               style_dom_css
             }
@@ -246,6 +248,12 @@ module Glimmer
             style(class: 'scrolled-composite-style') {
               Glimmer::SWT::ScrolledCompositeProxy::STYLE
             }
+            style(class: 'table-item-style') {
+              Glimmer::SWT::TableItemProxy::STYLE
+            }
+            style(class: 'table-column-style') {
+              Glimmer::SWT::TableColumnProxy::STYLE
+            }
           }
         }.to_s
       end

data/lib/glimmer/swt/table_column_proxy.rb

@@ -1,12 +1,51 @@
 require 'glimmer/swt/widget_proxy'
+require 'glimmer/swt/swt_proxy'
 
 module Glimmer
   module SWT
     class TableColumnProxy < WidgetProxy
+      STYLE = <<~CSS
+        th.table-column {
+          background: rgb(246, 246, 246);
+          text-align: left;
+          padding: 5px;
+        }
+        
+        th.table-column .sort-direction {
+          float: right;
+        }
+      CSS
       include Glimmer
       
-      attr_reader :text, :width      
+      attr_accessor :sort_block, :sort_by_block
+      attr_reader :text, :width,
+                  :no_sort, :sort_property, :editor
+      alias no_sort? no_sort
+      
+      def initialize(parent, args, block)
+        @no_sort = args.delete(:no_sort)
+        super(parent, args, block)
+        unless no_sort?
+          content {
+            on_widget_selected { |event|
+              parent.sort_by_column!(self)
+            }
+          }
+        end
+      end
+      
+      def sort_property=(args)
+        @sort_property = args unless args.empty?
+      end
+      
+      def sort_direction
+        parent.sort_direction if parent.sort_column == self
+      end
       
+      def redraw_sort_direction
+        sort_icon_dom_element.attr('class', sort_icon_class)
+      end
+            
       def text=(value)
         @text = value
         redraw
@@ -21,36 +60,47 @@ module Glimmer
         parent.columns_path
       end
       
-      def css
-        <<~CSS
-          width: #{width}px;
-        CSS
-      end
-    
       def element
         'th'
       end
       
+      def sort_icon_class
+        @sort_icon_class = 'sort-direction'
+        @sort_icon_class += (sort_direction == SWTProxy[:up] ? ' ui-icon ui-icon-caret-1-n' : ' ui-icon ui-icon-caret-1-s') unless sort_direction.nil?
+        @sort_icon_class
+      end
+      
+      def sort_icon_dom_element
+        dom_element.find('.sort-direction')
+      end
+      
       def observation_request_to_event_mapping
         {
           'on_widget_selected' => {
-            event: 'click'
+            event: 'click',
+            event_handler: -> (event_listener) {
+              -> (event) {
+                event_listener.call(event)
+                redraw_sort_direction
+              }
+            }
           },
         }
-      end      
+      end
       
       def dom
         table_column_text = text
         table_column_id = id
-        table_column_id_style = css
+        table_column_id_style = "width: #{width}px;"
         table_column_css_classes = css_classes
         table_column_css_classes << name
         @dom ||= html {
           th(id: table_column_id, style: table_column_id_style, class: table_column_css_classes.to_a.join(' ')) {
-            table_column_text
+            span {table_column_text}
+            span(class: sort_icon_class)
           }
         }.to_s
-      end      
+      end
     end
   end
 end

data/lib/glimmer/swt/table_item_proxy.rb

@@ -3,10 +3,17 @@ require 'glimmer/swt/widget_proxy'
 module Glimmer
   module SWT
     class TableItemProxy < WidgetProxy
+      STYLE = <<~CSS
+        tr.table-item:nth-child(even):not(.selected) {
+          background: rgb(243, 244, 246);
+        }
+      CSS
+      
       attr_reader :data
       
       def initialize(parent, args, block)
         super(parent, args, block)
+        # TODO check if there is a need to remove this observer when removing widget from table upon items update
         on_widget_selected { |event|
           parent.select(parent.index_of(self), event.meta?)
         }
@@ -54,7 +61,7 @@ module Glimmer
       end
       
       def redraw
-        super() #TODO re-enalbe and remove below lines
+        super() #TODO re-enable and remove below lines
 
         # TODO perhaps turn the following lambdas into methods
         table_item_edit_handler = lambda do |event, cancel = false|

data/lib/glimmer/swt/table_proxy.rb

@@ -4,15 +4,22 @@ require 'glimmer/swt/table_column_proxy'
 module Glimmer
   module SWT
     class TableProxy < WidgetProxy
-      attr_reader :columns, :selection
-      attr_accessor :column_properties
+      attr_reader :columns, :selection,
+                  :sort_type, :sort_column, :sort_property, :sort_block, :sort_by_block, :additional_sort_properties
+      attr_accessor :column_properties, :item_count, :data
       alias items children
+      alias model_binding data
       
       def initialize(parent, args, block)
         super(parent, args, block)
         @columns = []
         @children = []
         @selection = []
+        if editable?
+          on_mouse_up { |event|
+            edit_table_item(event.table_item, event.column_index)
+          }
+        end
       end
       
       # Only table_columns may be added as children
@@ -25,13 +32,33 @@ module Glimmer
         child.redraw
       end
       
+      def post_add_content
+        return if @initially_sorted
+        initial_sort!
+        @initially_sorted = true
+      end
+      
+      def get_data(key=nil)
+        data
+      end
+      
       def remove_all
         items.clear
         redraw
       end
       
+      def editable?
+        args.include?(:editable)
+      end
+      alias editable editable?
+      
+      def selection
+        @selection.to_a
+      end
+      
       def selection=(new_selection)
-        changed = (@selection + new_selection) - (@selection & new_selection)
+        new_selection = new_selection.to_a
+        changed = (selection + new_selection) - (selection & new_selection)
         @selection = new_selection
         changed.each(&:redraw)
       end
@@ -41,6 +68,15 @@ module Glimmer
         redraw
       end
       
+      def item_count=(value)
+        @item_count = value
+        redraw_empty_items
+      end
+      
+      def cells_for(model)
+        column_properties.map {|property| model.send(property)}
+      end
+      
       def search(&condition)
         items.select {|item| condition.nil? || condition.call(item)}
       end
@@ -61,8 +97,147 @@ module Glimmer
         self.selection = new_selection
       end
       
+      def search(&condition)
+        items.select {|item| condition.nil? || condition.call(item)}
+      end
+      
+      def sort_block=(comparator)
+        @sort_block = comparator
+      end
+      
+      def sort_by_block=(property_picker)
+        @sort_by_block = property_picker
+      end
+      
+      def sort_property=(new_sort_property)
+        @sort_property = [new_sort_property].flatten.compact
+      end
+      
+      def detect_sort_type
+        @sort_type = sort_property.size.times.map { String }
+        array = model_binding.evaluate_property
+        sort_property.each_with_index do |a_sort_property, i|
+          values = array.map { |object| object.send(a_sort_property) }
+          value_classes = values.map(&:class).uniq
+          if value_classes.size == 1
+            @sort_type[i] = value_classes.first
+          elsif value_classes.include?(Integer)
+            @sort_type[i] = Integer
+          elsif value_classes.include?(Float)
+            @sort_type[i] = Float
+          end
+        end
+      end
+      
+      def column_sort_properties
+        column_properties.zip(columns.map(&:sort_property)).map do |pair|
+          [pair.compact.last].flatten.compact
+        end
+      end
+      
+      def sort_direction
+        @sort_direction == :ascending ? SWTProxy[:up] : SWTProxy[:down]
+      end
+      
+      def sort_direction=(value)
+        @sort_direction = value == SWTProxy[:up] ? :ascending : :descending
+      end
+      
+      # Sorts by specified TableColumnProxy object. If nil, it uses the table default sort instead.
+      def sort_by_column!(table_column_proxy=nil)
+        index = columns.to_a.index(table_column_proxy) unless table_column_proxy.nil?
+        new_sort_property = table_column_proxy.nil? ? @sort_property : table_column_proxy.sort_property || [column_properties[index]]
+        
+        return if table_column_proxy.nil? && new_sort_property.nil? && @sort_block.nil? && @sort_by_block.nil?
+        if new_sort_property && table_column_proxy.nil? && new_sort_property.size == 1 && (index = column_sort_properties.index(new_sort_property))
+          table_column_proxy = columns[index]
+        end
+        if new_sort_property && new_sort_property.size == 1 && !additional_sort_properties.to_a.empty?
+          selected_additional_sort_properties = additional_sort_properties.clone
+          if selected_additional_sort_properties.include?(new_sort_property.first)
+            selected_additional_sort_properties.delete(new_sort_property.first)
+            new_sort_property += selected_additional_sort_properties
+          else
+            new_sort_property += additional_sort_properties
+          end
+        end
+        
+        new_sort_property = [new_sort_property].flatten.compact unless new_sort_property.is_a?(Array)
+        @sort_direction = @sort_direction.nil? || @sort_property.first != new_sort_property.first || @sort_direction == :descending ? :ascending : :descending
+        
+        @sort_property = new_sort_property
+        table_column_index = column_properties.index(new_sort_property.to_s.to_sym)
+        table_column_proxy ||= columns[table_column_index] if table_column_index
+        @sort_column = table_column_proxy if table_column_proxy
+                
+        if table_column_proxy
+          @sort_by_block = nil
+          @sort_block = nil
+        end
+        @sort_type = nil
+        if table_column_proxy&.sort_by_block
+          @sort_by_block = table_column_proxy.sort_by_block
+        elsif table_column_proxy&.sort_block
+          @sort_block = table_column_proxy.sort_block
+        else
+          detect_sort_type
+        end
+                
+        sort!
+      end
+      
+      def initial_sort!
+        sort_by_column!
+      end
+      
+      def sort!
+        return unless sort_property && (sort_type || sort_block || sort_by_block)
+        array = model_binding.evaluate_property
+        array = array.sort_by(&:hash) # this ensures consistent subsequent sorting in case there are equivalent sorts to avoid an infinite loop
+        # Converting value to_s first to handle nil cases. Should work with numeric, boolean, and date fields
+        if sort_block
+          sorted_array = array.sort(&sort_block)
+        elsif sort_by_block
+          sorted_array = array.sort_by(&sort_by_block)
+        else
+          sorted_array = array.sort_by do |object|
+            sort_property.each_with_index.map do |a_sort_property, i|
+              value = object.send(a_sort_property)
+              # handle nil and difficult to compare types gracefully
+              if sort_type[i] == Integer
+                value = value.to_i
+              elsif sort_type[i] == Float
+                value = value.to_f
+              elsif sort_type[i] == String
+                value = value.to_s
+              end
+              value
+            end
+          end
+        end
+        sorted_array = sorted_array.reverse if @sort_direction == :descending
+        model_binding.call(sorted_array)
+      end
+      
+      def additional_sort_properties=(*args)
+        @additional_sort_properties = args unless args.empty?
+      end
+      
       def edit_table_item(table_item, column_index)
-        table_item.edit(column_index)
+        table_item&.edit(column_index) unless column_index.nil?
+      end
+      
+      def header_visible=(value)
+        @header_visible = value
+        if @header_visible
+          thead_dom_element.remove_class('hide')
+        else
+          thead_dom_element.add_class('hide')
+        end
+      end
+      
+      def header_visible
+        @header_visible
       end
       
       def selector
@@ -96,6 +271,9 @@ module Glimmer
           'on_mouse_up' => {
             event: 'mouseup',
             event_handler: mouse_handler,
+          },
+          'on_widget_selected' => {
+            event: 'mouseup',
           }
         }
       end
@@ -103,6 +281,16 @@ module Glimmer
       def redraw
         super()
         @columns.to_a.each(&:redraw)
+        redraw_empty_items
+      end
+      
+      def redraw_empty_items
+        if @children&.size.to_i < item_count.to_i
+          item_count.to_i.times do
+            empty_columns = column_properties&.size.to_i.times.map { |i| "<td data-column-index='#{i}'></td>" }
+            items_dom_element.append("<tr class='table-item empty-table-item'>#{empty_columns}</tr>")
+          end
+        end
       end
       
       def element
@@ -136,6 +324,10 @@ module Glimmer
         }
       end
       
+      def thead_dom_element
+        dom_element.find('thead')
+      end
+      
       def items_dom
         tbody {
         }
@@ -154,6 +346,23 @@ module Glimmer
           }
         }.to_s
       end
+      
+      private
+
+      def property_type_converters
+        super.merge({
+          selection: lambda do |value|
+            if value.is_a?(Array)
+              search {|ti| value.include?(ti.get_data) }
+            else
+              search {|ti| ti.get_data == value}
+            end
+          end,
+        })
+      end
+      
     end
+    
   end
+  
 end