Note , I have removed most of the comments for brevity & since its mostly straightforward anyway.
Error checks have been removed for brevity !

da class ...


<?php
/**
* firepages.com.au - basic pagination class - see
* http://www.firepages.com.au/pagination.htm for more information
*/
class pager{
var $p_range = 0; # range to show if you dont want to show ALL pages returned
var $curr = 1; # current page number
var $_pages = ''; # no of pages in a recordset
var $_ctl = '_p'; # default control variable name
var $_req_url =''; # url to build links with
var $_req_qs =''; # query string to build links with
# allowed replacements for titles and links
var $_t_tpls = array('{CURRENT}','{FROM}','{TO}','{MAX}','{TOTAL}');
var $_l_tpls = array('{LINK_HREF}','{LINK_LINK}');
#when set_range() is in use
var $set_from=''; #min page number of returned set
var $set_to=''; #max number of returned set

function pager($max, $pp, $curr, $extra='')
{
if(!is_array($extra)){
$extra=array();
}
$this->_pp = $pp;
$this->curr = (int)$curr > 0 ? $curr : 1 ;
$this->set_from=1;//may be overriden by a set_range() paged set
$this->_pages = $this->set_to = $this->p_range = ceil( $max/$pp );
$this->_ctl .= empty($extra['suffix']) ? '' : $extra['suffix'] ;
$this->_req_qs = isset($extra['query_string']) ?
$extra['query_string'] : $_SERVER['QUERY_STRING'] ;
$this->_req_url = isset($extra['php_self']) ?
$extra['php_self'] : $_SERVER['PHP_SELF'] ;

#check for and remove control variables from query string#
if(strpos($this->_req_qs,$this->_ctl)!==false){
parse_str($this->_req_qs,$arr);
$tmp=array();
unset($arr[$this->_ctl]);
foreach($arr as $k=>$v){
$tmp[]="$k=$v";
}
$this->_req_qs = implode('&', $tmp);
unset($tmp);
}
#vars for eye_candy not declared ~#
$this->_from = (($this->curr * $this->_pp) - $this->_pp) + 1;
$to = ($this->_from + $this->_pp) -1 ;
$this->_to = ($to > $max ) ? $max : $to ;
$this->_total = $max ;
}

function set_range($p_range)
{
$this->p_range = $p_range;
}

function get_limit()
{
return ($this->curr * $this->_pp) - $this->_pp. ' , '.$this->_pp;
}

function get_limit_offset()
{
return ($this->curr * $this->_pp) - $this->_pp;
}

function get_title($format)
{
return str_replace($this->_t_tpls,
array($this->curr, $this->_from, $this->_to, $this->_pages, $this->_total), $format);
}

function _get_qurl()
{
$q = empty($this->_req_qs) ? '' : '?'.$this->_req_qs ;
$s = (substr($q, 0, 1) == '?') ? '&amp;' : '?' ;
return $this->_req_url . $q . $s . $this->_ctl . '=';
}

function get_prev($format)
{
return $this->curr > 1 ?
str_replace($this->_l_tpls,array($this->_get_qurl().($this->curr -1)),$format) : '' ;
}

function get_next($format)
{
return ($this->curr < $this->_pages) ?
str_replace($this->_l_tpls,array($this->_get_qurl().($this->curr +1)),$format) : '' ;
}

function get_range($format, $sep,$first='',$last='')
{
if($this->_pages < 2){
return ;
}
$pre_url = $this->_get_qurl();
$lfirst = $llast = '' ;
$min = 1 ;
$to = $this->_pages ;

if($this->_pages > $this->p_range){
$mid = ceil(($this->p_range / 2));
if(($this->curr - $mid) >= 1){
$min = $this->curr - $mid;
}
$to = $min + ($this->p_range-1);
if($this->_pages > $to){
$llast = (!empty($last)) ?
$sep.str_replace($this->_l_tpls,array($pre_url.$this->_pages,$last),$format) : '' ;
}
if($min > 1){
$lfirst = (!empty($first) && $this->curr >1 ) ?
str_replace($this->_l_tpls,array($pre_url.'1',$first),$format) .$sep : '' ;
}
if($to > $this->_pages){
$to = $this->_pages ;
}
//NEW readjust to show at least p_range links is set_range in use//
if(($to - $min) < $this->p_range){
$min= ($to-$this->p_range)+1;
}
//NEW external parsers may need the correct from and to values from a set_range() limited set
$this->set_from=$min;
$this->set_to=$to;
}
for($x=$min; $x<=$to; ++$x){
$rets[]=($this->curr!=$x)?str_replace($this->_l_tpls, array($pre_url.$x, $x) , $format):$x;
}
return $lfirst.implode($sep, $rets).$llast;
}
}
?>


