====Beschreibung
Eine Page ist im wesentlichen verwantwortlich für die Darstellung von Templates für eine Url. Die Erstellung der Page, sowie welche Pages für welche Url erstellt werden, wird in [engine|WebTek::Engine] besprochen. Hier wird im wesentlich nur die Funktionalität einer Page erklärt.

====Attribute und Gültigkeitsbereiche von Methoden
Jede Methode in einer Page hat die Möglichkeit folgende Attribute zu verwenden.
* Path
* Action
* Macro
* Param
* Public
desweiteren wurde die Methode can so adaptiert, daß nur die Methoden mit dem Attribute Public von den Kind-Klassen verwendet werden können.\\
package Class::A

sub methodA :Public { 1 }
sub methodB { 1 }

package Class::B
our @ISA = qw ( Class::A );

Class::A->can('methodA'); # liefert die coderef von methodA
Class::A->can('methodB'); # liefert undef
weitere Informationen zu den Attributen finden sich unter [attributes|Attributes].

====Path
Jede Page hat die Funktion path. Dieser Funktion definiert, wie sich die Page in der Url darstellt. Wenn ein Wert der Funktion path übergeben wird, wird er gesetzt, andernfalls wird der retourniert.

====Konstruktoren
* new() erstellt eine neue leere Page
* new_from_child($child) diese Methode wird aufgerufen, wenn versucht wird, die Page- Hirachie von Unten nach Oben aufzubauen. was heisst das?
Im Normalfall hat man ja eine Url, und die WebTek::Engine versucht, mit Hilfe dieser Url von Oben nach Unten zu parsen und die Pageklassen zu erstellen. Von Oben nach Unten heißt in dem Fall, zuerst wird die Rootpage erstellt, dann von der ein Kind usw..
Hier in unserem Fall ist es so, daß an irgendeiner Stelle im Applikationscode eine Page erzeugt wird, und WebTek muß jetzt die Url für dieser Page herausfinden (z.B. in der href funktion). Da aber jede Page nur ihren eigenen path hat und nicht die ganze Url weis, müssen alle Parent- Pages ebenfalls erzeugt werden, und das passiert dann eben von Unten nach Oben. d.h. jede page ruft in ihrer parent funktion die Superpage mit dem Konstruktor new_from_child($self) auf.
* new_for_path($path) :Path(/path) das hier ist nur eine Demonstration wie Konstruktoren definiert sein können, welche für die Erstellung aus der [engine|WebTek::Engine] benötigt werden.

====Konstanten
* LOCATION definiert die Location, welche vor jede Url, die in href generiert wird, geschrieben wird. Standardmäßig wird hier die request->location() verwendet.
* FORM_ERROR_CLASS definiert die Stylesheet Class für ein Formular Element, welches einen Fehler beinhaltet. Diese Konstante wird in render_form_element verwendet: es wird einfach ein <span&gt block mit der class aus FORM_ERROR_CLASS um das Formular Element herumgerendert.

====Actions
Jede Page hat eine Reihe von Standard Actions. Jede dieser Actions ist mit dem attribute Public versehen.
* not_found diese Action wird aufgerufen, wenn die Url nicht weiter, als bis zu dieser Page, geparst werden konnte.
* access_denied diese Action wird aufgerufen, wenn versucht wurde eine Action in der Page aufzurufen, für die nicht die notwendigen Rechte existieren.
* _info diese Action zeigt eine Seite mit allen Möglichkeiten, wie diese Page verwendet werden kann. Diese Action ist vor allem für WebdesingerINNEN gedacht.

====Methoden
* init() diese Methode initialisiert eine Page und findet heraus welche Macros, Actions, Paths die Page hat. Diese Funktion wird im [loader|Loader] beim Laden einer Page ausgeführt.
* parent($parent) setzt oder liefert die Parentpage von dieser Page. Wenn keine Parentpage gesetzt ist wird versucht die Parentpage zu erstellen (siehe weiter oben unter new_from_child).
* message holt eine Message von [message|Message] und rendert diese. d.h. es können Macros in den Messages verwendet werden.
* page_name() liefert den Namen der Page (= der letzte Part vom Klassennamen).
* error_on($name, $value) fragt nach, ob für einen gewissen Namen ein Fehler registriert wurde. Diese Funktion dient für die Formularfeld Überprüfung. Wenn zusätzlich die $value definiert ist, dann wird für den $name der Fehler mit $value (=ist im Normalfall ein Messagekey) gesetzt.
* error_keys() liefert eine Array- Reference mit allen Fehlern dieser Page. Diese sind im Normalfall Messagekeys.

====Methoden welche eine Page beschreiben
* paths() liefert eine Struktur welche alle Methoden mit dem Path Attribute für diese Page zusammenfasst. Es sind ebenfalls alle Paths der Superklassen mitenthalten. Die Struktur hat folgendes Format:
[
[ 'new_for_foo', '/foo']
[ 'new_for_foo_with_number', '/foo\d' ]
]
* actions() liefert eine Array- Reference mit allen Actions (=Funktionsname der Action) für diese Page, inclusiver aller verwendbarer Actions in den Superklassen.
* macros() liefert eine Struktur welche Macros in dieser Page, inklusive Superklassen, existieren. Die Struktur hat folgendes Format:
[
[ 'macro-method-name1' , [ 'as="editor" render as editor'] ]
[ 'macro-method-name2' , [ 'as="link" render as link', 'param2' ] ]
]
* can($method_name) liefert eine coderef wenn die Methode $method_name existiert. ansonnsten wird undef retourniert.
* +can_action($action_name) gleich wie can, aber es wird auch noch zusätzlich überprüft, ob die Methode das Attribute Action besitzt.
* +can_path($path_name) gleich wie can, aber es wird auch noch zusätzlich überprüft, ob die Methode das Attribute Path besitzt.
* +can_macro($macro_name) gleich wie can, aber es wird auch noch zusätzlich überprüft, ob die Methode das Attribute Macro besitzt.

