motion-prime 0.8.1 → 0.8.2

data/motion-prime/sections/form.rb

@@ -29,31 +29,26 @@ module MotionPrime
       end
     end
 
-    def reload_cell(section)
+    def reload_cell_section(section)
       field = section.name.to_sym
-      index = field_indexes[field].split('_').map(&:to_i)
-      path = NSIndexPath.indexPathForRow(index.last, inSection: index.first)
+      path = field_indexes[field]
       section.cell.try(:removeFromSuperview)
 
       fields[field] = load_field(self.class.fields_options[field])
-      fields[field].load_section
+      fields[field].create_elements
       if flat_data?
         @data[path.row] = fields[field]
       else
         @data[path.section][path.row] = fields[field]
       end
 
-      set_data_stamp(field_indexes[field])
+      set_data_stamp(fields[field].object_id)
 
       # table_view.beginUpdates
       table_view.reloadRowsAtIndexPaths([path], withRowAnimation: UITableViewRowAnimationNone)
       # table_view.endUpdates
     end
 
-    def reset_data_stamps
-      set_data_stamp(self.field_indexes.values)
-    end
-
     # Returns element based on field name and element name
     #
     # Examples:
@@ -169,18 +164,13 @@ module MotionPrime
 
     def reload_data
       @groups_count = nil
+      init_form_fields # must be before resetting to reflect changes on @data
       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
+      group_header_options.present? || grouped_data.count > 1
     end
 
     def render_table
@@ -188,27 +178,13 @@ module MotionPrime
       super
     end
 
-    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
-
     # Table View Delegate
     # ---------------------
 
-    def number_of_sections(table = nil)
+    def number_of_groups(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
       def inherited(subclass)
         super
@@ -217,6 +193,11 @@ module MotionPrime
         subclass.text_view_limits = self.text_view_limits.try(:clone)
       end
 
+      def async_table_data(options = {})
+        super
+        self.send :include, Prime::AsyncFormMixin
+      end
+
       def field(name, options = {}, &block)
         options[:name] = name
         options[:type] ||= :string
@@ -237,9 +218,11 @@ module MotionPrime
     end
 
     private
-      def load_sections; end
+      def create_section_elements; end
 
       def init_form_fields
+        self.fields.values.each(&:clear_observers) if fields.present?
+
         self.fields = {}
         self.field_indexes = {}
         self.grouped_data = []
@@ -254,7 +237,7 @@ module MotionPrime
 
           section = load_field(field)
           self.fields[key] = section
-          self.field_indexes[key] = "#{section_id}_#{section_indexes[section_id]}"
+          self.field_indexes[key] = NSIndexPath.indexPathForRow(section_indexes[section_id], inSection: section_id)
           grouped_data[section_id][section_indexes[section_id]] = section
 
           section_indexes[section_id] += 1
@@ -264,8 +247,9 @@ module MotionPrime
       end
 
       def init_form_headers
-        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? }
+        options = Array.wrap(self.class.group_header_options).clone
+        options.compact.each { |opts| normalize_options(opts) }
+        self.group_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

@@ -36,11 +36,11 @@ module MotionPrime
     # @param height [Integet] new height of field
     # @return [MotionPrime::BaseFieldSection]
     def update_height(height)
+      return if container_options[:height] == height
       container_options[:height] = height
-      field_index = form.field_indexes[name]
-      index = field_index.split('_').map(&:to_i)
-      path = NSIndexPath.indexPathForRow(index.last, inSection: index.first)
-      form.table_view.reloadRowsAtIndexPaths([path], withRowAnimation: UITableViewRowAnimationFade)
+      index = form.field_indexes[name]
+      form.send :set_data_stamp, self.object_id
+      form.table_view.reloadRowsAtIndexPaths([index], withRowAnimation: UITableViewRowAnimationFade)
       self
     end
 
@@ -52,18 +52,19 @@ module MotionPrime
     def observe_model_errors
       return unless observing_errors?
       on_error_change = proc { |old_value, new_value|
-        next if old_value == new_value
-        if @status_for_updated == :rendered
-          reload_section
-        else
-          load_section!
-          form.reload_table_data
+        changes = observing_errors_for.errors.changes
+        errors_observer_fields.each do |field|
+          next unless changes.has_key?(field)
+          if @status_for_updated == :rendered
+            reload_section
+          else
+            create_elements!
+            form.reload_table_data
+          end
         end
       }.weak!
 
