motion-prime 0.3.2 → 0.3.3

data/files/app/sections/sidebar/action.rb

@@ -1,4 +1,4 @@
-class SidebarActionSection < Prime::BaseSection
+class SidebarActionSection < Prime::BaseCellSection
   container height: 43
   element :title, text: proc { model[:title] }
   element :arrow, type: :image

data/motion-prime/app_delegate.rb

@@ -20,9 +20,10 @@ module MotionPrime
     end
 
     def open_screen(screen, options = {})
+      screen = create_tab_bar(screen) if screen.is_a?(Array)
       if options[:sidebar]
         open_with_sidebar(screen, options.delete(:sidebar), options)
-      elsif options[:root]
+      elsif options[:root] || !self.window
         open_root_screen(screen)
       else
         open_content_screen(screen)
@@ -59,7 +60,7 @@ module MotionPrime
     end
 
     def sidebar?
-      self.window.rootViewController.is_a?(SidebarContainerScreen)
+      self.window && self.window.rootViewController.is_a?(SidebarContainerScreen)
     end
 
     def show_sidebar
@@ -81,5 +82,10 @@ module MotionPrime
       @current_user = nil
       NSNotificationCenter.defaultCenter.postNotificationName(:on_current_user_reset, object: user_was)
     end
+
+    private
+      def create_tab_bar(screens)
+        MotionPrime::TabBarController.new(screens)
+      end
   end
 end

data/motion-prime/elements/_content_padding_mixin.rb

@@ -1,31 +1,27 @@
 module MotionPrime
   module ElementContentPaddingMixin
     def content_padding_left
-      view.try(:padding_left) ||
-        computed_options[:padding_left] ||
+      computed_options[:padding_left] ||
         computed_options[:padding] ||
-        view_class.constantize.default_padding_left || 0
+        default_padding_for(:left) || 0
     end
 
     def content_padding_right
-      view.try(:padding_right) ||
-        computed_options[:padding_right] ||
+      computed_options[:padding_right] ||
         computed_options[:padding] ||
-        view_class.constantize.default_padding_right || 0
+        default_padding_for(:right) || 0
     end
 
     def content_padding_top
-      view.try(:padding_top) ||
-        computed_options[:padding_top] ||
+      computed_options[:padding_top] ||
         computed_options[:padding] ||
-        view_class.constantize.default_padding_top || 0
+        default_padding_for(:top) || 0
     end
 
     def content_padding_bottom
-      view.try(:padding_bottom) ||
-        computed_options[:padding_bottom] ||
+      computed_options[:padding_bottom] ||
         computed_options[:padding] ||
-        view_class.constantize.default_padding_bottom || 0
+        default_padding_for(:bottom) || 0
     end
 
     def content_padding_height
@@ -45,5 +41,9 @@ module MotionPrime
       width = content_padding_width + content_width
       [[width, computed_options[:min_outer_width]].compact.max, computed_options[:max_outer_width]].compact.min
     end
+
+    def default_padding_for(side)
+      view_class.constantize.send(:"default_padding_#{side}")
+    end
   end
 end

data/motion-prime/elements/_content_text_mixin.rb

