# simple html pager class


use strict;
use warnings;

my $pager = Pager->new();

$pager->uri('foo.com/x?bar=1');
$pager->cnt(25);               # from pre-query count
$pager->page( $ARGV[0] || 1 );   # requested page from query arg
$pager->limit(3);              # recs per page

print "cnt: " . $pager->cnt . "\n";
print "page: " . $pager->page . "\n";
print "limit: " . $pager->limit . "\n";
print "skip (derived): " . $pager->skip . "\n";
print "total_pages: " . $pager->total_pages . "\n";
print "html: \n" . $pager->html . "\n";

exit;


### Pager ###
package Pager;

use strict;
use warnings;

##</code><code>##

# new
sub new
{
my $proto = shift;
my $class = ref ($proto) || $proto;
my $self  = {
    cnt => 0,   
    skip => 0,    
    start => 0,    
    page => 1,    
    limit => 999,   
    uri => '',   
    template_next => '<a href="%URI%&p=%PAGE%">&gt;</a>',   
    template_prev => '<a href="%URI%&p=%PAGE%">&lt;</a>',   
    template_page => '<a href="%URI%&p=%PAGE%">%PAGE%</a>',   
    template_this => '<span class="def_text">%PAGE%</span>',   
    template_delim => "\n",   
    };
								
bless ($self, $class);
return $self;
}

# html
sub html
{
my $self = shift;
my $html = '';
my $start = 1;
my $tpages = &total_pages($self);
my $page = $self->{'page'};

    # previous
    if ($page > 1)
    {
    my $tmp = '';
    my $prev = $page - 1;
    
    $tmp = $self->{'template_prev'};
    $tmp =~ s/%URI%/$self->{'uri'}/;        
    $tmp =~ s/%PAGE%/$prev/;        
    $html .= $tmp . $self->{'template_delim'};        
    }

    # page list
    foreach my $p ($start .. $tpages)
    {
    my $tmp = '';
        
        if ($p == $page)
        {
        $tmp = $self->{'template_this'};
        $tmp =~ s/%URI%/$self->{'uri'}/;        
        $tmp =~ s/%PAGE%/$p/g;        
        }
        else
        {
        $tmp = $self->{'template_page'};
        $tmp =~ s/%URI%/$self->{'uri'}/;        
        $tmp =~ s/%PAGE%/$p/g;        
        }
       
    $html .= $tmp . $self->{'template_delim'};        
    }

    # next
    if ($page < $tpages)
    {
    my $tmp = '';
    my $next = $page + 1;
    
    $tmp = $self->{'template_next'};
    $tmp =~ s/%URI%/$self->{'uri'}/;        
    $tmp =~ s/%PAGE%/$next/;        
    $html .= $tmp;        
    }

return $html;
}

# template_next
sub template_next
{
my $self = shift;
$self->{'template_next'} = shift if $_[0];
}

# template_prev
sub template_prev
{
my $self = shift;
$self->{'template_prev'} = shift if $_[0];
}

# template_page
sub template_page
{
my $self = shift;
$self->{'template_page'} = shift if $_[0];
}

# template_this
sub template_this
{
my $self = shift;
$self->{'template_this'} = shift if $_[0];
}

# template_delim
sub template_delim
{
my $self = shift;
$self->{'template_delim'} = shift if $_[0];
}

# uri
sub uri
{
my $self = shift;
$self->{'uri'} = shift if $_[0];
}

# cnt
sub cnt
{
my $self = shift;

    if ($_[0]) { $self->{'cnt'} = shift; } 
    else { return  $self->{'cnt'}; } 
}

# page
sub page
{
my $self = shift;

    if ($_[0]) { $self->{'page'} = shift; } 
    else { return  $self->{'page'}; } 
}

# start
sub start
{
my $self = shift;

    if ($_[0]) { $self->{'skip'} = (shift) - 1 if $_[0] > 0; } 
    else { return  $self->{'start'}; } 
}

# skip
sub skip
{
my $self = shift;

return ($self->{'limit'} * $self->{'page'}) - $self->{'limit'};
}

# limit
sub limit
{
my $self = shift;

    if ($_[0]) { $self->{'limit'} = shift; } 
    else { return  $self->{'limit'}; } 
}

