dbCF.de

PHP Klasse zum Blättern

Demonstration gefällig?

Einige mögliche Kombinationen werden auf der Demoseite vorgestellt.

Wie wird’s gemacht?

Einfach den Code in eine beliebige Datei kopieren (oder hier runterladen). Nennen wir sie einfach mal blaettern.php. Der eigene Code sieht dann irgendwie so aus:

<?php
// Datei mit Code einbinden
include_once('blaettern.php');

// Aktuelle Seite ermitteln
$active_page = !empty($_GET['page']) ? $_GET['page'] : 0;

// Anzahl aller Eintraege ermitteln
$result=mysql_query('SELECT COUNT(feld) FROM tabelle');
list($entries)=mysql_fetch_row($result);


// Objekt erstellen, aktuelle Seite und Anzahl Ergebnisse uebergeben
$blaettern=new blaettern($active_page, $entries);
// URL fuer Links definieren
// Kann man auch im Code fest verankern und sich somit diesen Aufruf sparen
$blaettern->setLinkHref($_SERVER['PHP_SELF'].'?page=');


// Erste Linkliste erstellen und ausgeben
echo $blaettern->create();


// Abfrage mit Begrenzung (LIMIT) ausfuehren
$result=mysql_query('SELECT feld
                     FROM tabelle
                     LIMIT '.($blaettern->getEntriesPerPage() * $blaettern->getActivePage()).', '.$blaettern->getEntriesPerPage());
// Wenn Daten gefunden wurden, dann ausgeben
if (mysql_num_rows($result)>0) {
    while (list($feld)=mysql_fetch_row($result)) {
        echo "$feld<br />\n";
    }
}
else {
    echo "Keine Datens&auml;tze gefunden!\n";
}


// Zweite Linkliste zeigen
echo $blaettern->create();
?>

Sie sollten eine Linkliste erhalten, die in etwa so aussieht (abhängig von der Zahl Einträge und Ihren Einstellungen): [1], >2<, >3< ... >32<, >33<, >34< - Weiter -- Ende

Was bringt mir das?

Nachdem einer der Links angeklickt wurde, hat man eine neue $active_page. Mit dieser Zahl lassen sich beispielsweise in MySQL ganz einfach die darzustellenden Datensätze errechnen (siehe LIMIT '.($blaettern->getEntriesPerPage() * $blaettern->getActivePage()).', '.$blaettern->getEntriesPerPage()). Somit hat man die Daten einer Tabelle ganz einfach auf mehrere Seiten aufgeteilt.

<?php
/** Funktion zum Blaettern
* Funktion zum erstellen einer Linkliste, die das Blaettern durch eine bestimmte Zahl von Ergebnissen erlaubt
*
* @author Carsten Franke <mail@dbCF.de>
* @link http://dbCF.de/
* @version 1.2.1
* @copyright GPL
*/

// Nur waehrend der Entwicklung interessant
// error_reporting(E_ALL);

/*
Alle moeglichen Varianten
Anfang — Zurueck – 1, 2, 3 … 6, 7, 8 … 11, 12, 13 – Weiter — Ende
Zurueck – 1, 2, 3 … 6, 7, 8 … 11, 12, 13 – Weiter
Anfang – 1, 2, 3 … 6, 7, 8 … 11, 12, 13 – Ende
1, 2, 3 … 6, 7, 8 … 11, 12, 13

Anfang — Zurueck – … 6, 7, 8 … – Weiter — Ende
Zurueck … 6, 7, 8 … Weiter
Anfang … 6, 7, 8 … Ende
… 6, 7, 8 …

Anfang — Zurueck – 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 – Weiter — Ende
Zurueck – 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 – Weiter
Anfang – 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 – Ende
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13

Variablen fuer Links
Variable Beispiel Ausgabebeispiel
$delimiter1 — Anfang — Zurueck
$delimiter2 – Zurueck – 1
$delimiter3 , 1, 2, 3
$delimiter4 … 1, 2, 3 … 6, 7, 8

$linkActiveText Seite Seite 1, Seite 2, Seite 3
$linkActiveBracketLeft [ 6, [7], 8
$linkActiveBracketRight ] 6, [7], 8
$linkActiveMore style=’font-size:1.2em;’ <a href=’…’ style=’font-size:1.2em;’>

$linkText Seite Seite 1, Seite 2, Seite 3
$linkBracketLeft > >1<, >2<, >3<
$linkBracketRight < >1<, >2<, >3<
$linkMore target=’_blank’ <a href=’…’ target=’_blank’>

$linkFirstText Anfang Anfang — Zurueck
$linkLastText Ende Weiter — Ende
$linkFirstLastMore style=’font-family:arial;’ <a href=’…’ style=’font-family:arial;’>

$linkNextText Weiter Weiter — Ende
$linkPrevText Zurueck Anfang — Zurueck
$linkNextPrevMore class=’navigation’ <a href=’…’ class=’navigation’>

$showCount 3 6, 7, 8
$showContinuous true/false true: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
false: abhaengig von $showOuter
$showOuter true/false true: 1, 2, 3 … 6, 7, 8 … 11, 12, 13
false: … 6, 7, 8 …
$showNextPrev true/false true: Weiter/Zurueck anzeigen, false: nicht anzeigen
$showFirstLast true/false true: Anfang/Ende anzeigen, false: nicht anzeigen
$showActiveLink true/false true: 6, [7], 8, false: 6, 8
$showSingleLink true/false true: [1], false: (nichts)

$linkHref bilder.php?id=$id&page= <a href=’bilder.php?id=BMW&page=2’>
*/

class Blaettern {
/** Erstellt ein Objekt fuer die Blaetterfunktion
*
* @access public
* @param (int) $activePage Zahl der aktuellen Seite, erhaelt man ungefaehr so: “$activePage=isset($_GET[‘ap’]) ? $_GET[‘ap’] : 0;”
* @param (int) $entries Anzahl aller Ergebnisse; erhaelt man ungefaehr so: “$entries=mysql_num_rows($resource);”
*/
public function __construct($activePage, $entries) {
$this->setActivePage($activePage);
$this->setEntries($entries);
}

/** Erstellt die Liste mit Links
*
* @access public
* @return (mixed) Gibt den erstellten String der Links oder false bei Fehlern zurueck
*/
public function create() {
// Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf… :)
$activePage = &$this->activePage;
$entries = &$this->entries;
$entriesPerPage = &$this->entriesPerPage;
$linkCount = &$this->linkCount;
$linkCountSurround = &$this->linkCountSurround;
$showCount = &$this->showCount;
$showContinuous = &$this->showContinuous;
$showOuter = &$this->showOuter;
$showSingleLink = &$this->showSingleLink;
$showActiveLink = &$this->showActiveLink;
$pageNext = &$this->pageNext;
$pagePrev = &$this->pagePrev;
$pageFirst = &$this->pageFirst;
$pageLast = &$this->pageLast;
$links = &$this->links;

// Array neu initialisieren
$links = array ();

// Anzahl aller moeglichen Links zu den Seiten ermitteln
$linkCount = $entries % $entriesPerPage == 0 ? (int)$entries / $entriesPerPage : (int)ceil($entries / $entriesPerPage);

// Ermitteln, wie viele Links den aktuellen umgeben werden
$linkCountSurround = floor($showCount / 2);

// Wenn kein Blaettern zu Stande kommt, dann mal schauen, ob der Nutzer den einzelnen Link sehen will
if (($showSingleLink === false || $showActiveLink === false) && $entries <= $showCount) {
$links = ”;
return $links;
}
else if ($showSingleLink === true && $showActiveLink === true && $entries <= $showCount) {
$linkCount = 1;
}

// Wenn sinnvoll ($showOuter===true, aber $linkCount<=$showCount*3), dann ueberschreiben wir hier $showContinuous
if ($showOuter === true && $linkCount <= $showCount * 3) {
$showContinuous = true;
}

// Angabe der aktuelllen Seite pruefen, gegebenenfalls neu setzen
if ($linkCount < $activePage) {
$activePage = $linkCount – 1;
} elseif (!is_numeric($activePage) || $activePage < 0) {
$activePage = 0;
}

// Jetzt berechnen wir erst einmal die Seitenzahlen fuer die erste, letzte, naechste und vorherige Seite
// Sollte eine Seite nicht existieren, dann ist der Wert null (nicht 0!)
$pageNext = $activePage + 1;

if ($pageNext >= $linkCount – 1 && $activePage == $linkCount – 1) {
$pageNext = null;
}
$pagePrev = $activePage – 1;

if ($pagePrev <= 0 && $activePage == 0) {
$pagePrev = null;
}
$pageFirst = 0;

if ($activePage == 0) {
$pageFirst = null;
}
$pageLast = $linkCount – 1;

if ($activePage == $linkCount – 1) {
$pageLast = null;
}

// Alle Seitenzahlen durchgehen (egal, ob am Ende gezeigt oder nicht) und Seitenzahlen im Array speichern
for ($i = 0; $i < $linkCount; $i++) {
$links[] = $i;
}
// Links aus Seitenzahlen erstellen
$this->_makeLinks();

// Wenn alle Seiten angezeigt werden sollen…
// …oder Anzahl Links kleiner oder gleich der zu zeigenden ist, dann die Links speichern
if ($showContinuous === true || $linkCount <= $showCount) {
$this->_addDelimiter3();
} else {
// Oder wenn nicht alle Links angezeigt werden sollen…
// …und nicht die aeusseren, dann Links speichern
if ($showOuter === false) {
// Wenn aktiver Link einer der aeusseren ist, dann dieses gesondert zeigen
if ($activePage <= $linkCountSurround) {
$links = $this->_getOuterLinks(‘left’);
$this->_addDelimiter3();
$this->_addDelimiter4(false, true);
} elseif ($activePage >= $pageLast – $linkCountSurround) {
$links = $this->_getOuterLinks(‘right’);

$this->_addDelimiter3();
$this->_addDelimiter4(true, false);
}
// Ansonsten die $showCount relevanten Links ermitteln und speichern
else {
$links = $this->_getInnerLinks();
$this->_addDelimiter3();
$this->_addDelimiter4(true, true);
}
}
// Oder wenn nicht alle Links angezeigt werden sollen…
// …und die aeusseren, dann Links speichern
elseif ($showOuter === true) {
// Alle moeglichen Links sammeln
$temp[0] = $this->_getOuterLinks(‘left’);
$temp[1] = $this->_getInnerLinks();
$temp[2] = $this->_getOuterLinks(‘right’);

// Alle drei Arrays in eins packen
// Keine array_*-Funktion, da diese die Indizes loeschen
$temp2 = $temp[0];

for ($i = 1; $i < 3; $i++) {
foreach ($temp[$i] as $k => $v) {
$temp2[$k] = $v;
}
}
$temp = $temp2;
unset ($temp2);
ksort ($temp);

// Zusammenhaengende Links (Abstand zum naechsten gleich 1) in eigene Arrays packen
$last_index = 0;
$j = 0;

foreach ($temp as $k => $v) {
if ($k – $last_index > 1) {
$j++;
}

$temp2[$j][] = $v;

$last_index = $k;
}

// Arrays zusammenhaengender Links zu Strings zusammenfassen
// Kein Funktionsaufruf, da diese auf $this->links zugreifen
unset ($temp);

for ($i = 0; $i < count($temp2); $i++) {
$temp[] = join($this->delimiter3, $temp2[$i]);
}
$links = join($this->delimiter4, $temp);
}
}

// Links fuer Weiter/Zurueck und Anfang/Ende hinzufuegen, na ja, wenn es denn gewuenscht ist
$this->_addNextPrev();
$this->_addFirstLast();

return $links;
}

/** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum
*
* @access private
*/
private function _makeLinks() {
// Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf… :)
$activePage = &$this->activePage;
$linkHref = &$this->linkHref;
$linkActiveBracketLeft = &$this->linkActiveBracketLeft;
$linkActiveBracketRight = &$this->linkActiveBracketRight;
$linkActiveMore = &$this->linkActiveMore;
$linkActiveText = &$this->linkActiveText;
$linkBracketLeft = &$this->linkBracketLeft;
$linkBracketRight = &$this->linkBracketRight;
$linkMore = &$this->linkMore;
$linkText = &$this->linkText;
$showActiveLink = &$this->showActiveLink;
$links = &$this->links;

for ($i = 0; $i < count($links); $i++) {
$num_link = $i + $this->numberFirstPage;
$num_show = $i + 1;

if ($i == $activePage) {
$links[$i]
= “<a href='{$linkHref}{$num_link}'{$linkActiveMore}>{$linkActiveBracketLeft}{$linkActiveText}{$num_show}{$linkActiveBracketRight}</a>”;
} else {
$links[$i]
= “<a href='{$linkHref}{$num_link}'{$linkMore}>{$linkBracketLeft}{$linkText}{$num_show}{$linkBracketRight}</a>”;
}
}

// Jetzt lassen wir den aktiven Link verschwinden – wenn denn gewuenscht
if ($showActiveLink === false) {
unset($links[$activePage]);
}
unset ($temp);

foreach ($links as $k => $v) {
$temp[] = $v;
}
$links = $temp;
}

/** Gibt Array der inneren Links zurueck
*
* @access private
*/
private function _getInnerLinks() {
// Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf… :)
$activePage = &$this->activePage;
$pageFirst = &$this->pageFirst;
$pageLast = &$this->pageLast;
$linkCountSurround = &$this->linkCountSurround;
$linkCount = &$this->linkCount;
$showCount = &$this->showCount;
$links = &$this->links;

$temp = false;
$from = $activePage – $linkCountSurround;

if ($from < 0) {
$from = 0;
}
$to = $from + $showCount;

if ($to > $linkCount – 1) {
$to = $linkCount – 1;
}

for ($i = $from; $i < $to; $i++) {
$temp[$i] = $links[$i];
}

return $temp;
}

/** Gibt Array mit aeusseren Links (links ‘left’ oder rechts ‘right’) zurueck
*
* @access private
*/
private function _getOuterLinks($side = null) {
// Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf… :)
$showActiveLink = &$this->showActiveLink;
$linkCount = &$this->linkCount;
$showCount = &$this->showCount;
$links = &$this->links;

$temp = false;

if ($side === ‘left’) {
for ($i = 0; $i < $showCount; $i++) {
$temp[$i] = $links[$i];
}
} elseif ($side === ‘right’) {
// Der erste Workaround, da sonst ein Link zu wenig gezeigt wird, wenn aktiver ausgeblendet
if ($showActiveLink === false) {
$from = $linkCount – $showCount – 1;
} else {
$from = $linkCount – $showCount;
}
$to = $from + $showCount;

for ($i = $from; $i < $to; $i++) {
$temp[$i] = $links[$i];
}
}

return $temp;
}

/** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum (siehe Beispiele)
*
* @access private
*/
private function _addDelimiter1() {
if ($this->pageFirst !== null) {
$this->links = $this->delimiter1 . $this->links;
}

if ($this->pageLast !== null) {
$this->links = $this->links . $this->delimiter1;
}
}

/** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum (siehe Beispiele)
*
* @access private
*/
private function _addDelimiter2() {
// Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf… :)
$links = &$this->links;
$pagePrev = &$this->pagePrev;
$pageNext = &$this->pageNext;
$delimiter2 = &$this->delimiter2;
$delimiter4 = &$this->delimiter4;

if ($pagePrev !== null &&
// Verhindern, dass Delimiter2 gezeigt wird, wenn Delimiter4 schon da ist (pure Schoenheit)
substr($links, 0, strlen($delimiter4)) != $delimiter4) {
$links = $delimiter2 . $links;
}

if ($pageNext !== null && substr($links, -1 * strlen($delimiter4)) != $delimiter4) {
$links = $links . $delimiter2;
}
}

/** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum (siehe Beispiele)
*
* @access private
*/
private function _addDelimiter3() { $this->links = join($this->delimiter3, $this->links); }

/** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum (siehe Beispiele)
*
* @access private
*/
private function _addDelimiter4($left = false, $right = false) {
if ($left === true) {
$this->links = $this->delimiter4 . $this->links;
}

if ($right === true) {
$this->links = $this->links . $this->delimiter4;
}
}

/** Fuegt dem Array Links fuer Weiter/Zurueck hinzu – wenn denn gewuenscht
*
* @access private
*/
private function _addNextPrev() {
// Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf… :)
$activePage = &$this->activePage;
$linkHref = &$this->linkHref;
$linkNextText = &$this->linkNextText;
$linkPrevText = &$this->linkPrevText;
$linkNextPrevMore = &$this->linkNextPrevMore;
$showNextPrev = &$this->showNextPrev;
$pageNext = &$this->pageNext;
$pagePrev = &$this->pagePrev;
$links = &$this->links;

if ($showNextPrev === true) {
$this->_addDelimiter2();

$temp1 = $temp2 = ”;

if ($pagePrev !== null) {
$temp1 = “<a href='{$linkHref}” . ($pagePrev – $this->stepsNextPrev + 1 + $this->numberFirstPage)
. “‘{$linkNextPrevMore}>$linkPrevText</a>”;
}

if ($pageNext !== null) {
$temp2 = “<a href='{$linkHref}” . ($pageNext + $this->stepsNextPrev – 1 + $this->numberFirstPage)
. “‘{$linkNextPrevMore}>$linkNextText</a>”;
}
$links = $temp1 . $links . $temp2;
}
}

/** Fuegt dem Array Links fuer Anfang/Ende hinzu – wenn denn gewuenscht
*
* @access private
*/
private function _addFirstLast() {
// Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf… :)
$linkHref = &$this->linkHref;
$linkFirstText = &$this->linkFirstText;
$linkLastText = &$this->linkLastText;
$linkFirstLastMore = &$this->linkFirstLastMore;
$showFirstLast = &$this->showFirstLast;
$pageFirst = &$this->pageFirst;
$pageLast = &$this->pageLast;
$links = &$this->links;

if ($showFirstLast === true) {
$this->_addDelimiter1();

$temp1 = $temp2 = ”;

if ($pageFirst !== null) {
$temp1 = “<a href='{$linkHref}” . ($pageFirst + $this->numberFirstPage)
. “‘{$linkFirstLastMore}>$linkFirstText</a>”;
}

if ($pageLast !== null) {
$temp2 = “<a href='{$linkHref}” . ($pageLast + $this->numberFirstPage)
. “‘{$linkFirstLastMore}>$linkLastText</a>”;
}
$links = $temp1 . $links . $temp2;
}
}

/** Setzt Wert fuer Zahl der aktuelle Seite
* <b>Achtung</b> 10 hier, bedeutet bei der Ausgabe Seite 11
* Dieser Wert MUSS dynamisch festgelegt werden
* ‘ap’ MUSS mit der letzten Variable bei $linkHref uebereinstimmen (ap = active page)
*
* @access public
* @param (int) $activePage Zahl der aktuellen Seite, erhaelt man ungefaehr so: “$activePage=isset($_GET[‘ap’]) ? $_GET[‘ap’] : 0;”
* @return (bool) Gibt false zurueck, wenn $activePage keinen gueltigen Wert hat
*/
public function setActivePage($activePage) {
if (is_numeric($activePage)) {
$this->activePage = round($activePage) – $this->numberFirstPage;
return true;
} else {
return false;
}
}

/** Setzt Wert fuer Zahl der ersten Seite
* Wer also beim Link auf Seite 1 nicht 0 sondern 12 uebergeben
* haben will, muss hier auch 12 eintragen.
*
* @access public
* @param (int) $numberFirstPage Zahl der ersten Seite
* @return (bool) Gibt false zurueck, wenn $numberFirstPage keinen gueltigen Wert hat
*/
public function setNumberFirstPage($numberFirstPage) {
if (is_numeric($numberFirstPage)) {
$this->numberFirstPage = round($numberFirstPage);
return true;
} else {
return false;
}
}

/** Setzt Wert fuer Gesamtzahl aller Eintraege
*
* @access public
* @param (int) $entries Anzahl aller Ergebnisse; erhaelt man ungefaehr so: “$entries=mysql_num_rows($resource);”
* @return (bool) Gibt false zurueck, wenn $entries keinen gueltigen Wert hat
*/
public function setEntries($entries) {
if (is_numeric($entries)) {
$this->entries = round($entries);
return true;
} else {
return false;
}
}

/** Setzt Wert fuer Anzahl Ergebnis pro Seite, die angezeigt werden sollen
*
* @access public
* @param (int) $entriesPerPage Anzahl Ergebnis pro Seite, die angezeigt werden sollen
* @return (bool) Gibt false zurueck, wenn $entriesPerPage keinen gueltigen Wert hat
*/
public function setEntriesPerPage($entriesPerPage) {
if (is_numeric($entriesPerPage) && $entriesPerPage >= 0) {
$this->entriesPerPage = round($entriesPerPage);
return true;
} else {
return false;
}
}

/** Setzt Wert fuer Link, zu dem verwiesen werden soll
* <b>WICHTIG</b> Die Variable, die den Wert der aktuellen Seite enthaelt muss ganz am Ende stehen und dahinter ein = (siehe Beispiele)!!
* Die Seitenzahl wird immer hinten angehangen, weshalb das unbedingt beachtet werden muss!
*
* @access public
* @param (string) $linkHref Link, zu dem verwiesen werden soll
* @return (bool) Gibt false zurueck, wenn $linkHref keinen gueltigen Wert hat
*/
public function setLinkHref($linkHref) {
if (is_string($linkHref)) {
if (substr($linkHref, -1) != ‘=’) {
$linkHref .= ‘=’;
}
$this->linkHref = trim($linkHref);
return true;
} else {
return false;
}
}

/** Setzt Trennzeichen zwischen Links Anfang/Zurueck und Weiter/Ende
*
* @access public
* @param (string) $delimiter1 Zeichen, die zwischen Links Anfang/Zurueck und Weiter/Ende angezeigt werden (siehe ‘Alle moeglichen Varianten’)
* @return (bool) Gibt false zurueck, wenn $delimiter1 keinen gueltigen Wert hat
*/
public function setDelimiter1($delimiter1 = ‘ — ‘) {
if (is_string($delimiter1)) {
$this->delimiter1 = $delimiter1;
return true;
} else {
return false;
}
}

/** Setzt Trennzeichen zwischen Links Zurueck und den Seitenzahlen sowie Weiter und den Seitenzahlen
*
* @access public
* @param (string) $delimiter2 Zeichen, die zwischen Links Zurueck und den Seitenzahlen sowie Weiter und den Seitenzahlen angezeigt werden (siehe ‘Alle moeglichen Varianten’)
* @return (bool) Gibt false zurueck, wenn $delimiter2 keinen gueltigen Wert hat
*/
public function setDelimiter2($delimiter2 = ‘ – ‘) {
if (is_string($delimiter2)) {
$this->delimiter2 = $delimiter2;
return true;
} else {
return false;
}
}

/** Setzt Trennzeichen zwischen Links der einzelnen Seiten
*
* @access public
* @param (string) $delimiter3 Zeichen, die zwischen Links der einzelnen Seiten gezeigt weden (siehe ‘Alle moeglichen Varianten’)
* @return (bool) Gibt false zurueck, wenn $delimiter3 keinen gueltigen Wert hat
*/
public function setDelimiter3($delimiter3 = ‘, ‘) {
if (is_string($delimiter3)) {
$this->delimiter3 = $delimiter3;
return true;
} else {
return false;
}
}

/** Setzt Trennzeichen zwischen Links der einzelnen Seiten
*
* @access public
* @param (string) $delimiter4 Zeichen, die zwischen Links der einzelnen Seiten gezeigt werden (siehe ‘Alle moeglichen Varianten’)
* @return (bool) Gibt false zurueck, wenn $delimiter4 keinen gueltigen Wert hat
*/
public function setDelimiter4($delimiter4 = ‘ … ‘) {
if (is_string($delimiter4)) {
$this->delimiter4 = $delimiter4;
return true;
} else {
return false;
}
}

/** Setzt Wert fuer Zeichen vor und hinter aktivem Link
*
* @access public
* @param (string) $linkActiveBracketLeft Zeichen vor aktivem Link (siehe ‘Variablen’)
* @param (string) $linkActiveBracketRight Zeichen hinter aktivem Link (siehe ‘Variablen’)
* @return (bool) Gibt false zurueck, wenn $linkActiveBracketLeft oder $linkActiveBracketRight keinen gueltigen Wert hat
*/
public function setLinkActiveBracket($linkActiveBracketLeft = ‘[‘, $linkActiveBracketRight = ‘]’) {
if (is_string($linkActiveBracketLeft) && is_string($linkActiveBracketRight)) {
$this->linkActiveBracketLeft = trim($linkActiveBracketLeft);
$this->linkActiveBracketRight = trim($linkActiveBracketRight);
return true;
} else {
return false;
}
}

/** Setzt erweiterte Einstellungen des aktiven Links
*
* @access public
* @param (string) $linkActiveMore Erweitere Einstellungen des aktiven Links (JavaScript, CSS, target, …)
* @return (bool) Gibt false zurueck, wenn $linkActiveMore keinen gueltigen Wert hat
*/
public function setLinkActiveMore($linkActiveMore = ”) {
if (is_string($linkActiveMore)) {
$linkActiveMore = ‘ ‘ . trim($linkActiveMore);
$this->linkActiveMore = $linkActiveMore;
return true;
} else {
return false;
}
}

/** Setzt Wert fuer Zeichen vor und hinter jeden (nicht aktiven) Link
*
* @access public
* @param (string) $linkBracketLeft Zeichen vor jedem (nicht aktiven) Link (siehe ‘Variablen’)
* @param (string) $linkBracketRight Zeichen hinter jedem (nicht aktiven) Link (siehe ‘Variablen’)
* @return (bool) Gibt false zurueck, wenn $linkBracketLeft keinen gueltigen Wert hat
*/
public function setLinkBracket($linkBracketLeft = ”, $linkBracketRight = ”) {
if (is_string($linkBracketLeft) && is_string($linkBracketRight)) {
$this->linkBracketLeft = trim($linkBracketLeft);
$this->linkBracketRight = trim($linkBracketRight);
return true;
} else {
return false;
}
}

/** Setzt erweiterte Einstellungen fuer jeden (nicht aktiven) Link
*
* @access public
* @param (string) $linkMore Erweitere Einstellungen des jedes (nicht aktiven) Links (JavaScript, CSS, target, …)
* @return (bool) Gibt false zurueck, wenn $linkMore keinen gueltigen Wert hat
*/
public function setLinkMore($linkMore = ”) {
if (is_string($linkMore)) {
$linkMore = ‘ ‘ . trim($linkMore);
$this->linkMore = $linkMore;
return true;
} else {
return false;
}
}

/** Setzt Text fuer Links Zurueck/Weiter
*
* @access public
* @param (string) $linkNextText Text des Links Weiter
* @param (string) $linkPrevText Text des Links Zurueck
* @return (bool) Gibt false zurueck, wenn $linkNextText oder $linkPrevText keinen gueltigen Wert hat
*/
public function setLinkNextPrevText($linkNextText = ‘Weiter’, $linkPrevText = ‘Zurück’) {
if (is_string($linkNextText) && is_string($linkPrevText)) {
$this->linkNextText = $linkNextText;
$this->linkPrevText = $linkPrevText;
return true;
} else {
return false;
}
}

/** Setzt erweiterte Einstellungen fuer Links Zurueck/Weiter
*
* @access public
* @param (string) $linkNextPrevMore Erweitere Einstellungen Links Zurueck/Weiter (JavaScript, CSS, target, …)
* @return (bool) Gibt false zurueck, wenn $linkNextPrevMore keinen gueltigen Wert hat
*/
public function setLinkNextPrevMore($linkNextPrevMore = ”) {
if (is_string($linkNextPrevMore)) {
$linkNextPrevMore = ‘ ‘ . trim($linkNextPrevMore);
$this->linkNextPrevMore = $linkNextPrevMore;
return true;
} else {
return false;
}
}

/** Setzt Text fuer Links Anfang/Ende
*
* @access public
* @param (string) $linkFirstText Text des Links Anfang
* @param (string) $linkLastText Text des Links Ende
* @return (bool) Gibt false zurueck, wenn $linkFirstText oder $linkLastText keinen gueltigen Wert hat
*/
public function setLinkFirstLastText($linkFirstText = ‘Anfang’, $linkLastText = ‘Ende’) {
if (is_string($linkFirstText) && is_string($linkLastText)) {
$this->linkFirstText = $linkFirstText;
$this->linkLastText = $linkLastText;
return true;
} else {
return false;
}
}

/** Setzt erweiterte Einstellungen fuer Links Anfang/Ende
*
* @access public
* @param (string) $linkFirstLastMore Erweitere Einstellungen Links Anfang/Ende (JavaScript, CSS, target, …)
* @return (bool) Gibt false zurueck, wenn $linkFirstLastMore keinen gueltigen Wert hat
*/
public function setLinkFirstLastMore($linkFirstLastMore = ”) {
if (is_string($linkFirstLastMore)) {
$linkFirstLastMore = ‘ ‘ . trim($linkFirstLastMore);
$this->linkFirstLastMore = $linkFirstLastMore;
return true;
} else {
return false;
}
}

/** Setzt den Wert, wie viele Links gezeigt werden sollen
*
* @access public
* @param (int) $showCount Gibt Zahl der Links an, die nebeneinander gezeigt werden (ungerade Zahlen sind idealer)
* @return (bool) Gibt false zurueck, wenn $showCount keinen gueltigen Wert hat
*/
public function setShowCount($showCount = 3) {
if (is_numeric($showCount) && $showCount >= 3) {
$this->showCount = ceil($showCount);
return true;
} else {
return false;
}
}

/** Setzt den Wert, um wie viele Seiten bei Weiter/Zurueck gesprungen werden soll
*
* @access public
* @param (bool) $stepsNextPrev Gibt Zahl der Seiten an, um die bei Weiter/Zurueck gesprungen werden soll
* @return (bool) Gibt false zurueck, wenn $stepsNextPrev keinen gueltigen Wert hat
*/
public function setStepsNextPrev($stepsNextPrev = null) {
if (is_numeric($stepsNextPrev) && $stepsNextPrev >= 1) {
$this->stepsNextPrev = round($stepsNextPrev);
return true;
} else {
return false;
}
}

/** Setzt den Wert, ob alle Links auf einmal gezeigt werden sollen
*
* @access public
* @param (bool) $showContinuous Wenn true, dann werden alle Links auf einmal gezeigt
* @return (bool) Gibt false zurueck, wenn $showOuter keinen gueltigen Wert hat
*/
public function setShowContinuous($showContinuous = false) {
if (is_bool($showContinuous)) {
$this->showContinuous = $showContinuous;
return true;
} else {
return false;
}
}

/** Setzt den Wert, ob aeussere Links der Seiten gezeigt werden sollen
*
* @access public
* @param (bool) $showOuter Wenn true, dann werden aeusseren Links der Seiten angezeigt (siehe ‘Alle moeglichen Varianten’)
* @return (bool) Gibt false zurueck, wenn $showOuter keinen gueltigen Wert hat
*/
public function setShowOuter($showOuter = true) {
if (is_bool($showOuter)) {
$this->showOuter = $showOuter;
return true;
} else {
return false;
}
}

/** Setzt den Wert, ob Link der aktuellen Seite gezeigt werden soll
*
* @access public
* @param (bool) $showActiveLink Wenn true, dann wird der Link der aktuellen Seite angezeigt
* @return (bool) Gibt false zurueck, wenn $showActiveLink keinen gueltigen Wert hat
*/
public function setShowActiveLink($showActiveLink = true) {
if (is_bool($showActiveLink)) {
$this->showActiveLink = $showActiveLink;
return true;
} else {
return false;
}
}

/** Setzt den Wert, ob Links fuer Zurueck/Weiter gezeigt werden sollen
*
* @access public
* @param (bool) $showNextPrev Wenn true, dann werden Links fuer Zurueck/Weiter angezeigt
* @return (bool) Gibt false zurueck, wenn $showNextPrev keinen gueltigen Wert hat
*/
public function setShowNextPrev($showNextPrev = true) {
if (is_bool($showNextPrev)) {
$this->showNextPrev = $showNextPrev;
return true;
} else {
return false;
}
}

/** Setzt den Wert, ob Links fuer Anfang/Ende gezeigt werden sollen
*
* @access public
* @param (bool) $showFirstLast Wenn true, dann werden Links fuer Anfang/Ende angezeigt
* @return (bool) Gibt false zurueck, wenn $showFirstLast keinen gueltigen Wert hat
*/
public function setShowFirstLast($showFirstLast = true) {
if (is_bool($showFirstLast)) {
$this->showFirstLast = $showFirstLast;
return true;
} else {
return false;
}
}

/** Setzt den Wert, ob ein einzelner Link gezeigt werden sollen
*
* @access public
* @param (bool) $showSingleLink Wenn true, wird auch bei nur einer Seite ein Link zurueckgegeben, sonst nichts
* @return (bool) Gibt false zurueck, wenn $showSingleLink keinen gueltigen Wert hat
*/
public function setShowSingleLink($showSingleLink = false) {
if (is_bool($showSingleLink)) {
$this->showSingleLink = $showSingleLink;
return true;
} else {
return false;
}
}

/** Gibt Zahl zu zeigender Ergebnisse pro Seite zurueck
*
* @access public
* @return (int) Zahl zu zeigender Ergebnisse pro Seite
*/
public function getEntriesPerPage() {
return $this->entriesPerPage;
}

/** Gibt (eventuell korrigierte) Zahl der aktuellen Seite zurueck
*
* @access public
* @return (int) (eventuell korrigierte) Zahl der aktuellen Seite
*/
public function getActivePage() {
return $this->activePage;
}

/** Zeigt den Wert aller Variablen an
*
* @access public
*/
public function dump() {
$width = 30;
$vars = array (
‘activePage’,
‘delimiter1’,
‘delimiter2’,
‘delimiter3’,
‘delimiter4’,
‘entries’,
‘entriesPerPage’,
‘linkActiveBracketLeft’,
‘linkActiveBracketRight’,
‘linkActiveMore’,
‘linkActiveText’,
‘linkBracketLeft’,
‘linkBracketRight’,
‘linkCount’,
‘linkCountSurround’,
‘linkFirstLastMore’,
‘linkFirstText’,
‘linkHref’,
‘linkLastText’,
‘linkMore’,
‘linkNextPrevMore’,
‘linkNextText’,
‘linkPrevText’,
‘linkText’,
‘pageFirst’,
‘pageLast’,
‘pageNext’,
‘pagePrev’,
‘showActiveLink’,
‘showContinuous’,
‘showCount’,
‘showFirstLast’,
‘showNextPrev’,
‘showOuter’,
‘showSingleLink’,
‘stepsNextPrev’
);

echo “<pre>\n”;

for ($i = 0; $i < count($vars); $i++) {
$temp = $this->$vars[$i];

if (is_bool($temp)) {
$temp = $temp ? ‘true’ : ‘false’;
}

echo ‘$’ . str_pad($vars[$i], $width, ‘ ‘, STR_PAD_RIGHT) . ” = $temp\n”;
}

if (is_array($this->links)) {
echo ‘$links = ‘;
print_r ($this->links);

echo ‘$links = Array’ . “\n(\n”;

for ($i = 0; $i < count($this->links); $i++) {
echo ” [$i] => ” . htmlentities($this->links[$i]) . “\n”;
}

echo “)\n”;
} else {
echo ‘$’ . str_pad(‘links’, $width, ‘ ‘, STR_PAD_RIGHT) . ” = $this->links\n”;

echo ‘$’ . str_pad(‘links’, $width, ‘ ‘, STR_PAD_RIGHT) . ‘ = ‘
. htmlentities(str_replace(‘<a href’, “\n <a href”, $this->links)) . “\n”;
}

echo “</pre>\n”;
}

// Wer hier Werte setzt, der sollte sicher sein, dass sie richtig sind, geprueft werden sie nicht!
// Also lieber die dafuer vorgesehenen Methoden nutzen.

//////////////////////////////////////////////////
// Erforderliche Variablen
//////////////////////////////////////////////////
/** Zahl der aktuellen Seite (Seite 1 hat Wert $this->numberFirstPage)
*
* @access private
* @var (int)
*/
private $activePage = 0;

/** Welchen Wert soll die erste Seite haben?
*
* @access private
* @var (int)
*/
private $numberFirstPage = 1;

/** Anzahl aller Eintraege
*
* @access private
* @var (int)
*/
private $entries = 0;

/** Eintraege, die pro Seite gezeigt werden sollen
*
* @access private
* @var (int)
*/
private $entriesPerPage = 3;

/** URI zur Datei, plus Variablen, fuer Links
*
* @access private
* @var (string)
*/
private $linkHref = ”;

//////////////////////////////////////////////////
// Optionale Variablen
//////////////////////////////////////////////////
/** Trennzeichen, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $delimiter1 = ‘ – ‘;

/**
*
* @access private
* @var (string)
*/
private $delimiter2 = ‘ – ‘;

/** Trennzeichen, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $delimiter3 = ‘ – ‘;

/** Trennzeichen, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $delimiter4 = ‘ … ‘;

/** Text vor aktivem Link, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkActiveText = ”;

/** Zeichen vor aktivem Link, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkActiveBracketLeft = ‘[‘;

/** Zeichen hinter aktivem Link, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkActiveBracketRight = ‘]’;

/** Zusaetzliche Angaben zum aktiven Link, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkActiveMore = ”;

/** Zeichen vor nicht-aktiven Links, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkText = ”;

/** Zeichen vor nicht-aktiven Links, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkBracketLeft = ”;

/** Zeichen hinter nicht-aktiven Links, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkBracketRight = ”;

/** Zusaetzliche Angaben zu nicht-aktiven Links, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkMore = ”;

/** Text fuer ‘Weiter’ (naechste Seite), siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkNextText = ‘Weiter’;

/** Text fuer ‘Zurueck’ (vorherige Seite), siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkPrevText = ‘Zurück’;

/** Zusaetzliche Angaben zu Links ‘Weiter’ und ‘Zurueck’, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkFirstLastMore = ”;

/** Text fuer ‘Anfang’ (erste Seite), siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkFirstText = ‘Anfang’;

/** Text fuer ‘Ende’ (letzte Seite), siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkLastText = ‘Ende’;

/** Zusaetzliche Angaben zu Links ‘Anfang’ und ‘Ende’, siehe ‘Variablen fuer Links’
*
* @access private
* @var (string)
*/
private $linkNextPrevMore = ”;

/** Anzahl Links, die nebeneinander gezeigt werden, siehe ‘Variablen fuer Links’
*
* @access private
* @var (int)
*/
private $showCount = 3;

/** Alle Links zeigen ja/nein, siehe ‘Variablen fuer Links’
*
* @access private
* @var (bool)
*/
private $showContinuous = false;

/** Aeussere Links zeigen ja/nein, siehe ‘Variablen fuer Links’
*
* @access private
* @var (bool)
*/
private $showOuter = true;

/** ‘Weiter’ und ‘Zurueck’ zeigen ja/nein, siehe ‘Variablen fuer Links’
*
* @access private
* @var (bool)
*/
private $showNextPrev = true;

/** ‘Anfang’ und ‘Ende’ zeigen ja/nein, siehe ‘Variablen fuer Links’
*
* @access private
* @var (bool)
*/
private $showFirstLast = true;

/** Link der aktuellen Seite zeigen ja/nein, siehe ‘Variablen fuer Links’
*
* @access private
* @var (bool)
*/
private $showActiveLink = true;

/** Wenn nur eine Seite, Link zeigen ja/nein, siehe ‘Variablen fuer Links’
*
* @access private
* @var (bool)
*/
private $showSingleLink = false;

/** Um wie viele Seiten Weiter/Zurueck springen soll
*
* @access private
* @var (bool)
*/
private $stepsNextPrev = 1;

//////////////////////////////////////////////////
// Voll und ganz interne Variablen
//////////////////////////////////////////////////
/** Anzahl aller Links
*
* @access private
* @var (int)
*/
private $linkCount = 0;

/** Anzahl der Links, die den aktuellen umgeben
*
* @access private
* @var (int)
*/
private $linkCountSurround = 0;

/** Seitenzahl fuer vorherige Seite
*
* @access private
* @var (int)
*/
private $pagePrev = 0;

/** Seitenzahl fuer naechste Seite
*
* @access private
* @var (int)
*/
private $pageNext = 0;

/** Seitenzahl fuer erste Seite
*
* @access private
* @var (int)
*/
private $pageFirst = 0;

/** Seitenzahl fuer letzte Seite
*
* @access private
* @var (int)
*/
private $pageLast = 0;

/** Array aller Links, String mit Links bei Uebergabe
*
* @access private
* @var (mixed)
*/
private $links = array ();
}

/*
//////////////////////////////////////////////////
// Ein paar (alle?) Beispiele
//////////////////////////////////////////////////
echo “<html><body bgcolor=’white’ style=’margin:5px; font-size:0.8em; font-family:verdana;’>\n”;
$activePage = !empty($_GET[‘page’]) ? $_GET[‘page’] : 0;
$PAGES=54;

echo ‘alle, mit aktivem und mit grossen (5 Seiten) Spruengen<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowContinuous(true);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(true);
$blaettern->setStepsNextPrev(5);
echo $blaettern->create().”<br>\n”;

echo ‘<br>3 Links – innere, mit aktivem und grossen (3 Seiten) Spruengen<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(3);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(true);
$blaettern->setStepsNextPrev(3);
echo $blaettern->create().”<br>\n”;

echo ‘<br>Aktuelle Seite und Eintraege pro Seite fuer obige Links<br>’;
echo ‘Active page: ‘.$blaettern->getActivePage().’, Eintraege pro Seite: ‘.$blaettern->getEntriesPerPage().”<br>\n”;

echo ‘<hr>’;
echo ‘<br>alle, mit aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(3);
$blaettern->setShowContinuous(true);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(true);
echo $blaettern->create().”<br>\n”;

echo ‘<br>alle, ohne aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(3);
$blaettern->setShowContinuous(true);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(false);
echo $blaettern->create().”<br>\n”;

echo ‘<br>alle, mit aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(4);
$blaettern->setShowContinuous(true);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(true);
echo $blaettern->create().”<br>\n”;

echo ‘<br>alle, ohne aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(4);
$blaettern->setShowContinuous(true);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(false);
echo $blaettern->create().”<br>\n”;

echo ‘<br>alle, mit aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(5);
$blaettern->setShowContinuous(true);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(true);
echo $blaettern->create().”<br>\n”;

echo ‘<br>alle, ohne aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(5);
$blaettern->setShowContinuous(true);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(false);
echo $blaettern->create().”<br>\n”;

echo ‘<hr>’;
echo ‘<br>3 Links – innere, mit aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(3);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(true);
echo $blaettern->create().”<br>\n”;

echo ‘<br>3 Links – innere, ohne aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(3);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(false);
echo $blaettern->create().”<br>\n”;

echo ‘<br>4 Links – innere, mit aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(4);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(true);
echo $blaettern->create().”<br>\n”;

echo ‘<br>4 Links – innere, ohne aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(4);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(false);
echo $blaettern->create().”<br>\n”;

echo ‘<br>5 Links – innere, mit aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(5);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(true);
echo $blaettern->create().”<br>\n”;

echo ‘<br>5 Links – innere, ohne aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(5);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(false);
$blaettern->setShowActiveLink(false);
echo $blaettern->create().”<br>\n”;

echo ‘<hr>’;
echo ‘<br>3 Links – aeussere, mit aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(3);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(true);
$blaettern->setShowActiveLink(true);
echo $blaettern->create().”<br>\n”;

echo ‘<br>3 Links – aeussere, ohne aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(3);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(true);
$blaettern->setShowActiveLink(false);
echo $blaettern->create().”<br>\n”;

echo ‘<br>4 Links – aeussere, mit aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(4);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(true);
$blaettern->setShowActiveLink(true);
echo $blaettern->create().”<br>\n”;

echo ‘<br>4 Links – aeussere, ohne aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(4);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(true);
$blaettern->setShowActiveLink(false);
echo $blaettern->create().”<br>\n”;

echo ‘<br>5 Links – aeussere, mit aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(5);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(true);
$blaettern->setShowActiveLink(true);
echo $blaettern->create().”<br>\n”;

echo ‘<br>5 Links – aeussere, ohne aktivem<br>’;
$blaettern=new blaettern($activePage, $PAGES);
$blaettern->setLinkHref($_SERVER[‘PHP_SELF’].’?page=’);
$blaettern->setShowCount(5);
$blaettern->setShowContinuous(false);
$blaettern->setShowOuter(true);
$blaettern->setShowActiveLink(false);
echo $blaettern->create().”<br>\n”;
*/
?>

Posted in Dev

2 thoughts on “PHP Klasse zum Blättern

  1. boa, so viel Code für eine einfache Aufgabe für vor und zurück. Du hast zwar verschiedene Varianten integriert, dennoch finde ich das sehr viel Code.

    Eigentlich bin ich auf der Suche nach einem vor/zurück von einzelnen Seiten (text1.php text2.php … textx.php) die in einer Seite integriert sind.

    Vielleicht lasse ich mich doch irgenwie insperieren.

    mfg

  2. Stimmt allerdings. Dafür kann man fast alles konfigurieren und kann sich auch noch zwischen unterschiedlichen Darstellungsvarianten entscheiden.

    Für Deine Zwecke wäre das Skript gar nicht gewappnet. Bisher muss die Seitenzahl immer am Ende der URL stehen. Prinzipiell lässt sich natürlich ganz einfach ein Suffix zur URL anhängen. Natürlich konfigurierbar und damit noch mehr Code. ;)

    Carsten

Leave a Reply

Your email address will not be published. Required fields are marked *

Scroll To Top