-      errors_observer_fields.each do |field|
-        observe observing_errors_for.errors, observing_errors_for.errors.unique_key(field), &on_error_change
-      end
+      observe observing_errors_for.errors, :info, &on_error_change
     end
 
     def dealloc
@@ -75,18 +76,32 @@ module MotionPrime
       form.name
     end
 
-    def focus(begin_editing = true)
-      # scroll to cell
-      path = form.table_view.indexPathForCell(cell)
-      form.table_view.scrollToRowAtIndexPath path,
-        atScrollPosition: UITableViewScrollPositionTop, animated: true
+    def focus(begin_editing = false)
       # focus on text field
-      return unless begin_editing
-      elements.values.each do |element|
+      elements.values.detect do |element|
         if element.view.is_a?(UITextField) || element.view.is_a?(UITextView)
-          element.view.becomeFirstResponder and return
+          element.view.becomeFirstResponder
         end
+      end if begin_editing
+
+      # scroll to cell
+      # path = form.table_view.indexPathForCell(cell)
+      # form.table_view.scrollToRowAtIndexPath path,
+      #   atScrollPosition: UITableViewScrollPositionTop, animated: true
+      return self unless input_view = element(:input).try(:view)
+      origin = input_view.frame.origin
+      point = container_view.convertPoint(origin, toView: form.table_view)
+
+      nav_bar_height = screen.navigationController ? screen.navigationController.navigationBar.frame.size.height : 0
+      nav_bar_height += 20 # status bar height
+
+      offset = form.table_view.contentOffset
+      new_top_offset = point.y - nav_bar_height
+      unless new_top_offset == offset.y
+        offset.y = new_top_offset
+        form.table_view.setContentOffset(offset, animated: true)
       end
+
       self
     rescue
       NSLog("can't focus on element #{self.class_name_without_kvo}")
@@ -104,7 +119,7 @@ module MotionPrime
     end
 
     def default_label_options
-      label_options = options[:label]
+      label_options = options[:label] || {}
       if label_options.has_key?(:text)
         label_options
       else
@@ -114,7 +129,7 @@ module MotionPrime
 
     def bind_text_input
       view(:input).on :change do |view|
-        focus
+        focus if options[:auto_focus]
         form.on_input_change(view(:input))
       end
     end
@@ -125,9 +140,7 @@ module MotionPrime
 
     def has_errors?
       return false unless observing_errors?
-      errors_observer_fields.any? do |field|
-        observing_errors_for.errors[field].present?
-      end
+      observing_errors_for.errors.info.slice(*errors_observer_fields).values.any?(&:present?)
     end
 
     def errors_observer_fields
@@ -145,23 +158,18 @@ module MotionPrime
     def all_errors
       return [] unless observing_errors?
 
-      errors_observer_fields.map do |field|
-        observing_errors_for.errors[field]
-      end
+      observing_errors_for.errors.info.slice(*errors_observer_fields).values.flatten
     end
 
     def reload_section
       clear_observers
-      form.reload_cell(self)
+      form.reload_cell_section(self)
     end
 
     def clear_observers
       return unless observing_errors?
       # unobserve_all cause double dealloc, following code is a replacement
-      block = proc { |field|
-        unobserve observing_errors_for.errors, observing_errors_for.errors.unique_key(field)
-      }.weak!
-      errors_observer_fields.each(&block)
+      unobserve observing_errors_for.errors, :info
       # TODO: clear 'on' events
     end
 

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

@@ -0,0 +1,9 @@
+module MotionPrime
+  class StaticFieldSection < Section
+    include CellSectionMixin
+
+    def form
+      table
+    end
+  end
+end

data/motion-prime/sections/table.rb

@@ -7,65 +7,116 @@ module MotionPrime
     include HasStyleChainBuilder
     include HasSearchBar
 
-    class_attribute :async_data_options, :section_header_options, :pull_to_refresh_block
+    class_attribute :group_header_options, :pull_to_refresh_block
 
