motion-prime 0.4.3 → 0.4.4

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

@@ -2,82 +2,92 @@ motion_require '../draw.rb'
 module MotionPrime
   class LabelDrawElement < DrawElement
     include ElementContentTextMixin
+    include ElementTextMixin
     include DrawBackgroundMixin
 
-    def default_padding_for(side)
-      return super unless side.to_s == 'top'
-      @padding_top || 0
-    end
-
-    def draw_in(rect)
-      size_to_fit_if_needed or set_text_position
+    def draw_options
       options = computed_options
-
-      return if computed_options[:hidden]
-
-      # render background and border
-      background_rect = CGRectMake(computed_left, computed_top, computed_outer_width, computed_outer_height)
-      draw_background_in(background_rect, options)
-
-      # render text
-      color = (options[:text_color] || :black).uicolor
+      text = (options[:html] || options[:text]).to_s.gsub(/^[\n\r]+/, '')
+      text_color = (options[:text_color] || :black).uicolor
       font = (options[:font] || :system).uifont
-      alignment = (options.has_key?(:text_alignment) ? options[:text_alignment] : :left).uitextalignment
-      line_break_mode = (options.has_key?(:line_break_mode) ? options[:line_break_mode] : :tail_truncation).uilinebreakmode
-      label_text = options[:text].to_s.gsub(/^[\n\r]+/, '')
+
+      text_alignment_name = options.has_key?(:text_alignment) ? options[:text_alignment] : :left
+      text_alignment = text_alignment_name.uitextalignment
+      line_break_mode_name = options.has_key?(:line_break_mode) ? options[:line_break_mode] : :tail_truncation
+      line_break_mode = line_break_mode_name.uilinebreakmode
 
       top_left_corner = CGPointMake(computed_inner_left, computed_inner_top)
       if options[:number_of_lines].to_i.zero?
-        rect = CGRectMake(*top_left_corner.to_a, computed_width, computed_height)
+        inner_rect = CGRectMake(*top_left_corner.to_a, computed_width, computed_height)
       end
+      super.merge({
+        text: text,
+        is_html: options[:html].present?,
+        text_color: text_color,
+        font: font,
+        text_alignment_name: text_alignment_name,
+        text_alignment: text_alignment,
+        line_break_mode_name: line_break_mode_name,
+        line_break_mode: line_break_mode,
+        line_spacing: options[:line_spacing],
+        underline: options[:underline],
+        top_left_corner: top_left_corner,
+        inner_rect: inner_rect
+      })
+    end
 
-      if options[:line_spacing] || options[:underline]
-        # attributed string
-        paragrahStyle = NSMutableParagraphStyle.alloc.init
+    def draw_in(rect)
+      draw_in_context(UIGraphicsGetCurrentContext())
+    end
 
-        paragrahStyle.setLineSpacing(options[:line_spacing]) if options[:line_spacing]
-        paragrahStyle.setAlignment(alignment)
-        paragrahStyle.setLineBreakMode(line_break_mode)
-        attributes = {}
-        attributes[NSParagraphStyleAttributeName] = paragrahStyle
-        attributes[NSForegroundColorAttributeName] = color
-        attributes[NSFontAttributeName] = font
+    def draw_in_context(context)
+      return if computed_options[:hidden]
+      size_to_fit_if_needed
+      set_text_position
 
-        label_text = NSMutableAttributedString.alloc.initWithString(label_text, attributes: attributes)
-        if underline_range = options[:underline]
-          # FIXME
-          # label_text = NSMutableAttributedString.alloc.initWithAttributedString(label_text)
-          # label_text.addAttributes({NSUnderlineStyleAttributeName => NSUnderlineStyleSingle}, range: underline_range)
-        end
+      draw_background_in_context(context)
 
-        rect ? label_text.drawInRect(rect) : label_text.drawAtPoint(top_left_corner)
+      UIGraphicsPushContext(context)
+      options = draw_options
+      if options[:is_html] || options[:line_spacing] || options[:underline]
+        prepared_text = options[:is_html] ? html_string(options) : attributed_string(options)
+
+        if options[:inner_rect]
+          prepared_text.drawInRect(options[:inner_rect])
+        else
+          prepared_text.drawAtPoint(options[:top_left_corner])
+        end
       else
         # regular string
