motion-prime 0.8.1 → 0.8.2

data/motion-prime/screens/screen.rb

@@ -53,6 +53,10 @@ module MotionPrime
       super
     end
 
+    def strong_references
+      self.main_controller
+    end
+
     def visible?
       @visible
     end

data/motion-prime/sections/_async_form_mixin.rb

@@ -0,0 +1,12 @@
+module Prime
+  module AsyncFormMixin
+    def reload_table_data
+      return super unless async_data?
+      sections = NSMutableIndexSet.new
+      number_of_groups.times do |section_id|
+        sections.addIndex(section_id)
+      end
+      table_view.reloadSections sections, withRowAnimation: UITableViewRowAnimationFade
+    end
+  end
+end

data/motion-prime/sections/_async_table_mixin.rb

@@ -0,0 +1,193 @@
+module Prime
+  module AsyncTableMixin
+    extend ::MotionSupport::Concern
+
+    included do
+      class_attribute :async_data_options
+    end
+
+    # Returns true if table section have enabled async data. False by defaul.
+    #
+    # @return [Boolean] is async data enabled.
+    def async_data?
+      self.class.async_data_options
+    end
+
+    def table_element_options
+      options = super
+      if async_data? && self.class.async_data_options.has_key?(:estimated_cell_height)
+        options[:estimated_cell_height] = self.class.async_data_options[:estimated_cell_height]
+      end
+      options
+    end
+
+    # Reset async loaded table data and preloader queue.
+    #
+    # @return [Boolean] true
+    def reset_data
+      super # must be before to update fixed_table_data
+      @async_loaded_data = async_data? ? fixed_table_data : nil
+      Array.wrap(@preloader_queue).each { |queue| queue[:state] = :cancelled }
+      @preloader_next_starts_from = nil
+    end
+
+    def height_for_index(table, index)
+      section = cell_section_by_index(index)
+      preload_section_by_index(index)
+      section.container_height
+    end
+
+    def render_cell(index, table)
+      preload_sections_after(index)
+      super
+    end
+
+    def on_async_data_loaded; end
+    def on_queue_preloaded(queue_id, loaded_index); end
+    def on_cell_section_preloaded(section, index); end
+
+    # Preloads sections after rendering cell in current sheduled index or given index.
+    # TODO: probably should be in separate class.
+    #
+    # @param from_index [NSIndexPath] Value of first index to load if current sheduled index not exists.
+    # @return [NSIndexPath, Boolean] Index of next sheduled index.
+    def preload_sections_after(from_index)
+      return unless async_data?
+      service = preloader_index_service
+      load_limit = self.class.async_data_options.try(:[], :preload_cells_count)
+
+      if @preloader_next_starts_from
+        index_to_start_preloading = service.sum_index(@preloader_next_starts_from, load_limit ? -load_limit/2 : 0)
+        # should we start preload based on index of rendered cell
+        return false if service.compare_indexes(from_index, index_to_start_preloading) < 0
+      end
+
+      # adjust start/finish points based on current queues
+      current_group = from_index.section
+      left_to_load_in_group = cell_sections_for_group(current_group).count - from_index.row
+      load_count = [left_to_load_in_group, load_limit].compact.min
+      to_index = service.sum_index(from_index, load_count - 1)
+      @preloader_next_starts_from = to_index
+
+      Array.wrap(@preloader_queue).each do |queue_info|
+        # cancelled and dealloc are left from prev data
+        next unless [:in_progress, :completed].include?(queue_info[:state])
+        # filter by current group
+        next unless queue_info[:from_index].section == current_group
+        # reject not started threads
+        next if queue_info[:to_index].nil? && queue_info[:state] != :in_progress
+
+        if from_index.row >= queue_info[:from_index].row
+          from_index = NSIndexPath.indexPathForRow([from_index.row, queue_info[:to_index].try(:row).try(:+, 1), (queue_info[:target_index] if queue_info[:state] == :in_progress).try(:row).try(:+, 1)].compact.max, inSection: current_group)
+        else
+          to_index = NSIndexPath.indexPathForRow([to_index.row, queue_info[:from_index].try(:row).try(:-, 1)].compact.min, inSection: current_group)
+        end
+      end
+
+      load_count = to_index.row - from_index.row + 1
+      preload_sections_schedule_from(from_index, load_count) if load_count > 0
+    end
+
+    # Schedules preloading sections starting with given index with given limit.
+    # TODO: probably should be in separate class.
+    #
+    # @param index [NSIndexPath] Value of first index to load.
+    # @param load_count [Integer] Count of sections to load.
+    # @return [Integer] Queue ID
+    def preload_sections_schedule_from(index, load_count)
+      service = preloader_index_service
+
+      @preloader_queue ||= []
+
+      # TODO: we do we need to keep screen ref too?
+      queue_id = @preloader_queue.count
+
+      allocate_strong_references(queue_id)
+
+      @preloader_queue[queue_id] = {
+        state: :in_progress,
+        target_index: service.sum_index(index, load_count-1),
+        from_index: index
+      }
+
+      BW::Reactor.schedule(queue_id) do |queue_id|
+        result = load_count.times do |offset|
+          if @preloader_queue[queue_id][:state] == :cancelled
+            release_strong_references(queue_id)
+            break
+          end
+          if allocated_references_released?
+            @preloader_queue[queue_id][:state] = :dealloc
+            release_strong_references(queue_id)
+            break
+          end
+
+          if section = preload_section_by_index(index)
+            on_cell_section_preloaded(section, index)
+          end
+
+          @preloader_queue[queue_id][:to_index] = index
+          unless offset == load_count - 1
+            index = service.sum_index(index, 1)
+          end
+          true
+        end
+
+        if result
+          @preloader_queue[queue_id][:state] = :completed
+          on_queue_preloaded(queue_id, index)
+        end
+        release_strong_references(queue_id)
+      end
+      queue_id
+    end
+
+    def preloader_index_service
+      TableDataIndexes.new(@data)
+    end
+
+    private
+      def set_table_data
+        sections = load_sections_async
+        prepare_table_cell_sections(sections)
+        @data = sections
+        reset_data_stamps
+        @data
+      end
+
+      def load_sections_async
+        @async_loaded_data || begin
+          ref_key = allocate_strong_references
+          BW::Reactor.schedule_on_main do
+            @async_loaded_data = fixed_table_data
+            @data = nil
+            reload_table_data
+            on_async_data_loaded
+            release_strong_references(ref_key)
+          end
+          []
+        end
+      end
+
+      def preload_section_by_index(index)
+        section = cell_section_by_index(index)
+        if section.create_elements && !section.container_element && async_data? # perform only if just loaded
+          section.load_container_with_elements(container: container_element_options_for(index))
+          section
+        end
+      end
+
+      def create_section_elements; end
+
+    module ClassMethods
+      def inherited(subclass)
+        super
+        subclass.async_data_options = self.async_data_options.try(:clone)
+      end
+
+      def set_async_data_options(options = {})
+        self.async_data_options = options
+      end
+    end
+  end
+end

