C'est une classe permettant de générer des formulaires, avec, entre autres, une vérification par javascript.
On peut aussi récupérer les valeurs envoyées via ce formulaire grâce à une autre fonction.
Utilisation "traditionnelle" de ce script:
fichier "formulaire.php" ou autre (non fourni) : contient la définition du formulaire (différents champs de ce formulaire) et création et récupération (avec éventuellement re-création si erreur). ----> cf exemple 1 dans le zip
OU :
fichier "formulaire.php" (ou autre) : contient la définition du formulaire
fichier "afficher.php" : contient une inclusion du fichier "formulaire.php" et simplement la fonction de génération du formulaire
fichier "recuperer.php" : contient une inclusion du fichier "formulaire.php" et simplement la fonction de récupération des données du formulaire.
----> cf exemple 2 dans le zip
OU: (cela concerne les 2 exemples)
Au lieu de créer le formulaire par la fonction dédiée à cela, vous créez élément par élémetn le formulaire, ce qui vous permet de mieux gérer la mise en page ---> exemple 3 dans le zip toujours.
Bien sûr, tout cela intégré à vos scripts personnels ;)
Le fichier config_formulaire.ini contient certaines valeurs par défaut du programme.
Source / Exemple :
//fichier formulaire.class.php, le fichier principal
<?php
/*
- Copyright :
- Pas de Copyright. Je vous encourage même à modifier le code et/ou ajouter des options supplémentaires si
- vous le souhaitez ;) .
- A condition tout de même que vous notiez que la base est de Samiby ou que vous envoyiez un lien vers le
- code sur phpcs.com, et que vous m'informiez des modifications (quelles soient utilisées sur le code
- original) si vous comptez diffuser votre version modifiée
-
- Explications :
- Les variables souvent utilisées :
- $attributs = Contient sous forme d'un tableau (array) les différents attributs que vont avoir la balise
- lorsqu'elle sera créée (ex: tableau du style 'array("name","nom_de_l_element")')
- $proprietes = Contient sous forme d'un tableau les proprietes de l'élément, les propriétés utilisées par
- le code (ex: tableau de style array(OBLIGATOIRE => OUI))
- $html (uilisée dans les fonctions) = chaîne de code HTML qui sera renvoyée en tant que résultat.
- FORM_xxx_CLASSE = classe par défaut de l'élément. On l'attribue automatiquement à la création de
- l'objet.
- FORM_xxx = toutes les constantes utilisées par le sript. On peut les modifier dans le fichier
- config_formulaire.ini.
- D'autres informations :
- La classe element est générique et a plein de filles et sous-filles. Elle est la base du programme, elle
- contient des variables et fonctions utilisées par tous les éléments de formulaire.
- Les filles de cette classe (ou sous-filles parfois) sont celles qui seront utilisées par votre programme
- (voir exemple.php pour plus de détails).
-
- Remerciements :
- GRenard pour son commentaire à l'adresse http://www.phpcs.com/code.aspx?ID=28354 qui m'a donné quelques
- idées
-
- Dernières informations/remarques:
- Je compte améliorer ce script par différents ajouts:
- - Ajout de nouveau types de champs de formulaire (un champ date, par exemple)
- - [...] Pas plus d'idées pour l'instant, je verrais bien
- Pour bien fonctionner pour l'instant, il faut que chaque formulaire soit traité en entier séparément.
- Autrement dit, il ne vaut mieux pas commencer la génération d'un formulaire avant d'en avoir fini
- avec le précédent.
- Pour les puristes, j'admet qu'en toute rigueur, les classes "formulaire" et "element" auraient dû être
- filles d'une classe mère à cause des fonctions que l'on retrouve dans ces deux classes. Je le ferai
- peut-être plus tard. Ce n'est pas un élément capital
-
- Bon codage, j'espère que ça vous falicitera la tâche et vous débarrassera des tâches répétitives de
- programmation de formulaire.
- /
//Les variables qui suivent ($i_ ...) sont des itérateurs. Ils sont nécessaires pour nommer ou numéroter
//les différents éléments (formulaires, champs de formulaire, ...)
global $i_form;
$i_form = 0;
global $i_text, $i_hidden, $i_password, $i_textarea, $i_radio, $i_checkbox, $i_button, $i_submit, $i_reset,
$i_select;
$i_textarea = 0;;
$i_text = 0;
$i_hidden = 0;
$i_password = 0;
$i_textarea = 0;
$i_radio = 0;
$i_checkbox = 0;
$i_button = 0;
$i_submit = 0;
$i_reset = 0;
$i_select = 0;
//Ce fichier contient différentes définitions, et surtout, la gestion des valeurs du config.ini
include('definitions.formulaire.class.php5');
//Cette classe concerne les formulaires. Utilisée donc pour créer les formulaires
class formulaire{
//Pour les variables $attributs et $proprietes, cf. explication générale plus haut
public $attributs, $erreurs, $proprietes;
function formulaire($methode = FORM_METHODE_DEFAUT, $action = '', $proprietes = ''){
//On appelle et incrément l'itérateur $i_form, qui sert à numéroter les formulaires
global $i_form;
$i_form++;
//On donne pour nom à ce formulaire "form" + n° choisi.
$this->attribut("name", FORM_NOM_PREFIXE . $i_form);
//On enregistre la méthde (POST ou GET) dans les attributs du formulaire
$this->attribut("method", $methode);
//Si il n'y a pas d'action (fichier dans lequel sera traité la requête) défini,
//cette 'action' sera le fichier actuel
if($action == ''){
$action = $_SERVER['REQUEST_URI'];
}
$this->attribut("action", $action);
//On transforme les proprietes éventuellement données en paramètre en un tableau
//de propriétés
if($proprietes != '')
$this->proprietes_array($proprietes);
}
//Cette fonction permet d'affecte ou de modifier une valeur à un attribut (cf. explication en haut)
public function attribut($nom, $valeur){
$this->attributs[$nom] = $valeur;
}
//Cette fonction transforme le tableau (array) des attributs en une chaîne utilisable pour une balise
//HTML
public function attributs_html(){
$liste = '';
foreach($this->attributs as $nom => $valeur){
$liste .= " " . $nom . "='" . $valeur . "'";
}
return $liste;
}
//Fonction permettant de gérer les propriétés de l'élément (équivalent de attribut, mais pour la
//variable $proprietes)
public function propriete($prop, $valeur){
$this->proprietes[$prop] = $valeur;
}
//Cette fonction permet d'affecter des porpriétés entrées en paramètres sous forme d'un tableau
public function proprietes_array($proprietes){
//On parcourt le tableau donné en paramètre, et pour chaque valeur, on enregistre la propriété
foreach($proprietes as $prop => $valeur){
$this->propriete($prop, $valeur);
}
}
//Cette fonction en crée une autre en Javascript qui va ser charger de vérifier que tous les champs
//ont été remplis
private function fonction_js_verification(){
global $i_form;
$html = "<script type='text/javascript'>\n";
//On génère une fonction pour ce formulaire au nom de ce formulaire qui sera déclenchée
$html .= "function verif_" . FORM_NOM_PREFIXE . $i_form ."(){\n";
foreach($this as $element){
//Pour chaque élément, si cet élément doit être renseigné ...
if(isset($element->type) and $element->proprietes[OBLIGATOIRE] == OUI){
//... on ajoute une condition (vérification de la validité de la valeur donnée) qui,
//si elle est satisfaite ...
$nom_document_js = "document." . $this->attributs['name'] . "."
. $element->attributs['name'];
$html .= "\tif(" . $nom_document_js . ".value == '' || " . $nom_document_js . ".value == "
. $nom_document_js . ".defaultValue";
if($element->proprietes[NOMBRE] == OUI){
$html .= " || isNaN(" . $nom_document_js . ".value)";
}
$html .= "){\n";
// ... entraine un message d'erreur
$html .= "\t\talert('" . $element->proprietes[MESSAGE_ERREUR] . "');\n";
$html .= "\t\tdocument." . $this->attributs['name'] . "."
. $element->attributs['name'] . ".focus();\n";
//Le return false permet d'interrompre la validation du formulaire et
//l'éxécution de la fonction (javascript)
$html .= "\t\treturn false;\n\t}\n";
}
}
//Ensuite, on accepte la validation du formulaire (si on arrive à cet endroit, ça veut dire que
//toutes les conditions sont satisfaites)
$html .= "\treturn true;\n";
$html .= "}\n";
$html .= "</script>\n";
return $html;
}
//Cette fonction sert à créer le formulaire
public function creer(){
//Regarder la fonction recuperer_erreurs pour plus de détails
$html = $this->recuperer_erreurs();
//Si dans les proprietes du formulaire, il y a indication d'une vérification par JavaScript ...
if($this->proprietes[VERIFICATION_JS] == OUI){
global $i_form;
//On ajoute un attribut au formulaire : lorsqu'il est validé, on déclenche la fonction
//de vérification ...
$this->attribut("onsubmit", "return verif_" . FORM_NOM_PREFIXE . $i_form ."();");
// ... et on ajoute au formulaire la fonction qui va se charger de le vérifier quand celui-ci
//sera validé.
$html .= $this->fonction_js_verification();
}
//On crée le formulaire proprement dit
$html .= "<form" . $this->attributs_html() . ">\n";
//On crée une table pour optimiser l'alignement des éléments et de leurs légendes
$html .= "<table cellspacing='0' cellspadding='0'>\n";
//on parcourt les différents éléments de l'objet formulaire ($this ici) en vérifiant qu'il s'agit
// bien de champs que l'utilisateur a à remplir.
foreach($this as $cle => $element){
if(isset($element->type)){
//On ajoute la balise de l'élément (en fait, toute la ligne avec légende + balise)
$html .= $element->balise_tableau();
}
}
//On ferme la table et le formulaire, puis c'est fini
$html .= "</table>\n</form>";
return $html;
}
//Fonction permettant d'ajouter une erreur dans la liste de celles rencontrées. On enregistre en fait
//dans le tableau des erreurs l'élément concerné (celui qui génère l'erreur).
//D'ailleurs, une erreur n'est ici que un manque de valeur pour un champ particulier
private function erreur($elem_erreur){
$this->erreurs[] = $elem_erreur;
}
//Fonction permettant de renvoyer la liste des erreurs rencontrées
private function recuperer_erreurs(){
if($this->erreurs != ''){
//On affiche le(s) message(s) d'erreur en rouge et en gras, histoire que ce soit visible
$html = "<span style='font-weight: bold; color: #FF0000;'>\n";
foreach($this->erreurs as $element){
//Le message d'erreur est très simple : "Veuillez indiquer le champ" + légende dudit champ
$html .= $element->proprietes[MESSAGE_ERREUR] .".<br />\n";
}
$html .= "</span>\n";
return $html;
}
}
//Fonction permettant de récupérer les valeurs envoyées via le formulaire
public function recuperer(){
if(empty($_POST)){
return false;
}
//On parourt les éléments de l'objet courant ($this) en vérifiant qu'il s'agit bien de champs à
//vérifier
foreach($this as $cle => $element){
if(isset($element->type)){
//Si la valeur de l'élément est nulle et qu'elle est sensée être obligatoire, on ajoute une
//erreur à la liste des erreurs
if($element->proprietes[OBLIGATOIRE] == OUI and
($_POST[$element->attributs['name']] == '' or
$_POST[$element->attributs['name']] == $element->attributs['value'])){
$this->erreur($element);
}
if($element->proprietes[NOMBRE] == OUI and
!is_numeric($_POST[$element->attributs['name']])){
$this->erreur($element);
}
//Si il y a une valeur pour le champ qui a été indiquée ...
if(isset($_POST[$element->attributs['name']])){
// ... on l'enregistre dans l'attribut "value" de l'élément. Cela permet de :
// - accéder à cette valeur par : $formulaire->elem->attribut('value')
// - D'indiquer cette valeur entrée comme valeur par défaut s'il y re-création du
//formulaire sur la même page
$element->valeur($_POST[$element->attributs['name']]);
}
}
}
if(empty($this->erreurs))
return true;
else
return false;
}
}
//classe de base : toutes les classes de champs de formulaire sont héritières de cette classe
class element{
//Variables pour ces éléments :
//$type correspond au type de l'élément ("text", "textarea", ou "select" par exemple)
//$legende est le nom d'invite pour ce champ qui sera affiché (ex: "Votre nom :")
//$attributs et $proprietes, cf. explications en haut
public $type, $valeur, $proprietes, $attributs, $legende;
//Fonction d'initialisation des différents éléments
protected function init($type, $legende, $attributs, $proprietes){
global $i_form;
//Bon, là c'est simple, on enregistre la $type passére en paramètre dans la $type de l'objet
$this->type = $type;
//Attention pour les débutant, on atteint un certain niveau d'abstraction
//On crée une variable contenant une chaine ("i_" + $type,
//ça donnera par exemple "i_text" ou "i_radio")
$nom_var_i = "i_" . $this->type;
//On déclare la variable portant ce nom pour l'utiliser (un des itérateurs définis au début)
global ${$nom_var_i};
//On affecte à l'élément le nom "form" + n° du formulaire + "_" + type de l'élément + n° de
//l'élément parmi ces types
$this->nom(FORM_NOM_PREFIXE . $i_form . "_" . $this->type . "_" . $$nom_var_i);
//On incrément le n° de l'élément
${$nom_var_i}++;
//Plus simple : comme 12 lignes plus haut, mais pour la légende
$this->legende = $legende;
//On définit toutes les propriétés de l'élément à non, dnas votre script vous en activerez
//certaines.
$this->proprietes = array_fill(0, 3, NON);
//Si vous avez iondiqué une liste d'attributs, on l'enregistre
if($attributs != '')
$this->attributs_array($attributs);
//Pareil pour les proprietes
if($proprietes != '')
$this->proprietes_array($proprietes);
//On définit le message d'erreur (en cas d'absence de valeur) par défaut. Pour modifier cela après,
//dans votre script, placez simplment la commande
//$*formulaire*->*element*->propriete(MESSAGE_ERREUR, "votre message d'erreur");
$this->propriete(MESSAGE_ERREUR, "Veuillez vérifier la valeur du champ "
. strtolower($this->legende));
}
//Les 2 fonctions qui suivent servent à ajouter/modifier des attributs à la balise
//La première est pou ajouter simplement un attribut
public function attribut($nom, $valeur = ''){
if($valeur != ''){
$this->attributs[$nom] = $valeur;
}
}
//Cette seconde sert à ajouter des attributs contenus dans un array
public function attributs_array($attributs_ajout){
foreach($attributs_ajout as $nom => $valeur){
$this->attribut($nom, $valeur);
}
}
//Cette fonction permet simplement de donner la liste des attributs (cf. plus haut dans la classe
//formulaire pour plus de détails)
public function attributs_html(){
$liste = '';
foreach($this->attributs as $nom => $valeur){
$liste .= " " . $nom . "='" . $valeur . "'";
}
return $liste;
}
//Les fonctions qui suivent sont des raccourcis de la fonction attribut() pour un but précis.
//Ce sont en fait les raccourcis pour les attributs les plus utilisés.
public function valeur($valeur){
if($this->type != "textarea" and $this->type != "select"){
$this->attribut("value", $valeur);
}
$this->valeur = $valeur;
}
public function classe($valeur){
$this->attribut("class", $valeur);
}
public function nom($valeur){
$this->attribut("name", $valeur);
}
public function js_clic($valeur){
$this->attribut("onclick", $valeur);
}
public function js_changement($valeur){
$this->attribut("onchange", $valeur);
}
//Fonction permettant de gérer les propriétés de l'élément
public function propriete($prop, $valeur){
$this->proprietes[$prop] = $valeur;
}
//Equivalent de la fonction attributs_aray, mais pour les proprietes
public function proprietes_array($proprietes){
foreach($proprietes as $prop => $valeur){
$this->propriete($prop, $valeur);
}
}
}
//Les classes concernant les champs input (presque tout)
class input extends element{
//La fonction balise_tableau est celle qui renvoie le code HTML de la ligne (de tableau) contenant le champ et
//sa légende
public function balise_tableau(){
$html = "\t<tr>\n\t\t<td>";
$html .= "<label for='" . addslashes($this->attributs['name']). "'>";
$html .= htmlspecialchars($this->legende);
$html .= "</label>";
$html .= "</td>\n\t\t<td>";
$html .= $this->balise();
$html .= "</td>\n\t</tr>\n";
return $html;
}
//La fonction balise renvoie le code HMTL de la balise
public function balise(){
$balise = "<input type='" . $this->type . "'";
$balise .= $this->attributs_html();
$balise .= " />";
return $balise;
}
}
class text extends input{
public function text($legende, $attributs = '', $proprietes = ''){
$this->init("text", $legende, $attributs, $proprietes);
$this->classe(FORM_TEXT_CLASSE);
$this->attribut("id", $this->attributs['name']);
if(FORM_TEXT_SUPPR == 1)
$this->js_suppr_defaut();
}
public function js_suppr_defaut(){
$this->attribut("onfocus", "if(this.value == this.defaultValue) { this.value = \"\"; }");
}
}
class password extends input{
public function password($legende, $attributs = '', $proprietes = ''){
$this->init("password", $legende, $attributs, $proprietes);
$this->classe(FORM_PASSWORD_CLASSE);
$this->attribut("id", $this->attributs['name']);
if(FORM_PASSWORD_SUPPR == 1)
$this->js_suppr_defaut();
}
public function js_suppr_defaut(){
$this->attribut("onfocus", "if(this.value == this.defaultValue) { this.value = \"\"; }");
}
}
class checkbox extends element{
public function checkbox($legende, $attributs = '', $proprietes = ''){
$this->init("checkbox", $legende, $attributs, $proprietes);
$this->classe(FORM_CHECKBOX_CLASSE);
$this->attribut("id", $this->attributs['name']);
}
public function coche(){
$this->attribut("checked", "true");
}
public function decoche(){
$this->attribut("checked", "false");
}
public function balise_tableau(){
$html = "\t<tr>\n\t\t<td></td>\n\t\t<td>";
$html .= $this->balise();
$html .= "<label for='" . addslashes($this->attributs['name']). "'>";
$html .= htmlspecialchars($this->legende);
$html .= "</label></td>\n";
return $html;
}
//La fonction balise renvoie le code HMTL de la balise
public function balise(){
$balise = "<input type='checkbox'";
$balise .= $this->attributs_html();
$balise .= " />";
return $balise;
}
}
//Classes concerant les boutons (fonction balise différente)
//Classe générique pour tous les boutons
class bouton extends element{
public function balise_tableau(){
$html = "\t<tr>\n\t\t<td colspan='2' style='text-align: center;'>";
$html .= $this->balise();
$html .= "</td>\n\t</tr>\n";
return $html;
}
public function balise(){
$balise = "<input type='" . $this->type . "'";
$balise .= $this->attributs_html();
$balise .= " />";
return $balise;
}
}
class button extends bouton{
public function button($legende, $attributs = '', $proprietes = ''){
$this->init("button", $legende, $attributs, $proprietes);
$this->valeur($legende);
$this->classe(FORM_BUTTON_CLASSE);
}
}
class submit extends bouton{
public function submit($legende, $attributs = '', $proprietes = ''){
$this->init("submit", $legende, $attributs, $proprietes);
$this->valeur($legende);
$this->classe(FORM_SUBMIT_CLASSE);
}
}
class reset extends bouton{
public function reset($legende, $attributs = '', $proprietes = ''){
$this->init("reset", $legende, $attributs, $proprietes);
$this->valeur($legende);
$this->classe(FORM_RESET_CLASSE);
}
}
//Classe hidden mise à part, car la fonction balise est légèrement différente
class hidden extends element{
public function hidden($valeur, $attributs = '', $proprietes = ''){
$this->init("hidden", $valeur, $attributs, $proprietes);
$this->valeur($valeur);
}
public function balise_tableau(){
$html = $this->balise();
return $html;
}
public function balise(){
$balise = "<input type='hidden'";
$balise .= $this->attributs_html();
$balise .= " />\n";
return $balise;
}
}
//autres champs : TEXTAREA et listes de choix (select et radio)
class textarea extends element{
public function textarea($legende, $attributs = '', $proprietes = ''){
$this->init("textarea", $legende, $attributs, $proprietes);
$this->classe(FORM_TEXTAREA_CLASSE);
$this->attribut("id", $this->attributs['name']);
if(FORM_TEXTAREA_SUPPR == 1)
$this->js_suppr_defaut();
}
public function balise_tableau(){
$html = "\t<tr>\n\t\t<td>";
$html .= "<label for='" . addslashes($this->attributs['name']). "'>";
$html .= htmlspecialchars($this->legende);
$html .= "</label></td>\n";
$html .= "</td>\n\t\t<td>";
$html .= $this->balise();
$html .= "</td>\n\t</tr>\n";
return $html;
}
public function balise(){
$html = '<textarea';
$html .= $this->attributs_html();
$html .= ">" . $this->valeur . "</textarea>";
return $html;
}
public function js_suppr_defaut(){
$this->attribut("onfocus", "if(this.value == this.defaultValue) { this.value = \"\"; }");
}
}
//classe générique pour les select et radio (tous deux des éléments où il y a plusieurs choix possibles)
class multi_choix extends element{
public function option($value, $legende, $selected = PAS_SELECTIONNE){
$this->options[$value]['selectionne'] = (isset($selected)) ? $selected : PAS_SELECTIONNE;
$this->options[$value]['legende'] = $legende;
if($this->type == "select")
$this->option_attribut($value, "class", FORM_OPTION_CLASSE);
}
public function option_attribut($option, $name, $value = ''){
if($value != ''){
$this->options[$option]['attributs'][$name] = $value;
}
}
}
class select extends multi_choix{
public function select($legende, $attributs = '', $proprietes = ''){
$this->init("select", $legende, $attributs, $proprietes);
$this->classe(FORM_SELECT_CLASSE);
$this->attribut("id", $this->attributs['name']);
}
public function balise_tableau(){
$html = "\t<tr>\n\t\t<td>";
$html .= "<label for='" . addslashes($this->attributs['name']). "'>";
$html .= htmlspecialchars($this->legende);
$html .= "</label></td>\n";
$html .= "</td>\n\t\t<td>";
$html .= $this->balise();
$html .= "</td>\n\t</tr>\n";
return $html;
}
public function balise(){
$balise = '<select ';
$balise .= $this->attributs_html();
$balise .= ">\n";
foreach($this->options as $value => $attributs){
$balise .= '<option value="' . $value . '"';
if(isset($attributs['attributs'])){
foreach($attributs['attributs'] as $name => $valeur){
$balise .= " " . $name . "='" . $valeur . "'";
}
}
$balise .= ($attributs['selectionne'] == 1) ? " selected='selected'>" : ">";
$balise .= $attributs['legende'] . "</option>\n";
}
$balise .= "</select>";
return $balise;
}
}
class radio extends multi_choix{
public function radio($legende, $attributs = '', $proprietes = ''){
$this->init("radio", $legende, $attributs, $proprietes);
$this->classe(FORM_RADIO_CLASSE);
}
public function balise_tableau(){
$html = "\t<tr>\n";
$html .= "\t<td>";
$html .= "<label for='" . addslashes($this->attributs['name']). "'>";
$html .= htmlspecialchars($this->legende);
$html .= "</label></td>\n";
$html .= "</td>\n\t\t<td>";
$html .= $this->balise();
$html .= "\t\t</td>\n\t</tr>\n";
return $html;
}
public function balise(){
$balise = '';
foreach($this->options as $value => $attributs){
$balise .= '<input type="radio" value="' . addslashes($value) . '"';
$balise .= 'id="' . addslashes($value) . '"';
$balise .= $this->attributs_html();
if(isset($attributs['attributs'])){
foreach($attributs['attributs'] as $name => $valeur){
$balise .= " " . $name . "='" . $valeur . "'";
}
}
$balise .= ($attributs['selectionne'] == 1) ? " checked='checked' />" : "/>";
$balise .= "<label for='" . addslashes($value). "'>";
$balise .= htmlspecialchars($attributs['legende']);
$balise .= "</label><br />\n";
}
return $balise;
}
}
?>
//Le fichier definitions.formulaire.php : contient quelques définitions (communication votre application <-> classe)
//et surtout la récupération des données config_formulaire.php (voir ce fichier pour plus de détails)
<?php
//Quelques définitions pour simplifier la communication entre la classe et votre programme
define("PAS_SELECTIONNE", 0);
define("SELECTIONNE", 1);
//Définitions des noms d'options pour les champs (j'en ajouterai d'autres: options)
//Indique si une valeur doit être obligatoire ment renseignée
define("OBLIGATOIRE", 0);
//Indique si la valeur doit être un nombre
define("NOMBRE", 1);
//Pour indiquer un message en cas d'absence de valeur ou de problème avce la valeur
define("MESSAGE_ERREUR", 2);
//Définitions des noms d'options pour les formiulaire (j'en ajouterai d'autres)
define("VERIFICATION_JS", 0);
//Pour communiquer et avoir des tableaux en paramètres :
//ex: $formulaire->objet = new ([...], array(OBLIGATOIRE => OUI);
//Cela simplifie la relecture du code
define("NON", 0);
define("OUI", 1);
//on récupère les valeurs du config_formulaire.ini . Si vous déplacez dans un dossier particulier ce
//fichier .ini, n'oubliez pas de modifier la valeur ici.
$config = parse_ini_file("config_formulaire.ini");
//On définit plusieurs constantes en fonction de ce qu'on a trouvé dans le fichier .ini
define("FORM_METHODE_DEFAUT", $config['methode_defaut']);
define("FORM_NOM_PREFIXE", $config['prefixe_nom_formulaire']);
define("FORM_TEXT_CLASSE", $config['text_classe']);
define("FORM_PASSWORD_CLASSE", $config['password_classe']);
define("FORM_CHECKBOX_CLASSE", $config['checkbox_classe']);
define("FORM_BUTTON_CLASSE", $config['button_classe']);
define("FORM_SUBMIT_CLASSE", $config['submit_classe']);
define("FORM_RESET_CLASSE", $config['reset_classe']);
define("FORM_TEXTAREA_CLASSE", $config['textarea_classe']);
define("FORM_SELECT_CLASSE", $config['select_classe']);
define("FORM_OPTION_CLASSE", $config['option_classe']);
define("FORM_RADIO_CLASSE", $config['radio_classe']);
define("FORM_TEXT_SUPPR", $config['text_suppression_defaut']);
define("FORM_PASSWORD_SUPPR", $config['password_suppression_defaut']);
define("FORM_TEXTAREA_SUPPR", $config['textarea_suppression_defaut']);
?>
//Le gros exemple :
<?php=
include_once("formulaire.class.php5");
$form = new formulaire();//On crée l'élément formulaire
//... ici, on ne demande pas de vérification javascript (on pourrait)
$form->nom = new text("Votre nom", array("size" => 20, "maxlength" => 150)); //On crée un champ texte avec
//pour attributs "size" (20) et "maxlength" (150). Onpourrait en ajouter d'autres
$form->nom->propriete(OBLIGATOIRE, OUI); //Le nom devra absolument être indiqué. On aurait pu passer
//cette propriete en ajoutant un paramètre à la ligne du dessus (cf ligne suivante par exemple)
$form->nom->valeur("valeur"); //On ajoute une valeur par défaut ("valeur") à ce champ
$form->nom->js_suppr_defaut(); //On ajoute une fonction javascript qui supprime la valeur par défaut dans
//le champ (testez pour essayer). Possibilité donnée pour les champs de type text, textarea et password
$form->mdp = new password("Mot de passe", '', array(OBLIGATOIRE => OUI)); //On ajoute un nouveau champ
//de type password avec comme propriété d'être obligatoirement rempmli
$form->mdp->attribut("size", 20); //On ajoute un attribut à l'élément : "size" (20). Ca sera traduit
//dans la balise par " size='20'"
$form->mdp->attributs_array(array("value" => "mot de passe", "maxlength" => 50));
//On ajoute différents attributs à cet élément que l'on passe à la fonction sous forme d'un tableau
$form->valeur_cachee = new hidden("j05vPm"); //On ajoute un champ caché avec pour valeur "j05vPm"
$form->description = new textarea("Description de vous-même"); //On ajoute un champ textarea
$form->description->valeur("Âge, sexe, profession, ..."); //On indique la valeur par défaut à ce textarea.
//On aurait aussi pu mettre : $form->description->attribut("value", "Âge, sexe, profession, ...");
$form->inscr = new checkbox("Inscription à la newsletter"); //On ajoute une case à cocher
$form->inscr->coche(); //On indique que cette case sera par défaut cochée ($form->inscr->decoch(); si on
//veut l'inverse').
$form->animal = new select("Votre animal de compagnie préféré"); //On ajoute un champ select
$form->animal->option(1, "Chien"); //On ajoute une option avec pour valeur 0 et légende "Chien"
$form->animal->option(2, "Chat"); //Pareil
$form->animal->option(0, "Autre", SELECTIONNE); //On indique que cete valeur sera par défaut sélectionnée
$form->age = new radio("Votre âge"); //On ajoute une liste de champs radio
$form->age->option("Enfant", "Entre 0 et 12 ans"); //Le nom de ce choix (celui renvoyé au script) sera
//"Enfant"
$form->age->option("Adolescent", "Entre 13 et 17 ans");
$form->age->option("Adulte", "Entre 17 et 59 ans", SELECTIONNE);
$form->age->option("Retraité", "60 ans et plus");
$form->age->classe("form_select");//On affecte à cet élément une classe (qui dans le cas présent n'existe
//pas) appelée "form_select". On aurai aussi pu écrire $form->age->attribut("class", "form_select");
$form->annuler = new reset("Annuler"); //Création d'un bouton reset
$form->bouton = new button("bouton inutile"); //On crée un bouton quelconque
//On pourrait ajouter $form->bouton->attribut("onclick", "fonction_particuliere();"); pour déclencher une
//fonction javascript quand on clique dessus.
//Et à la place de ce dernier, on pourrait mettre $form->bouton->js_clic("fonction_particuliere();)")
//ce qui serait la même chose
$form->valider = new submit("Enregistrer");
if(!empty($_POST)){
//La fonction $form->recuperer renvoie false si il y a eu des erreurs, et true sinon
//Si il manque des informations (il y a des erreurs), on re-crée le formulaire. On peut aussi renvoyer
//vers la page qui contient le formulaire
if(!$form->recuperer()){
echo $form->creer();
exit();
//Sinon, on peut continuer le script
}else{
//On récupère la valeur envoyée par le formulaire par la variable "attributs['value']"
$nom = $form->nom->valeur;
$animal = $form->animal->valeur;
/* ... */
//Exemple ridicule, pour vous prouver que ça a marché
echo "Vous avez entré le nom " . $nom;
}
} else {
//on crée simplement le formulaire
echo $form->creer();
}
?>
//Pour saisir toutes les possibilités de ce script, je vous conseille de regarder l'exemple 1 (celui-ci correspond à peu près à l'exemple 2), qui contient des options utilisées en plus et en moins de celui-ci.
Conclusion :
Remerciements à GRenard pour son commentaire à l'adresse
http://www.phpcs.com/code.aspx?ID=28354 qui m'a aidé en donnant quelques notions.
Je devrais pas mettre à jour de sitôt.
Prévenez-moi quand même si vous rencontrez par pur hasard des bugs.
Quelques idées à approfondir (je les mettrai en place, quand j'aurai le temps, ou vous pouvez le faire si l'envie vous en prend) :
Ajouter un tpe de champ date équivalent à 3 champs textes numériques (JJ/MM/AAAA) avec différentes options (affichage système Us ou fr par exemple).
Le script est compatible PHP4 et PHP5.
Attention, pour ceux qui utilisent PHP4, le fichier "config_formulaire.ini" doit impérativement être placé dans le dossier dans lequel se trouve le fichier appellant, c'est-à-dire dans le dossier où la page chargée par internet se trouve. Si vous voulez mettre dans un autre dossier, il faut changer la ligne 'parse_ini_file("config_formulaire.ini")' (environ la ligne 25) du fichier 'definitions.formulaire.php' en modifiant par la nouvelle adresse du fichier .ini.
Voilà, bon codage ;) .
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.