[zend.git] / documentation / manual / fr / module_specs / Zend_Controller-ActionHelpers-ContextSwitch.xml
| blob | a79a02a4bca74bdbea29dc8ff2652b390b85dae8 |
1 <?xml version="1.0" encoding="utf-8"?>
2 <!-- EN-Revision: 21824 -->
3 <!-- Reviewed: no -->
4 <sect3 id="zend.controller.actionhelpers.contextswitch">
5 <title>ContextSwitch et AjaxContext</title>
7 <para>
8 L'aide d'action <emphasis>ContextSwitch</emphasis> est destinée à faciliter le retour de
9 différents formats de réponse à une requête.L'<emphasis>AjaxContext</emphasis> est une aide
10 spécialisée de <emphasis>ContextSwitch</emphasis> qui permet le renvoi de réponses à
11 XmlHttpRequest.
12 </para>
14 <para>
15 Pour l'activer, vous devez indiquer à votre contrôleur quelles actions répondent à
16 quel contexte. Si une requête d'entrée indique un contexte valide pour une action, alors
17 l'aide d'action en charge :
18 </para>
20 <itemizedlist>
21 <listitem>
22 <para>
23 Va désactiver les layouts, si elles sont activées.
24 </para>
25 </listitem>
26 <listitem>
27 <para>
28 Va changer le suffixe de la vue à rendre, il faudra donc créer une vue par
29 contexte.
30 </para>
31 </listitem>
32 <listitem>
33 <para>
34 Va envoyer les bons en-têtes de réponse en fonction du contexte désiré.
35 </para>
36 </listitem>
37 <listitem>
38 <para>
39 Va éventuellement en option appeler des fonctions pour configurer le
40 contexte, ou des fonctions de post-processing.
41 </para>
42 </listitem>
43 </itemizedlist>
45 <para>Comme exemple, prenons le contrôleur suivant :</para>
47 <programlisting language="php"><![CDATA[
48 class NewsController extends Zend_Controller_Action
49 {
50 /**
51 * page d'arrivée; forward vers listAction()
52 */
53 public function indexAction()
54 {
55 $this->_forward('list');
56 }
58 /**
59 * Liste les news
60 */
61 public function listAction()
62 {
63 }
65 /**
66 * Affiche une new particulière
67 */
68 public function viewAction()
69 {
70 }
71 }
72 ]]></programlisting>
74 <para>
75 Imaginons que nous voulions que <methodname>listAction()</methodname> soit aussi accessible
76 au format <acronym>XML</acronym>. Plutôt que de créer une autre action, nous pouvons lui
77 indiquer qu'elle doit retourner du <acronym>XML</acronym> :
78 </para>
80 <programlisting language="php"><![CDATA[
81 class NewsController extends Zend_Controller_Action
82 {
83 public function init()
84 {
85 $contextSwitch = $this->_helper->getHelper('contextSwitch');
86 $contextSwitch->addActionContext('list', 'xml')
87 ->initContext();
88 }
90 // ...
91 }
92 ]]></programlisting>
94 <para>Ce code aura pour effet :</para>
96 <itemizedlist>
97 <listitem>
98 <para>
99 De changer le "Content-Type" de la réponse en "<filename>text/xml</filename>".
100 </para>
101 </listitem>
102 <listitem>
103 <para>
104 De changer le suffixe de vue vers "<filename>xml.phtml</filename>" (ou un autre
105 suffixe si vous en utilisez un personnalisé "xml.[votre suffixe]").
106 </para>
107 </listitem>
108 </itemizedlist>
110 <para>
111 Il est donc nécessaire de créer un nouveau script de vue,
112 "<filename>news/list.xml.phtml</filename>", qui créera et rendra le
113 <acronym>XML</acronym>.
114 </para>
116 <para>
117 Pour savoir si la requête doit utiliser un contexte switch, l'aide vérifie un jeton
118 dans l'objet de requête. Par défaut, l'aide va chercher le paramètre de requête "format",
119 ceci peut être changé. Ceci signifie que dans la plupart des cas, pour changer le contexte
120 d'une réponse, il faut simplement injecter un paramètre "format" à la requête:
121 </para>
123 <itemizedlist>
124 <listitem>
125 <para>
126 Via l'<acronym>URL</acronym> : <filename>/news/list/format/xml</filename>
127 (le routeur par défaut utilise les paires clés et valeurs fournies après l'action)
128 </para>
129 </listitem>
130 <listitem>
131 <para>
132 Via un paramètre <constant>GET</constant> :
133 <command>/news/list?format=xml</command>
134 </para>
135 </listitem>
136 </itemizedlist>
138 <para>
139 <emphasis>ContextSwitch</emphasis> vous permet d'écrire des contextes, ceux-ci spécifient le
140 suffixe de vue qui change, les en-têtes de réponse à modifier, et les fonctions de
141 rappel éventuelles.
142 </para>
144 <sect4 id="zend.controller.actionhelpers.contextswitch.contexts">
145 <title>Contextes inclus par défaut</title>
147 <para>
148 Par défaut, il existe 2 contextes dans l'aide <emphasis>ContextSwitch</emphasis> :
149 json et <acronym>XML</acronym>.
150 </para>
152 <itemizedlist>
153 <listitem>
154 <para>
155 <emphasis><acronym>JSON</acronym></emphasis>. Le contexte
156 <acronym>JSON</acronym> met le "Content-Type" de la réponse à
157 "<filename>application/json</filename>", et le suffixe de la vue est
158 "<filename>json.phtml</filename>".
159 </para>
160 <para>
161 Par défaut cependant, aucun script de vue n'est nécessaire, il va simplement
162 sérialiser en <acronym>JSON</acronym> toutes les variables de vues, et les
163 envoyer en tant que réponse.
164 </para>
165 <para>
166 Ce comportement peut être désactivé en éteigant le paramètre de
167 sérialisation <acronym>JSON</acronym> :
168 </para>
169 <programlisting language="php"><![CDATA[
170 $this->_helper->contextSwitch()->setAutoJsonSerialization(false);
171 ]]></programlisting>
172 </listitem>
173 <listitem>
174 <para>
175 <emphasis><acronym>XML</acronym></emphasis>. Le contexte <acronym>XML</acronym>
176 met le "Content-Type" de la réponse à "<filename>text/xml</filename>", et
177 utilise un suffixe de vue "<filename>xml.phtml</filename>". Vous devrez
178 créer une nouvelle vue pour ce contexte.
179 </para>
180 </listitem>
181 </itemizedlist>
182 </sect4>
184 <sect4 id="zend.controller.actionhelpers.contextswitch.custom">
185 <title>Créer ses propres contextes</title>
187 <para>
188 Vous pouvez créer vos propres contextes d'action. Par exemple pour retourner du
189 <acronym>YAML</acronym>, du <acronym>PHP</acronym> sérialisé, ou encore du
190 <acronym>RSS</acronym> ou du <acronym>ATOM</acronym>. <emphasis>ContextSwitch</emphasis>
191 est là pour cela.
192 </para>
194 <para>
195 La manière la plus simple d'ajouter un nouveau contexte d'action est la méthode
196 <methodname>addContext()</methodname>. Elle prend 2 paramètres : le nom du contexte,
197 et un tableau d'options. Ce tableau d'option doit comporter au moins une des clés
198 suivantes :
199 </para>
201 <itemizedlist>
202 <listitem>
203 <para>
204 <emphasis>suffix</emphasis> : Le préfixe qui va s'ajouter au suffixe de
205 vue. Il sera utiliser par le ViewRenderer.
206 </para>
207 </listitem>
208 <listitem>
209 <para>
210 <emphasis>headers</emphasis> : un tableau d'en-têtes et de valeurs que
211 vous voulez ajouter à la réponse.
212 </para>
213 </listitem>
214 <listitem>
215 <para>
216 <emphasis>callbacks</emphasis> : un tableau dont les clés peuvent être
217 "init" ou "post", et les valeurs représentent des noms de fonctions
218 <acronym>PHP</acronym> valides, qui seront utilisées pour initialiser ou
219 traiter la fin du contexte.
220 </para>
221 <para>
222 Les fonctions d'initialisation interviennent lorsque le contexte est détecté
223 par <emphasis>ContextSwitch</emphasis>. Par exemple dans le contexte intégré
224 <acronym>JSON</acronym>, la fonction désactive le ViewRenderer lorsque la
225 sérialisation automatique <acronym>JSON</acronym> est activée.
226 </para>
227 <para>
228 Les fonctions de traitement de fin de contexte (Post processing) interviennent
229 durant le processus de <methodname>postDispatch()</methodname> de l'action en
230 cours. Par exemple pour le contexte intégré <acronym>JSON</acronym>, la
231 fonction de post process regarde si la sérialisation automatique
232 <acronym>JSON</acronym> est active, si c'est le cas, elle va sérialiser les
233 variables de la vue en <acronym>JSON</acronym>, et envoyer la réponse ;
234 mais dans le cas contraire, elle va réactiver le ViewRenderer.
235 </para>
236 </listitem>
237 </itemizedlist>
239 <para>Voici les méthodes d'interaction avec les contextes :</para>
241 <itemizedlist>
242 <listitem>
243 <para>
244 <methodname>addContext($context, array $spec)</methodname> : Ajoute un
245 nouveau contexte. Si celui-ci existe déjà, une exception sera lancée.
246 </para>
247 </listitem>
248 <listitem>
249 <para>
250 <methodname>setContext($context, array $spec)</methodname> : Ajoute un
251 nouveau contexte, mais écrase celui-ci s'il existait déjà. Utilise les mêmes
252 spécifications que <methodname>addContext()</methodname>.
253 </para>
254 </listitem>
255 <listitem>
256 <para>
257 <methodname>addContexts(array $contexts)</methodname> : Ajoute plusieurs
258 contextes d'un coup. Le tableau <varname>$contexts</varname> doit être un
259 tableau de paires contexte et specifications. Si un des contextes existe déjà,
260 une exception est lancée.
261 </para>
262 </listitem>
263 <listitem>
264 <para>
265 <methodname>setContexts(array $contexts)</methodname> : Ajoute des
266 nouveaux contextes, mais écrase ceux déjà présents éventuellement. Utilise
267 les mêmes spécifications que <methodname>addContexts()</methodname>.
268 </para>
269 </listitem>
270 <listitem>
271 <para>
272 <methodname>hasContext($context)</methodname> : retourne
273 <constant>TRUE</constant> si le contexte existe déjà,
274 <constant>FALSE</constant> sinon.
275 </para>
276 </listitem>
277 <listitem>
278 <para>
279 <methodname>getContext($context)</methodname> : retourne un contexte
280 par son nom. Le retour est un tableau qui a la même syntaxe que celui utilisé
281 par <methodname>addContext()</methodname>.
282 </para>
283 </listitem>
284 <listitem>
285 <para>
286 <methodname>getContexts()</methodname> : retourne tous les contextes.
287 Le tableau de retour est de la forme contexte => spécifications.
288 </para>
289 </listitem>
290 <listitem>
291 <para>
292 <methodname>removeContext($context)</methodname> : Supprime un contexte
293 grâce à son nom. Retourne <constant>TRUE</constant> si réussi,
294 <constant>FALSE</constant> si le contexte n'a pas été trouvé.
295 </para>
296 </listitem>
297 <listitem>
298 <para>
299 <methodname>clearContexts()</methodname> : Supprime tous les contextes.
300 </para>
301 </listitem>
302 </itemizedlist>
303 </sect4>
305 <sect4 id="zend.controller.actionhelpers.contextswitch.actions">
306 <title>Affecter des contextes par action</title>
308 <para>
309 Il existe deux mécanismes pour créer et affecter des contextes. Vous pouvez créer
310 des tableaux dans vos contrôleurs, ou utiliser plusieurs méthodes de
311 <emphasis>ContextSwitch</emphasis> pour les assembler.
312 </para>
314 <para>
315 La méthode principale pour ajouter des contextes à des actions est
316 <methodname>addActionContext()</methodname>. Elle attend 2 arguments, l'action et le
317 contexte (ou un tableau de contextes). Par exemple, considérons la classe
318 suivante :
319 </para>
321 <programlisting language="php"><![CDATA[
322 class FooController extends Zend_Controller_Action
323 {
324 public function listAction()
325 {
326 }
328 public function viewAction()
329 {
330 }
332 public function commentsAction()
333 {
334 }
336 public function updateAction()
337 {
338 }
339 }
340 ]]></programlisting>
342 <para>
343 Imaginons que nous voulions ajouter un contexte <acronym>XML</acronym> à l'action
344 "list", et deux contextes <acronym>XML</acronym> et <acronym>JSON</acronym> à
345 l'action "comments". Nous pourrions faire ceci dans la méthode
346 <methodname>init()</methodname> :
347 </para>
349 <programlisting language="php"><![CDATA[
350 class FooController extends Zend_Controller_Action
351 {
352 public function init()
353 {
354 $this->_helper->contextSwitch()
355 ->addActionContext('list', 'xml')
356 ->addActionContext('comments', array('xml', 'json'))
357 ->initContext();
358 }
359 }
360 ]]></programlisting>
362 <para>
363 De la même manière, il est aussi possible de simplement définir la propriété
364 <varname>$contexts</varname> :
365 </para>
367 <programlisting language="php"><![CDATA[
368 class FooController extends Zend_Controller_Action
369 {
370 public $contexts = array(
371 'list' => array('xml'),
372 'comments' => array('xml', 'json')
373 );
375 public function init()
376 {
377 $this->_helper->contextSwitch()->initContext();
378 }
379 }
380 ]]></programlisting>
382 <para>Cette syntaxe est simplement moins pratique et plus prompte aux erreurs.</para>
384 <para>Pour construire vos contextes, les méthodes suivantes vous seront utiles :</para>
386 <itemizedlist>
387 <listitem>
388 <para>
389 <methodname>addActionContext($action, $context)</methodname> : Ajoute un
390 ou plusieurs contextes à une action. <varname>$context</varname> doit donc être
391 une chaîne, ou un tableau de chaînes.
392 </para>
393 <para>
394 Passer la valeur <constant>TRUE</constant> comme contexte marquera tous les
395 contextes comme disponibles pour cette action.
396 </para>
397 <para>
398 Une valeur vide pour <varname>$context</varname> désactivera tous les contextes
399 donnés à cette action.
400 </para>
401 </listitem>
402 <listitem>
403 <para>
404 <methodname>setActionContext($action, $context)</methodname> : Marque un
405 ou plusieurs contextes comme disponibles pour cette action. Si ceux-ci existent
406 déjà, ils seront remplacés. <varname>$context</varname> doit être une chaîne ou
407 un tableau de chaînes.
408 </para>
409 </listitem>
410 <listitem>
411 <para>
412 <methodname>addActionContexts(array $contexts)</methodname> : Ajoute
413 plusieurs paires action et contexte en une fois. <varname>$contexts</varname>
414 doit être un tableau associatif action et contexte. Cette méthode proxie vers
415 <methodname>addActionContext()</methodname>.
416 </para>
417 </listitem>
418 <listitem>
419 <para>
420 <methodname>setActionContexts(array $contexts)</methodname> : agit comme
421 <methodname>addActionContexts()</methodname>, mais écrase les paires
422 action et contexte existantes.
423 </para>
424 </listitem>
425 <listitem>
426 <para>
427 <methodname>hasActionContext($action, $context)</methodname> : détermine
428 si une action possède un contexte donné.
429 </para>
430 </listitem>
431 <listitem>
432 <para>
433 <methodname>getActionContexts($action = null)</methodname> : Retourne tous
434 les contextes d'une action donnée, si pas d'action passée, retourne alors toutes
435 les paires action et contexte.
436 </para>
437 </listitem>
438 <listitem>
439 <para>
440 <methodname>removeActionContext($action, $context)</methodname> : Supprime
441 un ou plusieurs contextes pour une action. <varname>$context</varname> doit être
442 une chaîne ou un tableau de chaînes.
443 </para>
444 </listitem>
445 <listitem>
446 <para>
447 <methodname>clearActionContexts($action = null)</methodname> : Supprime
448 tous les contextes d'une action. Si aucune action n'est spécifiée, supprime
449 alors tous les contextes de toutes les actions.
450 </para>
451 </listitem>
452 </itemizedlist>
453 </sect4>
455 <sect4 id="zend.controller.actionhelpers.contextswitch.initcontext">
456 <title>Initialiser le Context Switch</title>
458 <para>
459 Pour initialiser la permutation de contextes (contexte switching), vous devez
460 appeler <methodname>initContext()</methodname> dans vos contrôleurs d'action :
461 </para>
463 <programlisting language="php"><![CDATA[
464 class NewsController extends Zend_Controller_Action
465 {
466 public function init()
467 {
468 $this->_helper->contextSwitch()->initContext();
469 }
470 }
471 ]]></programlisting>
473 <para>
474 Dans certains cas, vous voudriez forcer un contexte pour une action ; par exemple
475 vous pouvez vouloir seulement le contexte <acronym>XML</acronym> si la permutation de
476 contexte est active. Passez le alors à <methodname>initContext()</methodname> :
477 </para>
479 <programlisting language="php"><![CDATA[
480 $contextSwitch->initContext('xml');
481 ]]></programlisting>
482 </sect4>
484 <sect4 id="zend.controller.actionhelpers.contextswitch.misc">
485 <title>Fonctionnalités avancées</title>
487 <para>
488 Voici quelques méthodes qui peuvent être utilisées pour changer le comportement
489 de l'aide <emphasis>ContextSwitch</emphasis> :
490 </para>
492 <itemizedlist>
493 <listitem>
494 <para>
495 <methodname>setAutoJsonSerialization($flag)</methodname>: Par défaut, le
496 contexte <acronym>JSON</acronym> va sérialiser toute variable en notation
497 <acronym>JSON</acronym> et les retourner en tant que réponse. Si vous voulez
498 créer votre propre réponse, vous voudriez désactiver cet effet. Ceci doit être
499 fait avant l'appel à <methodname>initContext()</methodname>.
500 </para>
501 <programlisting language="php"><![CDATA[
502 $contextSwitch->setAutoJsonSerialization(false);
503 $contextSwitch->initContext();
504 ]]></programlisting>
505 <para>
506 Pour récupérer la valeur actuelle, utilisez
507 <methodname>getAutoJsonSerialization()</methodname>.
508 </para>
509 </listitem>
510 <listitem>
511 <para>
512 <methodname>setSuffix($context, $suffix,
513 $prependViewRendererSuffix)</methodname> :
514 Cette méthode permet de personnaliser le suffixe de vue d'un contexte. Le
515 troisième argument indique si le suffixe actuel du ViewRenderer doit être
516 utilisé comme préfixe de votre suffixe. Par défaut, c'est le cas.
517 </para>
518 <para>
519 Passer une valeur vide au suffixe aura pour effet de n'utiliser que le
520 suffixe du ViewRenderer.
521 </para>
522 </listitem>
523 <listitem>
524 <para>
525 <methodname>addHeader($context, $header, $content)</methodname> : Ajoute
526 un en-tête à la réponse pour un contexte donné. <varname>$header</varname>
527 est le nom de l'en-tête et <varname>$content</varname> sa valeur.
528 </para>
529 <para>
530 Chaque contexte peut posséder plusieurs en-têtes,
531 <methodname>addHeader()</methodname> ajoute des en-têtes dans une pile,
532 pour un contexte donné.
533 </para>
534 <para>
535 Si l'en-tête <varname>$header</varname> spécifié pour le contexte existe déjà,
536 une exception sera alors levée.
537 </para>
538 </listitem>
539 <listitem>
540 <para>
541 <methodname>setHeader($context, $header, $content)</methodname> :
542 <methodname>setHeader()</methodname> agit comme
543 <methodname>addHeader()</methodname>, sauf qu'il va écraser un en-tête
544 qui aurait déjà été présent.
545 </para>
546 </listitem>
547 <listitem>
548 <para>
549 <methodname>addHeaders($context, array $headers)</methodname> : Ajoute
550 plusieurs en-têtes en une seule fois. Proxie vers
551 <methodname>addHeader()</methodname>.<varname>$headers</varname> est un
552 tableau de paires header => contexte.
553 </para>
554 </listitem>
555 <listitem>
556 <para>
557 <methodname>setHeaders($context, array $headers.)</methodname> : comme
558 <methodname>addHeaders()</methodname>, sauf que cette méthode proxie vers
559 <methodname>setHeader()</methodname>, vous permettant d'écraser des en-têtes
560 déjà présents.
561 </para>
562 </listitem>
563 <listitem>
564 <para>
565 <methodname>getHeader($context, $header)</methodname> : retourne une
566 valeur d'en-tête pour un contexte. Retourne <constant>NULL</constant>
567 si non trouvé.
568 </para>
569 </listitem>
570 <listitem>
571 <para>
572 <methodname>removeHeader($context, $header)</methodname> : supprime
573 un en-tête d'un contexte.
574 </para>
575 </listitem>
576 <listitem>
577 <para>
578 <methodname>clearHeaders($context, $header)</methodname> : supprime
579 tous les en-têtes d'un contexte.
580 </para>
581 </listitem>
582 <listitem>
583 <para>
584 <methodname>setCallback($context, $trigger, $callback)</methodname> :
585 affecte une fonction de rappel (callback) pour un contexte. Le déclencheur
586 peut être soit "init" ou "post" (la fonction de rappel sera appelée soit à
587 l'initialisation du contexte, ou à la fin, en postDispatch).
588 <varname>$callback</varname> doit être un nom de fonction <acronym>PHP</acronym>
589 valide.
590 </para>
591 </listitem>
592 <listitem>
593 <para>
594 <methodname>setCallbacks($context, array $callbacks)</methodname> :
595 affecte plusieurs fonctions de rappel pour un contexte.
596 <varname>$callbacks</varname> doit être un tableau de paires trigger et
597 callback. Actuellement, seules deux fonctions maximum peuvent être enregistrées
598 car il n'existe que 2 déclencheurs (triggers) : "init" et "post".
599 </para>
600 </listitem>
601 <listitem>
602 <para>
603 <methodname>getCallback($context, $trigger)</methodname> : retourne un
604 nom de fonction de rappel affectée à un contexte.
605 </para>
606 </listitem>
607 <listitem>
608 <para>
609 <methodname>getCallbacks($context)</methodname> : retourne un tableau
610 de paires trigger et callback pour un contexte.
611 </para>
612 </listitem>
613 <listitem>
614 <para>
615 <methodname>removeCallback($context, $trigger)</methodname> : supprime
616 une fonction de rappel d'un contexte.
617 </para>
618 </listitem>
619 <listitem>
620 <para>
621 <methodname>clearCallbacks($context)</methodname> : supprime toutes
622 les fonctions de rappel d'un contexte.
623 </para>
624 </listitem>
625 <listitem>
626 <para>
627 <methodname>setContextParam($name)</methodname> : affecte le paramètre
628 de requête à vérifier pour savoir si un contexte a été appelé. La valeur par
629 défaut est "format".
630 </para>
631 <para>
632 <methodname>getContextParam()</methodname> en retourne la valeur actuelle.
633 </para>
634 </listitem>
635 <listitem>
636 <para>
637 <methodname>setAutoDisableLayout($flag)</methodname> : Par défaut, les
638 layouts sont désactivées lorsqu'un contexte intervient, ceci provient du fait
639 que les layouts n'ont en théorie pas de signification particulière pour un
640 contexte, mais plutôt pour une réponse 'normale'. Cependant si vous désirez
641 utiliser les layouts pour des contexte, passez alors la valeur
642 <constant>FALSE</constant> à <methodname>setAutoDisableLayout()</methodname>.
643 Ceci devant être fait <emphasis>avant</emphasis> l'appel à
644 <methodname>initContext()</methodname>.
645 </para>
646 <para>
647 Pour récupérer la valeur de ce paramètre, utilisez
648 <methodname>getAutoDisableLayout()</methodname>.
649 </para>
650 </listitem>
651 <listitem>
652 <para>
653 <methodname>getCurrentContext()</methodname> est utilisée pour savoir quel
654 contexte a été détecté (si c'est le cas). Cette méthode retourne
655 <constant>NULL</constant> si aucune permutation de contexte a été détectée,
656 ou si elle est appelée avant <methodname>initContext()</methodname>.
657 </para>
658 </listitem>
659 </itemizedlist>
660 </sect4>
662 <sect4 id="zend.controller.actionhelpers.contextswitch.ajaxcontext">
663 <title>Fonctionnalité AjaxContext</title>
665 <para>
666 L'aide <emphasis>AjaxContext</emphasis> étend l'aide de permutation de contexte
667 <emphasis>ContextSwitch</emphasis>, donc toutes les fonctionnalités de
668 <emphasis>ContextSwitch</emphasis> s'y retrouvent. Il y a cependant quelques
669 différences :
670 </para>
672 <para>
673 Cette aide utilise une propriété de contrôleur d'action différente pour
674 déterminer les contextes, <varname>$ajaxable</varname>. Vous pouvez avoir différents
675 contextes utilisés avec les requêtes <acronym>AJAX</acronym> ou <acronym>HTTP</acronym>.
676 Les différentes méthodes <methodname>ActionContext()</methodname> de
677 <emphasis>AjaxContext</emphasis> vont écrire dans cette propriété.
678 </para>
680 <para>
681 De plus, cette aide ne sera déclenchée que si la requête répond au critère
682 <methodname>isXmlHttpRequest()</methodname>. Donc même si le paramètre "format" est
683 passée à la requête, il faut nécessairement que celle ci soit une requête
684 XmlHttpRequest, sinon la permutation de contexte n'aura pas lieu.
685 </para>
687 <para>
688 Enfin, <emphasis>AjaxContext</emphasis> ajoute un contexte, <acronym>HTML</acronym>.
689 Dans ce contexte, le suffixe de vue est "<filename>ajax.phtml</filename>". Il n'y a
690 pas d'en-tête particulier ajouté à la réponse.
691 </para>
693 <example id="zend.controller.actionhelpers.contextswitch.ajaxcontext.example">
694 <title>Autoriser les actions à répondre aux requêtes AJAX</title>
696 <para>
697 Dans l'exemple qui suit, nous autorisons les actions "view", "form", et
698 "process" à répondre aux requêtes <acronym>AJAX</acronym>. Dans les actions,
699 "view" et "form", nous retournerons des portions de <acronym>HTML</acronym> ;
700 dans "process", nous retournerons du <acronym>JSON</acronym>.
701 </para>
703 <programlisting language="php"><![CDATA[
704 class CommentController extends Zend_Controller_Action
705 {
706 public function init()
707 {
708 $ajaxContext = $this->_helper->getHelper('AjaxContext');
709 $ajaxContext->addActionContext('view', 'html')
710 ->addActionContext('form', 'html')
711 ->addActionContext('process', 'json')
712 ->initContext();
713 }
715 public function viewAction()
716 {
717 // Voir les commentaires.
718 // Quand le AjaxContext est détecté, il utilise le script de vue
719 // comment/view.ajax.phtml
720 }
722 public function formAction()
723 {
724 // Rend les formulaire "ajoutez un commentaire".
725 // Lorsque le AjaxContext est détecté, il utilise le script de
726 // vue : comment/form.ajax.phtml
727 }
729 public function processAction()
730 {
731 // Traite un commentaire
732 // Retourne les résultats sous forme JSON ; assignez simplement
733 // vos résultats comme variables de vues.
734 }
735 }
736 ]]></programlisting>
738 <para>
739 Coté client, votre bibliothèque <acronym>AJAX</acronym> requêtera simplement
740 "<filename>/comment/view</filename>",
741 "<filename>/comment/form</filename>", et "<filename>/comment/process</filename>",
742 en passant le paramètre "format" :
743 "<filename>/comment/view/format/html</filename>",
744 "<filename>/comment/form/format/html</filename>",
745 "<filename>/comment/process/format/json</filename>".
746 (Ceci fonctionne aussi avec "?format=json".)
747 </para>
749 <para>
750 Il est nécessaire que votre bibliothèque envoie l'en-tête
751 "X-Requested-With: XmlHttpRequest", ce qui est en général le cas.
752 </para>
753 </example>
754 </sect4>
755 </sect3>