-    attr_accessor :table_element, :did_appear, :section_headers, :section_header_options
+    attr_accessor :table_element, :did_appear, :group_header_sections, :group_header_options
     attr_reader :decelerating
     before_render :render_table
     after_render :init_pull_to_refresh
     delegate :init_pull_to_refresh, to: :table_delegate
 
+
+    # Return sections which will be used to render as table cells.
+    #
+    # This method should be redefined in your table section and must return array.
+    # @return [Array<Prime::Section>] array of sections
     def table_data
       @model || []
     end
 
-    def dealloc
-      Prime.logger.dealloc_message :table, self, self.table_view.to_s
-      table_delegate.clear_delegated
-      table_view.setDataSource nil
-      super
+    # Returns cached version of table data
+    #
+    # @return [Array<Prime::Section>] cached array of sections
+    def data
+      @data || set_table_data
     end
 
-    def async_data?
-      self.class.async_data_options
+    # IMPORTANT: when you use #map in table_data,
+    # then #dealloc of Prime::Section will not be called to section created on that #map.
+    # We did not find yet why this happening, for now just using hack.
+    def fixed_table_data
+      table_data.to_enum.to_a
     end
 
-    def data
-      @data || set_table_data
+    def dealloc
+      Prime.logger.dealloc_message :table, self, self.table_element.try(:view).to_s
+      table_delegate.clear_delegated
+      table_view.setDataSource nil
+      super
     end
 
+    # Reset all table data and reload table view
+    #
+    # @return [Boolean] true
     def reload_data
       reset_data
-      @async_loaded_data = table_data if async_data?
       reload_table_data
     end
 
+    # Reload table view
+    #
+    # @return [Boolean] true
     def reload_table_data
       table_view.reloadData
+      true
     end
 
+    # Reload table view if data was empty before.
+    #
+    # @return [Boolean] true if reload was happened
     def refresh_if_needed
-      reload_table_data if @data.nil?
+      @data.nil? ? reload_table_data : false
     end
 
+    # Reset all table data.
+    #
+    # @return [Boolean] true
     def reset_data
       @did_appear = false
       @data = nil
-      @async_loaded_data = nil
-      @preloader_next_starts_from = nil
-      @preloader_cancelled = false
       @data_stamp = nil
-      @preloader_queue[-1] = :cancelled if @preloader_queue.present?
-    end
-
-    def add_cells(cells)
-      prepare_table_cells(cells)
+      @reusable_cells.each do |object_id, cell|
+        cell.reuseIdentifier = nil
+      end if @reusable_cells
+      @reusable_cells = nil
+      true
+    end
+
+    # Add cells to table view and reload table view.
+    #
+    # @param cell sections [Prime::Section, Array<Prime::Section>] cells which will be added to table view.
+    # @return [Boolean] true
+    def add_cell_sections(sections)
+      prepare_table_cell_sections(sections)
       @data ||= []
-      @data += cells
+      @data += sections
       reload_table_data
     end
 
-    def reload_cell(section)
+    # Delete cells from table data and remove them from table view with animation.
+    #
+    # @param cell sections [Prime::Section, Array<Prime::Section>] cells which will be removed from table view.
+    # @return [Array<NSIndexPath>] index paths of removed cells.
+    def delete_cell_sections(sections)
+      paths = []
+      Array.wrap(sections).each do |section|
+        paths << NSIndexPath.indexPathForRow(@data.index(section), inSection: 0)
+        delete_from_data(section)
+      end
+      table_view.beginUpdates
+      table_view.deleteRowsAtIndexPaths(paths, withRowAnimation: UITableViewRowAnimationLeft)
+      table_view.endUpdates
+      paths
+    end
+
+    def delete_from_data(section)
+      # section will not deallocate if you'll just write @data.delete(section)
+      index = @data.index(section)
+      @data[index] = nil
+      @data.delete_at(index)
+    end
+
+    def reload_cell_section(section)
       section.elements.values.each(&:compute_options!)
       section.cached_draw_image = nil
       # TODO: reset date stamps, reload row
@@ -81,7 +132,7 @@ module MotionPrime
       {common: base_styles, specific: item_styles}
     end
 
