ProMotion 0.7.8 → 1.0.0

data/lib/ProMotion/{screen_helpers → screen}/screen_navigation.rb

@@ -8,13 +8,11 @@ module ProMotion
       screen = set_up_screen_for_open(screen, args)
       ensure_wrapper_controller_in_place(screen, args)
 
-      screen.send(:on_load) if screen.respond_to?(:on_load)
-
       if args[:in_detail] && self.split_screen
         self.split_screen.detail_screen = screen
 
       elsif args[:in_master] && self.split_screen
-        self.split_screen.master_screen = screen 
+        self.split_screen.master_screen = screen
 
       elsif args[:close_all]
         open_root_screen screen
@@ -29,10 +27,11 @@ module ProMotion
         push_view_controller screen
 
       else
-        open_root_screen screen.pm_main_controller
+        open_root_screen (screen.navigationController || screen)
 
       end
 
+      screen
     end
     alias :open :open_screen
 
@@ -77,11 +76,6 @@ module ProMotion
       end
     end
 
-    def open_view_controller(screen)
-      PM.logger.deprecated "Use `open_root_screen` instead of the more ambiguous `open_view_controller`."
-      open_root_screen screen
-    end
-
     def push_view_controller(vc, nav_controller=nil)
       unless self.navigation_controller
         PM.logger.error "You need a nav_bar if you are going to push #{vc.to_s} onto it."
@@ -98,7 +92,7 @@ module ProMotion
 
       # Instantiate screen if given a class
       screen = screen.new if screen.respond_to?(:new)
-      
+
       # Set parent
       screen.parent_screen = self if screen.respond_to?(:parent_screen=)
 
@@ -125,7 +119,7 @@ module ProMotion
     end
 
     def present_modal_view_controller(screen, animated)
-      self.presentModalViewController(screen.pm_main_controller, animated:animated)
+      self.presentModalViewController((screen.navigationController || screen), animated:animated)
     end
 
     def present_view_controller_in_tab_bar_controller(screen, tab_name)
@@ -155,7 +149,9 @@ module ProMotion
 
     def close_nav_screen(args={})
       args[:animated] = true unless args.has_key?(:animated)
-      if args[:to_screen] && args[:to_screen].is_a?(UIViewController)
+      if args[:to_screen] == :root
+        self.navigation_controller.popToRootViewControllerAnimated args[:animated]
+      elsif args[:to_screen] && args[:to_screen].is_a?(UIViewController)
         self.parent_screen = args[:to_screen]
         self.navigation_controller.popToViewController(args[:to_screen], animated: args[:animated])
       else

data/lib/ProMotion/{screens/_tables → table/cell}/table_view_cell_module.rb

@@ -1,16 +1,15 @@
 module ProMotion
   module TableViewCellModule
-    include ViewHelper
+    include Styling
 
-    attr_accessor :data_cell
+    attr_accessor :data_cell, :table_screen
 
-    def setup(data_cell)
+    def setup(data_cell, screen)
+      self.table_screen = WeakRef.new(screen)
       self.data_cell = data_cell
 
       # TODO: Some of these need to go away. Unnecessary overhead.
       set_cell_attributes
-      set_background_color
-      set_class_attributes
       set_accessory_view
       set_subtitle
       set_image
@@ -25,33 +24,25 @@ module ProMotion
 
     def set_cell_attributes
       data_cell_attributes = data_cell.dup
-      [:image, :accessory_action].each { |k| data_cell_attributes.delete(k) }
+      [:image, :accessory_action, :editing_style].each { |k| data_cell_attributes.delete(k) }
       set_attributes self, data_cell_attributes
       self
     end
 
-    def set_background_color
-      self.backgroundView = UIView.new.tap{|v| v.backgroundColor = data_cell[:background_color]} if data_cell[:background_color]
-    end
-
-    def set_class_attributes
-      if data_cell[:cell_class_attributes]
-        PM.logger.deprecated "`cell_class_attributes` is deprecated. Just add the attributes you want to set right into your cell hash."
-        set_attributes self, data_cell[:cell_class_attributes]
-      end
-      self
-    end
-
     def set_accessory_view