# total_pages
sub total_pages
{
my $self = shift;

my $praw = 0;
my $p = 0;

$praw = $self->{'cnt'} / $self->{'limit'} if $self->{'cnt'} > 0;
$p = int ($praw) == $praw ? $praw : int ($praw) + 1;

$self->{'total_pages'} = $p;

return $p;
}

1;

##</code><code>##


// simple html pager class


using System;
using System.Text.RegularExpressions;


public class Test 
{
    public static void Main (string[] args)
    {
    Pager pager = new Pager();
    pager.uri = "foo.com/x?bar=1";
    pager.cnt = 25;
    pager.page = args[0];
    pager.limit = 3;
    
    Console.WriteLine("cnt: " + pager.cnt);
    Console.WriteLine("page: " + pager.page);
    Console.WriteLine("limit: " + pager.limit);
    Console.WriteLine("skip (derived): " + pager.skip);
    Console.WriteLine("total_pages: " + pager.total_pages());
    Console.WriteLine("html: \n" + pager.html());
    }
}


public class Pager
{

##</code><code>##

private int _cnt;
public int start;
private int _page;
private int _limit;
public string uri;
public string template_next;
public string template_prev;
public string template_page;
public string template_this;
public string template_delim;

    // constructor
    public Pager ()
    {
    _cnt = 0;
    //_skip = 0;
    start = 0;
    _page = 1;
    _limit = 999;
    uri = "";
    template_next = "<a href=\"%URI%&p=%PAGE%\">&gt;</a>";
    template_prev = "<a href=\"%URI%&p=%PAGE%\">&lt;</a>";
    template_page = "<a href=\"%URI%&p=%PAGE%\">%PAGE%</a>";
    template_this = "%PAGE%";
    template_delim = "\n";
    }
    
    // html (output)
    public string html ()
    {
    string htmlo = "";
    int start = 1;
    int tpages = this.total_pages();
    int page = this._page;

        // previous
        if (page > 1)
        {
        string tmp = "";
        int prev = page - 1;
        
        tmp = this.template_prev;
        tmp = Regex.Replace(tmp, "%URI%", this.uri);
        tmp = Regex.Replace(tmp, "%PAGE%", Convert.ToString(prev));
        htmlo += tmp + this.template_delim;        
        }

        // page list
        for (int p = start; p <= tpages; p++)
        {
        string tmp = "";
            
            if (p == page)
            {
            tmp = this.template_this;
            tmp = Regex.Replace(tmp, "%URI%", this.uri);
            tmp = Regex.Replace(tmp, "%PAGE%", Convert.ToString(p));
            }
            else
            {
            tmp = this.template_page;
            tmp = Regex.Replace(tmp, "%URI%", this.uri);
            tmp = Regex.Replace(tmp, "%PAGE%", Convert.ToString(p));
            }
           
        htmlo += tmp + this.template_delim;        
        }

        // next
        if (page < tpages)
        {
        string tmp = "";
        int next = page + 1;
        
        tmp = this.template_next;
        tmp = Regex.Replace(tmp, "%URI%", this.uri);
        tmp = Regex.Replace(tmp, "%PAGE%", Convert.ToString(next));
        htmlo += tmp;        
        }

    return htmlo;
    }

    // cnt
    public object cnt 
    { 
        get { return this._cnt; } 
        set { this._cnt = Convert.ToInt32((object) value); } 
    }
    
    // page
    public object page 
    { 
        get { return this._page; } 
        set { this._page = Convert.ToInt32((object) value); } 
    }

    // skip
    public int skip 
    { 
        get 
        { 
        return ((int)this.limit * (int)this.page) - (int)this.limit; 
        } 
    }

    // limit
    public object limit 
    { 
        get { return this._limit; } 
        set { this._limit = Convert.ToInt32((object) value); } 
    }

    // total_pages
    public int total_pages ()
    { 
    int praw = 0;
    int p = 0;

    if (this._cnt > 0) { praw = this._cnt / this._limit; }
    p = Convert.ToInt32(praw) == praw ? 
      praw : Convert.ToInt32(praw) + 1;

    return p;
    }
}