<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 15156 -->
<!-- Reviewed: no -->
<sect3 id="zend.controller.actionhelpers.contextswitch">
    <title>ContextSwitch und AjaxContext</title>

    <para>
        Der <code>ContextSwitch</code> Action Helfer ist vorgesehen für die Erleicherung bei der
        Rückgabe von unserschiedlichen Antwortformaten oder Anfragen. Der <code>AjaxContext</code>
        Helfer ist eine spezialisierte Version von <code>ContextSwitch</code> die die
        Rückgabe von Antworten zu XmlHttpRequests erleichtert.
    </para>

    <para>
        Um einen von Ihnen zu aktivieren, muß der Kontroller darauf hingewiesen werden welche
        Aktion zu welchem Kontext antworten kann. Wenn eine hereinkommende Anfrage einen gültigen
        Kontext für eine gegebene Aktion indiziert, dann wird der Helfer:
    </para>

    <itemizedlist>
        <listitem><para>
                das Layout ausschalten wenn es eingeschaltet ist.
        </para></listitem>

        <listitem><para>
                einen alternativen View suffix setzen, was effektiv ein separates View Skript für
                den Kontext benötigt.
        </para></listitem>

        <listitem><para>
                die richtigen Antwort Header für den gewünschten Kontext senden.
        </para></listitem>

        <listitem><para>
                optional den spezifizierten Callback aufrufen um den Kontext zu definieren und/oder
                anschließende Berechnungen durchführen.
        </para></listitem>
    </itemizedlist>

    <para>
        Als Beispiel wird der folgende Kontroller angenommen:
    </para>

    <programlisting role="php"><![CDATA[
class NewsController extends Zend_Controller_Action
{
    /**
     * Landeseite; leitet zu listAction() weiter
     */
    public function indexAction()
    {
        $this->_forward('list');
    }

    /**
     * News Items auflisten
     */
    public function listAction()
    {
    }

    /**
     * Ein News Item anzeigen
     */
    public function viewAction()
    {
    }
}
]]></programlisting>

    <para>
        Angenommen wir wollen das <code>listAction()</code> auch im XML Format vorhanden ist. Statt
        der Erstellung einer anderen Aktion, kann angezeigt werden das eine XML Antwort
        zurückgegeben wird:
    </para>

    <programlisting role="php"><![CDATA[
class NewsController extends Zend_Controller_Action
{
    public function init()
    {
        $contextSwitch = $this->_helper->getHelper('contextSwitch');
        $contextSwitch->addActionContext('list', 'xml')
                      ->initContext();
    }

    // ...
}
]]></programlisting>

    <para>
        Was macht das:
    </para>

    <itemizedlist>
        <listitem><para>
                Setzt den 'Content-Type' Antwort Header auf 'text/xml'.
        </para></listitem>

        <listitem><para>
                Ändert den View Suffix auf 'xml.phtml' (oder, wenn ein alternativer View Suffix
                verwendet wird, 'xml.[dein Suffix]').
        </para></listitem>
    </itemizedlist>

    <para>
        Jetzt muß ein neues View Skript erstellt werden, 'news/list.xml.phtml', welches das XML
        erzeugt und darstellt.
    </para>

    <para>
        Um zu ermitteln ob eine Anfrage eine Kontextänderung initiiert, prüft der Helfer auf ein
        token im Anfrage Objekt. Standardäßig schaut er auf den 'format' Parameter, durch den das
        konfiguriert werden kann. Das bedeutet das, in den meisten Fällen, um eine Kontextänderung
        zu triggern, ein 'format' Parameter in der Anfrage hinzugefügt werden kann:
    </para>

    <itemizedlist>
        <listitem><para>
                über URL Parameter: <code>/news/list/format/xml</code> (beachte, das Standard
                Routing Schema erlaubt übliche Schlüssel/Werte Paare nach der Aktion)
        </para></listitem>

        <listitem><para>
                über Abfrage String: z.B., <code>/news/list?format=xml</code>
        </para></listitem>
    </itemizedlist>

    <para>
        <code>ContextSwitch</code> erlaubt es beliebige Kontexte zu spezifizieren, inklusive
        welche Kontextänderung stattfinden wird (wenn überhaupt), jegliche Antwort Header die
        gesendet werden sollen, und beliebige Callbacks für Initialisierung und folgende
        Bearbeitung.
    </para>

    <sect4 id="zend.controller.actionhelpers.contextswitch.contexts">
        <title>Vorhandene Standard Kontexte</title>

        <para>
            Standardmäßig sind zwei Kontexte im <code>ContextSwitch</code> Helfer vorhanden: json
            und xml.
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <emphasis>JSON</emphasis>. Der JSON Kontext setzt den 'Content-Type' Antwort
                    Header auf 'application/json' und den View Skript Suffix auf 'json.phtml'.
                </para>

                <para>
                    Trotzdem wird standardmäßig kein View Skript benötigt. Es serialisiert einfach
                    alle View Variablen und sendet die JSON Antwort sofort aus.
                </para>

                <para>
                    Dieses Verhalten kann deaktiviert werden indem die auto-JSON Serialisierung
                    abgeschaltet wird:
                </para>

                <programlisting role="php"><![CDATA[
$this->_helper->contextSwitch()->setAutoJsonSerialization(false);
]]></programlisting>
            </listitem>

            <listitem>
                <para>
                    <emphasis>XML</emphasis>. Der XML Kontext setzt den 'Content-Type' Antwort
                    Header auf 'text/xml' und den View Skript Suffix auf 'xml.phtml'. Es muß ein
                    neues View Skript für den Kontext erstellt werden.
                </para>
            </listitem>
        </itemizedlist>
    </sect4>

    <sect4 id="zend.controller.actionhelpers.contextswitch.custom">
        <title>Eigene Kontexte erstellen</title>

        <para>
            Manchmal sind die Standardkontexte nicht genug. Zum Beispiel wenn man YAML zurückgeben
            will, oder PHP serialisieren, ein RSS oder ATOM Feed, usw. <code>ContextSwitch</code>
            erlaubt es das zu tun.
        </para>

        <para>
            Der einfachste Weg einen neuen Kontext hinzuzufügen ist über die
            <code>addContext()</code> Methode. Diese Methoe nimmt zwei Argumente, den Namen des
            Kontextes, und eine Array Spezifikation. Die Spezifikation sollte ein oder mehrere der
            folgenden Dinge enthalten:
        </para>

        <itemizedlist>
            <listitem>
                <para><emphasis>suffix</emphasis>: Der Suffix der dem Standard View Suffix angefügt
                werden soll der im ViewRenderer registriert ist.</para>
            </listitem>

            <listitem>
                <para><emphasis>headers</emphasis>: Ein Array von Header/Wert Paaren das als Teil
                der Antwort gesendet werden soll.</para>
            </listitem>

            <listitem>
                <para><emphasis>callbacks</emphasis>: Ein Array das ein oder mehrere der Schlüssel
                'init' oder 'post' enthält, die auf gültige PHP Callbacks zeigen und die für die
                Initialisierung des Contextes und die Nachbearbeitung verwendet werden können.</para>

                <para>Initialisierungs Callbacks treten auf wenn der Kontext durch
                <code>ContextSwitch</code> erkannt wird. Sie können verwendet werden um spezielle
                Logik auszuführen die stattfinden soll. Als Beispiel verwendet der JSON Kontext
                einen Callback um den ViewRenderer auszuschalten wenn auto-JSON Serialisierung
                eingeschaltet ist.</para>

                <para>Nachbearbeitung tritt wärend der <code>postDispatch()</code> Routine der
                Aktion auf, und kann verwendet werden um spezielle Logik auszuführen. Als Beispiel
                verwendet der JSON Kontext einen Callback um festzustellen ob auto-JSON
                Serialisierung eingeschaltet ist; wenn dem so ist, serialisiert es die View
                Variablen zu JSON und sendet die Antwort, aber wenn dem nicht so ist, schaltet es
                den ViewRenderer wieder ein.</para>
            </listitem>
        </itemizedlist>

        <para>
            Es gibt eine Vielzahl an Methoden für die Interaktion mit Kontexten:
        </para>

        <itemizedlist>
            <listitem><para>
                <code>addContext($context, array $spec)</code>: Fügt einen neuen Kontext hinzu.
                Wirft eine Ausnahme wenn der Kontext bereits existiert.
            </para></listitem>

            <listitem><para>
                <code>setContext($context, array $spec)</code>: Fügt einen neuen Kontext hinzu oder
                überschreibt einen bestehenden Kontext. Verwendet die gleiche Spezifikation wie
                <code>addContext()</code>.
            </para></listitem>

            <listitem><para>
                <code>addContexts(array $contexts)</code>: Fügt viele Kontexte auf einmal hinzu.
                Das <code>$contexts</code> Array sollte ein Array von Kontext/Spezifikation Paaren
                sein. Wenn einer der Kontexte bereits existiert, wird eine Ausnahme geworfen.
            </para></listitem>

            <listitem><para>
                <code>setContexts(array $contexts)</code>: Fügt neue Kontexte hinzu und
                überschreibt bestehende. Verwendet die gleiche Spezifikation wie
                <code>addContexts()</code>.
            </para></listitem>

            <listitem><para>
                <code>hasContext($context)</code>: Gibt true zurück wenn der Kontext existiert,
                andernfalls false.
            </para></listitem>

            <listitem><para>
                <code>getContext($context)</code>: Empfängt einen einzelnen Kontext
                durch den Namen. Gibt ein Array zurück das der Spezifikation folgt die in
                <code>addContext()</code> verwendet wird.
            </para></listitem>

            <listitem><para>
                <code>getContexts()</code>: Empfängt alle Kontexte. Gibt ein Array von
                Kontext/Spezifikation Paaren zurück.
            </para></listitem>

            <listitem><para>
                <code>removeContext($context)</code>: Entfernt einen einzelnen Kontext durch seinen
                Namen. Gibt im Erfolgsfall true zurück, und false wenn der Kontext nicht gefunden
                wurde.
            </para></listitem>

            <listitem><para>
                <code>clearContexts()</code>: Entfernt alle Kontexte.
            </para></listitem>
        </itemizedlist>
    </sect4>

    <sect4 id="zend.controller.actionhelpers.contextswitch.actions">
        <title>Kontexte per Aktion setzen</title>

        <para>
            Es gibt zwei Mechanismen für das Setzen vorhandener Kontexte. Es kann entweder manuell
            ein Array im Kontroller erstellt werden, oder es können verschiedene Methoden in
            <code>ContextSwitch</code> verwendet werden um Sie zu bauen.
        </para>

        <para>
            Die prinzipielle Methode für das Hinzufügen von Aktion/Kontext Relationen ist
            <code>addActionContext()</code>. Sie erwartet zwei Argumente, die Aktion zu der der
            Kontext hinzugefügt werden soll, und entweder den Namen des Kontextes oder ein Array
            von Kontexten. Als Beispiel nehmen wir die folgende Controller Klasse an:
        </para>

        <programlisting role="php"><![CDATA[
class FooController extends Zend_Controller_Action
{
    public function listAction()
    {
    }

    public function viewAction()
    {
    }

    public function commentsAction()
    {
    }

    public function updateAction()
    {
    }
}
]]></programlisting>

        <para>
            Angenommen wir sollen einen XML Kontext zu der 'list' Aktion hinzufügen, und XML und
            JSON Kontexte zu der 'comments' Aktion. Wir können das in der <code>init()</code>
            Methode machen:
        </para>

        <programlisting role="php"><![CDATA[
class FooController extends Zend_Controller_Action
{
    public function init()
    {
        $this->_helper->contextSwitch()
             ->addActionContext('list', 'xml')
             ->addActionContext('comments', array('xml', 'json'))
             ->initContext();
    }
}
]]></programlisting>

        <para>
            Alternativ kann einfach die Array-Eigenschaft <code>$contexts</code> definiert werden:
        </para>

        <programlisting role="php"><![CDATA[
class FooController extends Zend_Controller_Action
{
    public $contexts = array(
        'list'     => array('xml'),
        'comments' => array('xml', 'json')
    );

    public function init()
    {
        $this->_helper->contextSwitch()->initContext();
    }
}
]]></programlisting>

        <para>
            Das obige ist weniger Overhead, aber enthält auch potentielle Fehler.
        </para>

        <para>
            Die folgenden Methoden können verwendet werden um die Kontext-Mappings zu erstellen:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <code>addActionContext($action, $context)</code>: markiert einen oder mehrere
                    Kontexte als in einer Aktion vorhanden. Wenn bereits Mapping existieren wird
                    einfach bei diesen Mappings angehängt. <code>$context</code> kann ein einzelner
                    Kontext sein, oder ein Array von Kontexten.
                </para>

                <para>
                    Ein Wert von <code>true</code> für den Kontext markiert alle vorhandenen
                    Kontexte als vorhanden für die Aktion.
                </para>

                <para>
                    Ein leerer Wert für $context deaktiviert alle Kontexte für die gegebene Aktion.
                </para>
            </listitem>

            <listitem><para>
                    <code>setActionContext($action, $context)</code>: markiert einen oder mehrere
                    Kontexte als in einer Aktion vorhanden. Wenn bereits Mappings existieren werden
                    Sie mit den spezifizierten ersetzt. <code>$context</code> kann ein einzelner
                    Kontext sein, oder ein Array von Kontexten.
            </para></listitem>

            <listitem><para>
                    <code>addActionContexts(array $contexts)</code>: fügt mehrere Aktion/Kontext
                    Paare auf einmal hinzu. <code>$contexts</code> sollte ein assoziatives Array
                    von Aktion/Kontext Paaren sein. Es entspricht <code>addActionContext()</code>,
                    was bedeutet das wenn eine Paarung bereits existiert, diese hinzugefügt wird.
            </para></listitem>

            <listitem><para>
                    <code>setActionContexts(array $contexts)</code>: fungiert wie
                    <code>addActionContexts()</code>, überschreibt aber bestehende Aktion/Kontext
                    Paare.
            </para></listitem>

            <listitem><para>
                    <code>hasActionContext($action, $context)</code>: ermittelt ob eine spezielle
                    Aktion einen gegebenen Kontext hat.
            </para></listitem>

            <listitem><para>
                    <code>getActionContexts($action = null)</code>: gibt entweder alle Kontexte
                    für eine gegebene Aktion zurück, oder alle Aktion/Kontext Paare.
            </para></listitem>

            <listitem><para>
                    <code>removeActionContext($action, $context)</code>: entfernt ein oder mehrere
                    Kontexte von einer gegebenen Aktion. <code>$context</code> kann ein einzelner
                    Kontext sein, oder ein Array von Kontexten.
            </para></listitem>

            <listitem><para>
                    <code>clearActionContexts($action = null)</code>: entfernt alle Kontexte von
                    einer gegebenen Aktion, oder von allen Aktionen mit Kontexten.
            </para></listitem>
        </itemizedlist>
    </sect4>

    <sect4 id="zend.controller.actionhelpers.contextswitch.initcontext">
        <title>Kontext Switching initialisieren</title>

        <para>
            Um Kontext Switching zu initialisieren, muß <code>initContext()</code> im Action
            Controller aufgerufen werden:
        </para>

        <programlisting role="php"><![CDATA[
class NewsController extends Zend_Controller_Action
{
    public function init()
    {
        $this->_helper->contextSwitch()->initContext();
    }
}
]]></programlisting>

        <para>
            In einigen Fällen, will man einen Kontext erzwingen der verwendet werden soll; zum
            Beispiel wenn man nur den XML Kontext erlauben will wenn Kontext Switching aktiviert
            ist. Das kann durch die Übergaben des Kontextes zu <code>initContext()</code> getan
            werden:
        </para>

        <programlisting role="php"><![CDATA[
$contextSwitch->initContext('xml');
]]></programlisting>
    </sect4>

    <sect4 id="zend.controller.actionhelpers.contextswitch.misc">
        <title>Zusätzliche Funktionalitäten</title>

        <para>
            Eine Vielzahl an Methoden kann verwendet werden um das Verhalten des
            <code>ContextSwitch</code> Helfers zu verändern. Diese sind:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <code>setAutoJsonSerialization($flag)</code>: Standardmäßig serialisieren JSON
                    Kontexte alle View Variablen in die JSON Notierung und geben diese als Antwort
                    zurück. Wenn man seine eigene Antwort erstellen will, sollte das ausgeschaltet
                    werden; das muß vor dem Aufruf von <code>initContext()</code> geschehen.
                </para>

                <programlisting role="php"><![CDATA[
$contextSwitch->setAutoJsonSerialization(false);
$contextSwitch->initContext();
]]></programlisting>

                <para>
                    Der Wert des Flags erhält man mit <code>getAutoJsonSerialization()</code>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>setSuffix($context, $suffix, $prependViewRendererSuffix)</code>: Mit
                    dieser Methode kann ein anderer Suffix spezifiziert werden der für einen
                    gegebenen Kontext verwendet werden soll. Das dritte Argument wird verwendet um
                    anzuzeigen ob der aktuelle Suffix des ViewRenderers dem neuen Suffix
                    vorangestellt werden soll oder nicht; dieses Flag ist standardmäßig aktiviert.
                </para>

                <para>
                    Die Übergabe eines leeren Werte an den Suffix führt dazu das nur der Suffix des
                    ViewRenderers verwendet wird.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>addHeader($context, $header, $content)</code>: Fügt einen Antwort Header
                    für einen gegebenen Kontext hinzu. <code>$header</code> ist der Headername, und
                    <code>$content</code> ist der Wert der an diesen Header übergeben werden soll.
                </para>

                <para>
                    Jeder Kontxt kann mehrere Header haben; <code>addHeader()</code> fügt
                    zusätzliche Header in den Header Stack des Kontextes ein.
                </para>

                <para>
                    Wenn der spezifizierte <code>$header</code> bereits für diesen Kontext
                    existiert, wird eine Ausnahme geworfen.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>setHeader($context, $header, $content)</code>: <code>setHeader()</code>
                    funktioniert wie <code>addHeader()</code>, ausser das sie erlaubt das
                    existierende Kontext Header überschrieben werden.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>addHeaders($context, array $headers)</code>: Fügt einen gegebenen Kontext
                    mehrere Header auf einmal hinzu. Entspricht <code>addHeader()</code>, was
                    bedeutet das eine Ausnahme geworfen wird wenn der Header bereits existiert.
                    <code>$headers</code> ist ein Array von Header/Kontext Paaren.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>setHeaders($context, array $headers.)</code>: Wie
                    <code>addHeaders()</code>, nur das es <code>setHeader()</code> entspricht und
                    damit das Überschreiben existierender Header erlaubt.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>getHeader($context, $header)</code>: Enpfängt den Wert eines Headers für
                    einen gegebenen Kontext. Gibt null zurück wenn dieser nicht gefunden wird.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>removeHeader($context, $header)</code>: Entfernt einen einzelnen Header
                    für einen gegebenen Kontext.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>clearHeaders($context, $header)</code>: Entfernt alle Header für einen
                    gegebenen Kontext.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>setCallback($context, $trigger, $callback)</code>: Setzt einen Callback
                    bei einem gegebenen Trigger für einen gegebenen Kontext. Trigger können
                    entweder 'init' oder 'post' sein (was zeigt das der Callback entweder bei der
                    Initialisierung oder der Nachbearbeitung aufgerufen wird).
                    <code>$callback</code> sollte ein gültiger PHP Callback sein.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>setCallbacks($context, array $callbacks)</code>: Setzt mehrere Callbacks
                    für einen gegebenen Kontext. <code>$callbacks</code> sollte ein
                    Trigger/Callback Paar sein. Aktuell sind die meisten Callbacks die registriert
                    werden können zwei, einer für Initialisierung und einer für die
                    Nachbearbeitung.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>getCallback($context, $trigger)</code>: Empfängt einen Callback für einen
                    gegebenen Trigger in einem gegebenen Kontext.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>getCallbacks($context)</code>: Empfängt alle Callbacks für einen gegebenen
                    Kontext. Gibt ein Array von Trigger/Callback Paaren zurück.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>removeCallback($context, $trigger)</code>: Entfernt einen Callback für
                    einen gegebenen Trigger und Kontext.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>clearCallbacks($context)</code>: Entfernt alle Callbacks für einen
                    gegebenen Kontext.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>setContextParam($name)</code>: Setzt den Anfrageparameter der geprüft
                    werden muß um zu entscheiden ob eine Kontextumschaltung angefragt wurde oder
                    nicht. Der Wert ist standardmäßig 'format', aber dieser Zugriffspunkt kann
                    verwendet werden um einen alternativen wert zu setzen.
                </para>

                <para>
                    <code>getContextParam()</code> kann verwendet werden um den aktuellen Wert zu
                    erhalten.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>setAutoDisableLayout($flag)</code>: Standardmäßig sind Layouts
                    ausgeschaltet wenn eine Kontextumschaltung erfolgt; das ist weil Layouts
                    typischerweise dafür verwendet werden um normale Antworten darzustellen, und
                    Sie in alternativen Kontexten keine Bedeutung haben. Wenn man trotzdem Layouts
                    verwenden will (möglicherweise hat man ein Layout für einen neuen Kontext),
                    kann dieses Verhalten mit der Übergabe eines false Wertes an
                    <code>setAutoDisableLayout()</code> geändert werden. Das sollte aber
                    <emphasis>before</emphasis> dem Aufruf von <code>initContext()</code>
                    geschehen.
                </para>

                <para>
                    Um den Wert dieses Flags zu erhalten, kann der Zugriffspunkt
                    <code>getAutoDisableLayout()</code> verwendet werden.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>getCurrentContext()</code> kann verwendet werden um festzustellen welcher
                    Kontext erkannt wurde, wenn überhaupt. Er gibt null zurück wenn keine
                    Kontextumschaltung stattgefunden hat, oder wenn er aufgerufen wurde bevor
                    <code>initContext()</code> stattgefunden hat.
                </para>
            </listitem>
        </itemizedlist>
    </sect4>

    <sect4 id="zend.controller.actionhelpers.contextswitch.ajaxcontext">
        <title>AjaxContext Funktionalität</title>

        <para>
            Der <code>AjaxContext</code> Helfer erweitert <code>ContextSwitch</code>, sodas alle
            für <code>ContextSwitch</code> gelisteten Funktionalitäten in Ihm vorhanden sind. Es
            gibt trotzdem ein paar wichtige Änderungen.
        </para>

        <para>
            Zuerst, verwendet es eine andere Action Kontroller Eigenschaft<code>$ajaxable</code>
            um Kontexte festzustellen. Damit kann man verschiedene Kontexte verwenden für AJAX
            gegenüber normalen HTTP Anfragen. Die verschiedenen <code>*ActionContext*()</code>
            Methoden von <code>AjaxContext</code> schreiben in diese Eigenschaft.
        </para>

        <para>
            Zweitens, wird nur dann getriggert wenn ein XmlHttpRequest stattgefunden hat, was durch
            die <code>isXmlHttpRequest()</code> Methode den Anfrageobjektes festgestellt wird.
            Deshalb wird, wenn der Kontextparameter ('format') in der Anfrage übergeben wird, aber
            die anfrage nicht als XmlHttpRequest gemacht wurde, keine Kontextumschaltung
            getriggert.
        </para>

        <para>
            Drittens, fügr der <code>AjaxContext</code> einen zusätzlichen, HTML, Kontext hinzu. In
            diesem Kontext setzt er den Suffix auf 'ajax.phtml' um diesen Kontext von einer
            normalen Anfrage zu unterscheiden. Es werden keine zusätzlichen Header zurückgegeben.
        </para>

        <example id="zend.controller.actionhelpers.contextswitch.ajaxcontext.example">
            <title>Aktionen erlauben auf Ajax Anfragen zu antworten</title>

            <para>
                In dem folgenden Beispiel erlauben wir Anfragen auf die Aktionen 'view', 'form' und
                'process' auf AJAX Anfragen zu antworten. In den ersten zwei Fällen, 'view' und
                'form' wird ein HTML Teilstück zurückgegeben mit dem die Seite aktualisiert werden
                soll; im letzteren wird JSON zurückgegeben.
            </para>

            <programlisting role="php"><![CDATA[
class CommentController extends Zend_Controller_Action
{
    public function init()
    {
        $ajaxContext = $this->_helper->getHelper('AjaxContext');
        $ajaxContext->addActionContext('view', 'html')
                    ->addActionContext('form', 'html')
                    ->addActionContext('process', 'json')
                    ->initContext();
    }

    public function viewAction()
    {
        // Ein einzelnes Kommentar holen um es anzuzeigen.
        // Wenn AjaxContext erkannt wurde, verwendet es das
        // comment/view.ajax.phtml View Skript.
    }

    public function formAction()
    {
        // Stellt die "add new comment" Form dar.
        // Wenn AjaxContext erkannt wurde, verwendes es das
        // comment/form.ajax.phtml View Skript.
    }

    public function processAction()
    {
        // Bearbeitet einen neuen Kommentar
        // Gibt das Ergebnis als JSON zurück; fügt die Ergebnisse einfach als
        // View Variablen hinzu, und JSON wird zurückgegeben.
    }
}
]]></programlisting>

            <para>
                Auf der Seite des Clients, wird die JAX Bibliothe einfach die Endpunkte
                '/comment/view', '/comment/form', und '/comment/process' anfragen, und den
                'format' Parameter übergeben: '/comment/view/format/html',
                '/comment/form/format/html', '/comment/process/format/json'. (Oder der Parameter
                kann über GET übergeben werden: z.B. , "?format=json".)
            </para>

            <para>
                Angenommen die Bibliothek übergibt den 'X-Requested-With: XmlHttpRequest'
                Header, dann werden diese Aktionen das richtige Antwortformat zurückgeben.
            </para>
        </example>
    </sect4>
</sect3>
<!--
vim:se ts=4 sw=4 et:
-->
