glimmer-dsl-opal 0.1.0 → 0.2.0

data/lib/glimmer/swt/label_proxy.rb

@@ -7,17 +7,21 @@ module Glimmer
 
       def text=(value)
         @text = value
-        redraw
+        dom_element.html(value)
       end
       
       def element
         'label'
       end
       
-      def dom
+      def alignment
+        [:left, :center, :right].detect {|value| args.detect { |arg| SWTProxy[value] == arg } }
+      end
+      
+      def dom        
         label_text = @text
         label_id = id
-        label_style = css
+        label_style = "text-align: #{alignment};"
         label_class = name
         @dom ||= html {
           label(id: label_id, style: label_style, class: label_class) {

data/lib/glimmer/swt/layout_proxy.rb

@@ -31,8 +31,14 @@ module Glimmer
         
       def initialize(parent, args)
         @parent = parent
-        @args = args
+        @parent.css_classes.each do |css_class|
+          @parent.remove_css_class(css_class) if css_class.include?('layout')
+        end
+        @args = args        
         @parent.add_css_class(css_class)
+        @parent.layout = self
+        self.margin_width = 15 if respond_to?(:margin_width=)
+        self.margin_height = 15 if respond_to?(:margin_height=)        
       end
 
       def css_class
@@ -40,21 +46,17 @@ module Glimmer
       end
       
       def reapply
-        layout_css = <<~CSS
-          display: grid;
-          grid-template-columns: #{'auto ' * @num_columns.to_i};
-          grid-row-gap: #{@vertical_spacing}px;
-          grid-column-gap: #{@horizontal_spacing}px;
-          justify-content: start;
-        CSS
-        layout_css.split(";").map(&:strip).map {|l| l.split(':').map(&:strip)}.each do |key, value|
-          unless key.nil?
-            @parent.dom_element.css(key, value)
-          end
-        end
+        # subclasses can override this
+      end
+      
+      # Decorates widget dom. Subclasses may override. Returns widget dom by default.
+      def dom(widget_dom)
+        widget_dom
       end
     end
   end
 end
 
 require 'glimmer/swt/grid_layout_proxy'
+require 'glimmer/swt/fill_layout_proxy'
+require 'glimmer/swt/row_layout_proxy'

data/lib/glimmer/swt/list_proxy.rb

@@ -13,7 +13,18 @@ module Glimmer
       
       def items=(items)
         @items = items.map {|item| item.strip == '' ? ITEM_EMPTY : item}
-        redraw # consider repopulating li's instead of redrawing when li's are available.
+        list_selection = selection
+        items_dom = @items.to_a.each_with_index.map do |item, index|
+          li_class = ''
+          li_class += ' selected' if list_selection.include?(item)
+          li_class += ' empty-list-item' if item == ITEM_EMPTY
+          html {
+            li(class: li_class) {
+              item
+            }
+          }.to_s
+        end
+        dom_element.html(items_dom)
       end
       
       def index_of(item)
@@ -23,7 +34,11 @@ module Glimmer
       # used for multi-selection taking an array
       def selection=(selection)
         @selection = selection
-        redraw
+        dom_element.find('li').remove_class('selected')
+        @selection.each do |item|
+          index = @items.index(item)
+          dom_element.find("li:nth-child(#{index + 1})").add_class('selected')
+        end
       end
       
       # used for single selection taking an index
@@ -60,21 +75,11 @@ module Glimmer
       end
       
       def dom
-        list_items = @items
         list_id = id
         list_style = css
         list_selection = selection
         @dom ||= html {
           ul(id: list_id, class: name, style: list_style) {
-            list_items.to_a.each_with_index do |item, index|
-              li_class = ''
-              li_class += ' selected' if list_selection.include?(item)
-              li_class += ' empty-list-item' if item == ITEM_EMPTY
-              li(class: li_class) {
-                item
-              }
-            end
-            nil #TODO   look into glimmer-dsl-xml and why it doesn't ignore collections like each_with_index
           }
         }.to_s
       end

data/lib/glimmer/swt/message_box_proxy.rb

@@ -10,8 +10,6 @@ module Glimmer
         @parent = parent
         @args = args
         @children = Set.new
-        @css_classes = Set.new(['modal', name])
-        @css = ''
         @enabled = true
         content do
           on_widget_selected {
@@ -22,12 +20,12 @@ module Glimmer
       
       def text=(txt)
         @text = txt
-        redraw if @dom
+        dom_element.find('.modal-content .text').html(@text)
       end
     
       def message=(msg)
         @message = msg
-        redraw if @dom
+        dom_element.find('.modal-content .message').html(@text)
       end
       
       def document
@@ -120,8 +118,7 @@ module Glimmer
         modal_style = css
         modal_text = text
         modal_message = message
-        modal_css_classes = css_classes
-        modal_class = modal_css_classes.to_a.join(' ')
+        modal_class = ['modal', name].join(' ')
         @dom ||= html {        
           div(id: modal_id, style: modal_style, class: modal_class) {
             style(class: 'modal-style') {
@@ -131,7 +128,7 @@ module Glimmer
               header(class: 'text') {
                 modal_text
               }
-              tag(_name: 'p', id: 'message') {
+              tag(_name: 'p', id: 'message', class: 'message') {
                 modal_message
               }
               input(type: 'button', class: 'close', autofocus: 'autofocus', value: 'OK')

data/lib/glimmer/swt/row_layout_proxy.rb

@@ -0,0 +1,105 @@
+require 'glimmer/swt/layout_proxy'
+
+module Glimmer
+  module SWT
+    class RowLayoutProxy < LayoutProxy
+      include Glimmer
+      
+      STYLE = <<~CSS
+        .row-layout {
+          display: flex;
+        }
+                
+        .row-layout-pack {
+          display: initial;
+        }
+                
+        .row-layout-horizontal {
+          flex-direction: row;
+        }
+        
+        .row-layout-horizontal.row-layout-pack {
+          flex-direction: none;
+        }
+        
+        .row-layout-vertical {
+          flex-direction: column;
+        }
+        
+        .row-layout-vertical.row-layout-pack {
+          flex-direction: none;          
+        }
+      CSS
+    
+      attr_reader :type, :margin_width, :margin_height, :spacing, :pack
+    
+      def initialize(parent, args)
+        super(parent, args)
+        @type = @args.first || :horizontal
+        @marign_width = 15
+        @margin_height = 15
+        self.pack = true
+        @parent.dom_element.add_class('row-layout')
+        @parent.dom_element.add_class(horizontal? ? 'row-layout-horizontal' : 'row-layout-vertical')
+      end
+      
+      def horizontal?
+        @type == :horizontal
+      end
+
+      def vertical?
+        @type == :vertical
+      end
+      
+      def dom(widget_dom)        
+        dom_result = widget_dom
+        dom_result += '<br />' if vertical? && @pack
+        dom_result
+      end
+
+      def pack=(value)
+        @pack = value
+        if @pack
+          @parent.dom_element.add_class('row-layout-pack')
+        else
+          @parent.dom_element.remove_class('row-layout-pack')
+        end
+      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('margin-top', @margin_height)
+        @parent.dom_element.css('margin-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/shell_proxy.rb

@@ -1,19 +1,25 @@
-    require 'glimmer/swt/widget_proxy'
+require 'glimmer/swt/widget_proxy'
 require 'glimmer/swt/point'
 
 module Glimmer
   module SWT
-    class ShellProxy < WidgetProxy
+    class ShellProxy < CompositeProxy
       # TODO consider renaming to ShellProxy to match SWT API
       attr_reader :minimum_size
     
+      WIDTH_MIN = 130
+      HEIGHT_MIN = 0
+    
       def initialize(args)
         @args = args
         @children = []
-#         Document.ready? do
+#         Document.ready? do end # TODO consider embedding this jQuery call in so outside consumers don't have to use it
         Document.find('body').empty unless ENV['RUBY_ENV'] == 'test'
-        redraw
-#         end
+        render
+        @layout = FillLayoutProxy.new(self, [])
+        @layout.margin_width = 0
+        @layout.margin_height = 0
+        self.minimum_size = Point.new(WIDTH_MIN, HEIGHT_MIN)
       end
       
       def element
@@ -29,14 +35,14 @@ module Glimmer
       end
 
       def text=(value)
-#         Document.ready? do
-          Document.title = value
-#         end
+        Document.title = value
       end
       
       def minimum_size=(width_or_minimum_size, height = nil)
         @minimum_size = height.nil? ? width_or_minimum_size : Point.new(width_or_minimum_size, height)
-        redraw
+        return if @minimum_size.nil?
+        dom_element.css('min-width', "#{@minimum_size.x}px")
+        dom_element.css('min-height', "#{@minimum_size.y}px")
       end
       
       def style_dom_css
@@ -57,11 +63,15 @@ module Glimmer
             width: 100%;
             height: 100%;
           }
-          body, .shell {
+          body {
             width: 100%;
             height: 100%;
             margin: 0;
           }
+          .shell {
+            height: 100%;
+            margin: 0;
+          }
           .shell iframe {
             width: 100%;
             height: 100%;
@@ -179,7 +189,7 @@ module Glimmer
       end
       
       def style_dom_table_css
-        <<~CSS
+        <<~CSS        
           table {
             border-spacing: 0;
           }
@@ -193,15 +203,9 @@ module Glimmer
       def dom
         i = 0
         body_id = id
-        body_class = name
-        body_style = '' # a start for more styling further along
-        if @minimum_size
-          body_style += "min-width: #{@minimum_size.x}px; min-height: #{@minimum_size.y}px;" if @minimum_size
-          Document.find('body').css('min-width', "#{@minimum_size.x}px")
-          Document.find('body').css('min-height', "#{@minimum_size.y}px")
-        end
+        body_class = ([name] + css_classes.to_a).join(' ')
         @dom ||= html {
-          div(id: body_id, class: body_class, style: body_style) {
+          div(id: body_id, class: body_class) {
             style(class: 'common-style') {
               style_dom_css
             }
@@ -213,16 +217,22 @@ module Glimmer
             }
             style(class: 'tab-style') {
               style_dom_tab_css
-            }        
+            }            
 #             style(class: 'tab-item-style') {
 #               style_dom_tab_item_css
 #             }        
 #             style(class: 'modal-style') {
 #               style_dom_modal_css
 #             }        
-            style(class: 'table-style') {
+            style(class: 'table-style') {            
               style_dom_table_css
-            }        
+            }
+            style(class: 'fill-layout-style') {
+              Glimmer::SWT::FillLayoutProxy::STYLE
+            }
+            style(class: 'row-layout-style') {
+              Glimmer::SWT::RowLayoutProxy::STYLE
+            }
           }
         }.to_s
       end

data/lib/glimmer/swt/style_constantizable.rb

@@ -0,0 +1,154 @@
+# 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
+    # Mixin for all proxy classes that manage style constants (e.g. SWT, DND, etc...)
+    module StyleConstantizable
+      module ClassMethods
+        REGEX_SYMBOL_NEGATIVITY = /^([^!]+)(!)?$/
+      
+        def constant_source_class
+          raise 'Not implemented! Mixer must implement!'
+        end
+ 
+        def constant_value_none
+          # TODO instead of raising error try a convention instead like CLASSNAME::NONE by default
+          raise 'Not implemented! Mixer must implement!'
+        end
+        
+        # hash of extra styles (i.e. new style combinations)
+        def extra_styles
+          raise 'Not implemented! Mixer must implement!'
+        end
+                
+        def error_message_invalid_style
+          " is an invalid #{constant_source_class.name.split(':').last} style! Please choose a style from #{constant_source_class.name} class constants." # TODO parameterize
+        end
+
+        # Gets constants (e.g. SWT::CONSTANT) where constant is
+        # passed in as a lower case symbol
+        def [](*symbols)
+          symbols = symbols.first if symbols.size == 1 && symbols.first.is_a?(Array)
+          result = symbols.compact.map do |symbol|
+            constant(symbol).tap do |constant_value|
+              raise Glimmer::Error, symbol.to_s + error_message_invalid_style unless constant_value.is_a?(Integer)
+            end
+          end.reduce do |output, constant_value|
+            if constant_value < 0
+              output & constant_value
+            else
+              output | constant_value
+            end
+          end
+          result.nil? ? constant_value_none : result
+        end
+
+        # Returns style integer value for passed in symbol or allows
+        # passed in object to pass through (e.g. Integer). This makes is convenient
+        # to use symbols or actual style integers in Glimmer
+        # Does not raise error for invalid values. Just lets them pass as is.
+        # (look into [] operator if you want an error raised on invalid values)
+        def constant(symbol)
+          return symbol unless symbol.is_a?(Symbol) || symbol.is_a?(String)
+          symbol_string, negative = extract_symbol_string_negativity(symbol)
+          swt_constant_symbol = symbol_string.downcase == symbol_string ? symbol_string.upcase.to_sym : symbol_string.to_sym
+          bit_value = constant_source_class.const_get(swt_constant_symbol)
+          negative ? ~bit_value : bit_value
+        rescue => e
+          begin
+#             Glimmer::Config.logger.debug {e.full_message}
+            alternative_swt_constant_symbol = constant_source_class.constants.find {|c| c.to_s.upcase == swt_constant_symbol.to_s.upcase}
+            bit_value = constant_source_class.const_get(alternative_swt_constant_symbol)
+            negative ? ~bit_value : bit_value
+          rescue => e
+#             Glimmer::Config.logger.debug {e.full_message}
+            bit_value = extra_styles[swt_constant_symbol]
+            if bit_value
+              negative ? ~bit_value : bit_value
+            else
+              symbol
+            end
+          end
+        end
+        
+        def extract_symbol_string_negativity(symbol)
+          if symbol.is_a?(Symbol) || symbol.is_a?(String)
+            symbol_negativity_match = symbol.to_s.match(REGEX_SYMBOL_NEGATIVITY)
+            symbol = symbol_negativity_match[1]
+            negative = !!symbol_negativity_match[2]
+            [symbol, negative]
+          else
+            negative = symbol < 0
+            [symbol, negative]
+          end
+         end
+
+        def negative?(symbol)
+          extract_symbol_string_negativity(symbol)[1]
+        end
+
+        def has_constant?(symbol)
+          return false unless symbol.is_a?(Symbol) || symbol.is_a?(String)
+          constant(symbol).is_a?(Integer)
+        end
+
+        def constantify_args(args)
+          args.map {|arg| constant(arg)}
+        end
+
+        # Deconstructs a style integer into symbols
+        # Useful for debugging
+        def deconstruct(integer)
+          constant_source_class.constants.reduce([]) do |found, c|
+            constant_value = constant_source_class.const_get(c) rescue -1
+            is_found = constant_value.is_a?(Integer) && (integer & constant_value) == integer
+            is_found ? found += [c] : found
+          end
+        end
+
+        # Reverse engineer a style integer into a symbol
+        # Useful for debugging
+        def reverse_lookup(integer)
+          constant_source_class.constants.reduce([]) do |found, c|
+            constant_value = constant_source_class.const_get(c) rescue -1
+            is_found = constant_value.is_a?(Integer) && integer == constant_value
+            is_found ? found += [c] : found
+          end
+        end
+
+        def include?(swt_constant, *symbols)
+          swt_constant & self[symbols] == self[symbols]
+        end
+        
+      end
+      
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+      
+    end
+    
+  end
+  
+end