-        color.set
-        if rect
-          label_text.drawInRect(rect,
-            withFont: font,
-            lineBreakMode: line_break_mode,
-            alignment: alignment)
+        prepared_text = options[:text]
+        options[:text_color].set
+        if options[:inner_rect]
+          prepared_text.drawInRect(options[:inner_rect],
+            withFont: options[:font],
+            lineBreakMode: options[:line_break_mode],
+            alignment: options[:text_alignment])
         else
-          label_text.drawAtPoint(top_left_corner, withFont: font)
+          prepared_text.drawAtPoint(options[:top_left_corner], withFont: options[:font])
         end
       end
+      UIGraphicsPopContext()
+    end
+
+    def default_padding_for(side)
+      return super unless side.to_s == 'top'
+      @padding_top || 0
     end
 
     def size_to_fit_if_needed
       if computed_options[:size_to_fit]
         computed_options[:width] ||= cached_content_outer_width
-        if computed_options[:width]
-          computed_options[:height] ||= cached_content_outer_height
-        end
+        computed_options[:height] ||= cached_content_outer_height
         reset_computed_values
-        true
       end
     end
 
     def set_text_position
-      if computed_options.slice(:padding_top, :padding_bottom, :padding).none?
+      if computed_options.slice(:padding_top, :padding_bottom, :padding).values.none?
         computed_options[:width] ||= computed_width
         @padding_top = (computed_outer_height - cached_content_height)/2
         # @padding_top += 1 unless @padding_top.zero?

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

@@ -4,11 +4,13 @@ module MotionPrime
     include DrawBackgroundMixin
 
     def draw_in(rect)
+      draw_in_context(UIGraphicsGetCurrentContext())
+    end
+
+    def draw_in_context(context)
       return if computed_options[:hidden]
-      options = computed_options
 
-      background_rect = CGRectMake(computed_left, computed_top, computed_outer_width, computed_outer_height)
-      draw_background_in(background_rect, options)
+      draw_background_in_context(context)
     end
   end
 end

data/motion-prime/helpers/has_style_chain_builder.rb

@@ -5,9 +5,7 @@ module MotionPrime
       [*base_styles].each do |base_style|
         [*suffixes].each do |suffix|
           components = []
-          components << base_style.to_s if base_style.present?
-          components << suffix.to_s if suffix.present?
-          styles << components.join('_').to_sym if components.present?
+          styles << [base_style.to_s, suffix.to_s].join('_').to_sym if base_style.present? && suffix.present?
         end
       end
       styles

data/motion-prime/models/association_collection.rb

@@ -46,6 +46,14 @@ module MotionPrime
       data
     end
 
+    def last
+      all.last
+    end
+
+    def first
+      all.first
+    end
+
     def set_inverse_relation_for(models)
       [*models].each do |model|
         model.send("#{inverse_relation_name}=", inverse_relation)

data/motion-prime/models/finder.rb

@@ -22,6 +22,14 @@ module MotionPrime
       end
     end
 
+    def last
+      all.last
+    end
+
+    def first
+      all.first
+    end
+
     # Find model by criteria
     #
     # Examples:

data/motion-prime/mp.rb

@@ -10,6 +10,10 @@ module MotionPrime
   def self.low_camelize_factory_cache
     @camelize_factory_cache ||= {}
   end
+
+  def self.env
+    ENV['PRIME_ENV'] || ENV['RUBYMOTION_ENV'] || 'development'
+  end
 end
 ::MP = MotionPrime unless defined?(::MP)
 ::Prime = MotionPrime unless defined?(::Prime)

data/motion-prime/screens/_navigation_mixin.rb

@@ -99,8 +99,12 @@ module MotionPrime
       def close_screen_navigational(args = {})
         if args[:to_screen] && args[:to_screen].is_a?(UIViewController)
           self.parent_screen = args[:to_screen]
