classes/kohana/pagination.php

   1 <?php defined('SYSPATH') or die('No direct script access.');
   2 /**
   3  * This Pagination class will create pagination links for you;
   4  * however, it won't touch the data you are paginating.
   5  *
   6  * @package    Kohana
   7  * @author     Kohana Team
   8  * @copyright  (c) 2008-2009 Kohana Team
   9  * @license    http://kohanaphp.com/license.html
  10  */
  11 class Kohana_Pagination {
  12
  13         protected $uri;
  14         protected $view;
  15         protected $auto_hide;
  16         protected $query_string;
  17         protected $items_per_page;
  18         protected $total_items;
  19         protected $total_pages;
  20         protected $current_page;
  21         protected $current_first_item;
  22         protected $current_last_item;
  23         protected $prev_page;
  24         protected $next_page;
  25
  26         /**
  27          * Creates a new Pagination object.
  28          *
  29          * @param   array  configuration
  30          * @return  Pagination
  31          */
  32         public static function factory(array $config = array())
  33         {
  34                 return new Pagination($config);
  35         }
  36
  37         /**
  38          * Creates a new Pagination object.
  39          *
  40          * @param   array  configuration
  41          * @return  void
  42          */
  43         public function __construct(array $config = array())
  44         {
  45                 if (isset($config['group']))
  46                 {
  47                         // Recursively load requested config groups
  48                         $config += $this->load_config($config['group']);
  49                 }
  50
  51                 // Add default config values, not overwriting existing keys
  52                 $config += $this->load_config();
  53
  54                 // Load config into object and calculate pagination variables
  55                 $this->config($config);
  56         }
  57
  58         /**
  59          * Loads a pagination config group from the config file. One config group can
  60          * refer to another as its parent, which will be recursively loaded.
  61          *
  62          * @param   string   name of the pagination config group
  63          * @param   boolean  enable caching
  64          * @return  array    configuration
  65          */
  66         public function load_config($group = 'default', $cache = TRUE)
  67         {
  68                 // Load the pagination config file (object)
  69                 $config_file = Kohana::config('pagination', $cache);
  70
  71                 // Initialize the $config array
  72                 $config['group'] = $group;
  73
  74                 // Recursively load requested config groups
  75                 while (isset($config['group']) AND isset($config_file->$config['group']))
  76                 {
  77                         // Temporarily store config group name
  78                         $group = $config['group'];
  79                         unset($config['group']);
  80
  81                         // Add config group values, not overwriting existing keys
  82                         $config += $config_file->$group;
  83                 }
  84
  85                 // Get rid of possible stray config group names
  86                 unset($config['group']);
  87
  88                 // Return the $config array
  89                 return $config;
  90         }
  91
  92         /**
  93          * Loads configuration settings into the object and (re)calculates all
  94          * pagination variables.
  95          *
  96          * @param   array  configuration
  97          * @return  Pagination
  98          */
  99         public function config(array $config = array())
 100         {
 101                 if (isset($config['group']))
 102                 {
 103                         // Recursively load requested config groups
 104                         $config += $this->load_config($config['group']);
 105                 }
 106
 107                 // Convert config array to object properties
 108                 foreach ($config as $key => $value)
 109                 {
 110                         $this->$key = $value;
 111                 }
 112
 113                 if ($this->uri === NULL)
 114                 {
 115                         // Use the current URI by default
 116                         $this->uri = Request::instance()->uri;
 117                 }
 118
 119                 // Grab the current page number from the URL
 120                 $this->current_page = isset($_GET[$this->query_string]) ? (int) $_GET[$this->query_string] : 1;
 121
 122                 // Clean up and calculate pagination variables
 123                 $this->total_items        = (int) max(0, $this->total_items);
 124                 $this->items_per_page     = (int) max(1, $this->items_per_page);
 125                 $this->total_pages        = (int) ceil($this->total_items / $this->items_per_page);
 126                 $this->current_page       = (int) min(max(1, $this->current_page), max(1, $this->total_pages));
 127                 $this->current_first_item = (int) min((($this->current_page - 1) * $this->items_per_page) + 1, $this->total_items);
 128                 $this->current_last_item  = (int) min($this->current_first_item + $this->items_per_page - 1, $this->total_items);
 129                 $this->prev_page          = ($this->current_page > 1) ? $this->current_page - 1 : FALSE;
 130                 $this->next_page          = ($this->current_page < $this->total_pages) ? $this->current_page + 1 : FALSE;
 131
 132                 // Chainable method
 133                 return $this;
 134         }
 135
 136         /**
 137          * Generates the full URL for a certain page.
 138          *
 139          * @param   integer  page number
 140          * @return  string   page URL
 141          */
 142         public function url($page = 1)
 143         {
 144                 // Clean the page number
 145                 $page = max(1, (int) $page);
 146
 147                 // Generate the URL
 148                 return URL::site($this->uri).URL::query(array($this->query_string => $page));
 149         }
 150
 151         /**
 152          * Renders the pagination links.
 153          *
 154          * @param   string   view file to use; style
 155          * @param   boolean  hide pagination for single pages
 156          * @return  string   pagination output (HTML)
 157          */
 158         public function render($view = NULL, $auto_hide = NULL)
 159         {
 160                 // Possibly overload config settings
 161                 $view      = ($view === NULL) ? $this->view : $view;
 162                 $auto_hide = ($auto_hide === NULL) ? $this->auto_hide : $auto_hide;
 163
 164                 // Automatically hide pagination whenever it is superfluous
 165                 if ($auto_hide === TRUE AND $this->total_pages < 2)
 166                         return '';
 167
 168                 // Load the view file and pass on the whole Pagination object
 169                 return View::factory($view, get_object_vars($this))->set('page', $this)->render();
 170         }
 171
 172         /**
 173          * Renders the pagination links.
 174          *
 175          * @return  string  pagination output (HTML)
 176          */
 177         public function __toString()
 178         {
 179                 return $this->render();
 180         }
 181
 182         /**
 183          * Returns a Pagination property.
 184          *
 185          * @param   string  URI of the request
 186          * @return  mixed   Pagination property; NULL if not found
 187          */
 188         public function __get($key)
 189         {
 190                 return isset($this->$key) ? $this->$key : NULL;
 191         }
 192
 193         /**
 194          * Updates a single config setting, and recalculates all pagination variables.
 195          * Setting multiple config items should be done via the config() method.
 196          *
 197          * @param   string  config key
 198          * @param   mixed   config value
 199          * @return  void
 200          */
 201         public function __set($key, $value)
 202         {
 203                 $this->config(array($key => $value));
 204         }
 205
 206 } // End Pagination