@@ -0,0 +1,65 @@
+module MotionPrime
+  module ElementContentTextMixin
+    def content_text
+      (is_a?(ButtonElement) ? button_content_text : input_content_text).to_s
+    end
+
+    def content_font
+      (is_a?(ButtonElement) ? button_content_font : input_content_font) || :system.uifont
+    end
+
+    def content_width
+      min, max = computed_options[:min_width].to_f, computed_options[:max_width]
+      return min if content_text.blank?
+
+      rect = get_content_rect(Float::MAX)
+      [[rect.size.width.ceil, max].compact.min, min].max.ceil
+    end
+
+    def content_height
+      min, max = computed_options[:min_height].to_f, computed_options[:max_height]
+      return min if content_text.blank?
+      rect = get_content_rect(computed_options[:width])
+      [[rect.size.height.ceil, max].compact.min, min].max.ceil
+    end
+
+    private
+      def get_content_rect(width)
+        raise "Please set element width for content size calculation" unless width
+        attributes = {NSFontAttributeName => content_font }
+        if computed_options[:line_spacing]
+          paragrahStyle = NSMutableParagraphStyle.alloc.init
+          paragrahStyle.setLineSpacing(computed_options[:line_spacing])
+          attributes[NSParagraphStyleAttributeName] = paragrahStyle
+        end
+        attributed_text = NSAttributedString.alloc.initWithString(content_text, attributes: attributes)
+        attributed_text.boundingRectWithSize(
+          [width, Float::MAX], options:NSStringDrawingUsesLineFragmentOrigin, context:nil
+        )
+      end
+
+      def button_content_text
+        view ? view.titleLabel.text : computed_options[:title]
+      end
+
+      def button_content_font
+        computed_options[:title_label][:font]
+      end
+
+      def input_content_text
+        input_value_text.blank? ? input_placeholder_text : input_value_text
+      end
+
+      def input_content_font
+        input_value_text.blank? ? computed_options[:placeholder_font] : computed_options[:font]
+      end
+
+      def input_value_text
+        view && !is_a?(DrawElement) ? view.text : computed_options[:text]
+      end
+
+      def input_placeholder_text
+        computed_options[:placeholder]
+      end
+  end
+end

data/motion-prime/elements/base.rb

@@ -59,30 +59,62 @@ module MotionPrime
     end
 
     def compute_style_options(*style_sources)
-      @styles = []
-      base_styles = {common: [], specific: []}
-      suffixes = {common: [@view_name.to_sym, name.try(:to_sym)].compact, specific: []}
+      has_errors = section.respond_to?(:observing_errors?) && observing_errors? && has_errors?
+      is_cell_section = section.is_a?(BaseCellSection) || section.is_a?(DrawCellSection)
 
-      if section
-        cell_section = section.is_a?(BaseCellSection)
-        if cell_section
-          section.section_styles.each { |type, values| base_styles[type] += values }
+      @styles = []
+      if is_cell_section
+        base_styles = {common: [], specific: []}
+        suffixes = {common: [], specific: []}
+
+        # following example in Prime::TableSection#cell_styles
+        # form element/cell: <base|user>_form_field, <base|user>_form_string_field, user_form_field_email
+        # table element/cell: <base|categories>_table_cell, categories_table_title
+        section.section_styles.each { |type, values| base_styles[type] += values }
+        if %w[base table_view_cell].exclude?(@view_name.to_s)
+          # form element: _input
+          # table element: _image
+          suffixes[:common] << @view_name.to_sym
+          suffixes[:common] << :"#{@view_name}_with_errors" if has_errors
+        end
+        if name && name.to_s != @view_name.to_s
+          # form element: _input
+          # table element: _icon
+          suffixes[:specific] << name.to_sym
+          suffixes[:specific] << :"#{name}_with_errors" if has_errors
         end
-        if section.respond_to?(:observing_errors?) && observing_errors? && has_errors?
-          suffixes[:common] += [:"#{name}_with_errors", :"#{@view_name}_with_errors"]
+        # form cell: base_form_field, base_form_string_field
+        # form element: base_form_field_string_field, base_form_string_field_text_field
+        # table cell: base_table_cell
+        # table element: base_table_cell_image
+        common_styles = if suffixes[:common].any?
+          build_styles_chain(base_styles[:common], suffixes[:common])
+        elsif suffixes[:specific].any?
+          build_styles_chain(base_styles[:common], suffixes[:specific])
+        elsif @view_name.to_s == 'table_view_cell'
+          base_styles[:common]
         end
+        @styles += Array.wrap(common_styles)
+
+        # form cell: user_form_field, user_form_string_field, user_form_field_email
+        # form element: user_form_field_text_field, user_form_string_field_text_field, user_form_field_email_text_field
+        # table cell: categories_table_cell, categories_table_title
+        # table element: categories_table_cell_image, categories_table_title_image
+        specific_base_common_suffix_styles = if suffixes[:common].any?
+          build_styles_chain(base_styles[:specific], suffixes[:common])
+        elsif suffixes[:specific].empty? && @view_name.to_s == 'table_view_cell'
+          base_styles[:specific]
+        end
+        @styles += Array.wrap(specific_base_common_suffix_styles)
+        # form element: user_form_field_input, user_form_string_field_input, user_form_field_email_input
+        # table element: categories_table_cell_icon, categories_table_title_icon
+        @styles += build_styles_chain(base_styles[:specific], suffixes[:specific])
       end
