motion-prime 0.4.3 → 0.4.4

data/motion-prime/sections/base_section.rb

@@ -18,20 +18,33 @@ module MotionPrime
     include HasAuthorization
     include HasNormalizer
     include HasClassFactory
-    include DrawMixin
+    include DrawSectionMixin
 
     attr_accessor :screen, :model, :name, :options, :elements, :section_styles
-    class_attribute :elements_options, :container_options, :keyboard_close_bindings, :cell_name
+    class_attribute :elements_options, :container_options, :keyboard_close_bindings
     define_callbacks :render
 
     def initialize(options = {})
       @options = options
-      self.screen = options[:screen]
+      self.screen = options[:screen].try(:weak_ref)
       @model = options[:model]
       @name = options[:name] ||= default_name
       @options_block = options[:block]
     end
 
+    def dealloc
+      pp 'deallocating section. elements count: ', self.elements.try(:count)
+      self.elements = nil
+
+      NSNotificationCenter.defaultCenter.removeObserver self
+      self.delegate = nil if self.respond_to?(:delegate)
+      super
+    end
+
+    def container_bounds
+      options[:container_bounds] or raise "You must pass `container bounds` option to prerender base section"
+    end
+
     def container_options
       compute_container_options! unless @container_options
       @container_options
@@ -58,6 +71,7 @@ module MotionPrime
       @section_loading = true
       create_elements
       @section_loading = false
+
       return @section_loaded = true
     end
 
@@ -75,7 +89,7 @@ module MotionPrime
 
       if @table && !self.is_a?(BaseFieldSection)
         cell.setNeedsDisplay
-        @table.table_view.reloadData
+        @table.reload_table_data
       end
     end
 
@@ -90,7 +104,7 @@ module MotionPrime
     def load_elements
       self.elements.values.each do |element|
         element.size_to_fit_if_needed if element.is_a?(LabelDrawElement)
-        element.computed_options if element.respond_to?(:computed_options)
+        element.compute_options! if element.respond_to?(:computed_options) && !element.computed_options
       end
     end
 
@@ -127,9 +141,8 @@ module MotionPrime
     end
 
     def render(container_options = {})
-      self.container_options.merge!(container_options)
       load_section
-
+      self.container_options.merge!(container_options)
       run_callbacks :render do
         render!
       end
@@ -170,12 +183,6 @@ module MotionPrime
     def keyboard_will_show; end
     def keyboard_will_hide; end
 
-    def dealloc
-      NSNotificationCenter.defaultCenter.removeObserver self
-      self.delegate = nil if self.respond_to?(:delegate)
-      super
-    end
-
     def bind_keyboard_events
       NSNotificationCenter.defaultCenter.addObserver self,
                                          selector: :on_keyboard_show,
@@ -203,6 +210,14 @@ module MotionPrime
       views.compact.each(&:resignFirstResponder)
     end
 
+    def elements_to_draw
+      self.elements.select { |key, element| element.is_a?(DrawElement) }
+    end
+
+    def elements_to_render
+      self.elements.select { |key, element| element.is_a?(BaseElement) }
+    end
+
     protected
       def bind_keyboard_close
         return unless self.class.keyboard_close_bindings.present?
@@ -216,20 +231,13 @@ module MotionPrime
       def keyboard_close_bindings_options
         @keyboard_close_bindings_options ||= normalize_options(self.class.keyboard_close_bindings.clone, self)
       end
-      def elements_to_draw
-        self.elements.select { |key, element| element.is_a?(DrawElement) }
-      end
-
-      def elements_to_render
-        self.elements.select { |key, element| element.is_a?(BaseElement) }
-      end
 
       def build_options_for_element(opts)
         # we should clone options to prevent overriding options
         # in next element with same name in another class
         options = opts.clone
         options[:type] ||= (options[:text] || options[:attributed_text_options]) ? :label : :view
-        options.merge(screen: screen, section: self)
+        options.merge(screen: screen.try(:weak_ref), section: self.weak_ref)
       end
 
     private
@@ -269,9 +277,6 @@ module MotionPrime
       def bind_keyboard_close(options)
         self.keyboard_close_bindings = options
       end
-      def set_cell_name(value)
-        self.cell_name = value
-      end
     end
     after_render :bind_keyboard_events
     after_render :bind_keyboard_close

data/motion-prime/sections/form.rb

@@ -18,42 +18,17 @@ module MotionPrime
     # end
     #
 
