<?php

/**
 * CB_pageSplit
 * Klasse zum Aufbau einer Seiten Navigation
 * 
 * @package ContentBuilder
 * @author FoG
 * @copyright Copyright (c) 2004
 * @version $Id: CB_pageSplit.class.php,v 1.3 2004/07/18 00:05:58 cb_fog Exp $
 * @access public
 **/
class CB_pageSplit {
	
	var $limit   = 5;
	var $offset  = 0;
	var $entryAmount = 0;
	var $pageCounter = 0;
	
	var $nextOffset, $lastOffset, $lastAvailable, $nextAvailable, $actualPageIndex;
	var $pages = array();
	
	/**
	 * CB_pageSplit::CB_pageSplit()
	 * 
	 * @param int $limitation Anzahl Datensätze pro Seite
	 * @param int $offset Datensatz, bei dem die Navigation momentan steht
	 * @param int $entryAmount Anzahl der gesamten Datensätze
	 **/
	function CB_pageSplit($limitation, $offset, $entryAmount) {
		$this->limit  = $limitation;
		$this->offset = $offset;
		$this->entryAmount = $entryAmount;
		
		$pages = intval($entryAmount/$this->limit);
		
		if ($entryAmount % $this->limit) {
			++$pages;
		}
		
		$this->pageCounter = $pages;
		
		$this->_buildPages();
	}
	
	/**
	 * CB_pageSplit::lastPageExists()
	 * Existiert eine vorhergehende Seite?
	 * 
	 * @return boolean $result 
	 * @see CB_pageSplit::getLastOffset()
	 **/
	function lastPageExists() {
		return($this->lastAvailable);
	}
	
	/**
	 * CB_pageSplit::nextPageExists()
	 * Existiert eine nachfolgende Seite?
	 * 
	 * @return boolean $result 
	 * @see CB_pageSplit::getNextOffset()
	 **/
	function nextPageExists() {
		return($this->nextAvailable);
	}
	
	/**
	 * CB_pageSplit::getLastOffset()
	 * liefert den Pointer vom Anfang der letzten Seite
	 * 
	 * @return int $offset
	 **/
	function getLastOffset() {
		return($this->lastOffset);
	}
	
	/**
	 * CB_pageSplit::getNextOffset()
	 * liefert den Pointer vom Anfang der nächsten Seite
	 * 
	 * @return int $offset
	 **/
	 function getNextOffset() {
		return($this->nextOffset);
	}
	
	/**
	 * CB_pageSplit::getPages()
	 * Liefert das Pages Array aus, dass als index die Seitennummer und als Wert den Offset enthält
	 * 
	 * @return array $pages
	 **/
	function getPages() {
		return($this->pages); 
	}
	
	/**
	 * CB_pageSplit::getActualPage()
	 * Gibt die aktuelle Seitennummer zurück anhand der Offset Berechnungen
	 * 
	 * @return array $actualPageIndex
	 **/
	function getActualPage() {
		return($this->actualPageIndex); 
	}
	
	function getBackLink($urlStuff, $text) {
		$back = $text;
		if($this->lastPageExists()) {
			$back = '<a href="'.$urlStuff.$this->getLastOffset().'">'.$text.'</a> ';
		}
		return $back;
	}
	
	function getNextLink($urlStuff, $text) {
		$next = $text;
		if($this->nextPageExists()) {
			$next = '<a href="'.$urlStuff.$this->getNextOffset().'">'.$text.'</a> ';
		}
		return $next;
	}
	
	function getPageLinks($urlStuff) {
		foreach($this->pages as $key => $value) {
			if(!$this->checkThisPage($key)) {
				$pageLinks .= ' <a href="'.$urlStuff.$value.'">'.$key.'</a>';
			} else { $pageLinks .= ' '.$key; }
		}
		return($pageLinks);
	}
	
	/**
	 * CB_pageSplit::_checkThisPage()
	 * Ist diese Seite die aktuelle Seite?
	 * 
	 * @param int $check Seitennummer zum Checken
	 * @return boolean
	 **/
	function checkThisPage($check) {
		$result = false;
		if($check == $this->actualPageIndex) {
			$result = true;
		}
		return($result);
	}
	
	
	/**
	 * CB_pageSplit::isSplitInPages()
	 * prüft, ob die Einträge das Limit übersteigen
	 * 
	 * @return boolean $return sind mehrere Seiten vorhanden?
	 **/
	function isSplitInPages() {
		$return = 0;
		if($this->limit < $this->entryAmount) {
			$return = 1;
		}
		
		return $return;
	}
	
	/**
	 * CB_pageSplit::_buildPages()
	 * baut ein Array mit Navigationsinfos auf
	 * 
	 * @access private
	 **/
	function _buildPages() {
		if ($this->offset >= $this->limit) {
			$this->lastOffset = $this->offset - $this->limit;
			$this->lastAvailable = 1;
		} else {
			$this->lastOffset = 0;
			$this->lastAvailable = 0;
		}
		
		if ($this->offset != $this->limit * ($this->pageCounter - 1)) {
			$this->nextOffset = $this->offset + $this->limit;
			$this->nextAvailable = 1;
		} else { 
			$this->nextOffset = 0;
			$this->nextAvailable = 0; 
		}
		
		for ($i = 1; $i <= $this->pageCounter; $i++) {
			if ((($i-1) * $this->limit) == $this->offset) {
				$this->actualPageIndex = $i;
			}			
			$this->pages[$i] = ($i-1) * $this->limit;
		}
	}
}

?>