-      if data_cell[:accessory][:view] == :switch
-        switch_view = UISwitch.alloc.initWithFrame(CGRectZero)
-        switch_view.setAccessibilityLabel(data_cell[:accessory][:accessibility_label]) if data_cell[:accessory][:accessibility_label]
-        switch_view.addTarget(self.closest_parent(UITableView), action: "accessory_toggled_switch:", forControlEvents:UIControlEventValueChanged)
-        switch_view.on = true if data_cell[:accessory][:value]
-        self.accessoryView = switch_view
-      elsif data_cell[:accessory][:view]
-        self.accessoryView = data_cell[:accessory][:view]
-        self.accessoryView.autoresizingMask = UIViewAutoresizingFlexibleWidth
+      if data_cell[:accessory]
+        if data_cell[:accessory][:view] == :switch
+          switch_view = UISwitch.alloc.initWithFrame(CGRectZero)
+          switch_view.setAccessibilityLabel(data_cell[:accessory][:accessibility_label] || data_cell[:title])
+          switch_view.addTarget(self.table_screen, action: "accessory_toggled_switch:", forControlEvents:UIControlEventValueChanged)
+          switch_view.on = !!data_cell[:accessory][:value]
+          self.accessoryView = switch_view
+        elsif data_cell[:accessory][:view]
+          self.accessoryView = data_cell[:accessory][:view]
+          self.accessoryView.autoresizingMask = UIViewAutoresizingFlexibleWidth
+        end
+      else
+        self.accessoryView = nil
       end
 
       self

data/lib/ProMotion/table/data/table_data.rb

@@ -0,0 +1,98 @@
+module ProMotion
+  class TableData
+    attr_accessor :data, :filtered_data, :filtered, :table_view
+
+    def initialize(data, table_view)
+      self.data = data
+      self.table_view = table_view
+    end
+
+    def section(index)
+      s = sections.at(index)
+      s || { title: nil, cells: [] }
+    end
+
+    def sections
+      self.filtered ? self.filtered_data : self.data
+    end
+
+    def section_length(index)
+      section(index)[:cells].length
+    end
+
+    def cell(params={})
+      if params[:index_path]
+        params[:section] = params[:index_path].section
+        params[:index] = params[:index_path].row
+      end
+
+      table_section = self.section(params[:section])
+      c = table_section[:cells].at(params[:index].to_i)
+      set_data_cell_defaults c
+    end
+
+    def delete_cell(params={})
+      if params[:index_path]
+        params[:section] = params[:index_path].section
+        params[:index] = params[:index_path].row
+      end
+
+      table_section = self.section(params[:section])
+      table_section[:cells].delete_at(params[:index].to_i)
+    end
+
+    def search(search_string)
+      self.filtered_data = []
+      self.filtered = true
+
+      search_string = search_string.downcase.strip
+
+      self.data.compact.each do |section|
+        new_section = {}
+        new_section[:cells] = []
+
+        new_section[:cells] = section[:cells].map do |cell|
+          cell[:searchable] != false && "#{cell[:title]}\n#{cell[:search_text]}".downcase.strip.include?(search_string) ? cell : nil
+        end.compact
+
+        if new_section[:cells] && new_section[:cells].length > 0
+          new_section[:title] = section[:title]
+          self.filtered_data << new_section
+        end
+      end
+
+      self.filtered_data
+    end
+
+    def stop_searching
+      self.filtered_data = []
+      self.filtered = false
+    end
+
+    def set_data_cell_defaults(data_cell)
+      data_cell[:cell_style] ||= UITableViewCellStyleDefault
+      data_cell[:cell_class] ||= PM::TableViewCell
+      data_cell[:cell_identifier] ||= build_cell_identifier(data_cell)
+
+      data_cell[:accessory] = {
+        view: data_cell[:accessory],
+        value: data_cell[:accessory_value],
+        action: data_cell[:accessory_action],
+        arguments: data_cell[:accessory_arguments]
+      } unless data_cell[:accessory].nil? || data_cell[:accessory].is_a?(Hash)
+
+      data_cell
+    end
+
+    def build_cell_identifier(data_cell)
+      ident = "#{data_cell[:cell_class].to_s}"
+      ident << "-#{data_cell[:stylename].to_s}" if data_cell[:stylename] # For Teacup
+      ident << "-accessory" if data_cell[:accessory]
+      ident << "-subtitle" if data_cell[:subtitle]
+      ident << "-remoteimage" if data_cell[:remote_image]
+      ident << "-image" if data_cell[:image]
+      ident
+    end
+
+  end
+end