-    class_attribute :text_field_limits, :text_view_limits
-    class_attribute :fields_options, :section_header_options
-    attr_accessor :fields, :field_indexes, :keyboard_visible, :rendered_views, :section_headers, :section_header_options
+    class_attribute :fields_options, :text_field_limits, :text_view_limits
+    attr_accessor :fields, :field_indexes, :keyboard_visible, :rendered_views, :grouped_data
 
     def table_data
-      if @has_groups
-        section_indexes = []
-        data = fields.inject([]) do |result, (key, field)|
-          section = self.class.fields_options[key][:group].to_i
-          section_indexes[section] ||= 0
-          result[section] ||= []
-          result[section][section_indexes[section]] = field
-          section_indexes[section] += 1
-          result
-        end
-        self.section_header_options.delete_if.each_with_index { |opts, id| data[id].nil? }
-        data.compact
+      if has_many_sections?
+        grouped_data.compact
       else
         fields.values
       end
     end
 
-    def data
-      @data ||= table_data
-    end
-
-    def render_table
-      init_form_fields
-      options = {
-        styles: table_styles.values.flatten,
-        delegate: self,
-        dataSource: self,
-        style: (UITableViewStyleGrouped unless flat_data?)}
-      self.table_element = screen.table_view(options)
-    end
-
     def reload_cell(section)
       field = section.name.to_sym
       index = field_indexes[field].split('_').map(&:to_i)
@@ -223,27 +198,46 @@ module MotionPrime
       end
     end
 
-    def render_header(section)
-      return unless options = self.section_header_options.try(:[], section)
-      self.section_headers[section] ||= BaseHeaderSection.new(options.merge(screen: screen, table: self))
+    def reload_data
+      @groups_count = nil
+      reset_data
+      init_form_fields
+      reload_table_data
+    end
+
+    def reset_data
+      super
+      self.fields.values.each(&:clear_observers)
+    end
+
+    def has_many_sections?
+      section_header_options.present? || grouped_data.count > 1
     end
 
-    def header_for_section(section)
-      self.section_headers ||= []
-      self.section_headers[section] || render_header(section)
+    def render_table
+      init_form_fields unless self.fields.present?
+      super
     end
 
-    def tableView(table, viewForHeaderInSection: section)
-      return unless header = header_for_section(section)
-      wrapper = MotionPrime::BaseElement.factory(:view, screen: screen, styles: cell_styles(header).values.flatten, parent_view: table_view)
-      wrapper.render do |container_view, container_element|
-        header.container_element = container_element
-        header.render
+    def reload_table_data
+      return super unless async_data?
+      sections = NSMutableIndexSet.new
+      number_of_sections.times do |section_id|
+        sections.addIndex(section_id)
       end
+      table_view.reloadSections sections, withRowAnimation: UITableViewRowAnimationFade
     end
 
-    def tableView(table, heightForHeaderInSection: section)
-      header_for_section(section).try(:container_height) || 0
+    # Table View Delegate
+    # ---------------------
+
+    def number_of_sections(table = nil)
+      has_many_sections? ? grouped_data.compact.count : 1
+    end
+
+    def height_for_index(table, index)
+      section = load_cell_by_index(index, preload: false)
+      section.container_height
     end
 
     class << self
@@ -256,13 +250,6 @@ module MotionPrime
         self.fields_options[name]
       end
 
-      def group_header(name, options)
-        options[:name] = name
-        self.section_header_options ||= []
-        section = options.delete(:id)
-        self.section_header_options[section] = options
-      end
-
       def limit_text_field_length(name, limit)
         self.text_field_limits ||= {}
         self.text_field_limits[name] = limit
@@ -273,40 +260,36 @@ module MotionPrime
       end
     end
 
-    def reload_data
-      @groups_count = nil
-      reset_data
-      init_form_fields
-      table_view.reloadData
-    end
-
-    def reset_data
-      super
-      self.fields.values.each(&:clear_observers)
-    end
-
     private
+      def load_sections; end
+
       def init_form_fields
         self.fields = {}
         self.field_indexes = {}
+        self.grouped_data = []
         section_indexes = []
         (self.class.fields_options || {}).each do |key, field|
           next unless render_field?(key, field)
           section_id = field[:group].to_i
           @groups_count = [@groups_count || 1, section_id + 1].max
-          self.fields[key] = load_field(field)
 