-
-      # common + specific base - common suffixes
-      @styles += build_styles_chain(base_styles[:common], suffixes[:common])
-      @styles << [section.name, name].compact.join('_').to_sym if section
-      @styles += build_styles_chain(base_styles[:specific], suffixes[:common])
-      # specific base - specific suffixes
-      @styles += build_styles_chain(base_styles[:specific], suffixes[:specific])
-      if cell_section && section.table.present?
-        @styles << [section.table.name, section.cell_type, section.name, name].compact.join('_').to_sym
+      if section
+        # using for base sections
+        @styles << [section.name, name].compact.join('_').to_sym
       end
-      # custom style (from options or block options)
+      # custom style (from options or block options), using for TableViews as well
       custom_styles = style_sources.map do |source|
         normalize_object(source.delete(:styles), section)
       end.compact.flatten

data/motion-prime/elements/button.rb

@@ -1,7 +1,7 @@
 module MotionPrime
   class ButtonElement < BaseElement
     include MotionPrime::ElementContentPaddingMixin
-    include MotionPrime::ElementFieldDimensionsMixin
+    include MotionPrime::ElementContentTextMixin
 
     after_render :size_to_fit
 

data/motion-prime/elements/draw.rb

@@ -1,142 +1,55 @@
+motion_require '../views/_frame_calculator_mixin'
 module MotionPrime
   class DrawElement < BaseElement
     # MotionPrime::DrawElement is container for drawRect method options.
     # Elements are located inside Sections
 
-    def render!
-    end
+    include FrameCalculatorMixin
+    include ElementContentPaddingMixin
+
+    def render!; end
 
     def view
       @view ||= section.container_view
     end
 
-    def computed_max_width
-      view.bounds.size.width
-    end
-
-    def computed_max_height
-      view.bounds.size.height
-    end
-
-    def computed_padding_left
-      computed_options[:padding_left] ||
-      computed_options[:padding] || 0
-    end
-
-    def computed_padding_right
-      computed_options[:padding_right] ||
-      computed_options[:padding] || 0
-    end
-
-    def computed_padding_top
-      computed_options[:padding_top] ||
-      computed_options[:padding] || 0
-    end
-
-    def computed_padding_bottom
-      computed_options[:padding_bottom] ||
-      computed_options[:padding] || 0
-    end
-
-    def computed_width
-      @computed_width ||= begin
-        width = computed_options[:width]
-        width = 0.0 if width.nil?
-
-        # calculate width if width is relative, e.g 0.7
-        if width > 0 && width <= 1
-          width * computed_max_width
-        else
-          width > computed_max_width ? computed_max_width : width
-        end
-      end
-    end
-
-    # content width + content padding
-    def computed_outer_width
-      @computed_outer_width ||= begin
-        computed_width + computed_padding_left + computed_padding_right
-      end
-    end
-
-    def computed_height
-      @computed_height ||= begin
-        height = computed_options[:height]
-        height = 0.0 if height.nil?
-
-        # calculate height if height is relative, e.g 0.7
-        if height > 0 && height <= 1
-          height * computed_max_height
-        else
-          height > computed_max_height ? computed_max_height : height
-        end
-      end
+    def computed_frame
+      @computed_frame ||= calculate_frome_for(view.bounds, computed_options)
     end
 
-    # content height + content padding
-    def computed_outer_height
-      @computed_outer_height ||= begin
-        computed_height + computed_padding_top + computed_padding_bottom
-      end
+    def default_padding_for(side)
+      0
     end
 
-    def computed_left
-      @computed_left ||= begin
-        left = computed_options[:left]
-        right = computed_options[:right]
-        return left if left
-        return 0 if right.nil?
-
-        computed_max_width - (computed_width + right)
-      end
+    def computed_max_width
+      view.bounds.size.width
     end
 
-    # content left + content padding
-    def computed_inner_left
-      @computed_inner_left ||= begin
-        computed_left + computed_padding_left
-      end
+    def computed_max_height
+      view.bounds.size.height
     end
 