data/lib/ProMotion/table/extensions/indexable.rb

@@ -0,0 +1,9 @@
+module ProMotion
+  module Table
+    module Indexable
+      def index_from_section_titles
+        @promotion_table_data.filtered ? nil : @promotion_table_data.sections.collect{ |section| section[:title][0] }
+      end
+    end
+  end
+end

data/lib/ProMotion/table/extensions/refreshable.rb

@@ -0,0 +1,45 @@
+module ProMotion
+  module Table
+    module Refreshable
+      def make_refreshable(params={})
+        pull_message = params[:pull_message] || "Pull to refresh"
+        @refreshing = params[:refreshing] || "Refreshing data..."
+        @updated_format = params[:updated_format] || "Last updated at %s"
+        @updated_time_format = params[:updated_time_format] || "%l:%M %p"
+        @refreshable_callback = params[:callback] || :on_refresh
+
+        @refresh_control = UIRefreshControl.alloc.init
+        @refresh_control.attributedTitle = NSAttributedString.alloc.initWithString(pull_message)
+        @refresh_control.addTarget(self, action:'refreshView:', forControlEvents:UIControlEventValueChanged)
+        self.refreshControl = @refresh_control
+      end
+
+      def start_refreshing
+        return unless @refresh_control
+
+        @refresh_control.beginRefreshing
+      end
+      alias :begin_refreshing :start_refreshing
+
+      def end_refreshing
+        return unless @refresh_control
+
+        @refresh_control.attributedTitle = NSAttributedString.alloc.initWithString(sprintf(@updated_format, Time.now.strftime(@updated_time_format)))
+        @refresh_control.endRefreshing
+      end
+      alias :stop_refreshing :end_refreshing
+
+      ######### iOS methods, headless camel case #######
+
+      # UIRefreshControl Delegates
+      def refreshView(refresh)
+        refresh.attributedTitle = NSAttributedString.alloc.initWithString(@refreshing)
+        if @refreshable_callback && self.respond_to?(@refreshable_callback)
+          self.send(@refreshable_callback)
+        else
+          PM.logger.warn "You must implement the '#{@refreshable_callback}' method in your TableScreen."
+        end
+      end
+    end
+  end
+end

data/lib/ProMotion/table/extensions/searchable.rb

@@ -0,0 +1,61 @@
+module ProMotion
+  module Table
+    module Searchable
+
+      def make_searchable(params={})
+        params = set_searchable_param_defaults(params)
+
+        search_bar = create_search_bar(params)
+
+        if params[:search_bar] && params[:search_bar][:placeholder]
+          search_bar.placeholder = params[:search_bar][:placeholder]
+        end
+
+        @table_search_display_controller = UISearchDisplayController.alloc.initWithSearchBar(search_bar, contentsController: params[:content_controller])
+        @table_search_display_controller.delegate = params[:delegate]
+        @table_search_display_controller.searchResultsDataSource = params[:data_source]
+        @table_search_display_controller.searchResultsDelegate = params[:search_results_delegate]
+
+        self.table_view.tableHeaderView = search_bar
+      end
+      alias :makeSearchable :make_searchable
+
+      def set_searchable_param_defaults(params)
+        params[:content_controller] ||= params[:contentController]
+        params[:data_source] ||= params[:searchResultsDataSource]
+        params[:search_results_delegate] ||= params[:searchResultsDelegate]
+
+        params[:frame] ||= CGRectMake(0, 0, 320, 44) # TODO: Don't hardcode this...
+        params[:content_controller] ||= self
+        params[:delegate] ||= self
+        params[:data_source] ||= self
+        params[:search_results_delegate] ||= self
+        params
+      end
+
+      def create_search_bar(params)
+        search_bar = UISearchBar.alloc.initWithFrame(params[:frame])
+        search_bar.autoresizingMask = UIViewAutoresizingFlexibleWidth
+        search_bar
+      end
+
+      ######### iOS methods, headless camel case #######
+
+      def searchDisplayController(controller, shouldReloadTableForSearchString:search_string)
+        @promotion_table_data.search(search_string)
+        true
+      end
+
+      def searchDisplayControllerWillEndSearch(controller)
+        @promotion_table_data.stop_searching
+        @promotion_table_data_data = nil
+        self.table_view.setScrollEnabled true
+        self.table_view.reloadData
+      end
+
+      def searchDisplayControllerWillBeginSearch(controller)
+        self.table_view.setScrollEnabled false
+      end
+    end
+  end
+end

