Hallo Zergling,
dem Wunsch komme ich gerne nach. Ich versuche es so kurz wie möglich zu halten...
Folgende Komponenten sind am Geschehen beteiligt:
- Frontcontroller:
Stellt die Funktionalität bereit, dass vor dem Transformieren einer Seite die Business-Schicht bereits aufgebaut wird. Somit steht das Model der Anwendung zum Zeitpunkt der Transformation der Seite bereits zur Verfügung und die
Präsentations-Schicht muss nur noch gemäß den Model-Informationen die Views erzeugen.
- Pagecontroller
Kapselt verschiedene
Präsentations-Schicht-Funktionalitöten, wie das Parsen von Templates, Ausführen von im Interface eines Objektbaum der Seite definierten Objekts...
- Actions
Das sind FrontController-Actions, die zur Business-Schicht gehören und bestimmte Aktionen (hier das Backup) ausführen und das Model verändern (Informationen hinzufügen)
- Documentcontroller
Controller, die an Hand der Model-Informationen den View aufbauen. Es gint Standard-(Interface)-Methoden, die jeder DocumentController implementieren muss. Hier ist das transformContent(). Diese wird beim rekursiven Transformieren des Objektbaums der Seite auf jeden DocumentController aufgerufen und generiert den View.
In Code bedeutet das folgendes:
index.php PHP-Code:
$fC = &Singleton::getInstance('Frontcontroller');
$fC->set('Context','sites::weiterbildungsveranstaltung');
$fC->start('namespace::to::myapp::pres::templates','main_template');
?>
Die index.php instanziiert den Frontcontroller. Dieser parst die URL nach Action-Anweisungen der Form {namespace}-action:{action}={params} und erzeugt die zugehörigen Action-Objekte. Ist die Backup-Action gefragt, so instanziiert er diese und führt die run()-Methode aus.
Frontcontroller.php PHP-Code:
function start($Namespace,$Template){
$this->__parseActions();
if($this->__EnablePermanentActions == true){
$this->__loadPermanentActions();
// end if
}
$Page = new Page();
$Page->set('Context',$this->__Context);
$Page->loadDesign($Namespace,$Template);
$this->__runActions('permanentpre');
$this->__runActions('pre');
$PageContent = $Page->transform();
$this->__runActions('post');
$this->__runActions('permanentpost');
echo $PageContent;
// end function
}
?>
BackupDatabase.php PHP-Code:
function BackupDatabase(){
$this->__M = & Singleton::getInstance('wvManager');
// end function
}
function run(){
if($this->__Input->getAttribute('view') == 'backup'){
$BackupDatei = $this->__M->sichereDatenbank();
$this->__Input->setAttribute('BackupFileName',$BackupDatei);
$this->__Input->setAttribute('view','bestaetigung');
// end if
}
// end function
}
?>
In der Action (Klasse "BackupDatabase") wird dann die Business-Schicht (Klasse "wvManager") instanziiert (immer Singleton!) und das Backup ausgeführt. Zusäzlich werden die relevanten Informationen in das Input-Objekt geschreiben (=Model), damit die
Präsentations-Schicht weiß, was zu tun ist.
backup_v1_controller.php PHP-Code:
function transformContent(){
$Action = & $this->__M->getActionByName('Backup');
$Input = & $Action->getInput();
if($Input->getAttribute('view') == 'auswahl'){
$Template__Formular = & $this->__getTemplate('Formular');
$this->setPlaceHolder('Inhalt',$Template__Formular->transformTemplate());
// end if
}
if($Input->getAttribute('view') == 'bestaetigung'){
$this->setPlaceHolder('Inhalt',$this->__generiereBestaetigung($Input->getAttribute('BackupFileName')));
// end if
}
// end function
}
function __generiereBestaetigung($BackupFileName){
$Action = & $this->__M->getActionByName('Backup');
$Input = & $Action->getInput();
$BackupFileName = $Input->getAttribute('BackupFileName');
$Template = & $this->__getTemplate('Bestaetigung');
$Template->setPlaceHolder('BackupLink',BACKUP__URL_PATH.'/'.$BackupFileName);
$Template->setPlaceHolder('BackupDatei',$BackupFileName);
return $Template->transformTemplate();
}
?>
In der Datei des Document Controllers werden einige Methoden der API verwendet. Hier die wichtigste: __getTemplate(). Sie stammt vom Objekt Document, von dem jeder Baum-Knoten ableitet. Innderhalb des Contents eines Dockuments können Templates der Form
eingebettet sein. Die Methode __generiereBestaetigung() benutzt das angezeigte Template um die Bestätigungs-Nachricht im View auszugeben.
Ich hoffe das war knapp genug (Kommentare wurden aus dem Code weitestgehend entfernt). Essentiell ist eben, dass der Aufbau des DOM's der Seite über die Logik des PageControllers passiert, der die Designs parst und nach Tags durchsucht. Man kann beispielsweise in eine Seite per
Code:
<core::importdesign namespace="" template="" />
in ein vorhandenes Document ein weiteres als Kind-Document einhängen. Beispiel hierfür wäre die Content- und Menü-Area einer Seite. Jeders dieser Document's hat wiederum seinen DocumentController (bei Bedarf; kann auch mal keinen haben, wenn keine logische Funktionalität im Design steckt), der logische Funktion in das Template bringt.
Ich kann gerne mal die API-Dokumentation zur Verfügung stellen, bzw. ein UML hinzufügen, dann wird klarer, was hier passiert.
Any questions left?