+
+          screens = self.navigation_controller.childViewControllers
+          app_delegate.close_screens(screens[screens.index(parent_screen)+1..-1])
           self.navigation_controller.popToViewController(args[:to_screen], animated: args[:animated])
         else
+          app_delegate.close_screens(self)
           self.navigation_controller.popViewControllerAnimated(args[:animated])
         end
         send_on_return(args)

data/motion-prime/screens/base_screen.rb

@@ -33,5 +33,12 @@ module MotionPrime
       end
       @on_appear_happened = true
     end
+
+    def on_destroy
+      BW::Reactor.schedule do
+        pp 'destroying screen'
+        @main_section = nil
+      end
+    end
   end
 end

data/motion-prime/screens/sidebar_container_screen.rb

@@ -4,7 +4,7 @@ module MotionPrime
 
     def self.new(menu, content, options={})
       screen = self.alloc.initWithContentViewController(nil, menuViewController: nil)
-      screen.backgroundImage = MotionPrime::Config.sidebar.background_image
+      screen.backgroundImage = Prime::Config.sidebar.background_image
       screen.parallaxEnabled = false
 
       full_width = UIScreen.mainScreen.bounds.size.width
@@ -71,7 +71,7 @@ module MotionPrime
           controller.send(:on_screen_load) if controller.respond_to?(:on_screen_load)
           controller = controller.main_controller if controller.respond_to?(:main_controller)
         else
-          controller.navigation_controller = content_controller
+          controller.navigation_controller = content_controller if controller.respond_to?(:navigation_controller)
           controller.send(:on_screen_load) if controller.respond_to?(:on_screen_load)
         end
         controller

data/motion-prime/sections/_cell_section_mixin.rb

@@ -1,9 +1,16 @@
 module MotionPrime
   module CellSectionMixin
+    extend ::MotionSupport::Concern
+
     attr_writer :table
+    attr_reader :pending_display
+
+    included do
+      class_attribute :custom_cell_name
+    end
 
     def table
-      @table ||= options[:table]
+      @table ||= options[:table].try(:weak_ref)
     end
 
     def section_styles
@@ -17,22 +24,54 @@ module MotionPrime
     end
 
     def cell_name
-      self.class.cell_name || begin
+      self.class.custom_cell_name || begin
         return name unless table
         table_name = table.name.gsub('_table', '')
         name.gsub("#{table_name}_", '')
       end
     end
 
-    def load_container_element(options = {})
+    def container_bounds
+      @container_bounds ||= CGRectMake(0, 0, table.table_view.bounds.size.width, container_height)
+    end
+
+    def init_container_element(options = {})
       @container_element ||= begin
         options.merge!({
-          screen: screen,
-          section: self,
+          screen: screen.try(:weak_ref),
+          section: self.weak_ref,
           has_drawn_content: true
         })
+        options[:styles] ||= []
+        options[:styles] = [:"#{table.name}_first_cell"] if table.data.first == self
+        options[:styles] = [:"#{table.name}_last_cell"] if table.data.last == self
         MotionPrime::BaseElement.factory(:table_view_cell, options)
       end
     end
+
+    def load_container_element(options = {})
+      init_container_element(options)
+      load_elements
+      @container_element.compute_options! unless @container_element.computed_options
+      if respond_to?(:prerender_elements_for_state) && prerender_enabled?
+        prerender_elements_for_state(:normal)
+      end
+    end
+
+    def pending_display!
+      @pending_display = true
+      display unless table.decelerating
+    end
+
+    def display
+      @pending_display = false
+      container_view.setNeedsDisplay
+    end
+
+    module ClassMethods
+      def set_cell_name(value)
+        self.custom_cell_name = value
+      end
+    end
   end
 end

data/motion-prime/sections/_draw_section_mixin.rb