data/motion-prime/sections/_cell_section_mixin.rb

@@ -9,7 +9,7 @@ module MotionPrime
     attr_reader :pending_display
 
     included do
-      class_attribute :custom_cell_name
+      class_attribute :custom_cell_section_name
       container_element type: :table_view_cell
     end
 
@@ -18,7 +18,7 @@ module MotionPrime
     end
 
     def section_styles
-      @section_styles ||= table.try(:cell_styles, self) || {}
+      @section_styles ||= table.try(:cell_section_styles, self) || {}
     end
 
     def cell_type
@@ -27,8 +27,8 @@ module MotionPrime
       end
     end
 
-    def cell_name
-      self.class.custom_cell_name || begin
+    def cell_section_name
+      self.class.custom_cell_section_name || begin
         return name unless table
         table_name = table.name.gsub('_table', '')
         name.gsub("#{table_name}_", '')
@@ -68,8 +68,8 @@ module MotionPrime
     end
 
     module ClassMethods
-      def set_cell_name(value)
-        self.custom_cell_name = value
+      def set_cell_section_name(value)
+        self.custom_cell_section_name = value
       end
     end
   end

data/motion-prime/sections/_draw_section_mixin.rb

@@ -35,6 +35,11 @@ module MotionPrime
       self.container_gesture_recognizers << {element: element, action: action, receiver: receiver}
     end
 
+    def clear_gesture_for_receiver(receiver)
+      return unless self.container_gesture_recognizers
+      self.container_gesture_recognizers.delete_if { |recognizer| recognizer[:receiver] == receiver }
+    end
+
     def prerender_elements_for_state(state = :normal)
       scale = UIScreen.mainScreen.scale
       space = CGColorSpaceCreateDeviceRGB()
@@ -60,10 +65,6 @@ module MotionPrime
       @cached_draw_image ||= MotionSupport::HashWithIndifferentAccess.new
     end
 
-    def strong_references
-      [self, screen.main_controller].map(&:strong_ref)
-    end
-
     private
       def set_container_gesture_recognizer
         single_tap = UITapGestureRecognizer.alloc.initWithTarget(self, action: 'on_container_tap_gesture:')
@@ -74,7 +75,14 @@ module MotionPrime
 
       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))
+          point = recognizer.locationInView(container_view)
+          element = gesture_data[:element]
+          section = element.section
+          if section.has_container_bounds?
+            point.x -= section.container_bounds.origin.x
+            point.y -= section.container_bounds.origin.y
+          end
+          CGRectContainsPoint(element.computed_frame, point)
         end
         (target[:receiver] || self).send(target[:action], recognizer, target[:element]) if target
       end

data/motion-prime/sections/base_section.rb

@@ -35,18 +35,36 @@ module MotionPrime
         @name = options[:name] ||= default_name
         @options_block = options[:block]
       end
+
+      if Prime.env.development?
+        @_section_info = "#{@name} #{screen.try(:class)}"
+        @@_allocated_sections ||= []
+        @@_allocated_sections << @_section_info
+      end
     end
 
     def dealloc