+          grouped_data[section_id] ||= []
           section_indexes[section_id] ||= 0
+
+          section = load_field(field)
+          self.fields[key] = section
           self.field_indexes[key] = "#{section_id}_#{section_indexes[section_id]}"
+          grouped_data[section_id][section_indexes[section_id]] = section
+
           section_indexes[section_id] += 1
         end
         init_form_headers
-        @has_groups = section_header_options.present? || @groups_count > 1
         reset_data_stamps
       end
 
       def init_form_headers
-        self.section_header_options = Array.wrap(self.class.section_header_options).clone
+        options = Array.wrap(self.class.section_header_options).clone
+        self.section_header_options = options.delete_if.each_with_index { |opts, id| grouped_data[id].nil? }
       end
   end
 end

data/motion-prime/sections/form/base_field_section.rb

@@ -7,7 +7,7 @@ module MotionPrime
     after_render :on_section_render
 
     def initialize(options = {})
-      @form = options[:table]
+      @form = options[:table].try(:weak_ref)
       @errors_observer_options = normalize_options(options.delete(:observe_errors).clone, self) if options[:observe_errors]
       super
       observe_model_errors
@@ -37,7 +37,7 @@ module MotionPrime
             reload_section
           else
             load_section!
-            form.table_view.reloadData
+            form.reload_table_data
           end
         end
       end

data/motion-prime/sections/table.rb

@@ -1,14 +1,24 @@
 motion_require './table/refresh_mixin'
+motion_require './table/table_delegate'
+
 module MotionPrime
   class TableSection < BaseSection
     include TableSectionRefreshMixin
     include HasStyleChainBuilder
     include HasSearchBar
 
-    class_attribute :async_data_options
-    attr_accessor :table_element, :did_appear
+    class_attribute :async_data_options, :section_header_options
+    attr_accessor :table_element, :did_appear, :section_headers, :section_header_options
+    attr_reader :decelerating
     before_render :render_table
 
+    def dealloc
+      pp 'deallocating table. sections count:', @data.try(:count)
+      @data = nil
+      @async_loaded_data = nil
+      super
+    end
+
     def table_data
       []
     end
@@ -24,11 +34,15 @@ module MotionPrime
     def reload_data
       reset_data
       @async_loaded_data = table_data if async_data?
+      reload_table_data
+    end
+
+    def reload_table_data
       table_view.reloadData
     end
 
     def refresh_if_needed
-      table_view.reloadData if @data.nil?
+      reload_table_data if @data.nil?
     end
 
     def reset_data
@@ -36,14 +50,16 @@ module MotionPrime
       @data = nil
       @async_loaded_data = nil
       @next_portion_starts_from = nil
+      @preloader_cancelled = false
       @data_stamp = nil
+      @queue_states[-1] = :cancelled if @queue_states.present?
     end
 
     def table_styles
       type = self.is_a?(FormSection) ? :base_form : :base_table
 
       base_styles = [type]
-      base_styles << :"#{type}_with_sections" unless flat_data?
+      base_styles << :"#{type}_with_sections" #unless flat_data?
       item_styles = [name.to_sym]
       item_styles << @styles if @styles.present?
       {common: base_styles, specific: item_styles}
@@ -92,10 +108,11 @@ module MotionPrime
     end
 
     def render_table
+      delegate = TableDelegate.new(section: self)
       options = {
         styles: table_styles.values.flatten,
-        delegate: self,
-        data_source: self,
+        delegate: delegate,
+        data_source: delegate,
         style: (UITableViewStyleGrouped unless flat_data?)
       }
       if async_data? && self.class.async_data_options.has_key?(:estimated_row_height)
@@ -118,38 +135,71 @@ module MotionPrime
 
     def render_cell(index, table)
       section = rows_for_section(index.section)[index.row]
-      cell_element = container_element_for(index)
-      cell_view = cell_element.render do
-        section.render
+      element = section.container_element || section.init_container_element(container_element_options_for(index))
+
+      view = element.render do
+        rows_for_section(index.section)[index.row].render
       end
 
-      @rendered_cells[index.section][index.row] = cell_view
-      on_row_render(cell_view, index)
+      @rendered_cells[index.section][index.row] = view
+      on_row_render(view, index)
 
       preload_sections_for(index)
 