@@ -0,0 +1,120 @@
+module MotionPrime
+  module DrawSectionMixin
+    extend ::MotionSupport::Concern
+
+    include HasStyles
+    include FrameCalculatorMixin
+    attr_accessor :container_element, :container_gesture_recognizers, :cached_draw_image
+    included do
+      class_attribute :prerender_enabled
+    end
+
+    def container_view
+      container_element.try(:view)
+    end
+
+    def draw_in(rect, state = :normal)
+      if cached_draw_image[state]
+        context = UIGraphicsGetCurrentContext()
+        CGContextDrawImage(context, container_bounds, cached_draw_image[state])
+        render_image_elements
+      elsif prerender_enabled?
+        prerender_elements_for_state(state)
+        draw_in(rect, state)
+      else
+        draw_background_in_context(UIGraphicsGetCurrentContext(), rect)
+        draw_elements(rect)
+      end
+    end
+
+    def bind_gesture_on_container_for(element, action, receiver = nil)
+      self.container_gesture_recognizers ||= begin
+        set_container_gesture_recognizer
+        []
+      end
+      self.container_gesture_recognizers << {element: element, action: action, receiver: receiver}
+    end
+
+    def prerender_elements_for_state(state = :normal)
+      scale = UIScreen.mainScreen.scale
+      space = CGColorSpaceCreateDeviceRGB()
+      bits_per_component = 8
+      context = CGBitmapContextCreate(nil, container_bounds.size.width*scale, container_bounds.size.height*scale,
+        bits_per_component, container_bounds.size.width*scale*4, space, KCGImageAlphaPremultipliedLast)
+
+      CGContextScaleCTM(context, scale, scale)
+
+      draw_background_in_context(context, container_bounds)
+      elements_to_draw.each do |key, element|
+        element.draw_in_context(context)
+      end
+
+      cached_draw_image[state] = CGBitmapContextCreateImage(context)
+    end
+
+    def prerender_enabled?
+      self.class.prerender_enabled
+    end
+
+    def cached_draw_image
+      @cached_draw_image ||= MotionSupport::HashWithIndifferentAccess.new
+    end
+
+    private
+      def set_container_gesture_recognizer
+        single_tap = UITapGestureRecognizer.alloc.initWithTarget(self, action: 'on_container_tap_gesture:')
+        single_tap.cancelsTouchesInView = false
+        container_view.addGestureRecognizer single_tap
+        container_view.setUserInteractionEnabled true
+      end
+
+      def on_container_tap_gesture(recognizer)
+        target = Array.wrap(container_gesture_recognizers).detect do |gesture_data|
+          CGRectContainsPoint(gesture_data[:element].computed_frame, recognizer.locationInView(container_view))
+        end
+        (target[:receiver] || self).send(target[:action], recognizer, target[:element]) if target
+      end
+
+      def draw_elements(rect)
+        elements_to_draw.each do |key, element|
+          element.draw_in(rect)
+        end
+      end
+
+      def draw_background_in_context(context, rect)
+        return unless container_element
+
+        options = container_element.computed_options
+        background_color = options[:background_color].try(:uicolor)
+
+        if gradient_options = options[:gradient]
+          start_point = CGPointMake(CGRectGetMidX(rect), CGRectGetMinY(rect))
+          end_point = CGPointMake(CGRectGetMidX(rect), CGRectGetMaxY(rect))
+
+          # CGContextSaveGState(context)
+          CGContextAddRect(context, rect)
+          CGContextClip(context)
+          gradient = prepare_gradient(gradient_options)
+          CGContextDrawLinearGradient(context, gradient, start_point, end_point, 0)
+          # CGContextRestoreGState(context)
+        elsif background_color && background_color != :clear.uicolor
+          UIGraphicsPushContext(context)
+          background_color.uicolor.setFill
+          UIRectFill(rect)
+          UIGraphicsPopContext()
+        end
+      end
+
+      def render_image_elements
+        elements_to_draw.each do |key, element|
+          element.load_image if element.is_a?(ImageDrawElement)
+        end
+      end
+
+    module ClassMethods
+      def enable_prerender
+        self.prerender_enabled = true
+      end
+    end
+  end
+end