====Macros
Macros sind funktionen welche von Templates aus aufgerufen werden können. Desweiteren gibt es Parameter, welche in den Macros definiert werden können. Ein Macro kann z.B so aussehen:
<% action action="delete" as="link" display="delete" prefix="" suffix="" %>
damit das Macro hier funktioniert, muß es die folgende Methode action geben:
sub action :Macro {
my $self = shift;
my %params = @_; # hier drinnen stehen die ganzen paramter welche im Macro definiert sind.

...

return "was auch immer"; # alles was ein macro retourniert wird im Template angezeigt.
}
desweiteren gibt es noch folgende Parameter, welche eine spezielle Funktionalität besitzen und daher auch nicht der Macro Funktion mitübergeben werden:
* default_text wenn die Macro Funktion keine Zeichen retourniert hat, wird dieser Parameter angezeigt.
* default_message hier definiert man einen Messagekey, welcher angezeigt wird, wenn die Macro Funktion keine Zeichen retourniert hat.
* if das Macro wird nur angezeigt, wenn der darin enthaltene Ausdruck (=Perl Code, welcher in einem eval block ausgeführt wird) true liefert. z.B:
<% action action="login" if="!session->user()" %>
* prefix alles was hier definiert ist, wird vor dem Macro- Output geschrieben, aber nur dann, wenn das Macro auch etwas zurückgeliefert hat. Diese Funktionalität ist zum Beispiel sinnvoll, wenn man das Ergebnis von einem Macro fett darstellen möchte: <% href prefix="<b>" suffix="</b>" %>
* suffix das gleich wie bei prefix, nur daß es nach dem Macro- Output geschrieben wird.
In jeder Page gibt es Standard Macros, welche hier nur ganz kurz aufgelistet sind. Mehr Informationen finden befinden sich in der [_info] Action.
* href liefert die URL für eine Page.
* form liefert einen Form Tag für die Page.
* input liefert ein Formular Feld für diese Page.
* textarea liefert ein Testfeld für diese Page.
* action liefert die Url auf eine Action dieser Page (nur wenn die nötigen Rechte vorhanden sind).
* template liefert ein Template für diese Page.
* message liefert eine Message.
* errors liefert alle Fehler dieser Page.

====Render Methoden
Render Methoden sind Methoden, welche Html Output generieren.
* render_form_element(%params) diese Funktion rendert, wie der Name schon sagt, ein Fomularelement. Desweitern schreibt sie, wenn ein Fehler für dieses Element aufgetreten ist, einen span block mit der class (definiert in FORM_ERROR_CLASS) um das Feld herum. Ausserdem versucht diese Funktion eine default Value für dieses Formularfeld herauszufinden. Folgende Parameter werden momentan unterstützt.
** name definiert den Namen des Formular- Elements.
** type definiert den Typ des Formular- Elements. Als default wird der Typ text verwendet.
** model definiert für welchen Model- Accessor (siehe [model|Model|) dieses feld verwendet wird. Man braucht diese Information u.a. wenn die default Value für dieses Feld herausgefunden werden soll.
** value definiert die Value für dieses Element.
** default dieser Wert wird verwendet, wenn keine Value für dieses Element gefunden wurde.
** alle weiteren Parameter werden unverändert in das Formular- Element übernommen.
* render_page diese Funktion wird verwendet um eine Page zu rendern. u.a. wird diese Funktion in der [engine|Engine] verwendet. Im Grossen und Ganzen rendert diese Gunktion das Template für die aufgerufene Action. Dieses Template wird dann als response->body() in das master.tpl eingebunden. Desweiteren werden Defaultwerte für response->action und response->title berechnet, sofern diese noch nicht gesetzt sind.
Die zwei kommenden Methoden rendern einen String oder ein Template. d.h. es werden für die Macros in dem String/Template die entsprechenden Methoden in der Page aufgerufen.
* render_string($string, $params)
* render_template($templatename, $params)
folgende Macros werden unterstützt:
* <% param.xyz >+ dieses macro wird durch die Werte des übergebenen $params Hashes ersetzt, wobei xyz der Haskkey wäre.

* +< request.xyz >+ dieses Macro ruft die funktion xyz im Request Objekt auf, und rendert das Ergebnis.

* +< request.param.xyz >+ liefert den Formular- Parameter xyz aus dem Request.

* +< response.xyz >+ gleich wie request.xyz nur eben für das Response Objekt.

* +< path.pagename.macro >+ holt das erste (von hinten nach vorne gesucht) gefunde Page Objekt aus dem Path request->path() mit dem Klassennamen pagename, und führt das macro für diese Page aus. z.B. *< path.root.href >*

* +< session.user >+ ruft das user_macro im Session Objekt auf.

* +< macro %> alle weiteren Macros werden in der aktuellen Page aufgerufen.