-    def cell_styles(cell)
+    def cell_section_styles(section)
       # type = [`cell`, `header`, `field`]
 
       # UserFormSection example: field :email, type: :string
@@ -93,29 +144,29 @@ module MotionPrime
       # CategoriesTableSection example: table is a `CategoryTableSection`, cell is a `CategoryTitleSection`, element :icon, type: :image
       # table_name = `categories`
       # type = `cell` (always true)
-      # table_cell_name = `title`
-      type = cell.respond_to?(:cell_type) ? cell.cell_type : 'cell'
+      # table_cell_section_name = `title`
+      type = section.respond_to?(:cell_type) ? section.cell_type : 'cell'
       suffixes = [type]
-      if cell.is_a?(BaseFieldSection)
-        suffixes << cell.default_name
+      if section.is_a?(BaseFieldSection)
+        suffixes << section.default_name
       end
 
       styles = {}
       # table: base_table_<type>
       # form: base_form_<type>, base_form_<field_type>
       styles[:common] = build_styles_chain(table_styles[:common], suffixes)
-      if cell.is_a?(BaseFieldSection)
+      if section.is_a?(BaseFieldSection)
         # form cell: _<type>_<field_name> = `_field_email`
-        suffixes << :"#{type}_#{cell.name}" if cell.name
-      elsif cell.respond_to?(:cell_name) # cell section came from table
-        # table cell: _<table_cell_name> = `_title`
-        suffixes << cell.cell_name
+        suffixes << :"#{type}_#{section.name}" if section.name
+      elsif section.respond_to?(:cell_section_name) # cell section came from table
+        # table cell: _<table_cell_section_name> = `_title`
+        suffixes << section.cell_section_name
       end
-      # table: <table_name>_table_<type>, <table_name>_table_<table_cell_name> = `categories_table_cell`, `categories_table_title`
+      # table: <table_name>_table_<type>, <table_name>_table_<table_cell_section_name> = `categories_table_cell`, `categories_table_title`
       # form: <form_name>_form_<type>, <form_name>_form_<field_type>, user_form_<type>_email = `user_form_field`, `user_form_string_field`, `user_form_field_email`
       styles[:specific] = build_styles_chain(table_styles[:specific], suffixes)
 
-      container_options_styles = cell.container_options[:styles]
+      container_options_styles = section.container_options[:styles]
       if container_options_styles.present?
         styles[:specific] += Array.wrap(container_options_styles)
       end
@@ -127,17 +178,18 @@ module MotionPrime
       @table_delegate ||= TableDelegate.new(section: self)
     end
 
-    def render_table
-      options = {
+    def table_element_options
+      {
+        section: self.weak_ref,
         styles: table_styles.values.flatten,
         delegate: table_delegate,
         data_source: table_delegate,
         style: (UITableViewStyleGrouped unless flat_data?)
       }
-      if async_data? && self.class.async_data_options.has_key?(:estimated_row_height)
-        options[:estimated_row_height] = self.class.async_data_options[:estimated_row_height]
-      end
-      self.table_element = screen.table_view(options)
+    end
+
+    def render_table
+      self.table_element = screen.table_view(table_element_options)
     end
 
     def table_view
@@ -152,91 +204,86 @@ module MotionPrime
       table_view.try(:show)
     end
 
-    def render_cell(index, table)
-      section = rows_for_section(index.section)[index.row]
+    def render_cell(index, table = nil)
+      table ||= table_view
+      section = cell_sections_for_group(index.section)[index.row]
       element = section.container_element || section.init_container_element(container_element_options_for(index))
 
       view = element.render do
         section.render
       end
-      on_row_render(view, index)
-      preload_sections_after(index)
+
+      @reusable_cells ||= {}
+      @reusable_cells[section.object_id] = view
+      on_cell_render(view, index)
       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.weak_ref))
+      return unless options = self.group_header_options.try(:[], section)
+      self.group_header_sections[section] ||= BaseHeaderSection.new(options.merge(screen: screen, table: self.weak_ref))
     end
 