data/lib/ProMotion/table/grouped_table.rb

@@ -0,0 +1,9 @@
+module ProMotion
+  module GroupedTable
+    include ProMotion::Table
+    
+    def table_style
+      UITableViewStyleGrouped
+    end
+  end
+end

data/lib/ProMotion/table/grouped_table_screen.rb

@@ -0,0 +1,6 @@
+module ProMotion
+  class GroupedTableScreen < TableViewController
+    include ProMotion::ScreenModule
+    include ProMotion::GroupedTable
+  end
+end

data/lib/ProMotion/table/table.rb

@@ -0,0 +1,312 @@
+module ProMotion
+  module Table
+
+    include ProMotion::Styling
+    include ProMotion::Table::Searchable
+    include ProMotion::Table::Refreshable
+    include ProMotion::Table::Indexable
+
+    def table_view
+      @table_view ||= begin
+        t = UITableView.alloc.initWithFrame(self.view.frame, style: table_style)
+        t.dataSource = self
+        t.delegate = self
+        t
+      end
+    end
+
+    def table_style
+      UITableViewStylePlain
+    end
+
+    def screen_setup
+      check_table_data
+      set_up_table_view
+      set_up_searchable
+      set_up_refreshable
+    end
+
+    def check_table_data
+      PM.logger.error "Missing #table_data method in TableScreen #{self.class.to_s}." unless self.respond_to?(:table_data)
+    end
+
+    def set_up_table_view
+      self.view = self.create_table_view_from_data(self.table_data)
+    end
+
+    def set_up_searchable
+      if self.class.respond_to?(:get_searchable) && self.class.get_searchable
+        self.make_searchable(content_controller: self, search_bar: self.class.get_searchable_params)
+      end
+    end
+
+    def set_up_refreshable
+      if self.class.respond_to?(:get_refreshable) && self.class.get_refreshable
+        if defined?(UIRefreshControl)
+          self.make_refreshable(self.class.get_refreshable_params)
+        else
+          PM.logger.warn "To use the refresh control on < iOS 6, you need to include the CocoaPod 'CKRefreshControl'."
+        end
+      end
+    end
+
+    def create_table_view_from_data(data)
+      @promotion_table_data = TableData.new(data, table_view)
+      table_view
+    end
+
+    def searching?
+      @promotion_table_data.filtered
+    end
+
+    def update_table_view_data(data)
+      @promotion_table_data.data = data
+      table_view.reloadData
+    end
+
+    # Methods to retrieve data
+
+    def section_at_index(index)
+      @promotion_table_data.section(index)
+    end
+
+    def cell_at_section_and_index(section, index)
+      @promotion_table_data.cell(section: section, index: index)
+    end
+
+    def trigger_action(action, arguments)
+      if self.respond_to?(action)
+        expected_arguments = self.method(action).arity
+        if expected_arguments == 0
+          self.send(action)
+        elsif expected_arguments == 1 || expected_arguments == -1
+          self.send(action, arguments)
+        else
+          PM.logger.warn "#{action} expects #{expected_arguments} arguments. Maximum number of required arguments for an action is 1."
+        end
+      else
+        PM.logger.info "Action not implemented: #{action.to_s}"
+      end
+    end
+
+    def accessory_toggled_switch(switch)
+      table_cell = closest_parent(UITableViewCell, switch)
+      index_path = closest_parent(UITableView, table_cell).indexPathForCell(table_cell)
+
+      if index_path
+        data_cell = cell_at_section_and_index(index_path.section, index_path.row)
+        data_cell[:accessory][:arguments] ||= {}
+        data_cell[:accessory][:arguments][:value] = switch.isOn if data_cell[:accessory][:arguments].is_a?(Hash)
+
+        trigger_action(data_cell[:accessory][:action], data_cell[:accessory][:arguments]) if data_cell[:accessory][:action]
+      end
+    end
+
+    def delete_row(index_paths, animation = nil)
+      animation = map_row_animation_symbol(animation)
+      index_paths = Array(index_paths)
+      deletable_index_paths = []
+
+      index_paths.each do |index_path|
+        delete_cell = false
+        delete_cell = send(:on_cell_deleted, @promotion_table_data.cell(index_path: index_path)) if self.respond_to?("on_cell_deleted:")
+        unless delete_cell == false
+          @promotion_table_data.delete_cell(index_path: index_path)
+          deletable_index_paths << index_path
+        end
+      end
+      table_view.deleteRowsAtIndexPaths(deletable_index_paths, withRowAnimation:animation) if deletable_index_paths.length > 0
+    end
+
+    def table_view_cell(params={})
+      if params[:index_path]
+        params[:section] = params[:index_path].section
+        params[:index] = params[:index_path].row
+      end
+
+      data_cell = @promotion_table_data.cell(section: params[:section], index: params[:index])
+      return UITableViewCell.alloc.init unless data_cell # No data?
+
+      table_cell = create_table_cell(data_cell)
+
+      table_cell
+    end
+
+    def create_table_cell(data_cell)
+      table_cell = table_view.dequeueReusableCellWithIdentifier(data_cell[:cell_identifier])
+
+      unless table_cell
+        data_cell[:cell_style] ||= UITableViewCellStyleSubtitle
+        table_cell = data_cell[:cell_class].alloc.initWithStyle(data_cell[:cell_style], reuseIdentifier:data_cell[:cell_identifier])
+        table_cell.extend PM::TableViewCellModule unless table_cell.is_a?(PM::TableViewCellModule)
+        table_cell.autoresizingMask = UIViewAutoresizingFlexibleWidth|UIViewAutoresizingFlexibleLeftMargin|UIViewAutoresizingFlexibleRightMargin
+      end
+
+      table_cell.setup(data_cell, self)
+
+      table_cell
+    end
+
+    def update_table_data
+      self.update_table_view_data(self.table_data)
+    end
+
+    ########## Cocoa touch methods #################
+    def numberOfSectionsInTableView(table_view)
+      return @promotion_table_data.data.size
+    end
+
+    # Number of cells
+    def tableView(table_view, numberOfRowsInSection:section)
+      return @promotion_table_data.section_length(section)
+      0
+    end
+
+    def tableView(table_view, titleForHeaderInSection:section)
+      return section_at_index(section)[:title] if section_at_index(section) && section_at_index(section)[:title]
+    end
+
+    # Set table_data_index if you want the right hand index column (jumplist)
+    def sectionIndexTitlesForTableView(table_view)
+      if @promotion_table_data.filtered
+        nil
+      else
+        if self.respond_to?(:table_data_index)
+          self.table_data_index
+        elsif self.class.get_indexable
+          self.index_from_section_titles
+        else
+          nil
+        end
+      end
+    end
+
+    def tableView(table_view, cellForRowAtIndexPath:index_path)
+      table_view_cell(index_path: index_path)
+    end
+
+    def tableView(table_view, willDisplayCell: table_cell, forRowAtIndexPath: index_path)
+      data_cell = @promotion_table_data.cell(index_path: index_path)
+      table_cell.backgroundColor = data_cell[:background_color] || UIColor.whiteColor
+      table_cell.send(:restyle!) if table_cell.respond_to?(:restyle!)
+    end
+
+    def tableView(table_view, heightForRowAtIndexPath:index_path)
+      (@promotion_table_data.cell(index_path: index_path)[:height] || table_view.rowHeight).to_f
+    end
+
+    def tableView(table_view, didSelectRowAtIndexPath:index_path)
+      data_cell = @promotion_table_data.cell(index_path: index_path)
+      table_view.deselectRowAtIndexPath(index_path, animated: true)
+
+      data_cell[:arguments] ||= {}
+      data_cell[:arguments][:cell] = data_cell if data_cell[:arguments].is_a?(Hash) # TODO: Should we really do this?
+
+      trigger_action(data_cell[:action], data_cell[:arguments]) if data_cell[:action]
+    end
+
+    def tableView(table_view, editingStyleForRowAtIndexPath: index_path)
+      data_cell = @promotion_table_data.cell(index_path: index_path)
+
+      case data_cell[:editing_style]
+      when nil, :none
+        UITableViewCellEditingStyleNone
+      when :delete
+        UITableViewCellEditingStyleDelete
+      when :insert
+        UITableViewCellEditingStyleInsert
+      else
+        data_cell[:editing_style]
+      end
+    end
+
+    def tableView(table_view, commitEditingStyle: editing_style, forRowAtIndexPath: index_path)
+      if editing_style == UITableViewCellEditingStyleDelete
+        delete_row(index_path)
+      end
+    end
+
+    def tableView(tableView, sectionForSectionIndexTitle:title, atIndex:index)
+      return index unless ["{search}", UITableViewIndexSearch].include?(self.table_data_index[0])
+
+      if index == 0
+        tableView.setContentOffset(CGPointZero, animated:false)
+        NSNotFound
+      else
+        index - 1
+      end
+    end
+
+    def deleteRowsAtIndexPaths(index_paths, withRowAnimation:animation)
+      PM.logger.warn "ProMotion expects you to use 'delete_cell(index_paths, animation)'' instead of 'deleteRowsAtIndexPaths(index_paths, withRowAnimation:animation)'."
+      delete_row(index_paths, animation)
+    end
+    
+    protected
+    
+    def map_row_animation_symbol(symbol)
+      symbol ||= UITableViewRowAnimationAutomatic
+      {
+        automatic:  UITableViewRowAnimationAutomatic,
+        fade:       UITableViewRowAnimationFade,
+        right:      UITableViewRowAnimationRight,
+        left:       UITableViewRowAnimationLeft,
+        top:        UITableViewRowAnimationTop,
+        bottom:     UITableViewRowAnimationBottom,
+        none:       UITableViewRowAnimationNone,
+        middle:     UITableViewRowAnimationMiddle,
+        automatic:  UITableViewRowAnimationAutomatic
+      }[symbol] || symbol
+    end
+
+    module TableClassMethods
+      # Searchable
+      def searchable(params={})
+        @searchable_params = params
+        @searchable = true
+      end
+
+      def get_searchable_params
+        @searchable_params ||= nil
+      end
+
+      def get_searchable
+        @searchable ||= false
+      end
+
+      # Refreshable
+      def refreshable(params = {})
+        @refreshable_params = params
+        @refreshable = true
+      end
+
+      def get_refreshable
+        @refreshable ||= false
+      end
+
+      def get_refreshable_params
+        @refreshable_params ||= nil
+      end
+      
+      # Indexable
+      def indexable(params = {})
+        @indexable_params = params
+        @indexable = true
+      end
+
+      def get_indexable
+        @indexable ||= false
+      end
+
+      def get_indexable_params
+        @indexable_params ||= nil
+      end
+
+    end
+
+    def self.included(base)
+      base.extend(TableClassMethods)
+    end
+
+  end
+end