-      cell_view
+      view
+    end
+
+    def render_header(section)
+      return unless options = self.section_header_options.try(:[], section)
+      self.section_headers[section] ||= BaseHeaderSection.new(options.merge(screen: screen, table: self))
+    end
+
+    def header_for_section(section)
+      self.section_headers ||= []
+      self.section_headers[section] || render_header(section)
     end
 
     def on_row_render(cell, index); end
     def on_appear; end
     def on_click(table, index); end
 
-    # ALIASES
-    # ---------------------
+    def has_many_sections?
+      section_header_options.present? || data.try(:first).is_a?(Array)
+    end
+
+    def flat_data?
+      !has_many_sections?
+    end
+
+    def rows_for_section(section)
+      flat_data? ? data : data[section]
+    end
+
+    def row_by_index(index)
+      rows_for_section(index.section)[index.row]
+    end
+
+    def on_async_data_loaded; end
+    def on_async_data_preloaded(loaded_index); end
+
+    def cell_name(table, index)
+      record = row_by_index(index)
+      if record && record.model &&
+         record.model.respond_to?(:id) && record.model.id.present?
+        "cell_#{record.model.id}_#{data_stamp_for("#{index.section}_#{index.row}")}"
+      else
+        "cell_#{index.section}_#{index.row}_#{data_stamp_for("#{index.section}_#{index.row}")}"
+      end
+    end
 
-    # def tableView(table, viewForFooterInSection: section) # cause bug in ios7.0.0-7.0.2
-    #   UIView.new
-    # end
-    # def tableView(table, heightForFooterInSection: section)
-    #   0.1
-    # end
+    # Table View Delegate
+    # ---------------------
 
-    def numberOfSectionsInTableView(tableView)
-      number_of_sections
+    def number_of_sections(table = nil)
+      has_many_sections? ? data.count : 1
     end
 
-    def tableView(table, cellForRowAtIndexPath:index)
+    def cell_for_index(table, index)
       @rendered_cells ||= []
       @rendered_cells[index.section] ||= []
 
@@ -162,58 +212,48 @@ module MotionPrime
       cell.is_a?(UIView) ? cell : cell.view
     end
 
-    def tableView(table, numberOfRowsInSection:section)
-      rows_for_section(section).length
+    def height_for_index(table, index)
+      section = load_cell_by_index(index, preload: true)
+      section.container_height
     end
 
-    def tableView(table, didSelectRowAtIndexPath:index)
-      on_click(table, index)
-    end
-
-    def tableView(table, heightForRowAtIndexPath: index)
-      load_cell_by_index(index)
-      cell = rows_for_section(index.section)[index.row]
-      cell.container_height
-    end
+    def view_for_header_in_section(table, section)
+      return unless header = header_for_section(section)
 
-    def number_of_sections
-      has_many_sections? ? data.count : 1
-    end
+      reuse_identifier = "header_#{section}"
+      cached = table.dequeueReusableHeaderFooterViewWithIdentifier(reuse_identifier)
+      return cached if cached.present?
 
-    def has_many_sections?
-      data.any? && data.first.is_a?(Array)
+      styles = cell_styles(header).values.flatten
+      wrapper = MotionPrime::BaseElement.factory(:table_view_header_footer_view, screen: screen, styles: styles, parent_view: table_view, reuse_identifier: reuse_identifier)
+      wrapper.render do |container_view, container_element|
+        header.container_element = container_element
+        header.render
+      end
     end
 
-    def flat_data?
-      !has_many_sections?
+    def height_for_header_in_section(table, section)
+      header_for_section(section).try(:container_height) || 0
     end
 
-    def row_by_index(index)
-      rows_for_section(index.section)[index.row]
+    def scroll_view_will_begin_dragging(scroll)
+      @decelerating = true
     end
 
-    def rows_for_section(section)
-      flat_data? ? data : data[section]
+    def scroll_view_did_end_decelerating(scroll)
+      @decelerating = false
+      display_pending_cells
     end
 
-    def self.async_table_data(options = {})
-      self.async_data_options = options
+    def scroll_view_did_end_dragging(scroll, willDecelerate: will_decelerate)
+      display_pending_cells unless @decelerating = will_decelerate
     end
 
-    def on_async_data_loaded; end
-    def on_async_data_preloaded(loaded_index); end
-
-    def cell_name(table, index)
-      record = row_by_index(index)
-      if record && record.model &&
-         record.model.respond_to?(:id) && record.model.id.present?
-        "cell_#{record.model.id}_#{data_stamp_for("#{index.section}_#{index.row}")}"
-      else
-        "cell_#{index.section}_#{index.row}_#{data_stamp_for("#{index.section}_#{index.row}")}"
+    private
+      def display_pending_cells
+        table_view.visibleCells.each { |cell_view| cell_view.section.display if cell_view.section.pending_display }
       end
