<?PHP
/**
Datei:
miniEngine.inc Vers. 0.4
Beschreibung:
Klasse 'CDEngine'. Templat - Engine zur Verwendung
auf einer CD auf der Php und SQLite oder XML laeuft.
Diese Bibliothek ist freie Software;
Sie dürfen sie unter den Bedingungen der GNU Lesser General Public License,
wie von der Free Software Foundation veröffentlicht,
weiterverteilen und/oder modifizieren; entweder gemäß Version 2.1 der Lizenz oder
jeder späteren Version.
Diese Bibliothek wird in der Hoffnung weiterverbreitet,
daß sie nützlich sein wird, jedoch OHNE IRGENDEINE GARANTIE,
auch ohne die implizierte Garantie der MARKTREIFE oder
der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK.
Mehr Details finden Sie in der GNU Lesser General Public License.
Sie sollten eine Kopie der GNU Lesser General Public License
zusammen mit dieser Bibliothek erhalten haben;
falls nicht, schreiben Sie an die
Free Software Foundation,
Inc., 59 Temple Place, Suite 330,
Boston, MA 02111-1307, USA.
Diese Bibliothek wurde von Stephan Krauß erstellt.
Ich bin unter hide@address.com zu erreichen.
***/
class CDEngine{
/*********************** allgemeine Variablen der Klasse CDEngine **************************/
var $erroranzeigen = true; // sollen Fehler angezeigt werden ?
var $rohblock; // gespeicherter Block
var $sichtbarkeit = array(); // soll ein Block angezeigt werden
var $startzeit; // Startzeit des parsen
var $platzhalter; // Inhalt eines Platzhalters
/*********************** Pfade der CDEngine **************************/
var $templatverzeichnis; // Auffindverzeichnis der Template
var $externverzeichnis; // Auffindverzeichnis der externen Dateien
var $pluginverzeichnis; // Auffindverzeichnis der PlugIns
/**
Name: CDEngine
Kurzbeschreibung:
Konstruktor der Klasse
Beschreibung:
laden der betreffenden Pfade
Typ: @public
Input:
$templatverzeichnis = Verzeichnis in dem sich die Template befinden
$externverzeichnis = Verzeichnis in dem sich zentrale grafische Elemente befinden
$pluginverzeichnis = Verzeichnis in dem sich zusaetzliche Funktionen befinden
***/
function CDEngine($templatverzeichnis = false, $externverzeichnis = false, $pluginverzeichnis = false){
// schaltet Block 'gesamt' sichtbar
$this->sichtbarkeit['gesamt'] = true;
// 'Pflicht' - Verzeichnis
if(empty($templatverzeichnis)) $this->print_error('Templatverzeichnis angeben , CDEngine()');
if($templatverzeichnis == '.') $this->templatverzeichnis = '';
elseif(!is_dir($templatverzeichnis)) $this->print_error('Templatverzeichnis '.$templatverzeichnis.' nicht vorhanden , CDEngine()');
else $this->templatverzeichnis = $templatverzeichnis;
// 'Kann' - Verzeichnis 'extern'
if(!empty($externverzeichnis) and is_dir($externverzeichnis)) $this->externverzeichnis = $externverzeichnis;
if(!empty($externverzeichnis) and !is_dir($externverzeichnis)) $this->print_error('Externverzeichnis '.$externverzeichnis.' nicht vorhanden , CDEngine()');
// 'Kann' - Verzeichnis 'plugin'
if(!empty($pluginverzeichnis) and is_dir($pluginverzeichnis)) $this->pluginverzeichnis = $pluginverzeichnis;
if(!empty($pluginverzeichnis) and !is_dir($pluginverzeichnis)) $this->print_error('Pluginverzeichnis '.$pluginverzeichnis.' nicht vorhanden , CDEngine()');
clearstatcache(); // loeschen Speicher
return;
}
/**
Name: lade_datei
Kurzbeschreibung:
laedt die Templat - Datei
Beschreibung:
Laedt das Templat aus dem Templatverzeichnis.
Wenn keine Sprache angegeben ist, wird die deutsche Sprachversion gewaehlt.
Bsp.: 'seite.ihtml'
Wird eine Sprache uebergeben, dann wird nach einem Templat in der entsprechenden Sprache
gesucht. Bsp.: 'seite_en.ihtml' oder 'seite_cz.ihtml'.
Die Extension ist immer *.ihtml.
Wird vom angegebenen Templat keine Sprachversion gefunden, so wird automatisch die deutsche
Sprachversion verwandt. Bsp.: 'seite.ihtml'.
Die deutsche Sprachversion hat keine gesonderte Sprachkennung.
Typ: @public
Input:
$templatdatei = Templatdatei
$sprache = Sprachversion
***/
function lade_datei($templatdatei = false, $sprache = false){
if($sprache == 'de') $sprache = false;
// Fehlermeldung wenn kein Templat angegeben
if(empty($templatdatei)) $this->print_error('Keine Templatdatei angegeben lade_datei()');
// wenn keine Sprache dann deutsche Sprachversion
elseif(empty($sprache)) $templatdatei1 = $templatdatei.'.ihtml';
// ermittelt moegliche Sprach-Templatdatei
elseif(!empty($sprache)){
$templatdatei1 = $this->erstelle_sprachtemplat($templatdatei,$sprache);
}
// Fehlerkontrolle auf Sprachtemplat
if(!is_file($this->templatverzeichnis.$templatdatei1)){
$this->print_error('Datei '.$this->templatverzeichnis.$templatdatei1.' nicht vorhanden , lade_datei()');
$templatdatei1 = $templatdatei.'.ihtml';
}
// verwendet die Sprachversion im Templatverzeichnis
else{
$this->templatdatei = $this->templatverzeichnis.$templatdatei1;
}
clearstatcache(); // Speicher loeschen
// einlesen der Datei
$this->datei_einlesen();
return;
}
/**
Name: erstelle_sprachtemplat
Kurzbeschreibung:
Sucht aus dem Templatverzeichnis das entsprechende Templat
Beschreibung:
Generiert aus dem Dateinamen den Namen des Templates.
Die Sprache und die Extension werden hinzugefuegt.
Bsp.:
$templatdatei = 'seite1'
$sprache = 'en'
$templatdatei = 'seite1_en.ihtml'
Typ: @privat
Input:
$templatdatei = Templat in der betreffenden Sprachvariante
Output:
$templatdatei = gibt den Templatnamen in der Sprachversion zurueck
***/
function erstelle_sprachtemplat($templatdatei,$sprache){
$templatdatei = $templatdatei.'_'.$sprache.'.ihtml';
return $templatdatei;
}
/**
Name: datei_einlesen
Kurzbeschreibung:
Liest den Gesamtblock in eine Variable
Beschreibung:
Liest den Gesamtblock in die Eigenschaft $this->block['gesamt'].
Die Eigenschaft $this->block['gesamt'] beinhaltet den Rohblock
mit allen Platzhaltern und Bloecken.
Typ: @private
***/
function datei_einlesen(){
$wert = $this->templatdatei;
$this->block['gesamt'] = fread($fp = fopen($wert, 'r'), filesize($wert)); // fuellen des Blockes 'gesamt'
fclose($fp);
clearstatcache();
// Leerzeichen vereinfachen
$this->block['gesamt'] = preg_replace("#([ ]{2,20})#i",' ',$this->block['gesamt']);
$this->block_durchsuchen('gesamt'); // durchsucht den Gesamtblock nach Sub - Bloecken
return;
}
/**
Name: block_durchsuchen
Kurzbeschreibung:
Durchsucht einen Block.
Beschreibung:
Durchsucht die Bloecke und speichert
den Inhalt der gefundenen Subbloecke
in die Variable $this->block['blockname']
An Stelle des Sub - Blockes wird ein
temporaerer Platzhalter im Format
'{block_blockname}' gesetzt.
Werden Unterbloecke gefunden, dann
wird diese Funktion rekursiv ausgefuehrt.
Gleichzeitig werden in jedem Block
die Tags des Typ 'extern' und 'plugin' ausgewertet.
Diese Tags sind <CDEngine:extern ... und
<CDEngine:plugin ... !
Typ: @privat
Input:
$blockname = Name des Gesamt oder Subblockes
***/
function block_durchsuchen($blockname){
// Kleinschreibung des Blockname
$blockname = strtolower($blockname);
// finden von 'Plug - In - Tags' im jeweiligen Block
if(preg_match("#(<CDEngine:plugin)#i",$this->block[$blockname])){
$this->ersetze_plugin($blockname);
}
// finden von 'Externen - Tags' im jeweiligen Block
if(preg_match("#(CDEngine:extern)#i",$this->block[$blockname])){
$this->ersetze_extern($blockname);
}
// finden von Bloecken
if(preg_match("#(<CDEngine:block)#i",$this->block[$blockname])){
$this->finde_rohblock($blockname);
}
$this->weitere_bloecke($blockname);
}
/**
Name: ersetze_plugin
Kurzbeschreibung:
Ersetzt den 'Plug In - Tag' durch den entsprechenden Wert.
Beschreibung:
Kontrolliert ob im Pluginverzeichnis eine Datei mit dem entsprechenden
Namen existiert.
Ersetzt das Tag durch den Rueckgabewert der Funktion.
Die Plugin - Datei wird in diese Funktion includiert.
Der Wert welcher den Plug - In - Tag ersetzt muss in der Variable
$ausgabe sein. Bitte beachten Sie den Unterschied zwischen 'extern' und
'plugin'.
'Externe -Tags' sind statischer Natur und koennen nur im Block 'gesamt'
verwandt werden. Sie dienen der grafischen Ergaenzung der Template
im Interesse des CI.
'Plug - In _Tags' sind dynamischer Natur und koennen in allen Bloecken
angewandt werden. Der Wert welcher den Plug - In -Tag ersetzt ist in der
Variable $ausgabe definiert.
Typ: @privat
Input:
$blockname = Name des Blockes
***/
function ersetze_plugin($blockname){
if(empty($this->pluginverzeichnis)) $this->print_error('Kein Pluginverzeichnis angegeben ! ersetze_plugin()');
if(preg_match("#(<CDEngine:plugin name=.)([a-z0-9]+\.[a-z0-9]+)(.>)#i",$this->block[$blockname],$name)){
if(!is_file($this->pluginverzeichnis.$name[2])) $this->print_error('Plugin '.$name[2].' nicht vorhanden ! ersetze_plugin()');
include_once($this->pluginverzeichnis.$name[2]);
$this->block[$blockname] = preg_replace("#<CDEngine:plugin name=.".$name[2].".>#i",$ausgabe,$this->block[$blockname]);
$this->ersetze_plugin($blockname);
}
else{
clearstatcache(); // loeschen Speicher
return;
}
}
/**
Name: ersetze_extern
Kurzbeschreibung:
Sucht und ersetzt den 'Extern - Tag'.
Beschreibung:
Sucht und ersetzt den 'Extern - Tag' im jeweiligen Block.
Dient dem ersetzen eines externen - Tag durch statische Werte.
Wird vorrangig angewandt fuer die grafische Ausgestaltung des
Blockes. Durch die externe Speicherung von grafischen Elementen
ist eine schnelle Aenderung des Layout moeglisch.
Die CI der Firma bleibt in allen Templaten konstant.
Typ: @privat
Input:
$blockname = Name des Blockes
***/
function ersetze_extern($blockname){
if(preg_match_all("#(<CDEngine:extern )(name=.)([a-z0-9]+\.[a-z]{2,4})(.>)#i",$this->block[$blockname],$teile)){
for($i=0;$i < count($teile[3]); $i++){
// ist die externe Datei vorhanden ?
if(!is_file($this->externverzeichnis.$teile[3][$i])){
$wert = "Datei ".$teile[3][$i]." im Verzeichnis ".$this->externverzeichnis." nicht vorhanden ! ersetze_extern()";
$this->print_error($wert);
}
// einlesen externe Datei
else{
$wert = fread($fp = fopen($this->externverzeichnis.$teile[3][$i], 'r'), filesize($this->externverzeichnis.$teile[3][$i]));
fclose($fp);
// einfuegen externe Block und ersetzen Tag
$this->block[$blockname] = preg_replace("#(<CDEngine:extern )(name=.)(".$teile[3][$i].")(.>)#i",$wert,$this->block[$blockname]);
}
}
}
return;
}
/**
Name: weitere_bloecke
Kurzbeschreibung:
Durchsucht den Block nach weiteren Platzhaltern.
Beschreibung:
Wenn im eigentlichen Block ein Platzhalter fuer 'IF' oder 'LOOP'
gefunden wurde, dann wird eine erneute Kontrolle auf Platzhalter
durchgefuehrt. Ist ein allgemeiner Platzhalter des Typ <CDEngine ...
vorhanden, dann wird die Funktion block_durchsuchen erneut aufgerufen.
Ist kein Tag <CDEngine vorhanden, dann wird das durchsuchen des betreffenden
Blockes beendet.
Typ: @privat
Input:
$blockname = Name des Rohblockes
***/
function weitere_bloecke($blockname){
if(preg_match("#(<CDEngine:block)#",$this->block[$blockname])){
$this->block_durchsuchen($blockname);
}
}
/**
Name: finde_rohblock
Kurzbeschreibung:
Schneidet den Block aus und setzt einen temporaeren
Platzhalter.
Beschreibung:
Wenn im angegebenen Block ($blockname) sich ein Kind - Block
befindet wird dieser ausgeschnitten. An die Stelle des Blockes
kommt ein temporaerer Platzhalter nach dem Muster 'block_blockname'.
Der Rohblock wird in der Variablen $this->block[$blockname] gespeichert.
Nach dem ausschneiden wird der ausgeschnittene Block zur erneuten Kontrolle
an die Funktion '$this->weitere_bloecke' uebergeben.
Typ: @privat
Input:
$blockname = Blockname des zu durchsuchenden Abschnittes
***/
function finde_rohblock($blockname){
// Bestimmung des Blocknamen und Kontrolle
preg_match("#(<CDEngine:block name=.)([a-z0-9]+)(.>)#i",$this->block[$blockname],$name);
$name[2] = strtolower($name[2]);
if(isset($this->block[$name[2]])) $this->print_error('Blockname: '.$name[2].' bereits vergeben ! finde_rohblock() ');
// ausschneiden neue Block und erneute Ueberpruefung
if(preg_match("#(<CDEngine:block name=.$name[2].>)([\w\W]+)(</CDEngine:block name=.$name[2].>)#i",$this->block[$blockname],$teile)){
$name[2] = strtolower($name[2]);
$this->block[$name[2]] = $teile[2];
$this->weitere_bloecke($name[2]);
}
else{
$this->print_error('Fehlerhafter Tag im Block: '.$name[2].' finde_rohblock()');
}
// temporaere Platzhalter in alte Block und erneute Ueberpruefung
$this->block[$blockname] = preg_replace("#(<CDEngine:block name=.$name[2].>[\w\W]+</CDEngine:block name=.$name[2].>)#i",'{block_'.$name[2].'}',$this->block[$blockname]);
$this->weitere_bloecke($blockname);
}
/**
Name: block_sichtbar
Kurzbeschreibung:
Bestimmt ob ein Block dargestellt wird oder nicht.
Beschreibung:
Es wird ein Array mit dem Wert 'true' gefuellt.
An Hand des vorhandensein dieser Variable wird bestimmt,
ob der temporaere Platzhalter gegen den entsprechenden Block
ausgetauscht wird.
Typ: @public
Input:
$blockname = Name des betreffenden Blockes der sichtbar geschaltet wird.
***/
function block_sichtbar($blockname){
$blockname = strtolower($blockname);
$this->sichtbarkeit[$blockname] = true;
return;
}
/**
Name: block_unsichtbar
Kurzbeschreibung:
Schaltet einen Block auf 'unsichtbar'.
Beschreibung:
Es kann vorkommen, dass ein Block auf unsichtbar geschaltet werden muss.
Da jeder Block in dem ein Platzhalter belegt wird automatisch als sichtbar
geschaltet wird, besteht hier die Moeglichkeit Blocke nachtraeglich auf
unsichtbar zu schalten.
Dabei ist zu beachten, das wenn ein 'Eltern - Block' auf 'unsichtbar'
geschaltet wird, der 'Kind - Block' gleichfalls unsichtbar ist.
Typ: @public
Input:
$blockname = Block der auf 'unsichtbar' geschaltet wird.
***/
function block_unsichtbar($blockname){
$blockname = strtolower($blockname);
$this->sichtbarkeit[$blockname] = false;
return;
}
/**
Name: platzhalter_belegen
Kurzbeschreibung:
Weist den Inhalt der jeweiligen Platzhalter
den Belegungsfunktionen zu.
Beschreibung:
Entsprechend dem Inhalt der 3 moeglichen Variablen
werden die Inhalte an die 3 Platzhalterfunktionen
uebergeben. Es werden Kontrollen durchgefuehrt.
Typ: @public
Input:
$blockname = Block dessen Platzhalter belegt werden
$belegung = Name des Platzhalter oder ein Array mit Inhalt
$inhalt = Inhalt eines einzelnen Platzhalter
***/
function platzhalter_belegen($blockname,$belegung,$inhalt = false){
$blockname = strtolower($blockname);
// ist Block vorhanden ?
if(!isset($this->block[$blockname])) $this->print_error('Block: '.$blockname.' nicht vorhanden ! platzhalter_belegen()');
// einzelner Platzhalter
if(!empty($blockname) and !is_array($belegung) and !empty($inhalt)){
$this->platzhalter_einzel($blockname,$belegung,$inhalt);
}
elseif(!empty($blockname) and is_array($belegung) and empty($inhalt)){
$belegung1 = $belegung;
$kontrolle = array_shift($belegung);
// globale Belegung
if(!is_array($kontrolle)){
$this->platzhalter_global($blockname,$belegung1);
}
// loop Belegung
else{
$this->platzhalter_loop($blockname,$belegung1);
}
}
else{
$this->print_error('falsche Parameter ! platzhalter_belegen()');
}
return;
}
/**
Name: platzhalter_einzel
Kurzbeschreibung:
Belegt einen einzelnen Platzhalter eines Blockes.
Beschreibung:
Belegt den einzelnen Platzhalter eines Bloeckes.
Der Block 'gesamt' ist das gesamte Templat, ohne das ein gesamter Block
gebildet werden muss.
Typ: @privat
Input:
$block = Block in dem der einzelne Platzhalter ersetzt werden soll.
$platzhaltername = Platzhalter der bearbeitet werden soll.
$inhalt = Inhalt des einzelnen Platzhalter.
***/
function platzhalter_einzel($block,$platzhalter,$inhalt){
$this->sichtbarkeit[$block] = true;
$this->platzhalter[$block] .= '{'.$platzhalter.'} = '.$inhalt.'<br>';
$this->block[$block] = preg_replace("#(\{".$platzhalter."\})#i",$inhalt,$this->block[$block]);
}
/**
Name: platzhalter_global
Kurzbeschreibung:
Belegt die Platzhalter eines Blockes mittels eines Array.
Beschreibung:
Belegt die Platzhalter eines Blockes mittels eines Array.
Der Block wird automatisch auf 'sichtbar' geschaltet.
Bsp. fuer den Aufbau eines Array.
$global['name'] = 'Krauss';
$global['vorname'] = 'Stephan';
$global['ort'] = 'Schneeberg';
Typ: @privat
Input:
$block = Block in dem die Platzhalter global ersetzt werden.
$global = Array in dem sich die Inhalt fuer die Platzhalter
befinden.
***/
function platzhalter_global($blockname,$global){
$this->sichtbarkeit[$blockname] = true;
foreach($global as $name => $inhalt){
$this->platzhalter[$blockname] .= '{'.$name.'} = '.$inhalt.'<br>';
$this->block[$blockname] = preg_replace("#(\{)(".$name.")(\})#i",$inhalt,$this->block[$blockname]);
}
return;
}
/**
Name: platzhalter_loop
Kurzbeschreibung:
Belegt einen Loop - Block mit Platzhalter.
Beschreibung:
Die Platzhalter eines Loop - Blockes werden mit Datensaetze gefuellt.
Die Datensaetze werden mittels eines 2 - dim Array gefuellt.
Der Aufbau des Array muss wie folgt sein.
Bsp.: Datensatz Nr. 0 und Nr. 1 fuer Platzhalter 'name' und 'vorname'
$wert[0]['name'] = 'Krauss';
$wert[0]['vorname'] = 'Stephan';
$wert[1]['name'] = 'Krauss';
$wert[1]['vorname'] = 'Walter';
Jeder Datensatz erhaelt einen Zaehler. Dieser Zaehler wird auf den Platzhalter
{zaehler} gesetzt.
Typ: @privat
Input:
$blockname = Name des 'Loop - Blockes'
$loop = Datensaetze
***/
function platzhalter_loop($blockname,$loop){
$this->sichtbarkeit[$blockname] = true;
$i = 1;
foreach($loop as $name => $inhalt){
$inhalt['zaehler'] = $i;
$temporaer = $this->block[$blockname];
foreach($inhalt as $name1 => $inhalt1){
$this->platzhalter[$blockname] .= "{".$name1."} = ".$inhalt1.' ';
$temporaer = preg_replace("#(\{)".$name1."(\})#i",$inhalt1,$temporaer);
}
$this->platzhalter[$blockname] .= '<br>';
$temporaer1 .= $temporaer;
$i++;
}
$this->block[$blockname] = $temporaer1;
return;
}
/**
Name: darstellung_templat
Kurzbeschreibung:
Stellt das gesamte Templat oder nur einzelne
Bloecke des Templates dar.
Beschreibung:
Mit dem Aufruf dieser Funktion wird das gesamte Templat
oder nur einzelne Teile des Templates dargestellt.
Die Grundeinstellung ist die Darstellung des gesamten
Templates. $blockname = 'gesamt'.
Durch die Angabe eines einzelnen Blockes kann
nur ein Teil des Templates dargestellt werden.
Bloecke werden nur dargestellt wenn diese auf 'sichtbar' geschaltet sind.
Ist ein 'Eltern - Block' nicht auf sichtbar geschaltet, dann werden die
'Kind - Bloecke' gleichfalls nicht dargestellt.
Typ: @public
Input:
$blockname = Name des Blockes
***/
function darstellung_templat($blockname = 'gesamt'){
$blockname = strtolower($blockname);
if(preg_match_all("#(\{)(block)(_)([a-z0-9]+)(\})#i",$this->block[$blockname],$name)){
for($i=0; $i < count($name[4]); $i++){ // belegen der temporaeren Platzhalter nur wenn diese 'sichtbar' sind !
if(!empty($this->sichtbarkeit[$name[4][$i]])){
$this->block[$blockname] = preg_replace("#(\{)(block)(_)(".$name[4][$i].")(\})#i",$this->block[$name[4][$i]],$this->block[$blockname]);
}
else{
$this->block[$blockname] = preg_replace("#(\{)(block)(_)(".$name[4][$i].")(\})#i",'',$this->block[$blockname]);
}
}
}
if(preg_match("#(\{)(block)(_[a-z0-9]+\})#i",$this->block[$blockname])) $this->darstellung_templat($blockname);
else{
$this->block[$blockname] = preg_replace("#(\{[a-z0-9]+\})#i",' ',$this->block[$blockname]);
echo $this->block[$blockname];
}
}
/******************************** Kontrollfunktionen *********************************************/
/**
Name: print_error
Kurzbeschreibung:
Darstellung von Fehlermeldungen
Beschreibung:
Funktionen haben die Moeglichkeit eine Fehlermeldung zu
generieren. Wenn die Eigenschaft $this->erroranzeigen 'true' ist,
werden die Fehler angezeigt und der Ablauf gestoppt.
Typ: @private
Input:
$meldung = Fehlermeldung der Funktionen
***/
function print_error($meldung){
if(!empty($this->erroranzeigen)){
$fehler = "<b>Fehler !</b><br>";
$fehler .= $meldung;
echo $fehler;
exit;
}
return;
}
/**
Name: start_zeit
Kurzbeschreibung:
Kontrollfunktion zur Ermittlung der Startzeit
Beschreibung:
Ermittelt die Startzeit fuer das Profiling.
Dadurch ist eine Zeit und Lastbetrachtung des Server moeglich.
Typ: @public
***/
function start_zeit(){
list($usec, $sec) = explode(" ", microtime());
$this->startzeit = ((float)$usec + (float)$sec);
}
/**
Name: end_zeit
Kurzbeschreibung:
Funktion zur Berechnung des Profiling.
Beschreibung:
Moeglichkeit zur Errechnung der Zeit die verwandt wird zum parsen
des Templates. Damit ist ein Profiling nach der Zeit und ein
abschaetzen der Serverlast moeglich.
Moegliche Flaschenhaelse der Programmierung werden erkannt und
koennen behoben werden.
Typ: @public
Input:
***/
function end_zeit(){
list($usec, $sec) = explode(" ", microtime());
$endzeit = ((float)$usec + (float)$sec);
$total = $endzeit - $this->startzeit;
echo '<br><b>verbrauchte Zeit:</b> '.$total.' Sekunden';
return;
}
/**
Name: uebersicht_bloecke
Kurzbeschreibung:
Beschreibung:
Funktion mit der die Sichtbarkeit und die Belegung der
Bloecke mit Variablen kontrolliert werden kann.
Mit dieser Funktion kann entsprechend der Abschnitte
in der Steuerungsdatei eine Kontrolle durchgefuehrt werden.
Dient zum auffinden von logischen Fehlern.
Die Kontrolle wird immer auf den Block 'gesamt' angewandt.
Typ: @public
***/
function uebersicht_bloecke(){
$i = 0;
$hintergrundfarbe = $this->berechne_farbwert($i);
$kontrolle = "<table border='1' rules='none' cellpadding='10' cellspacing='0' width='100%' bordercolor='blue' bgcolor='#".$hintergrundfarbe."'>\n<tr><th> Layer: 0 Blockname: gesamt </th><th align='right'> Status: </th><th bgcolor='#00ff00' align='left'> sichtbar </th></tr>
<tr><td align='center'> Inhalt: </td><td colspan='2'>".$this->platzhalter['gesamt']."</td></tr>
<tr><td colspan='3'>";
$fp = fopen($this->templatdatei,'r');
$i++;
while(!feof($fp)){
$str = fgets($fp,200);
if(preg_match("#(<CDEngine:block name=.)([a-z0-9]+)#i",$str,$name)){
$realname = $name[2];
$name[2] = strtolower($name[2]);
$hintergrundfarbe = $this->berechne_farbwert($i);
if($this->sichtbarkeit[$name[2]]){
$zellfarbe = '00ff00';
$info = 'sichtbar';
}
else{
$zellfarbe = 'ff0000';
$info = 'unsichtbar';
}
$kontrolle .= "\n<table width='100%' rules='none' border='1' cellpadding='10' cellspacing='0' bordercolor='blue' bgcolor='#".$hintergrundfarbe."'>\n<tr><th> Layer: ".$i." Blockname: '".$realname."'</th><th align='right'> Status: </th><th bgcolor='#".$zellfarbe."'> ".$info." </th></tr>
<tr><td align='center'> Inhalt: </td><td colspan='2'>".$this->platzhalter[$name[2]]."</td></tr>
<tr><td colspan='3'>";
$i++;
}
if(preg_match("#(</CDEngine:block name=.)([a-z0-9]+)#i",$str)){
$kontrolle .= "\n</td></tr></table> ";
$i--;
}
}
$kontrolle .= "\n</td></tr></table>";
fclose($fp);
echo $kontrolle;
}
/**
Name: berechne_farbwert
Kurzbeschreibung:
Berechnet den Farbwert zur Darstellung der einzelnen Bloecke.
Beschreibung:
Berechnet den Farbwert zur Darstellung der einzelnen Bloecke.
Jeder Block erhaelt zur Kennzeichnung eine eigene Farbe.
Typ: @privat
Input:
$i = Wert zur Berechnung der Farbe
Output:
$gesamtfarbe = Hintergrundfarbe des Blockes
***/
function berechne_farbwert($i){
$farbe = 255 - ($i * 20);
$farbe1 = dechex($farbe);
$hintergrundfarbe = $farbe1.$farbe1.$farbe1;
return $hintergrundfarbe;
}
} // Ende der Klasse
?>