+      if Prime.env.development?
+        index = @@_allocated_sections.index(@_section_info)
+        @@_allocated_sections.delete_at(index)
+      end
       Prime.logger.dealloc_message :section, self, self.name
       NSNotificationCenter.defaultCenter.removeObserver self # unbinding events created in bind_keyboard_events
       super
     end
 
+    def strong_references
+      [screen, screen.main_controller]
+    end
+
     def container_bounds
       options[:container_bounds] or raise "You must pass `container bounds` option to prerender base section"
     end
 
+    def has_container_bounds?
+      options[:container_bounds].present?
+    end
+
     # Get computed container options
     #
     # @return options [Hash] computed options
@@ -101,33 +119,31 @@ module MotionPrime
     # they will be rendered immediately after that or rendered async later, based on type of section.
     #
     # @return result [Boolean] true if has been loaded by this thread.
-    def load_section
+    def create_elements
       return if @section_loaded
       if @section_loading
         sleep 0.1
-        return @section_loaded ? false : load_section
+        return @section_loaded ? false : create_elements
       end
       @section_loading = true
-      create_elements
+
+      self.elements = {}
+      elements_options.each do |key, opts|
+        add_element(key, opts)
+      end
+      self.instance_eval(&@options_block) if @options_block.is_a?(Proc)
+
       @section_loading = false
       return @section_loaded = true
     end
 
-    # Force load section
-    #
-    # @return result [Boolean] true if has been loaded by this thread.
-    def load_section!
-      @section_loaded = false
-      load_section
-    end
-
     # Force reload section, will also re-render elements.
     # For table view cells will also reload it's table data.
     def reload_section
       self.elements_to_render.values.map(&:view).flatten.each do |view|
         view.removeFromSuperview if view
       end
-      load_section!
+      create_elements!
       run_callbacks :render do
         render!
       end
@@ -138,14 +154,6 @@ module MotionPrime
       end
     end
 
-    def create_elements
-      self.elements = {}
-      elements_options.each do |key, opts|
-        add_element(key, opts)
-      end
-      self.instance_eval(&@options_block) if @options_block.is_a?(Proc)
-    end
-
     def add_element(key, options = {})
       return unless render_element?(key)
       opts = options.clone
@@ -159,16 +167,7 @@ module MotionPrime
       else
         self.elements[key] = element
       end
-    end
-
-    def build_element(options = {})
-      type = options.delete(:type)
-      render_as = options.delete(:as).to_s
-      if self.is_a?(BaseFieldSection) || self.is_a?(BaseHeaderSection) || render_as == 'view'
-        BaseElement.factory(type, options)
-      else
-        DrawElement.factory(type, options) || BaseElement.factory(type, options)
-      end
+      element
     end
 
     def render_element?(element_name)
@@ -183,7 +182,7 @@ module MotionPrime
     end
 
     def render(container_options = {})
-      load_section
+      create_elements
       self.container_options.merge!(container_options)
       run_callbacks :render do
         render!
@@ -191,8 +190,8 @@ module MotionPrime
     end
 
     def render_container(options = {}, &block)
-      if should_render_container?
-        element = self.container_element || self.init_container_element(options)
+      if should_render_container? && !self.container_element.try(:view)
+        element = self.init_container_element(options)
         element.render do
           block.call
         end
@@ -210,7 +209,8 @@ module MotionPrime
     end
 
     def element(name)
-      elements[name.to_sym]
+      self.elements ||= {}
+      self.elements[name.to_sym]
     end
 
     def view(name)
@@ -262,7 +262,7 @@ module MotionPrime
       views = Array.wrap(keyboard_close_bindings_options[:views])
 
       elements.each do |el|
-        views << el.view if %w[text_field text_view].include?(el.view_name) && el.view
+        views << el.view if el.try(:view) && %w[text_field text_view].include?(el.view_name)
       end
       views.compact.each(&:resignFirstResponder)
     end
@@ -272,7 +272,15 @@ module MotionPrime
     end
 
     def elements_to_render
-      self.elements.select { |key, element| element.is_a?(BaseElement) }
+      self.elements.except(*elements_to_draw.keys)
+    end
+
+    def current_input_view_height
+      App.shared.windows.last.subviews.first.try(:height) || KEYBOARD_HEIGHT_PORTRAIT
+    end
+
+    def screen?
+      screen && screen.weakref_alive?
     end
 
     protected
@@ -312,6 +320,24 @@ module MotionPrime
         end
       end
 
+      # Force load section
+      #
+      # @return result [Boolean] true if has been loaded by this thread.
+      def create_elements!
+        @section_loaded = false
+        create_elements
+      end
+
+      def build_element(options = {})
+        type = options.delete(:type)
+        render_as = options.delete(:as).to_s
+        if render_as != 'draw' && (render_as == 'view' || self.is_a?(BaseFieldSection) || self.is_a?(BaseHeaderSection))
+          BaseElement.factory(type, options)
+        else
+          DrawElement.factory(type, options) || BaseElement.factory(type, options)
+        end
+      end
+
       def compute_container_options!
         raw_options = {}
         raw_options.merge!(self.class.container_options.try(:clone) || {})