-    def header_for_section(section)
-      self.section_headers ||= []
-      self.section_headers[section] || render_header(section)
+    def header_section_for_group(section)
+      self.group_header_sections ||= []
+      self.group_header_sections[section] || render_header(section)
     end
 
-    def on_row_render(cell, index); end
+    def on_cell_render(cell, index); end
     def on_appear; end
     def on_click(table, index); end
 
     def has_many_sections?
-      section_header_options.present? || data.try(:first).is_a?(Array)
+      group_header_options.present? || data.try(:first).is_a?(Array)
     end
 
     def flat_data?
       !has_many_sections?
     end
 
-    def rows_for_section(section)
+    def cell_sections_for_group(section)
       flat_data? ? data : data[section]
     end
 
-    def row_by_index(index)
-      rows_for_section(index.section)[index.row]
+    def cell_section_by_index(index)
+      cell_sections_for_group(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
+      record = cell_section_by_index(index)
+      "cell_#{record.object_id}_#{@data_stamp[record.object_id]}"
     end
 
     # Table View Delegate
     # ---------------------
 
-    def number_of_sections(table = nil)
+    def number_of_groups(table = nil)
       has_many_sections? ? data.count : 1
     end
 
     def cell_for_index(table, index)
       cell = cached_cell(index, table) || render_cell(index, table)
-
       # run table view is appeared callback if needed
-      if !@did_appear && index.row == rows_for_section(index.section).size - 1
+      if !@did_appear && index.row == cell_sections_for_group(index.section).size - 1
         on_appear
       end
       cell.is_a?(UIView) ? cell : cell.view
     end
 
     def height_for_index(table, index)
-      section = load_cell_by_index(index, preload: true)
+      section = cell_section_by_index(index)
+      section.create_elements
       section.container_height
     end
 
-    def view_for_header_in_section(table, section)
-      return unless header = header_for_section(section)
+    def header_cell_in_group(table, group)
+      return unless header = header_section_for_group(group)
 
-      reuse_identifier = "header_#{section}"
+      reuse_identifier = "header_#{group}"
       cached = table.dequeueReusableHeaderFooterViewWithIdentifier(reuse_identifier)
       return cached if cached.present?
 
-      styles = cell_styles(header).values.flatten
+      styles = cell_section_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
@@ -244,8 +291,8 @@ module MotionPrime
       end
     end
 
-    def height_for_header_in_section(table, section)
-      header_for_section(section).try(:container_height) || 0
+    def height_for_header_in_group(table, group)
+      header_section_for_group(group).try(:container_height) || 0
     end
 
     def scroll_view_will_begin_dragging(scroll)
@@ -274,49 +321,27 @@ module MotionPrime
       end
 
       def set_table_data
-        cells = async_data? ? load_sections_async : table_data
-        prepare_table_cells(cells)
-        @data = cells
+        sections = fixed_table_data
+        prepare_table_cell_sections(sections)
+        @data = sections
         reset_data_stamps
-        load_sections unless async_data?
+        create_section_elements
         @data
       end
 
-      def load_sections_async
-        @async_loaded_data || begin
-          BW::Reactor.schedule_on_main do
-            @async_loaded_data = table_data
-            @data = nil
-            reload_table_data
-            on_async_data_loaded
-          end
-          []
-        end
-      end
-
       def cached_cell(index, table = nil)
         table ||= self.table_view
         table.dequeueReusableCellWithIdentifier(cell_name(table, index))
       end
 
-      def prepare_table_cells(cell)
-        if cell.is_a?(Array)
-          cell.each { |c| prepare_table_cells(c) }
-        else
+      def prepare_table_cell_sections(cells)
+        Array.wrap(cells.flatten).each do |cell|
           Prime::Config.prime.cell_section.mixins.each do |mixin|
             cell.class.send(:include, mixin)
           end
           cell.screen ||= screen
-          cell.table ||= WeakRef.new(self) if cell.respond_to?(:table=)
-        end
-      end
-
-      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_with_elements(container: container_element_options_for(index))
+          cell.table ||= self.weak_ref if cell.respond_to?(:table=)
         end
-        section
       end
 
       def container_element_options_for(index)
@@ -326,125 +351,42 @@ module MotionPrime
         }
       end
 
