repo_zf1/documentation/manual/fr/module_specs/Zend_Form-StandardElements.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 21996 -->
<!-- Reviewed: no -->
<sect1 id="zend.form.standardElements">
    <title>Les éléments standards fournis avec Zend Framework</title>
    <para>
        Zend Framework est fournis avec des classes d'éléments couvrant la
        plupart des éléments de formulaire HTML. La plupart spécifie un helper de
        vue en particulier à utiliser pour décorer un élément, mais plusieurs
        d'entre elles offrent des fonctionnalités supplémentaires. Ce qui suit est
        une liste de toutes ces classes, ainsi que des descriptions des
        fonctionnalités offertes.
    </para>
    <sect2 id="zend.form.standardElements.button">
        <title>Zend_Form_Element_Button</title>
        <para>
            Utilisé pour créer des éléments boutons,
            <classname>Zend_Form_Element_Button</classname> étend <link
                linkend="zend.form.standardElements.submit">Zend_Form_Element_Submit</link>,
            spécifie quelques fonctionnalités personnalisées. Il spécifie le
            helper de vue 'formButton' pour la décoration.
        </para>
        <para>
            Comme l'élément submit, il utilise le label de l'élément en tant que
            valeur de l'élément lors de l'affichage ; autrement dit, pour définir
            le text du bouton, définissez la valeur de l'élément. Le label sera
            traduit si l'adapteur de traduction est présent.
        </para>
        <para>
            Comme le label est utilisé comme faisant partie de l'élément,
            l'élément bouton utilise seulement <link
                linkend="zend.form.standardDecorators.viewHelper">ViewHelper</link>
            et les décorateurs <link
                linkend="zend.form.standardDecorators.dtDdWrapper">DtDdWrapper</link>.
        </para>
        <para>
            Après avoir rempli ou validé un formulaire, vous pouvez vérifier si
            le bouton donné a été cliqué en utilisant la méthode
            <methodname>isChecked()</methodname>.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.captcha">
        <title>Zend_Form_Element_Captcha</title>
        <para>
            Les CAPTCHAs sont utilisé pour empêcher la soumission automatique des
            formulaires par des bots et autre processus automatisés.
        </para>
        <para>
            L'élément de formulaire Captcha permet de spécifier quel <link
                linkend="zend.captcha.adapters">Adapteur Zend_Captcha</link> vous
                désirez utiliser. Il définit ensuite cet adapteur comme
                validateur à l'objet, et utilise le décorateur du Captcha pour
                l'affichage (ce qui fait office de proxy vers l'adapteur CAPTCHA).
        </para>
        <para>
            Les adapteurs peuvent être n'importe quel adapteur de
            <classname>Zend_Captcha</classname>, ou n'importe quel adapteur que
            vous avez défini par ailleurs. Pour permettre ceci, vous devrez passer
            une clé supplémentaire de plugin loader, 'CAPTCHA'
            ou 'captcha', lorsque vous spécifiez un prefixe de chemin de plugin loader :
        </para>
        <programlisting language="php"><![CDATA[
$element->addPrefixPath('My_Captcha', 'My/Captcha/', 'captcha');
]]></programlisting>
        <para>
            Le Captcha peut ensuite être enregistré en utilisant la méthode
            <methodname>setCaptcha()</methodname>, qui prend en paramètre soit
            une instance concrête de CAPTCHA soit le nom court d'un adapteur CAPTCHA :
        </para>
        <programlisting language="php"><![CDATA[
// Instance concrête:
$element->setCaptcha(new Zend_Captcha_Figlet());
// Utilisation d'un nom court :
$element->setCaptcha('Dumb');
]]></programlisting>
        <para>
            Si vous souhaitez charger votre élément via la configuration, spécifiez soit
            la clé 'captcha' avec un tableau contenant la clé 'captcha', soit les clés
            'captcha' et 'captchaOptions' :
        </para>
        <programlisting language="php"><![CDATA[
// Utilisation d'une clé captcha :
$element = new Zend_Form_Element_Captcha('foo', array(
    'label' => "Merci de confirmer que vous êtes humain",
    'captcha' => array(
        'captcha' => 'Figlet',
        'wordLen' => 6,
        'timeout' => 300,
    ),
));
// Utilisation simultanée des clés captcha et captchaOption :
$element = new Zend_Form_Element_Captcha('foo', array(
    'label' => "Merci de confirmer que vous êtes humain",
    'captcha' => 'Figlet',
    'captchaOptions' => array(
        'captcha' => 'Figlet',
        'wordLen' => 6,
        'timeout' => 300,
    ),
));
]]></programlisting>
        <para>
            Le décorateur utilisé est déterminé lors de la récupération de l'adapteur
            du captcha. Par défaut, le <link
                linkend="zend.form.standardDecorators.captcha"> décorateur
                du captcha</link> est utilisé, mais un adapteur peut spécifier un décorateur
                différent via sa méthode <methodname>getDecorator()</methodname>.
        </para>
        <para>
            Comme noté, l'adapteur de captcha lui même agit comme un validateur pour
            l'élément. De plus, le validateur NotEmpty n'est pas utilisé, et l'élément
            est marqué comme requis. Dans la plupart des cas, vous n'aurez besoin de
            rien d'autre pour que le captcha soit présent dans votre formulaire.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.checkbox">
        <title>Zend_Form_Element_Checkbox</title>
        <para>
            Les cases à cocher HTML vous permettent de retourner une valeur spécifique,
            mais elles fonctionnent essentiellement comme des booléens. Lorsque elle
            est cochée, la valeur de la case à cocher est soumise. Lorsque la case à
            cocher n'est pas cochée, rien n'est soumis. En interne,
            <classname>Zend_Form_Element_Checkbox</classname> applique cet état.
        </para>
        <para>
            Par défaut, la valeur cochée est '1', et la valeur non cochée est '0'.
            Vous pouvez spécifier les valeurs en utilisant respectivement les accesseurs
            <methodname>setCheckedValue()</methodname>
            et <methodname>setUncheckedValue()</methodname>. En interne, à chaque fois que
            vous définissez une valeur, si la valeur fournie correspond à la valeur cochée,
            alors elle sera définie, mais toutes autres valeurs aura pour effet que la valeur
            non cochée sera sélectionnée.
        </para>
        <para>
            En sus, définir la valeur définit la propriété <code>checked</code>
            de la case à cocher. Vous pouvez la récupérer en utilisant
            <methodname>isChecked()</methodname> ou simplement en accédant à la propriété.
            Utiliser la méthode <methodname>setChecked($flag)</methodname> l'état du flag
            ainsi que la valeur cochée ou non cochée de l'élément.
            Veillez à utiliser cette méthode lorsque vous définissez l'état coché d'un élément
            case à cocher afin d'être sûr que la valeur est correctement définie.
        </para>
        <para>
            <classname>Zend_Form_Element_Checkbox</classname> utilise le helper de vue
            'formCheckbox'. La valeur cochée est toujours utilisé pour le remplir.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.file">
        <title>Zend_Form_Element_File</title>
        <para>
            L'élément de formulaire File fournit un mécanisme pour fournir des champs
            d'upload de fichier à votre formulaire. Il utilise <link
                linkend="zend.file.transfer.introduction">Zend_File_Transfer</link>
            en interne pour fournir cette fonctionnalité et le helper de vue
            <code>FormFile</code> ainsi que le décorateur <code>File</code>
            pour afficher l'élément de formulaire.
        </para>
        <para>
            Par défaut, il utilise l'adapteur de transfert<code>Http</code> qui
            inspecte le tableau <varname>$_FILES</varname> et vous permet d'attacher
            des validateurs et des filtres. Les validateurs et les filtres attachés
            au formulaire sont à leur tour attachés à l'adapteur de transfert.
        </para>
        <example id="zend.form.standardElements.file.usage">
            <title>Utilisation de l'élément de formulaire File</title>
            <para>
                L'explication d'utilisation de l'élément de formulaire File ci-dessous
                peut sembler ésotérique, mais l'usage est en fait relativement trivial :
            </para>
            <programlisting language="php"><![CDATA[
$element = new Zend_Form_Element_File('foo');
$element->setLabel('Upload une image:')
        ->setDestination('/var/www/upload');
// Fait en sorte qu'il y ait un seul fichier
$element->addValidator('Count', false, 1);
// limite à 100K
$element->addValidator('Size', false, 102400);
// seulement des JPEG, PNG, et GIFs
$element->addValidator('Extension', false, 'jpg,png,gif');
$form->addElement($element, 'foo');
]]></programlisting>
            <para>
                Vous devez aussi vous assurer que le type d'encodage correct est fourni au
                formulaire ; vous devez utiliser 'multipart/form-data'. Vous pouvez faire
                cela en définissant l'attribut 'enctype' du formulaire:
            </para>
            <programlisting language="php"><![CDATA[
$form->setAttrib('enctype', 'multipart/form-data');
]]></programlisting>
            <para>
                Après que le formulaire soit validé avec succès, vous devriez recevoir
                le fichier afin de le stocker dans sa destination finale en utilisant
                <methodname>receive()</methodname>.
                De plus, vous pouvez déterminer son emplacement finale en utilisant
                <methodname>getFileName()</methodname>:
            </para>
            <programlisting language="php"><![CDATA[
if (!$form->isValid()) {
    print "Uh oh... erreur de validation";
}
if (!$form->foo->receive()) {
    print "Erreur de réception de fichier";
}
$location = $form->foo->getFileName();
]]></programlisting>
        </example>
        <note>
            <title>Emplacement d'upload par défaut</title>
            <para>
                Par défaut, les fichiers sont uploadés dans le répertoire temp
                du système.
            </para>
        </note>
        <note>
            <title>Valeur de fichier</title>
            <para>
                Au sein du <acronym>HTTP</acronym> un élément fichier n'a aucune valeur.
                Pour cette raison et pour des raisons de sécurité
                <methodname>getValue()</methodname> retourne seulement le nom du fichier
                uploadé et non le chemin complet. Si vous avez besoin du chemin du fichier,
                appellez <methodname>getFileName()</methodname>, qui retourne à la fois le
                chemin et le nom du fichier.
            </para>
        </note>
        <para>
            Par défaut, le fichier sera automatiquement reçu quand vous appellerez
            <methodname>getValues()</methodname> sur le formulaire. La raison derrière
            ce comportement est que le fichier lui même est la valeur de l'élément fichier.
        </para>
        <programlisting language="php"><![CDATA[
$form->getValues();
]]></programlisting>
        <note>
            <para>
                Ainsi, un appel supplémentaire de <methodname>receive()</methodname> après avoir
                appellé <methodname>getValues()</methodname> n'aura aucun effet. De même, créer
                une instance de <classname>Zend_File_Transfer</classname> n'aura aucun effet non
                plus puisqu'il n'y aura plus de fichier à recevoir.
            </para>
        </note>
        <para>
            Cela dit, parfois vous aurez besoin d'appeller <methodname>getValues()</methodname> sans
            recevoir le fichier. Vous pouvez l'archiver en appellant
            <methodname>setValueDisabled(true)</methodname>. Afin de recevoir la véritable valeur de
            ce flag vous pouvez appeller <methodname>isValueDisabled()</methodname>.
        </para>
        <example id="zend.form.standardElements.file.retrievement">
            <title>Récupération explicite de fichier</title>
            <para>
                Tout d'abord appellez<methodname>setValueDisabled(true)</methodname>.
            </para>
            <programlisting language="php"><![CDATA[
$element = new Zend_Form_Element_File('foo');
$element->setLabel('Uploadez une image:')
        ->setDestination('/var/www/upload')
        ->setValueDisabled(true);
]]></programlisting>
            <para>
                Désormais le fichier sera reçu lorsque vous appellerez
                <methodname>getValues()</methodname>. Donc vous devez appeller vous même
                <methodname>receive()</methodname> sur l'élément fichier, ou une instance de
                <classname>Zend_File_Transfer</classname> .
            </para>
            <programlisting language="php"><![CDATA[
$values = $form->getValues();
if ($form->isValid($form->getPost())) {
    if (!$form->foo->receive()) {
        print "Erreur d'upload";
    }
}
]]></programlisting>
        </example>
        <para>
            Il ya plusieurs étapes du fichier uploadés qui peuvent être vérifiées
            avec les méthodes suivantes :
        </para>
        <itemizedlist>
            <listitem>
                <para>
                    <methodname>isUploaded()</methodname> : Vérifie si l'élément fichier
                    a été uploadé ou non.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>isReceived()</methodname> : Vérifie si l'élément fichier
                    a déjà été reçu.
                </para>
            </listitem>
            <listitem>
                <para>
                    <methodname>isFiltered()</methodname> : Vérifie si les filtres ont
                    déjà été appliqué ou non sur l'élément fichier.
                </para>
            </listitem>
        </itemizedlist>
        <example id="zend.form.standardElements.file.isuploaded">
            <title>Vérifier si un fichier optionnel a été uploadé</title>
            <programlisting language="php"><![CDATA[
$element = new Zend_Form_Element_File('foo');
$element->setLabel('Uploader une image:')
        ->setDestination('/var/www/upload')
        ->setRequired(false);
$element->addValidator('Size', false, 102400);
$form->addElement($element, 'foo');
// L'élément fichier foo est optionnel mais quand il est renseigné va là
if ($form->foo->isUploaded()) {
    // fichier foo donné, faire quelque chose
}
]]></programlisting>
        </example>
        <para>
            <classname>Zend_Form_Element_File</classname> supporte aussi les fichiers multiples.
            En appellant la méthode <methodname>setMultiFile($count)</methodname> vous pouvez définir,
            le nombre d'éléments fichier à créer. Ceci vous évite de définir les mêmes
            réglages plusieurs fois.
        </para>
        <example id="zend.form.standardElements.file.multiusage">
            <title>Définir plusieurs fichiers</title>
            <para>
                Créer un élément multifichier est identique à la création d'un élément unique.
                Appellez simplement <methodname>setMultiFile()</methodname> après que l'élément soit créé:
            </para>
            <programlisting language="php"><![CDATA[
$element = new Zend_Form_Element_File('foo');
$element->setLabel('Uploadez une image:')
        ->setDestination('/var/www/upload');
// s'assure qu'il y a un fichier au minimum, 3 au maximum
$element->addValidator('Count', false, array('min' => 1, 'max' => 3));
// Limite à 100K
$element->addValidator('Size', false, 102400);
// seulement des JPEG, PNG, et des GIF
$element->addValidator('Extension', false, 'jpg,png,gif');
// définit 3 éléments fichiers identiques
$element->setMultiFile(3);
$form->addElement($element, 'foo');
]]></programlisting>
            <para>
                Vous avez maintenant 3 éléments d'upload de fichier identiques
                avec les mêmes paramètres. Pour obtenir le nombre de fichiers multiples
                défini, appellez simplement
                <methodname>getMultiFile()</methodname>.
            </para>
        </example>
        <note>
            <title>Eléments de fichier dans un sous formulaire</title>
            <para>
                Quand vous l'utilisez dans des sous formulaires, vous devez définir
                des noms uniques.
                Par exemple, si vous nommez un élément fichier "file" dans le subform1,
                vous devez un nom différent à tout autre élément fichier dans subform2.
            </para>
            <para>
                Si il y a deux éléments fichier portant le même nom, le second élément
                n'est pas affiché ou soumis.
            </para>
            <para>
                De plus, les éléments fichiers ne sont pas affichés au sein du sous formulaire.
                Donc lorsque vous ajouter un élément fichier dans un sous formulaire, l'élément
                sera affiché dans le formulaire principal.
            </para>
        </note>
        <para>
            Afin de limiter, vous pouvez spécifier la taille maximum d'un fichier en définissant
            l'option <constant>MAX_FILE_SIZE</constant> sur le formulaire. Quand vous définissez
            cette valeur en utilisant la méthode
            <methodname>setMaxFileSize($size)</methodname>, elle sera affiché avec l'élément
            fichier.
        </para>
        <programlisting language="php"><![CDATA[
$element = new Zend_Form_Element_File('foo');
$element->setLabel('Uploadez une image:')
        ->setDestination('/var/www/upload')
        ->addValidator('Size', false, 102400) // limit to 100K
        ->setMaxFileSize(102400); // limite la taille de fichier coté client
$form->addElement($element, 'foo');
]]></programlisting>
        <note>
            <title>MaxFileSize et Eléments fichier multiple</title>
            <para>
                Quand vous utilisez des éléments fichiers multiples dans votre formulaire
                vous devez définir <constant>MAX_FILE_SIZE</constant> seulement une fois.
                La redéfinir écrasera la valeur précédente.
            </para>
            <para>
                Notez que c'est aussi le cas lorsque vous utilisez des formulaires multiples.
            </para>
        </note>
    </sect2>
    <sect2 id="zend.form.standardElements.hidden">
        <title>Zend_Form_Element_Hidden</title>
        <para>
            Les éléments cachés injectent des données qui doivent être soumises, mais pas manipulées
            par l'utilisateur. <classname>Zend_Form_Element_Hidden</classname> remplit cette tâche
            avec le helper de vue 'formHidden'.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.hash">
        <title>Zend_Form_Element_Hash</title>
        <para>
            Cette élément fournit une proctection contre les attaques CSRF sur les formulaires,
            en s'assurant que les données sont soumises par la session utilisateur qui a
            générée le formulaire et non par un script malveillant. La protection est réalisée
            en ajouté un élément de hachage au formulaire et en le vérifiant lors de la soumission
            du formulaire.
        </para>
        <para>
            Le nom de l'élément de hachage doit être unique. Nous recommandons d'utiliser
            l'option <literal>salt</literal> pour l'élément - deux hachages ayant le même nom
            mais des salt différent ne causeront pas de collision :
        </para>
        <programlisting language="php"><![CDATA[
$form->addElement('hash', 'no_csrf_foo', array('salt' => 'unique'));
]]></programlisting>
        <para>
            Vous pouvez définir le salt ultérieurement en utilisant la méthode
            <methodname>setSalt($salt)</methodname>.
        </para>
        <para>
            En interne, l'élément stocke un identifiant unique en utilisant
            <classname>Zend_Session_Namespace</classname>, et le vérifie lors de la soumission
            (en vérifiant que le TTL n'a pas expiré). Le validateur 'Identical' est ensuite
            utilisé pour s'assurer que le hachage soumis correspond au hachage stocké.
        </para>
        <para>
            Le helper de vue 'formHidden' est utilisé pour rendre l'élément dans le formulaire.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.Image">
        <title>Zend_Form_Element_Image</title>
        <para>
            Des images peuvent être utilisées comme éléments de formulaires, et vous
            pouvez utiliser ces images en tant qu'éléments graphiques sur les
            boutons de formulaires.
        </para>
        <para>
            Les images ont besoin d'une image source. <classname>Zend_Form_Element_Image</classname>
            permet de la spécifier en utilisant l'accesseur <methodname>setImage()</methodname>
            (ou la clé de configuration 'imageValue'). Quant la valeur définie pour l'élément
            corresponde à <code>imageValue</code>, alors l'accesseur
            <methodname>isChecked()</methodname> retournera <constant>TRUE</constant>.
        </para>
        <para>
            Les éléments image utilise le
            <link linkend="zend.form.standardDecorators.image"> décorateur Image
                </link> pour le rendu, en plus des décorateur standard Errors,
            HtmlTag et Label. Vous pouvez spécifier une balise en option au décorateur
            <code>Image</code> qui entourera l'élément image.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.multiCheckbox">
        <title>Zend_Form_Element_MultiCheckbox</title>
        <para>
            Souvent, vous pouvez avoir un ensemble de case à cocher apparenté, et vous
            souhaitez grouper ces résultat. Cela ressemble beaucoup à <link
                linkend="zend.form.standardElements.multiselect"> Multiselect</link>,
            mais au lieu que ce soit une liste déroulant, vous avez besoin d'afficher
            des paires case à cocher/valeur.
        </para>
        <para>
            <classname>Zend_Form_Element_MultiCheckbox</classname> rend cela simple
            comme bonjour. Comme tous les éléments qui étendent l'élément de base Multi,
            vous pouvez spécifier une liste d'options et les valider simplement à l'aide
            de cette même liste. Le helper de vue 'formMultiCheckbox' s'assure qu'elles
            seront retournées dans un tableau lors la soumission du formulaire.
        </para>
        <para>
            Par défaut, cet élément enregistre un validateur <code>InArray</code>
            qui effectue la validation à l'aide des clés du tableau d'options enregistrées.
            Vous pouvez désactiver ce comportement, soit en appellant
            <methodname>setRegisterInArrayValidator(false)</methodname>, soit en passant
            une valeur <constant>FALSE</constant> à la clé de configuration
            <code>registerInArrayValidator</code>.
        </para>
        <para>
            Vous pouvez manipuler les diverses options de case à cocher en utilisant
            les méthodes suivantes :
        </para>
        <itemizedlist>
            <listitem>
                <para><methodname>addMultiOption($option, $value)</methodname></para>
            </listitem>
            <listitem>
                <para><methodname>addMultiOptions(array $options)</methodname></para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setMultiOptions(array $options)</methodname> (écrase les options
                    existantes)
                </para>
            </listitem>
            <listitem><para><methodname>getMultiOption($option)</methodname></para></listitem>
            <listitem><para><methodname>getMultiOptions()</methodname></para></listitem>
            <listitem><para><methodname>removeMultiOption($option)</methodname></para></listitem>
            <listitem><para><methodname>clearMultiOptions()</methodname></para></listitem>
        </itemizedlist>
        <para>
            Pour marquer les éléments cochés, vous devez passer un tableau de valeur à
            <methodname>setValue()</methodname>. Ce qui suit cochera les valeur "bar"
            et "bat":
        </para>
        <programlisting language="php"><![CDATA[
$element = new Zend_Form_Element_MultiCheckbox('foo', array(
    'multiOptions' => array(
        'foo' => 'Foo Option',
        'bar' => 'Bar Option',
        'baz' => 'Baz Option',
        'bat' => 'Bat Option',
    )
));
$element->setValue(array('bar', 'bat'));
]]></programlisting>
        <para>
            Notez que même en définissant une valeur unique vous devrez passer un tableau.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.multiselect">
        <title>Zend_Form_Element_Multiselect</title>
        <para>
            Les éléments <code>select</code> <acronym>XHTML</acronym>  autorisent un attribut
            'multiple', indiquant que plusieurs options peuvent être sélectionné pour la soumission
            du formulaire, au lieu d'une seule habituellement.
            <classname>Zend_Form_Element_Multiselect</classname> étend
            <link
                linkend="zend.form.standardElements.select">Zend_Form_Element_Select</link>,
            et définit l'attribut <code>multiple</code> à 'multiple'. Comme les autres classes qui
            hétite la classe de base
            <classname>Zend_Form_Element_Multi</classname>, vous pouvez manipuler les options
            du select en utilisant :
        </para>
        <itemizedlist>
            <listitem>
                <para><methodname>addMultiOption($option, $value)</methodname></para>
            </listitem>
            <listitem>
                <para><methodname>addMultiOptions(array $options)</methodname></para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setMultiOptions(array $options)</methodname> (écrase les options
                    existantes)
                </para>
            </listitem>
            <listitem><para><methodname>getMultiOption($option)</methodname></para></listitem>
            <listitem><para><methodname>getMultiOptions()</methodname></para></listitem>
            <listitem><para><methodname>removeMultiOption($option)</methodname></para></listitem>
            <listitem><para><methodname>clearMultiOptions()</methodname></para></listitem>
        </itemizedlist>
        <para>
            Si un adapteur de traduction est enregistré au niveau du formulaire et/ou
            de l'élément, les valeurs des options seront traduites dans le cadre de
            l'affichage.
        </para>
        <para>
            Par défaut, cette élément utilise un validateur <code>InArray</code>
            qui effectue sa validation à partir des clés de tableau des options enregistrées.
            Vous pouvez désactiver ce comportement, soit en appellant
            <methodname>setRegisterInArrayValidator(false)</methodname>, ou en passant une valeur
            <constant>FALSE</constant> à la clé de configuration
            <code>registerInArrayValidator</code>.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.password">
        <title>Zend_Form_Element_Password</title>
        <para>
            Les éléments mot de passe sont fondamentalement des éléments texte normaux
            -- à l'exception du fait que vous ne voulez pas que le mot de passe soumis
            soit affiché dans les messages d'erreurs ou lorsque le formulaire est
            affiché à nouveau.
        </para>
        <para>
            <classname>Zend_Form_Element_Password</classname> effectue cela en appellant
            <methodname>setObscureValue(true)</methodname> sur chaque validateur (s'assurant
            ainsi que le mot de passe est dissimulé dans les messages d'erreur de validation),
            et utilise le helper de vue 'formPassword' qui n'affiche pas la valeur qui lui est
            passé).
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.radio">
        <title>Zend_Form_Element_Radio</title>
        <para>
            Les éléments radio vous permettend de spécifier plusieurs options, parmi
            lesquelles vous n'avez besoin que d'une seule. <classname>Zend_Form_Element_Radio</classname>
            étend la classe de base <classname>Zend_Form_Element_Multi</classname>,
            vous permettant ainsi de spécifier un nombre indéfini d'options, et utilise
            ensuite le helper de vue <code>formRadio</code> pour les afficher.
        </para>
        <para>
            Par défaut, cette élément utilise un validateur <code>InArray</code>
            qui effectue sa validation à partir des clés de tableau des options enregistrées.
            Vous pouvez désactiver ce comportement, soit en appellant
            <methodname>setRegisterInArrayValidator(false)</methodname>, ou en passant une valeur
            <constant>FALSE</constant> à la clé de configuration
            <code>registerInArrayValidator</code>.
        </para>
        <para>
            Comme tous les éléments étendant la classe de base Multi element, les méthodes
            suivantes peuvent être utilisé pour manipuler les options radio affichées :
        </para>
        <itemizedlist>
            <listitem>
                <para><methodname>addMultiOption($option, $value)</methodname></para>
            </listitem>
            <listitem>
                <para><methodname>addMultiOptions(array $options)</methodname></para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setMultiOptions(array $options)</methodname>
                    (écrase les options existantes)
                </para>
            </listitem>
            <listitem><para><methodname>getMultiOption($option)</methodname></para></listitem>
            <listitem><para><methodname>getMultiOptions()</methodname></para></listitem>
            <listitem><para><methodname>removeMultiOption($option)</methodname></para></listitem>
            <listitem><para><methodname>clearMultiOptions()</methodname></para></listitem>
        </itemizedlist>
    </sect2>
    <sect2 id="zend.form.standardElements.reset">
        <title>Zend_Form_Element_Reset</title>
        <para>
            Les boutons de mise à zéro sont typiquement utilisé pour vider un formulaire,
            et ne font pas partie des données soumises. Cela dit, comme ils remplissent un rôle
            dans l'affichage, ils sont inclus dans les éléments standards.
        </para>
        <para>
            <classname>Zend_Form_Element_Reset</classname> étend <link
                linkend="zend.form.standardElements.submit">Zend_Form_Element_Submit</link>.
            Ainsi, le label est utilisé pour l'affichage du bouton et sera traduit, si un
            adapteur de traduction est présent. Il utilise seulement les décorateurs
            'ViewHelper' et 'DtDdWrapper', puisqu'il ne devrait jamais y avoir de messages
            d'erreur pour ces éléments, le label ne sera pas non plus nécessaire.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.select">
        <title>Zend_Form_Element_Select</title>
        <para>
            Les listes d'options sont une manière habituelle de limiter des choix spécifiques.
            <classname>Zend_Form_Element_Select</classname> vous permet de les générer
            rapidement et facilement.
        </para>
        <para>
            Par défaut, cette élément utilise un validateur <code>InArray</code>
            qui effectue sa validation à partir des clés de tableau des options enregistrées.
            Vous pouvez désactiver ce comportement, soit en appellant
            <methodname>setRegisterInArrayValidator(false)</methodname>, ou en passant une valeur
            <constant>FALSE</constant> à la clé de configuration
            <code>registerInArrayValidator</code>.
        </para>
        <para>
            Comme il étend l'élément de base Multi, les méthodes suivantes peuvent
            être utilisées pour manipuler les options du select :
        </para>
        <itemizedlist>
            <listitem>
                <para><methodname>addMultiOption($option, $value)</methodname></para>
            </listitem>
            <listitem>
                <para><methodname>addMultiOptions(array $options)</methodname></para>
            </listitem>
            <listitem>
                <para>
                    <methodname>setMultiOptions(array $options)</methodname>
                    (écrase les options existantes)
                </para>
            </listitem>
            <listitem><para><methodname>getMultiOption($option)</methodname></para></listitem>
            <listitem><para><methodname>getMultiOptions()</methodname></para></listitem>
            <listitem><para><methodname>removeMultiOption($option)</methodname></para></listitem>
            <listitem><para><methodname>clearMultiOptions()</methodname></para></listitem>
        </itemizedlist>
        <para>
            <classname>Zend_Form_Element_Select</classname> utilise le helper de vue
            'formSelect pour la décoration.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.submit">
        <title>Zend_Form_Element_Submit</title>
        <para>
            Les boutons Submit sont utilisé pour soumettre un formulaire. Vous pouvez
            utiliser plusieurs boutons submit ; vous pouvez utiliser le bouton utilisé
            pour soumettre le formulaire afin de décider quelle action effectuer avec
            les données soumises.
            <classname>Zend_Form_Element_Submit</classname> rend cette décisions simple,
            en ajoutant une méthode <methodname>isChecked()</methodname> method ; puisqu'un
            seul élément bouton sera soumis par le formulaire, après avoir rempli ou validé
            le formulaire, vous pourrez appeller cette méthode sur chacun des boutons submit
            afin de déterminer lequel a été utilisé.
        </para>
        <para>
            <classname>Zend_Form_Element_Submit</classname> utilise le label comme "value"
            du bouton submit, il sera traduit si un adapeur de traduction est présent.
            <methodname>isChecked()</methodname> vérifie la valeur soumises avec
            le label pour déterminer si le bouton a été utilisé.
        </para>
        <para>
            Les décorateurs <link
                linkend="zend.form.standardDecorators.viewHelper">ViewHelper</link>
            et <link
                linkend="zend.form.standardDecorators.dtDdWrapper">DtDdWrapper</link>
            sont utilisé pour rendre cet élément. Aucun décorateur de label n'est utilisé,
            puisque le label du bouton est utilisé lors du rendu de l'élément ; de plus,
            vous n'associerez aucune erreurs avec l'élément submit.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.text">
        <title>Zend_Form_Element_Text</title>
        <para>
            De loin le type d'élément de formulaire le plus répandu est l'élément text,
            celui ci autorise des saisies de texte limité ; c'est un élément idéal pour
            la plupart des saisies de données. <classname>Zend_Form_Element_Text</classname>
            utilise simplement le helper de vue 'formText' pour afficher l'élément.
        </para>
    </sect2>
    <sect2 id="zend.form.standardElements.textarea">
        <title>Zend_Form_Element_Textarea</title>
        <para>
            Les Textareas sont utilisé lorsque de grandes quantités de texte sont
            attendues, et ne limite pas la quantité de texte soumise (si ce n'est la
            taille limite fixée par votre serveur ou  <acronym>PHP</acronym>).
            <classname>Zend_Form_Element_Textarea</classname> utilise le helper de vue
            'textArea' pour afficher ces éléments, et place la valeur comme contenu de
            l'élément.
        </para>
    </sect2>
</sect1>
<!--
vim:se ts=4 sw=4 tw=80 et:
-->