[Activate JS] ist eine JQuery basierende Templating Engine.

!!!Inhalt
[{TableOfContents title='Page contents' numbered='true'}]

!!!Aktueller Status
[Activate JS] befindet sich noch in der Entwicklung. Für die Nutzung einer Beta-Version nehmen Sie bitte [Kontakt] zu uns auf.

!!!Design Anforderungen
Es sind bereits einige populäre Templating Engines und Javascript-Framework auf dem Markt. Aus unserer Sicht erfüllt jedoch keines der Frameworks die von uns aufgestellten Forderungen:

* __Reines Javascript:__ Die Implementierung soll in reinem Javascript erfolgen, keine Zwischencompilierung, keine Installation von Tools.
** Einfaches Include in die Web-Page
** Verwenden einer beliebigen Entwicklungsumgebung
** Debugging des Javascript-Codes der 1:1 übereinstimmt, mit dem was geschrieben wurde
* __Reines HTML:__ Die Implementierung des HTML-Codes soll in HTML erfolgen.
** Leichte lesbarkeit, Javascript-Konstrukte wie $("<div>") sollen vermieden werden
** Zusammengehörigkeit des Codes nach dem Lokalitätsprinzip, Code ist nicht unnötig verteilt
** Der HTML-Code soll nicht durch wiederholte Script-Tags verunreinigt werden
* __Erweiterbarkeit:__ Activate JS soll einfach erweitert werden können
** Behandlung neuer Control-Strukturen
** Instantiierung von JQuery-Komponenten
** Verwenden von JQuery-Plugins
** Einbinden und Steuern von anderen Javascript-Bibliotheken
** Erweiterung zur Unterstützung von [JSF]
* __Unabhängig:__ [Activate JS] basiert rein auf [JQuery], sonst wird nichts gebraucht

!!!Controls
Die HTML-Seite wird grundsätzlich in reinem HTML oder XHTML aufgebaut. [Activate JS] greift nur durch Controls in den HTML-Code ein. Diese Controls werden über das Attribut control aktiviert.

Ein Control-Attribut besteht aus einem JSON-String, der ein oder mehrere Paare aus Control-Name und Control-Wert enthält {<control-name>: <control-value>, [...]}. Control-Werte können von unterschiedlichem Typ sein:

||Typ Control-Wert||Beispiel||Erklärung
|Literal|'some-value'|Die Zeichenkette wird so übernommen. Anwendungen sind die Definition von Template-Namen oder das Setzen von CSS-Literalen.
|Wert|true, false, 1, 2, 3|Der Wert wird so übernommen. Anwendungen sind Parameter, For-Werte oder Bedingungen.
|Javascript-Expression|this.test == 1, !x|Der Javascript-Ausdruck wird ausgewertet und das Ergebnis übernommen. Es ist zu beachten, dass die Evaluierung vor dem Verarbeiten des Controls ausgeführt wird. Eventuell später erzeugte Werte können daher nicht zur Verfügung stehen.
|Javascript-Function|function() {this.test == 1}|Die Funktion wird erst dann evaluiert, wenn der Wert tatsächlich verwendet wird. Damit können voneinander abhängige Ausdrücke verwendet werden, wie etwa bedingte Färbung von Zeilen innerhalb eines For-Control.

!!Apply
Mit dem Apply control können beliebige Javascript-Funktionen auf das JQuery-Objekt angewendet werden:

{{{
<div control="{apply: $.fn.Panel}">
	<div>Header</div>
	<div>Content</div>
</div>
}}}

__Erklärung:__ Das Attribut "control" enthält JSON-Code, der ein oder mehrere Key-Value-Paare enthalten kann. Jeder Key ist einem Control aus $.controls zugeordnet. Im obigen Beispiel also der Key apply ruft $.controls.apply auf. This entspricht dabei dem JQuery-Element des Elements. Verwendet man die Bridge eines JQuery-Widgets, wie etwa $.fn.Panel, wird das JQuery-Widget instantiiert.

!!Template
Mit dem Template Control wird der aktuelle DOM-Subtree zum Template mit dem Namen des Value aus dem JSON-Entry erklärt. Der DOM-Subtree wird aus dem aktuellen Browser-Document entfernt, sodass er nicht mehr sichtbar ist:

{{{
<div control="{template: 'some-panel', apply: $.fn.Panel}" style="margin-top: 10px;">
	<div>Template Header</div>
</div>
}}}

!!Apply Template
Mit dem Control applyTemplate wird ein mit dem Control template definiertes DOM-Element an der betreffenden Stelle wieder eingefügt. Das betreffende Template kann dabei mehrfach eingefügt werden:

{{{
<div control="{applyTemplate: 'some-panel'}">
	<div>Individual Content 1</div>
</div>
}}}