-      def data_stamp_for(id)
-        @data_stamp[id]
-      end
-
-      def set_data_stamp(cell_ids)
+      def set_data_stamp(section_ids)
         @data_stamp ||= {}
-        [*cell_ids].each { |id| @data_stamp[id] = Time.now.to_f }
+        [*section_ids].each do |id|
+          @data_stamp[id] = Time.now.to_f
+        end
       end
 
       def reset_data_stamps
-        keys = @data.each_with_index.map do |row, id|
-          if row.is_a?(Array)
-            section = id
-            rows = (0...row.count)
-          else
-            section = 0
-            rows = [id]
-          end
-          rows.map { |row| "#{section}_#{row}" }
-        end
-        set_data_stamp(keys.flatten)
+        keys = data.flatten.map(&:object_id)
+        set_data_stamp(keys)
       end
 
-      def load_sections
-        return if async_data?
+      def create_section_elements
         if flat_data?
-          data.each(&:load_section)
+          data.each(&:create_elements)
         else
-          data.each { |section_data| section_data.each(&:load_section) }
+          data.each { |group_sections| group_sections.each(&:create_elements) }
         end
       end
 
-
-      # Preloads sections after rendering cell in current sheduled index or given index.
-      # TODO: probably should be in separate class.
-      #
-      # @param 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(index)
-        return if !async_data? || @preloader_next_starts_from == false
-        service = preloader_index_service
-
-        load_limit = self.class.async_data_options.try(:[], :preload_rows_count)
-        @preloader_next_starts_from ||= index
-        index_to_start_preloading = service.sum_index(@preloader_next_starts_from, load_limit ? -load_limit/2 : 0)
-        if service.compare_indexes(index, index_to_start_preloading) >= 0
-          load_count = preload_sections_schedule_next(@preloader_next_starts_from, load_limit)
-          @preloader_next_starts_from = service.sum_index(@preloader_next_starts_from, load_count, false)
-        else
-          false
-        end
-      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 limit [Integer] Limit of sections to load.
-      # @return [Integer] Count of sections scheduled to load.
-      def preload_sections_schedule_next(index, limit)
-        service = preloader_index_service
-
-        left_to_load = rows_for_section(index.section).count - index.row
-        load_count = [left_to_load, limit].compact.min
-        @preloader_cancelled = false
-        @preloader_queue ||= []
-        @strong_refs ||= []
-
-        # TODO: we do we need to keep screen ref too?
-        queue_id = @preloader_queue.count
-        @strong_refs[queue_id] = [screen.strong_ref, screen.main_controller.strong_ref]
-        @preloader_queue[queue_id] = :in_progress
-        BW::Reactor.schedule(queue_id) do |queue_id|
-          result = load_count.times do |offset|
-            if @preloader_queue[queue_id] == :cancelled
-              @strong_refs[queue_id] = nil
-              break
-            end
-            if screen.main_controller.retainCount == 1
-              @strong_refs[queue_id] = nil
-              @preloader_queue[queue_id] = :dealloc
-              break
-            end
-
-            load_cell_by_index(index, preload: true)
-            unless offset == load_count - 1
-              index = service.sum_index(index, 1)
-            end
-          end
-
-          if result
-            on_async_data_preloaded(index)
-            @preloader_queue[queue_id] = :completed
-          end
-          @strong_refs[queue_id] = nil
-        end
-        load_count
-      end
-
-      def preloader_index_service
-        TableDataIndexes.new(@data)
-      end
-
     class << self
       def inherited(subclass)
         super
-        subclass.async_data_options = self.async_data_options.try(:clone)
-        subclass.section_header_options = self.section_header_options.try(:clone)
+        subclass.group_header_options = self.group_header_options.try(:clone)
       end
 
       def async_table_data(options = {})
-        self.async_data_options = options
+        self.send :include, Prime::AsyncTableMixin
+        self.set_async_data_options options
       end
 
       def group_header(name, options)
         options[:name] = name
-        self.section_header_options ||= []
+        self.group_header_options ||= []
         section = options.delete(:id)
-        self.section_header_options[section] = options
+        self.group_header_options[section] = options
       end
 
       def pull_to_refresh(&block)