-    def computed_top
-      @computed_top ||= begin
-        top = computed_options[:top]
-        bottom = computed_options[:bottom]
-        return top if top
-        return 0 if bottom.nil?
+    def computed_outer_width; computed_frame.size.width end
+    def computed_width; computed_outer_width - content_padding_width end
 
-        computed_max_height - (computed_height + bottom)
-      end
-    end
+    def computed_outer_height; computed_frame.size.height end
+    def computed_height; computed_outer_height - content_padding_height end
 
-    # content top + content padding
-    def computed_inner_top
-      @computed_inner_top ||= begin
-        computed_top + computed_padding_top
-      end
-    end
+    def computed_top; computed_frame.origin.y end
+    def computed_inner_top; computed_top + content_padding_top end
 
-    def computed_bottom
-      computed_options[:bottom] || 0
-    end
+    def computed_left; computed_frame.origin.x end
+    def computed_inner_left; computed_left + content_padding_left end
 
-    def computed_inner_bottom
-      computed_bottom + computed_padding_bottom
-    end
+    def computed_bottom; computed_top + computed_outer_height end
+    def computed_inner_bottom; computed_bottom - content_padding_bottom end
 
-    def computed_right
-      computed_options[:right] || 0
-    end
+    def computed_right; computed_left + computed_width end
+    def computed_inner_right; computed_right - content_padding_right end
 
-    def computed_inner_right
-      computed_right + computed_padding_right
-    end
 
     def reset_computed_values
-      [:left, :top, :right, :bottom, :width, :height].each do |key|
-        instance_variable_set "@computed_#{key}", nil
-        instance_variable_set "@computed_inner_#{key}", nil
-      end
+      @computed_frame = nil
     end
 
     class << self

data/motion-prime/elements/draw/_draw_background_mixin.rb

@@ -0,0 +1,26 @@
+module MotionPrime
+  module DrawBackgroundMixin
+    def draw_background_in(rect, options)
+      bg_color = options[:background_color]
+      border_radius = options[:layer].try(:[], :corner_radius)
+      border_width = options[:layer].try(:[], :border_width).to_f
+      border_color = options[:layer].try(:[], :border_color) || bg_color || :black
+
+      if bg_color || border_width > 0
+        context = UIGraphicsGetCurrentContext()
+        CGContextSetFillColorWithColor(context, bg_color.uicolor.cgcolor) if bg_color
+        CGContextSetLineWidth(context, border_width) if border_width > 0
+        CGContextSetStrokeColorWithColor(context, border_color.uicolor.cgcolor) if border_color
+
+        if border_radius
+          bezierPath = UIBezierPath.bezierPathWithRoundedRect rect, cornerRadius: border_radius
+          bezierPath.stroke if border_width > 0
+          bezierPath.fill if bg_color
+        else
+          CGContextStrokeRect(context, rect) if border_width > 0
+          CGContextFillRect(context, rect) if bg_color
+        end
+      end
+    end
+  end
+end

data/motion-prime/elements/draw/image.rb

@@ -1,15 +1,24 @@
 motion_require '../draw.rb'
 module MotionPrime
   class ImageDrawElement < DrawElement
+    include DrawBackgroundMixin
     attr_accessor :image_data
+
     def draw_in(rect)
       return if computed_options[:hidden]
+      options = computed_options
       image_rect = CGRectMake(
         computed_left,
         computed_top,
         computed_width,
         computed_height
       )
+
+      image_rect = CGRectInset(image_rect, -0.5, -0.5)
+      border_width = options[:layer].try(:[], :border_width).to_f
+      background_rect = CGRectInset(image_rect, -(border_width - 1)*0.5, -(border_width - 1)*0.5)
+      draw_background_in(background_rect, options)
+
       # draw already initialized image
       if image_data
         draw_with_layer(image_data, image_rect)
@@ -48,8 +57,8 @@ module MotionPrime
         layer.frame = CGRectMake(0, 0, image.size.width, image.size.height)
         layer.contents = image.CGImage
 
+        layer.masksToBounds = computed_options[:layer][:masks_to_bounds] || computed_options[:clips_to_bounds]
         if radius = computed_options[:layer][:corner_radius]
-          layer.masksToBounds = true
           k = image.size.width / rect.size.width
           radius = radius * k
           layer.cornerRadius = radius