repo_zf1/documentation/manual/fr/module_specs/Zend_Controller-ActionHelpers-ContextSwitch.xml

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

    <para>
        L'aide d'action <emphasis>ContextSwitch</emphasis> est destinée à faciliter le retour de
        différents formats de réponse à une requête.L'<emphasis>AjaxContext</emphasis> est une aide
        spécialisée de <emphasis>ContextSwitch</emphasis> qui permet le renvoi de réponses à
        XmlHttpRequest.
    </para>

    <para>
        Pour l'activer, vous devez indiquer à votre contrôleur quelles actions répondent à
        quel contexte. Si une requête d'entrée indique un contexte valide pour une action, alors
        l'aide d'action en charge&#160;:
    </para>

    <itemizedlist>
        <listitem>
            <para>
                Va désactiver les layouts, si elles sont activées.
            </para>
        </listitem>
        <listitem>
            <para>
                Va changer le suffixe de la vue à rendre, il faudra donc créer une vue par
                contexte.
            </para>
        </listitem>
        <listitem>
            <para>
                Va envoyer les bons en-têtes de réponse en fonction du contexte désiré.
            </para>
        </listitem>
        <listitem>
            <para>
                Va éventuellement en option appeler des fonctions pour configurer le
                contexte, ou des fonctions de post-processing.
            </para>
        </listitem>
    </itemizedlist>

    <para>Comme exemple, prenons le contrôleur suivant&#160;:</para>

    <programlisting language="php"><![CDATA[
class NewsController extends Zend_Controller_Action
{
    /**
     * page d'arrivée; forward vers listAction()
     */
    public function indexAction()
    {
        $this->_forward('list');
    }

    /**
     * Liste les news
     */
    public function listAction()
    {
    }

    /**
     * Affiche une new particulière
     */
    public function viewAction()
    {
    }
}
]]></programlisting>

    <para>
        Imaginons que nous voulions que <methodname>listAction()</methodname> soit aussi accessible
        au format <acronym>XML</acronym>. Plutôt que de créer une autre action, nous pouvons lui
        indiquer qu'elle doit retourner du <acronym>XML</acronym>&#160;:
    </para>

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

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

    <para>Ce code aura pour effet&#160;:</para>

    <itemizedlist>
        <listitem>
            <para>
                De changer le "Content-Type" de la réponse en "<filename>text/xml</filename>".
            </para>
        </listitem>
        <listitem>
            <para>
                De changer le suffixe de vue vers "<filename>xml.phtml</filename>" (ou un autre
                suffixe si vous en utilisez un personnalisé "xml.[votre suffixe]").
            </para>
        </listitem>
    </itemizedlist>

    <para>
        Il est donc nécessaire de créer un nouveau script de vue,
        "<filename>news/list.xml.phtml</filename>", qui créera et rendra le
        <acronym>XML</acronym>.
    </para>

    <para>
        Pour savoir si la requête doit utiliser un contexte switch, l'aide vérifie un jeton
        dans l'objet de requête. Par défaut, l'aide va chercher le paramètre de requête "format",
        ceci peut être changé. Ceci signifie que dans la plupart des cas, pour changer le contexte
        d'une réponse, il faut simplement injecter un paramètre "format" à la requête:
    </para>

    <itemizedlist>
        <listitem>
            <para>
                Via l'<acronym>URL</acronym>&#160;: <filename>/news/list/format/xml</filename>
                (le routeur par défaut utilise les paires clés et valeurs fournies après l'action)
            </para>
        </listitem>
        <listitem>
            <para>
                Via un paramètre <constant>GET</constant>&#160;:
                <command>/news/list?format=xml</command>
            </para>
        </listitem>
    </itemizedlist>

    <para>
        <emphasis>ContextSwitch</emphasis> vous permet d'écrire des contextes, ceux-ci spécifient le
        suffixe de vue qui change, les en-têtes de réponse à modifier, et les fonctions de
        rappel éventuelles.
    </para>

    <sect4 id="zend.controller.actionhelpers.contextswitch.contexts">
        <title>Contextes inclus par défaut</title>

        <para>
            Par défaut, il existe 2 contextes dans l'aide <emphasis>ContextSwitch</emphasis>&#160;:
            json et xml.
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <emphasis><acronym>JSON</acronym></emphasis>. Le contexte
                    <acronym>JSON</acronym> met le "Content-Type" de la réponse à
                    "<filename>application/json</filename>", et le suffixe de la vue est
                    "<filename>json.phtml</filename>".
                </para>
                <para>
                    Par défaut cependant, aucun script de vue n'est nécessaire, il va simplement
                    sérialiser en <acronym>JSON</acronym> toutes les variables de vues, et les
                    envoyer en tant que réponse.
                </para>
                <para>
                    Ce comportement peut être désactivé en éteigant le paramètre de
                    sérialisation <acronym>JSON</acronym>&#160;:
                </para>
                <programlisting language="php"><![CDATA[
$this->_helper->contextSwitch()->setAutoJsonSerialization(false);
]]></programlisting>
            </listitem>
            <listitem>
                <para>
                    <emphasis><acronym>XML</acronym></emphasis>. Le contexte <acronym>XML</acronym>
                    met le "Content-Type" de la réponse à "<filename>text/xml</filename>", et
                    utilise un suffixe de vue "<filename>xml.phtml</filename>". Vous devrez
                    créer une nouvelle vue pour ce contexte.
                </para>
            </listitem>
        </itemizedlist>
    </sect4>

    <sect4 id="zend.controller.actionhelpers.contextswitch.custom">
        <title>Créer ses propres contextes</title>

        <para>
            Vous pouvez créer vos propres contextes d'action. Par exemple pour retourner du
            <acronym>YAML</acronym>, du <acronym>PHP</acronym> sérialisé, ou encore du
            <acronym>RSS</acronym> ou du <acronym>ATOM</acronym>. <emphasis>ContextSwitch</emphasis>
            est là pour cela.
        </para>

        <para>
            La manière la plus simple d'ajouter un nouveau contexte d'action est la méthode
            <methodname>addContext()</methodname>. Elle prend 2 paramètres : le nom du contexte,
            et un tableau d'options. Ce tableau d'option doit comporter au moins une des clés
            suivantes&#160;:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <emphasis>suffix</emphasis>&#160;: Le préfixe qui va s'ajouter au suffixe de
                    vue. Il sera utiliser par le ViewRenderer.
                </para>
            </listitem>
            <listitem>
                <para>
                    <emphasis>headers</emphasis>&#160;: un tableau d'en-têtes et de valeurs que
                    vous voulez ajouter à la réponse.
                </para>
            </listitem>
            <listitem>
                <para>
                    <emphasis>callbacks</emphasis>&#160;: un tableau dont les clés peuvent être
                    "init" ou "post", et les valeurs représentent des noms de fonctions
                    <acronym>PHP</acronym> valides, qui seront utilisées pour initialiser ou
                    traiter la fin du contexte.
                </para>
                <para>
                    Les fonctions d'initialisation interviennent lorsque le contexte est détecté
                    par <emphasis>ContextSwitch</emphasis>. Par exemple dans le contexte intégré
                    <acronym>JSON</acronym>, la fonction désactive le ViewRenderer lorsque la
                    sérialisation automatique <acronym>JSON</acronym> est activée.
                </para>
                <para>
                    Les fonctions de traitement de fin de contexte (Post processing) interviennent
                    durant le processus de <methodname>postDispatch()</methodname> de l'action en
                    cours. Par exemple pour le contexte intégré <acronym>JSON</acronym>, la
                    fonction de post process regarde si la sérialisation automatique
                    <acronym>JSON</acronym> est active, si c'est le cas, elle va sérialiser les
                    variables de la vue en <acronym>JSON</acronym>, et envoyer la réponse&#160;;
                    mais dans le cas contraire, elle va réactiver le ViewRenderer.
                </para>
            </listitem>
        </itemizedlist>

        <para>Voici les méthodes d'interaction avec les contextes&#160;:</para>

        <itemizedlist>
            <listitem>
                <para>
                    <methodname>addContext($context, array $spec)</methodname>&#160;: Ajoute un
                    nouveau contexte. Si celui-ci existe déjà, une exception sera lancée.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setContext($context, array $spec)</methodname>&#160;: Ajoute un
                    nouveau contexte, mais écrase celui-ci s'il existait déjà. Utilise les mêmes
                    spécifications que <methodname>addContext()</methodname>.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>addContexts(array $contexts)</methodname>&#160;: Ajoute plusieurs
                    contextes d'un coup. Le tableau <varname>$contexts</varname> doit être un
                    tableau de paires contexte et specifications. Si un des contextes existe déjà,
                    une exception est lancée.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setContexts(array $contexts)</methodname>&#160;: Ajoute des
                    nouveaux contextes, mais écrase ceux déjà présents éventuellement. Utilise
                    les mêmes spécifications que <methodname>addContexts()</methodname>.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>hasContext($context)</methodname>&#160;: retourne
                    <constant>TRUE</constant> si le contexte existe déjà,
                    <constant>FALSE</constant> sinon.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>getContext($context)</methodname>&#160;: retourne un contexte
                    par son nom. Le retour est un tableau qui a la même syntaxe que celui utilisé
                    par <methodname>addContext()</methodname>.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>getContexts()</methodname>&#160;: retourne tous les contextes.
                    Le tableau de retour est de la forme contexte =&gt; spécifications.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>removeContext($context)</methodname>&#160;: Supprime un contexte
                    grâce à son nom. Retourne <constant>TRUE</constant> si réussi,
                    <constant>FALSE</constant> si le contexte n'a pas été trouvé.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>clearContexts()</methodname>&#160;: Supprime tous les contextes.
                </para>
            </listitem>
        </itemizedlist>
    </sect4>

    <sect4 id="zend.controller.actionhelpers.contextswitch.actions">
        <title>Affecter des contextes par action</title>

        <para>
            Il existe deux mécanismes pour créer et affecter des contextes. Vous pouvez créer
            des tableaux dans vos contrôleurs, ou utiliser plusieurs méthodes de
            <emphasis>ContextSwitch</emphasis> pour les assembler.
        </para>

        <para>
            La méthode principale pour ajouter des contextes à des actions est
            <methodname>addActionContext()</methodname>. Elle attend 2 arguments, l'action et le
            contexte (ou un tableau de contextes). Par exemple, considérons la classe
            suivante&#160;:
        </para>

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

    public function viewAction()
    {
    }

    public function commentsAction()
    {
    }

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

        <para>
            Imaginons que nous voulions ajouter un contexte <acronym>XML</acronym> à l'action
            "list", et deux contextes <acronym>XML</acronym> et <acronym>JSON</acronym> à
            l'action "comments". Nous pourrions faire ceci dans la méthode
            <methodname>init()</methodname>&#160;:
        </para>

        <programlisting language="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>
            De la même manière, il est aussi possible de simplement définir la propriété
            <varname>$contexts</varname>&#160;:
        </para>

        <programlisting language="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>Cette syntaxe est simplement moins pratique et plus prompte aux erreurs.</para>

        <para>Pour construire vos contextes, les méthodes suivantes vous seront utiles&#160;:</para>

        <itemizedlist>
            <listitem>
                <para>
                    <methodname>addActionContext($action, $context)</methodname>&#160;: Ajoute un
                    ou plusieurs contextes à une action. <varname>$context</varname> doit donc être
                    une chaîne, ou un tableau de chaînes.
                </para>
                <para>
                    Passer la valeur <constant>TRUE</constant> comme contexte marquera tous les
                    contextes comme disponibles pour cette action.
                </para>
                <para>
                    Une valeur vide pour <varname>$context</varname> désactivera tous les contextes
                    donnés à cette action.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setActionContext($action, $context)</methodname>&#160;: Marque un
                    ou plusieurs contextes comme disponibles pour cette action. Si ceux-ci existent
                    déjà, ils seront remplacés. <varname>$context</varname> doit être une chaîne ou
                    un tableau de chaînes.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>addActionContexts(array $contexts)</methodname>&#160;: Ajoute
                    plusieurs paires action et contexte en une fois. <varname>$contexts</varname>
                    doit être un tableau associatif action et contexte. Cette méthode proxie vers
                    <methodname>addActionContext()</methodname>.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setActionContexts(array $contexts)</methodname>&#160;: agit comme
                    <methodname>addActionContexts()</methodname>, mais écrase les paires
                    action et contexte existantes.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>hasActionContext($action, $context)</methodname>&#160;: détermine
                    si une action possède un contexte donné.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>getActionContexts($action = null)</methodname>&#160;: Retourne tous
                    les contextes d'une action donnée, si pas d'action passée, retourne alors toutes
                    les paires action et contexte.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>removeActionContext($action, $context)</methodname>&#160;: Supprime
                    un ou plusieurs contextes pour une action. <varname>$context</varname> doit être
                    une chaîne ou un tableau de chaînes.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>clearActionContexts($action = null)</methodname>&#160;: Supprime
                    tous les contextes d'une action. Si aucune action n'est spécifiée, supprime
                    alors tous les contextes de toutes les actions.
                </para>
            </listitem>
        </itemizedlist>
    </sect4>

    <sect4 id="zend.controller.actionhelpers.contextswitch.initcontext">
        <title>Initialiser le Context Switch</title>

        <para>
            Pour initialiser la permutation de contextes (contexte switching), vous devez
            appeler <methodname>initContext()</methodname> dans vos contrôleurs d'action&#160;:
        </para>

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

        <para>
            Dans certains cas, vous voudriez forcer un contexte pour une action&#160;; par exemple
            vous pouvez vouloir seulement le contexte <acronym>XML</acronym> si la permutation de
            contexte est active. Passez le alors à <methodname>initContext()</methodname>&#160;:
        </para>

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

    <sect4 id="zend.controller.actionhelpers.contextswitch.misc">
        <title>Fonctionnalités avancées</title>

        <para>
            Voici quelques méthodes qui peuvent être utilisées pour changer le comportement
            de l'aide <emphasis>ContextSwitch</emphasis>&#160;:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <methodname>setAutoJsonSerialization($flag)</methodname>: Par défaut, le
                    contexte <acronym>JSON</acronym> va sérialiser toute variable en notation
                    <acronym>JSON</acronym> et les retourner en tant que réponse. Si vous voulez
                    créer votre propre réponse, vous voudriez désactiver cet effet. Ceci doit être
                    fait avant l'appel à <methodname>initContext()</methodname>.
                </para>
                <programlisting language="php"><![CDATA[
$contextSwitch->setAutoJsonSerialization(false);
$contextSwitch->initContext();
]]></programlisting>
                <para>
                    Pour récupérer la valeur actuelle, utilisez
                    <methodname>getAutoJsonSerialization()</methodname>.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setSuffix($context, $suffix,
                        $prependViewRendererSuffix)</methodname>&#160;:
                    Cette méthode permet de personnaliser le suffixe de vue d'un contexte. Le
                    troisième argument indique si le suffixe actuel du ViewRenderer doit être
                    utilisé comme préfixe de votre suffixe. Par défaut, c'est le cas.
                </para>
                <para>
                    Passer une valeur vide au suffixe aura pour effet de n'utiliser que le
                    suffixe du ViewRenderer.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>addHeader($context, $header, $content)</methodname>&#160;: Ajoute
                    un en-tête à la réponse pour un contexte donné. <varname>$header</varname>
                    est le nom de l'en-tête et <varname>$content</varname> sa valeur.
                </para>
                <para>
                    Chaque contexte peut posséder plusieurs en-têtes,
                    <methodname>addHeader()</methodname> ajoute des en-têtes dans une pile,
                    pour un contexte donné.
                </para>
                <para>
                    Si l'en-tête <varname>$header</varname> spécifié pour le contexte existe déjà,
                    une exception sera alors levée.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setHeader($context, $header, $content)</methodname>&#160;:
                    <methodname>setHeader()</methodname> agit comme
                    <methodname>addHeader()</methodname>, sauf qu'il va écraser un en-tête
                    qui aurait déjà été présent.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>addHeaders($context, array $headers)</methodname>&#160;: Ajoute
                    plusieurs en-têtes en une seule fois. Proxie vers
                    <methodname>addHeader()</methodname>.<varname>$headers</varname> est un
                    tableau de paires header =&gt; contexte.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setHeaders($context, array $headers.)</methodname>&#160;: comme
                    <methodname>addHeaders()</methodname>, sauf que cette méthode proxie vers
                    <methodname>setHeader()</methodname>, vous permettant d'écraser des en-têtes
                    déjà présents.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>getHeader($context, $header)</methodname>&#160;: retourne une
                    valeur d'en-tête pour un contexte. Retourne <constant>NULL</constant>
                    si non trouvé.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>removeHeader($context, $header)</methodname>&#160;: supprime
                    un en-tête d'un contexte.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>clearHeaders($context, $header)</methodname>&#160;: supprime
                    tous les en-têtes d'un contexte.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setCallback($context, $trigger, $callback)</methodname>&#160;:
                    affecte une fonction de rappel (callback) pour un contexte. Le déclencheur
                    peut être soit "init" ou "post" (la fonction de rappel sera appelée soit à
                    l'initialisation du contexte, ou à la fin, en postDispatch).
                    <varname>$callback</varname> doit être un nom de fonction <acronym>PHP</acronym>
                    valide.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setCallbacks($context, array $callbacks)</methodname>&#160;:
                    affecte plusieurs fonctions de rappel pour un contexte.
                    <varname>$callbacks</varname> doit être un tableau de paires trigger et
                    callback. Actuellement, seules deux fonctions maximum peuvent être enregistrées
                    car il n'existe que 2 déclencheurs (triggers)&#160;: "init" et "post".
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>getCallback($context, $trigger)</methodname>&#160;: retourne un
                    nom de fonction de rappel affectée à un contexte.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>getCallbacks($context)</methodname>&#160;: retourne un tableau
                    de paires trigger et callback pour un contexte.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>removeCallback($context, $trigger)</methodname>&#160;: supprime
                    une fonction de rappel d'un contexte.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>clearCallbacks($context)</methodname>&#160;: supprime toutes
                    les fonctions de rappel d'un contexte.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setContextParam($name)</methodname>&#160;: affecte le paramètre
                    de requête à vérifier pour savoir si un contexte a été appelé. La valeur par
                    défaut est "format".
                </para>
                <para>
                    <methodname>getContextParam()</methodname> en retourne la valeur actuelle.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setAutoDisableLayout($flag)</methodname>&#160;: Par défaut, les
                    layouts sont désactivées lorsqu'un contexte intervient, ceci provient du fait
                    que les layouts n'ont en théorie pas de signification particulière pour un
                    contexte, mais plutôt pour une réponse 'normale'. Cependant si vous désirez
                    utiliser les layouts pour des contexte, passez alors la valeur
                    <constant>FALSE</constant> à <methodname>setAutoDisableLayout()</methodname>.
                    Ceci devant être fait <emphasis>avant</emphasis> l'appel à
                    <methodname>initContext()</methodname>.
                </para>
                <para>
                    Pour récupérer la valeur de ce paramètre, utilisez
                    <methodname>getAutoDisableLayout()</methodname>.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>getCurrentContext()</methodname> est utilisée pour savoir quel
                    contexte a été détecté (si c'est le cas). Cette méthode retourne
                    <constant>NULL</constant> si aucune permutation de contexte a été détectée,
                    ou si elle est appelée avant <methodname>initContext()</methodname>.
                </para>
            </listitem>
        </itemizedlist>
    </sect4>

    <sect4 id="zend.controller.actionhelpers.contextswitch.ajaxcontext">
        <title>Fonctionnalité AjaxContext</title>

        <para>
            L'aide <emphasis>AjaxContext</emphasis> étend l'aide de permutation de contexte
            <emphasis>ContextSwitch</emphasis>, donc toutes les fonctionnalités de
            <emphasis>ContextSwitch</emphasis> s'y retrouvent. Il y a cependant quelques
            différences&#160;:
        </para>

        <para>
            Cette aide utilise une propriété de contrôleur d'action différente pour
            déterminer les contextes, <varname>$ajaxable</varname>. Vous pouvez avoir différents
            contextes utilisés avec les requêtes <acronym>AJAX</acronym> ou <acronym>HTTP</acronym>.
            Les différentes méthodes <methodname>ActionContext()</methodname> de
            <emphasis>AjaxContext</emphasis> vont écrire dans cette propriété.
        </para>

        <para>
            De plus, cette aide ne sera déclenchée que si la requête répond au critère
            <methodname>isXmlHttpRequest()</methodname>. Donc même si le paramètre "format" est
            passée à la requête, il faut nécessairement que celle ci soit une requête
            XmlHttpRequest, sinon la permutation de contexte n'aura pas lieu.
        </para>

        <para>
            Enfin, <emphasis>AjaxContext</emphasis> ajoute un contexte, <acronym>HTML</acronym>.
            Dans ce contexte, le suffixe de vue est "<filename>ajax.phtml</filename>". Il n'y a
            pas d'en-tête particulier ajouté à la réponse.
        </para>

        <example id="zend.controller.actionhelpers.contextswitch.ajaxcontext.example">
            <title>Autoriser les actions à répondre aux requêtes AJAX</title>

            <para>
                Dans l'exemple qui suit, nous autorisons les actions "view", "form", et
                "process" à répondre aux requêtes <acronym>AJAX</acronym>. Dans les actions,
                "view" et "form", nous retournerons des portions de <acronym>HTML</acronym>&#160;;
                dans "process", nous retournerons du <acronym>JSON</acronym>.
            </para>

            <programlisting language="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()
    {
        // Voir les commentaires.
        // Quand le AjaxContext est détecté, il utilise le script de vue
        // comment/view.ajax.phtml
    }

    public function formAction()
    {
        // Rend les formulaire "ajoutez un commentaire".
        // Lorsque le AjaxContext est détecté, il utilise le script de
        // vue : comment/form.ajax.phtml
    }

    public function processAction()
    {
        // Traite un commentaire
        // Retourne les résultats sous forme JSON ; assignez simplement
        // vos résultats comme variables de vues.
    }
}
]]></programlisting>

            <para>
                Coté client, votre bibliothèque <acronym>AJAX</acronym> requêtera simplement
                "<filename>/comment/view</filename>",
                "<filename>/comment/form</filename>", et "<filename>/comment/process</filename>",
                en passant le paramètre "format"&#160;:
                "<filename>/comment/view/format/html</filename>",
                "<filename>/comment/form/format/html</filename>",
                "<filename>/comment/process/format/json</filename>".
                (Ceci fonctionne aussi avec "?format=json".)
            </para>

            <para>
                Il est nécessaire que votre bibliothèque envoie l'en-tête
                "X-Requested-With: XmlHttpRequest", ce qui est en général le cas.
            </para>
        </example>
    </sect4>
</sect3>