CLASSE POUR FORMULAIRE HTML : GÉNÉRATION ET RÉCUPÉRATION DES DONNÉES

//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.