Location: PHPKode > scripts > CD Engine > cd-engine/cdengine.php
<?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&szlig; 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",'&nbsp;',$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 &nbsp; 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>&nbsp;";
				$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
?>
Return current item: CD Engine