-    end
 
-    private
       def set_table_data
         cells = async_data? ? load_sections_async : table_data
         prepare_table_cells(cells)
@@ -228,7 +268,7 @@ module MotionPrime
           BW::Reactor.schedule_on_main do
             @async_loaded_data = table_data
             @data = nil
-            table_view.reloadData
+            reload_table_data
             on_async_data_loaded
           end
           []
@@ -240,31 +280,29 @@ module MotionPrime
         table.dequeueReusableCellWithIdentifier(cell_name(table, index))
       end
 
-      def prepare_table_cells(cells)
-        cells.each do |cell|
-          cell.send(:extend, CellSectionMixin)
-          cell.screen = screen
-          cell.table = self if cell.respond_to?(:table=)
+      def prepare_table_cells(cell)
+        if cell.is_a?(Array)
+          cell.each { |c| prepare_table_cells(c) }
+        else
+          cell.class.send(:include, CellSectionMixin)
+          cell.screen ||= screen
+          cell.table ||= WeakRef.new(self) if cell.respond_to?(:table=)
         end
       end
 
-      def load_cell_by_index(index)
-        cell = rows_for_section(index.section)[index.row]
-        return unless cell.load_section # return if already loaded
-        cell.load_elements
-        if async_data?
-          container_element = container_element_for(index)
-          container_element.computed_options # compute options
+      def load_cell_by_index(index, options = {})
+        section = rows_for_section(index.section)[index.row]
+        if section.load_section && options[:preload] && !section.container_element && async_data? # perform only if just loaded
+          section.load_container_element(container_element_options_for(index))
         end
+        section
       end
 
-      def container_element_for(index)
-        cell = rows_for_section(index.section)[index.row]
-        options = {
+      def container_element_options_for(index)
+        {
           reuse_identifier: cell_name(table_view, index),
           parent_view: table_view
         }
-        cell.load_container_element(options)
       end
 
       def data_stamp_for(id)
@@ -295,7 +333,7 @@ module MotionPrime
         if flat_data?
           data.each(&:load_section)
         else
-          data.count.times { |section_data| section_data.each(&:load_section) }
+          data.each { |section_data| section_data.each(&:load_section) }
         end
       end
 
@@ -306,7 +344,6 @@ module MotionPrime
         load_limit = self.class.async_data_options.try(:[], :preload_rows_count)
         @next_portion_starts_from ||= index
         start_preload_when_index_loaded = service.sum_index(@next_portion_starts_from, load_limit ? -load_limit/2 : 0)
-
         if service.compare_indexes(index, start_preload_when_index_loaded) >= 0
           section = @next_portion_starts_from.section
           next_row = @next_portion_starts_from.row
@@ -315,12 +352,23 @@ module MotionPrime
           load_count = [left_to_load, load_limit].compact.min
 
           next_index = @next_portion_starts_from
-          BW::Reactor.schedule do
-            load_count.times do |offset|
-              load_cell_by_index(next_index)
+          @preloader_cancelled = false
+
+          @queue_states ||= []
+
+          BW::Reactor.schedule(@queue_states.count) do |queue_id|
+            @queue_states[queue_id] = :in_progress
+
+            result = load_count.times do |offset|
+              break if @queue_states[queue_id] == :cancelled
+              load_cell_by_index(next_index, preload: true)
               next_index = service.sum_index(next_index, 1) unless offset == load_count - 1
             end
-            on_async_data_preloaded(next_index)
+
+            if result
+              on_async_data_preloaded(next_index)
+              @queue_states[queue_id] = :completed
+            end
           end
 
           @next_portion_starts_from = service.sum_index(@next_portion_starts_from, load_count, false)
@@ -330,5 +378,18 @@ module MotionPrime
       def index_service
         TableDataIndexes.new(@data)
       end
+
+    class << self
+      def async_table_data(options = {})
+        self.async_data_options = options
+      end
+
+      def group_header(name, options)
+        options[:name] = name
+        self.section_header_options ||= []
+        section = options.delete(:id)
+        self.section_header_options[section] = options
+      end
+    end
   end
 end