!!Define und Insert
Mit den Controls define und insert können weitere Elemente in ein Template eingefügt werden. Dabei ist define kein echtes Control, weil es durch das control applyTemplate aktiv ersetzt wird:

{{{
<div control="{template: 'some-panel', apply: $.fn.Panel}" style="margin-top: 10px;">
	<div>Panel Template</div>
	<div control="{insert: 'content'}"/>
</div>

<div control="{applyTemplate: 'some-panel'}">
	<div control="{define: 'content'}">Individual Content 2</div>
</div>
}}}

__Erklärung:__ Das Element (div) mit dem Control applyTemplate wird durch das Template mit dem Namen "some-panel" ersetzt. Dabei werden alle Controls des Templates angewendet, zusätzlich zu den einfügenden Element.

!!For
Um Elemente wiederholen zu können, wird das Control for genutzt:

<div control="{for: {begin: 0, end: 2, variable: 'index'}}">
	<label for="{prefix}:input" control="{interpolate: true}">Input {index}</label>
	<input control="{interpolate: true, apply: $.fn.InputText, id: 'input'}"/>
</div>

!!Interpolate
Das Control interpolate führt zum Ersetzen von Expressions in Attributen und Text-Children des aktuellen Tags:

{{{
<div control="{for: {begin: 0, end: 3, variable: 'x'}}">
	<div control="{interpolate: true}">Iteration No. {x}</div>
</div>
}}}

!!Id
Mit dem Control id kann das Attribut id gesetzt werden, sodass übergeordnete id-Attribute berücksichtigt werden, ähnlich wie bei den JSF-IDs:

{{{
<form id="form">
	<div control="{id: 'text'}">Some Text</div>
</form>
}}}

__Ergebnis:__ Das innere div-Element erhält das Attribut id="form:text".

!!CSS Style
Mit dem Attribut kann ein Style gesetzt werden. Grundsätzlich sollten Styleklassen mit dem Attribut class gesetzt werden und diese in einer CSS-Datei definiert werden. Einzelne Styles können mit dem Attribut style gesetzt werden. Manchmal werden jedoch dynamische Styles gebraucht.

Ein beliebter Kunstgriff ist, Teile der Page zunächst mit dem Style display oder visibility unsichtbar zu machen und erst nach fertiger Aktivierung anzuzeigen:

{{{
<div style="display: none;" control="{id: 'activate-test', after: {css: {display: 'block'}}}">
	[...]
</div>
}}}

!!After
Normalerweise werden zuerst die aktuellen Controls aktiviert, dann die Controls der untergeordneten Tags. Manchmal kann es erforderlich sein, dass die untergeordneten Tags bereits aktiviert sind. Dazu gibt es das Control after:

{{{
<div style="display: none;" control="{id: 'activate-test', after: {css: {display: 'block'}}}">
	[...]
</div>
}}}

__Erklärung:__ Es handelt sich um dasselbe Beispiel wie bei dem Control style, jedoch geht es hier um den Aspekt after. Das Control after enthält als Wert wieder eine Liste von Controls, die nach der Aktivierung der Children ausgeführt werden.

!!Set
Mit dem Control set können Werte im Context gesetzt werden, die allen untergeordneten Elementen zur Verfügung stehen. Maßgeblich ist dabei die Reihenfolge der Control-Ausführung:

{{{
<div control="{applyTemplate: 'some-panel', set: {templateParam: 2}}">
	<div control="{define: 'content'}">Individual Content 2</div>
</div>

<div control="{template: 'some-panel', apply: $.fn.Panel}" style="margin-top: 10px;">
	<div control="{interpolate: true}">Panel Template, Parameter: {templateParam}</div>
	<div control="{insert: 'content'}"/>
</div>
}}}

__Erklärung:__ Der Parameter templateParam wird von der Einfügestelle applyTemplate an das Template selbst übergeben. Das heißt, jede Template-Instanz kann einen unterschiedlichen Wert erhalten.

!!If
Mit dem Control if können die verbleibenden Controls bedingt ausgeführt werden:

{{{
<div control="{if: test == 2, css: {color: '#10a010'}}">Some Text</div>
}}}

__Hinweis:__ Die If-Condition wird während des Parsens des Javascript-Code ausgeführt, was in vielen Fällen zu früh sein kann.

Um auf Ergebnisse anderer Controls zugreifen zu können, kann die Condition auch eine Funktion sein:

{{{
<div control="{if: function() {return this.test == 2}, css: {color: '#10a010'}}">Some Text</div>
}}}

!!Rendered
Man kann Elemente zwar mit styles ausblenden, allerdings verbleiben diesen dann doch im DOM-Baum und brauchen weiterhin Ressourcen. Mit dem Control rendered werden die Elemente vollständig entfernt und das Ausführen weiterer Controls unterbunden:

{{{
<label control="{rendered: function() {this.type != 'input'}}">Input</label>
}}}

!!AJAX Request
Ein Server-Request kann durch das AJAX-Control durchgeführt werden:

{{{
<div control="{ajax: {url: 'http://localhost/test', variable: 'data'}, interpolate: true}">{data}</div>
}}}

__Erklärung:__ Es wird ein AJAX-Request durchgeführt und das Ergebnis in der Variable data gespeichert. Das nachfolgende Interpolation-Control fügt den Text in den Tag-Content ein.

Die möglichen AJAX-Control Parameter:

||Parameter||Bedeutung
|method|HTTP Method, die verwendet wird, wohl hauptsächlich GET oder POST
|URL|Die URL, die für den AJAX-Request benutzt wird
|data|Die Query/Post-Parameter für den AJAX-Request
|variable|Die Variable in der das Ergebnis gespeichert wird

!!!Spezielle Controls
Diese Controls werden normaler Weise nur intern verwendet. Es macht keinen Sinn, zu versuchen, diese Controls durch das Control-Attribut eines Tags anzusteuern. Der Vollständigkeit halber sollen sie jedoch erwähnt werden.

!!Children
Dieses Control aktiviert die Children des aktuell bearbeiteten DOM-Knotens, appliziert also deren Controls und damit auch die Children der Children und so weiter.

!!Warn
Damit wird eine Warnung auf der Browser-Konsole ausgegeben, wenn ein Problem bei der Konfiguration oder Verarbeitung der Controls festgestellt wird.

!!!Eigene Controls
[Activate JS] macht das Implementieren von eigenen Controls sehr leicht. Die Controls befinden sich in $.controls und können leicht erweitert werden. Das kann explizit erfolgen, indem ein neuer Key einer Funktion zugewiesen wird:

{{{
$.controls.myControl = function(next) {
	this.element.text("Hello World!");
	next();
};
}}}

__Hinweis:__ Ein Control hat immer den Parameter next, der in der Regel am Ende aufgerufen wird. Dieser sorgt dafür, dass die nachfolgenden Controls und damit auch untergeordnete Elemente aktiviert werden.

Bei mehreren Controls kann man die bequemere Variante mit QUuery extends verwenden:

{{{
$.controls.extend({
	myControl: function(next) {
		this.element.text("Hello World!");
		next();
	},
	myControl2: function(next) {
		this.element.text("Second Control!");
		next();
	}
});
}}}

Im Aufruf des Controls wird this auf den aktuellen Context gesetzt.

!!!Context
Ein wichtiges Prinzip von [Activate JS] ist der Context, in dem nahezu alle Funktionsaufrufe stattfinden. Der Context ist ein erweiterbares Objekt, das jedoch einige grundlegende Einträge enthält:

||Key||Beschreibung
|element|Das aktuelle JQuery-Element in dem der Funktionsaufruf stattfindet.
|controls|Die aktuelle Control-Struktur, die gerade abgearbeitet wird.
|control|Der aktuelle Control-Entry, der gerade verarbeitet wird. Er besteht aus key (Name) und value (function).
|root|Zugriff auf dem Root-Context. Kann für Templates und andere globale Variablen verwendet werden.
|prefix|Das aktuelle Prefix des aktuellen Id-Attributs. Dies besteht aus den Id's der übergeordneten Elemente, getrennt durch Doppelpunkte.

Der Context enthält auch eine Reihe von Funktionen, die für das Implementieren eines Controls nützlich sein können:

||Funktion||Beschreibung
|pop()|Holt das nächste Control aus der aktuellen Control Execution Chain. Das Control ist damit dauerhaft entfernt und wird nicht mehr durch den Aufruf von next() ausgeführt.
|activate(element, options)|Aktiviert die Controls an einem Element und deren Unterknoten. Normalerweise wird diese Funktion durch den Aufruf von next() automatisch ausgeführt. Programmatisch erzeugte Elemente, wie bei Iterationen, können einen expliziten Aufruf erfordern.
|interpolate(text)|Liefert den übergebenen Text, alle Variablen werden durch ihre Werte ersetzt.
|resolve(expression)|Liefert den Wert einer Variable zurück.
|warn(message)|Gibt eine Warnung auf der Konsole mit entsprechenden Kontext-Informationen und Aufrufstack aus, um Fehler leichter lokalisieren zu können.

!!!Design Richtlinien
In Activate JS gibt es einige Design Richtlinien im Verwenden des Frameworks, die die Arbeit erleichtern können:

* __Kurz halten:__ Die Parameterisierung von Controls im HTML durch das Attribut control sollte kurz bleiben. Eine komplexe Parameterisierung zeigt, dass hier ein neues Control implementiert werden sollte.