This class provides only the basics of pagination , it makes no queries itself, all it does is provide you with information about the results and links to go forward and backwards through your result set.

Its actually a good idea to keep SQL and specific database information out of your pagination class since it makes your code more reusable.
If you have a common database abstraction class you could agregate that into such a class but I think it would still be better to subclass such a solution and keep the pagination class as pure as possible.

Also to keep markup out of the class this class requires you pass your own formatting for page results and links, again it does make it more flexible in the long run.

Note that to make pagination efficient you normally end up making 2 queries , 1 to fetch the count , the next to fetch the actual data for display, with a properly indexed table this is not a big ask of the DB.

example basic usage...

Ideally you would use a function or create a subclass of the pager class to make the usage `neater` , its quite easy to wrap the above up for quicker coding.
The following example is at its most basic.


<?php
//find out the size of our recordset , only fetch a count, in this query nothing else
$max = mysql_result( mysql_query("SELECT COUNT(id) FROM table WHERE id > 0"), 0 ) ;
$pager = new pager(
$max , /*see above*/
10 , /*how many records to display at one time*/
@$_GET['_p'] /*this is the current page no carried via _GET*/
) ;

/*
optionally set a maximum number of pages to display
so you dont end up with 100's of links
*/
$pager->set_range(10);

/*the main query note the same WHERE conditions*/
$q = mysql_query("SELECT id,name FROM table WHERE id > 0 LIMIT ".$pager->get_limit());

/*show something for your troubles*/
echo $pager->get_title('Page {CURRENT} of {MAX}<br />Displaying results {FROM} to {TO} of {TOTAL}'). ' <br />';
echo $pager->get_range('<a href="{LINK_HREF}">{LINK_LINK}</a>',' &raquo ').'<br /><br />';

/*+ of course the actual data*/
while($r = mysql_fetch_assoc($q)){
echo "{$r['id']},{$r['name']}<br />";
}
?>


any feedback , suggestions, glaring errors etc appreciated.

22/01/2005
changed '&' to &amp; (Rich Pedley)
Added optional 'first' and 'last' links to get_range , first and last links only get shown if requested and is a first and last link is actually relevant....


echo $pager->get_range('<a href="{LINK_HREF}">{LINK_LINK}</a>',' &raquo ','First','Last').'<br /><br />';
//these could also be images/anything '<img src="first.jpg" />' etc


10/02/2005
Added get_prev() and get_next() for page by page navigation,
this did mean a change elsewhere in the class (gave get_qurl its own function) so if you are using a modified version check first.


echo $pager->get_prev('<a href="{LINK_HREF}">Prev</a>');
echo $pager->get_next('<a href="{LINK_HREF}">text or image here</a>');


17/02/1006
Fixed borked display when using get_range();
Added get_offset_limit() which returns the current offset for databases that can't handle the comma returned in get_limit()

5/5/2007
Added $pager->set_from & $pager->set_to variables for external routines that need to know the first and last page numbers of a set when using set_range();

5/5/2007
now displays a minimum of (e.g. with $pager->set_range(10)) 10 pages even when at end of set (previously might only display set_range()/2 links)

28/6/1007
StupidRalph just pointed out that there is the possibility of XSS in the code above & he is quite right.
I will not however be adding any checks for tainted data in the class above for the following reason.

There are so many places in a reasonably sized application for tainted data to cause havoc which means that there can be hundreds of bits of code that require tainted data to be escaped or otherwise processed, because of that I now filter all incoming data long before that data gets anywhere near my classes or functions... e.g. any page should..
initialize (load config vars etc)
iterate through all potential sources of trouble and clean (GET, POST COOKIE etc)
then and only then load the logic of your the application and play with data.

Much code is distributed with built in error/injection checks, this is ok until you realize you may end up doing the same thing to the same data time and time again, also you may not like the authors validation routines and you probably do not want several authors different routines clogging up your code.

So the moral is, the class above is insecure unless you already employ some pre-filtering of GPC data.