<?php

/**
 * Plugin générique de configuration pour SPIP
 *
 * @license    GNU/GPL
 * @package    plugins
 * @subpackage cfg
 * @category   outils
 * @copyright  (c) toggg, marcimat 2007-2008
 * @link       http://www.spip-contrib.net/
 * @version    $Id: cfg_formulaire.php 46896 2011-04-20 11:05:37Z marcimat@rezo.net $
 */

if (!defined("_ECRIRE_INC_VERSION")) return;


/**
 * la classe cfg represente une page de configuration
 *
 * @package    plugins
 * @subpackage cfg
 */
class cfg_formulaire{

	/**
	 * les parametres des formulaires cfg sont stockes dans cet objet
	 * @var Array 
	 */
	var $param;
	
	/**
	 * l'objet de classe cfg_depot qui assure lecture/ecriture/effacement des config
	 * @var <type> 
	 */
	var $depot = null;

	/**
	 * le fond html utilise , en general pour config simple idem $nom
	 * @var string 
	 */
	var $vue = '';

	/**
	 * l'adresse du fond html (sans l'extension .html)
	 * @var string 
	 */
	var $path_vue = '';

	/**
	 * provient-on d'un formulaire de type CVT (charger/verifier/traiter) dans formulaires/ ?
	 * @var boolean
	 */
	var $depuis_cvt = false;

	/**
	 * compte-rendu des mises a jour
	 * @var Array
	 */
	var $messages = array('message_ok'=>array(), 'message_erreur'=>array(), 'erreurs'=>array());

	/**
	 * les champs trouve dans le fond
	 * @var Array
	 */
	var $champs = array();

	/**
	 * les champs index
	 * @var Array
	 */
	var $champs_id = array();

	/**
	 * leurs valeurs
	 * @var Array
	 */
	var $val = array();

	/**
	 * pour tracer les valeurs modifiees
	 * @var string
	 */
	var $log_modif = '';

	/**
	 * contenu du fichier de formulaire
	 * @var string
	 */
	var $controldata ='';

	/**
	 * stockage du fond compile par recuperer_fond()
	 * @var <type>
	 */
	var $fond_compile = '';

	/**
	 * y a t-il des extensions (classes css 'type_{nom}' ou 'cfg_{nom}' sur champs) a traiter ?
	 * @var Array
	 */
	var $extensions = array();

	/**
	 * Alias pour passer facilement les parametres aux classes appelees
	 * @var Array
	 */
	var $params = array();

	/**
	 * Constructeur de la classe
	 * 
	 * @param string $nom
	 * @param string $cfg_id
	 * @param Array $opt 
	 */
	function cfg_formulaire($nom, $cfg_id = '', $opt = array())
	{
		$this->param = array(
			'afficher_messages' => true, // afficher ce compte rendu ?
			'autoriser' => 'configurer',	// le "faire" de autoriser($faire), par defaut, autoriser_configurer_dist()	
			'autoriser_absence_id' => 'non', // autoriser l'insertion de nouveau contenu dans une table sans donner d'identifiant ?
			'casier' => '', // sous tableau optionel du meta ou va etre stocke le fragment de config
			'cfg_id' => '', // pour une config multiple , l'id courant
			'descriptif' => '', // descriptif
			'depot' => 'metapack', // (ancien 'storage') le depot utilise pour stocker les donnees, par defaut metapack: spip_meta serialise 
			'fichier' => '', // pour storage php, c'est l'adresse du fichier (depuis la racine de spip), sinon ca prend /local/cfg/nom.php
			'gauche' => '', // pour une colonne à gauche
			'head' => '', // partie du fond cfg a inserer dans le head par le pipeline header_prive (todo insert_head?)
			'icone' => '', // lien pour une icone
			'inline' => '', // code qui sera insere apres le contenu du fond (peut servir pour inserer du js)
			'interpreter' => 'oui', // si interpreter vaut 'non', le fond ne sera pas traite comme un fond cfg, mais comme une inclusion simple (pas de recherche des champs de formulaires). Cela permet d'utiliser des #FORMULAIRES_XX dans un fonds/ tout en utilisant la simplicite des parametres <!-- liens=.. --> par exemple.
			'liens' => array(), // liens optionnels sur des sous-config <!-- liens*=xxx -->
			'liens_multi' => array(), // liens optionnels sur des sous-config pour des fonds utilisant un champ multiple  <!-- liens_multi*=xxx -->
			'nom' => '', // le nom du meta (ou autre) ou va etre stocke la config concernee
			'onglet' => 'oui', // cfg doit-il afficher un lien vers le fond sous forme d'onglet dans la page ?exec=cfg
			'presentation' => 'auto', // cfg doit-il encadrer le formulaire tout seul ?
			'refus' => '', // en cas de refus d'autorisation, un message informatif [(#REM) refus=...]
			'table' => '', // nom de la table sql pour storage extra ou table
		);
		$this->param['nom'] = $this->vue = $nom;
		$this->param['cfg_id'] = $cfg_id;

		// exception flagrante : le formulaire 'configurer'
		// si c'est un formulaire generique, le nom et l'id ne sont pas bon.
		if ($this->vue == 'configurer') {
			$this->param['nom'] = $cfg_id;
			$this->param['cfg_id'] = '';
		}
				
		// definition de l'alias params
		$this->params = array(
			'champs' => &$this->champs, 
			'champs_id' => &$this->champs_id,
			'messages' => &$this->messages,
			'val' => &$this->val,
			'param' => &$this->param
		);	
		
		foreach ($opt as $o=>$v) {
			$this->$o = $v;
		}    
		// charger les donnees du fond demande
		$this->charger();
	}
	
	/**
	 * retourne true en cas d'erreur...
	 * 
	 * @return boolean 
	 */
	function erreurs(){
		return $this->messages['erreurs'] || $this->messages['message_erreur'];
	}

	/**
	 * ajoute une erreur sur un champ donne
	 * 
	 * @param string $champ
	 * @param string $message 
	 */
	function ajouter_erreur($champ, $message) {
		$this->messages['erreurs'][$champ] = isset($this->messages['erreurs'][$champ]) 
			? $this->messages['erreurs'][$champ] .= '<br />' . $message
			: $message;
	}
	
	/**
	 * ajoute des erreurs sur les champs indiques dans le tableau
	 * (comme verifier de cvt)
	 * 
	 * @param Array $err
	 * @return boolean 
	 */
	function ajouter_erreurs($err) {
		if (!is_array($err)) return false;
		if (isset($err['message_erreur']) && $err['message_erreur']) 
			$this->messages['message_erreur'][] = $err['message_erreur'];
		if (isset($err['message_ok']) && $err['message_ok']) 	
			$this->messages['message_ok'][] = $err['message_ok'];
		unset($err['message_erreur'], $err['message_ok']);
		if ($err) $this->messages['erreurs'] = $err;		// ou un merge ?? //
		return true;
	}
	
	
	/**
	 * pre-analyser le formulaire,
	 * c'est a dire recuperer les parametres CFG 
	 * et les noms des champs du formulaire	
	 * 
	 * @return boolean 
	 */
	function charger(){
		$ok = true;
		
		// si pas de fichier, rien a charger
		if (!$this->vue) return false;

		// lecture de la vue (fond cfg)
		// il s'agit de recuperer le contenu du fichier
 		if (!$fichier = find_in_path($nom = 'fonds/cfg_' . $this->vue .'.html')){
			if ($fichier = find_in_path($nom = 'formulaires/' . $this->vue .'.html'))
				$this->depuis_cvt = true;
		}
		
		// si pas de fichier, rien a charger
		if (!$fichier) return false;
		
		if (!lire_fichier($fichier, $this->controldata)) {
			$ok = false;
			$this->messages['message_erreur'][] =  _T('cfg:erreur_lecture', array('nom' => $nom));
		} else {
			$this->path_vue = substr($fichier,0,-5);
		}		

		// recherche et stockage des parametres de cfg 
		$this->recuperer_parametres();

		// si le fond ne doit pas etre calcule comme un fond CFG,
		// on s'arrete ici. De cette maniere, CFG ne prendra pas
		// comme des champs a recuperer les champs issus d'un autre formulaire
		// CFG inclu depuis un formulaire CVT via #FORMULAIRE_XX
		if ($this->param['interpreter'] == 'non')
			return true;
			
		// recherche et stockage des noms de champs de formulaire
		if ($err = $this->recuperer_noms_champs()){
			$ok = false;
			$this->messages['message_erreur'][] = $err;
		}
	    
		// charger les champs particuliers si existants
		$this->actionner_extensions('pre_charger');	  
		  
		// creer le storage et lire les valeurs
		$this->param['depot'] = strtolower(trim($this->param['depot']));
		include_spip('inc/cfg_config');
		$this->depot = new cfg_depot($this->param['depot'], $this->params);
		$ok &= $this->lire();

		// charger les champs particuliers si existants
		$this->actionner_extensions('charger');
		
		return $ok;
	}

	/**
	 * Doit controler la validite des valeurs transmises
	 * 
	 * Verifie les valeurs postees.
	 * - stocke les valeurs qui ont changees dans $this->val[$nom_champ] = 'nouvelle_valeur'
	 * - verifie que les types de valeurs attendus sont corrects ($this->verifier_champs_types)
	 * 
	 * retourne les messages d'erreur
	 * @return boolean|string 
	 */
	function verifier() {

		if ($this->erreurs() || !$this->autoriser()) 
				return false;

		// si on a pas poste de formulaire, pas la peine de controler
		// ce qui mettrait de fausses valeurs dans l'environnement
		if  (!_request('_cfg_ok') && !_request('_cfg_delete')) return true;

		// les formulaires CVT ont deja leurs securites
		if (!$this->depuis_cvt) {
			$securiser_action = charger_fonction('securiser_action', 'inc');
			$securiser_action();
		}

		// actions par champs speciaux, avant les tests des nouvelles valeurs
		$this->actionner_extensions('pre_verifier');
		
		// stockage des nouvelles valeurs
		foreach ($this->champs as $name => $def) {
			// enregistrement des valeurs postees
			$oldval = $this->val[$name];
		    $this->val[$name] = _request($name);
		    
		    // tracer les modifications
		    if ($oldval != $this->val[$name]) {
		    	$this->log_modif .= $name . ':' . var_export($oldval, true) . '/' . var_export($this->val[$name], true) .', ';
		    }
		}
	    
		// si pas de changement, pas la peine de continuer
		if (!$this->log_modif && !_request('_cfg_delete')) {
			$this->messages['message_erreur'][] = _T('cfg:pas_de_changement', array('nom' => $this->nom_config()));
			return false;
		}
		
		// verifier la validite des champs speciaux (cfg_xx, type_xx)
		$this->actionner_extensions('verifier');
		
		// stocker le fait que l'on a controle les valeurs
		$this->verifier = true;
	    return !$this->erreurs();
	}
	
	/**
	 * Gere le traitement du formulaire.
	 * 
	 * Si le chargement ou le controle n'ont pas ete fait,
	 * la fonction s'en occupe.
	 *
	 * @return boolean
	 */
	function traiter()
	{
		if (!$this->verifier) $this->verifier();
		
		if ($this->erreurs() || !$this->autoriser()) return false;
	
		if (!_request('_cfg_ok') && !_request('_cfg_delete')) return false;
		
		// les formulaires CVT ont deja leurs securites
		if (!$this->depuis_cvt) {
			$securiser_action = charger_fonction('securiser_action', 'inc');
			$securiser_action();
		}
		
		$this->actionner_extensions('pre_traiter');	
		
		if ($this->erreurs()) return false;		
			
		// suppression
		if (_request('_cfg_delete')) {
			$this->effacer();
		
		// sinon modification
		} else {
			$this->ecrire();
		}

		// pipeline 'cfg_post_edition' ? (quelqu'un utilise ??)
		$this->messages = pipeline('cfg_post_edition',array('args'=>array('nom_config'=>$this->nom_config()),'data'=>$this->messages));

		$this->actionner_extensions('post_traiter');

		// annuler le cache de SPIP
		include_spip('inc/invalideur');
		suivre_invalideur('cfg/' . $this->param['nom'] .
			($this->param['casier'] ? '/' . $this->param['casier'] : '') .
			($this->param['cfg_id'] ? '/' . $this->param['cfg_id'] : ''));		
	}

	/**
	 * Determine l'arborescence ou CFG doit chercher les valeurs deja enregistrees
	 * 
	 * si nom=toto, casier=chose/truc, cfg_id=2, 
	 * cfg cherchera dans #CONFIG{toto/chose/truc/2}
	 *
	 * @return string
	 */
	function nom_config()
	{
	    return $this->param['nom'] . 
	    		($this->param['casier'] ? '/' . $this->param['casier'] : '') .
	    		($this->param['cfg_id'] ? '/' . $this->param['cfg_id'] : '');
	}

	/**
	 * Recherche et stockage
	 * des parametres #REM passes a CFG
	 * 
	 * @deprecated (DEPRECIE)
	 */
	function recuperer_parametres_rem(){
		// cas de #REM (deprecie)
		preg_replace_callback('/(\[\(#REM\) ([a-z0-9_]\w+)(\*)?=)(.*?)\]/sim',
					array(&$this, 'post_params'), $this->controldata);
	}

	/**
	 * cette fonction recherche et stocke les parametres passes a cfg par <!-- param=valeur -->
	 * ces lignes sont alors effacees du code html. Ces proprietes sont lues apres recuperer_fond(),
	 * et interpretent donc les balises spip et les chaines de langues
	 *
	 * si la fonction est appelee 2 fois, les parametres identiques ne seront pas copies
	 * sauf si le parametre est un tableau (<!-- param*=valeur -->), les valeurs seront dupliquees
	 */
	function recuperer_parametres(){

		// pour compatibilite, recuperer l'ancien code #REM
		$this->recuperer_parametres_rem();	
		
		$this->recuperer_fond();
		$this->fond_compile = preg_replace_callback('/(<!-- ([a-z0-9_]\w+)(\*)?=)(.*?)-->/sim',
							array(&$this, 'post_params'), $this->fond_compile);

		// s'il en reste : il y a un probleme !
		// est-ce utile de tester ça ?
		if (preg_match('/<!-- [a-z0-9_]\w+\*?=/', $this->fond_compile)) {
			die('Un parametre CFG n\'a pas pu etre importe depuis '.$this->vue);
		}

		// pour compatibilite avec les anciennes versions (<1.4.1)
		if (isset($this->param['storage'])) 
			$this->param['depot'] = $this->param['storage'];
		
		if ($this->param['depot'] == 'classic')
			$this->param['depot'] = 'meta';
			
		if ($this->param['depot'] == 'extrapack'){
			$this->param['depot'] = 'tablepack';
			$this->param['colonne'] = 'extra';
			$this->param['table'] = 'spip_auteurs';
		}
		
		// definir les parametres qui sont a traiter comme des extensions
		// il faut que le parametre ne soit pas vide et qu'un fichier 
		// /cfg/params/{param}.php existe
		$this->extensions_parametres = array();
		foreach ($this->param as $nom=>$val){
			if ($val) $this->ajouter_extension_parametre($nom);		
		}
	}

	/**
	 * une fonction pour effacer les parametres du code html
	 * ce qui evite de dupliquer les tableaux 
	 * (si on utilisait recuperer_parametres() a la place)
	 */
	function effacer_parametres(){
		$this->fond_compile = preg_replace('/(<!-- ([a-z0-9_]\w+)(\*)?=)(.*?)-->/sim', '', $this->fond_compile);		
	}
	
	/**
	 * Recherche  des noms des champs (y) du formulaire <input type="x" name="y"... />
	 * stockes dans le tableau $this->champs
	 * a l'exception des noms par _cfg_, reserves a ce plugin
	 *
	 * @return string
	 */
	function recuperer_noms_champs(){	
		if (!$this->vue) return;

		// recherche d'au moins un champ de formulaire pour savoir si la vue est valide
		$this->recuperer_fond();
		if (!preg_match_all(
		/*  '#<(?:(select|textarea)|input type="(text|password|checkbox|radio|hidden|file)") name="(\w+)(\[\])?"(?: class="[^"]*?(?:type_(\w+))?[^"]*?(?:cfg_(\w+))?[^"]*?")?( multiple=)?[^>]*?>#ims', */
		  '#<(?:(select|textarea)|input type="(text|password|checkbox|radio|hidden|file)") name="(\w+)(\[\])?"(?: class="([^"]*)")?( multiple=)?[^>]*?>#ims',
						$this->fond_compile, $matches, PREG_SET_ORDER)) {
			return _T('cfg:pas_de_champs_dans', array('nom' => $this->vue));
		}
		
		foreach ($matches as $regs) {
			$name = $regs[3];
			if (substr($name, 0, 5) == '_cfg_') continue;

			$this->champs[$name] = array('balise' => $regs[1]); 
			// input type
		    if ($regs[2]) $this->champs[$name]['type'] = $regs[2];
		    // champs tableau[]
			if ($regs[4]) $this->champs[$name]['tableau'] = true;

			//
			// Extensions et validations des champs
			// via les classes css
			//
			// attention : ordre important : <balise (type="xx")? name="xx" class="xx" multiple="xx" />
			//
			if ($regs[5]) {
				$tcss = explode(' ',trim($regs[5]));
				foreach($tcss as $css){
					// classes css type_xx
					if (substr($css,0,5)=='type_') {
						$this->ajouter_extension($css, $name);
					// classes css cfg_xx
					} elseif (substr($css,0,4)=='cfg_') {
						$this->champs[$name]['cfg'] = substr($css,4); // juste 'id' si classe = cfg_id
						$this->ajouter_extension($css, $name);
					}
				}
			}
			
			// cas particulier automatiques : 
			// * input type file => type de verification : fichier
			if (($regs[2] == 'file') AND (!$this->champs[$name]['cfg'])){
				$this->champs[$name]['cfg'] = 'fichier';
				$this->ajouter_extension('cfg_fichier', $name);	
			}
			
	    }

	    return '';
	}	 
	
	/**
	 * ajoute une extension (classe cfg_xx ou type_xx) 
	 * 
	 * ce qui dit a cfg d'executer des fonctions particulieres
	 * si elles existent : ex: cfg_traiter_cfg_xx()
	 * lors de l'appel de 'actionner_extensions($faire)'
	 *
	 * @param string $ext
	 * @param string $nom
	 */
	function ajouter_extension($ext, $nom){
		if (!is_array($this->extensions[$ext])) $this->extensions[$ext] = array();
		$this->extensions[$ext][] = $nom;	
	}

	/**
	 * ajoute une extension sur un parametre
	 * seulement si un fichier sur ce parametre existe
	 *
	 * @param string $param
	 * @return boolean
	 */
	function ajouter_extension_parametre($param){
		if (in_array($param, $this->extensions_parametres))
			return true;
		
		if (find_in_path('cfg/params/'.$param.'.php')){
			$this->extensions_parametres[] = $param;
			return true;
		}
		return false;
	}
	
	/**
	 * Compiler le fond CFG si ce n'est pas fait
	 * 
	 * @param Array $contexte
	 * @param boolean $forcer
	 * @return string
	 */
	function recuperer_fond($contexte = array(), $forcer = false){

		if (!$this->fond_compile OR $forcer){
			include_spip('inc/presentation'); // offrir les fonctions d'espace prive
			include_spip('public/assembler');
			
			// rendre editable systematiquement
			// sinon, ceux qui utilisent les fonds CFG avec l'API des formulaires dynamiques
			// et mettent des [(#ENV**{editable}|oui) ... ] ne verraient pas leurs variables
			// dans l'environnement vu que CFG ne pourrait pas lire les champs du formulaire

			if ($this->depuis_cvt)
				if (!isset($contexte['editable'])) $contexte['editable'] = true; // plante 1.9.2 !!
		
			// passer cfg_id...
			if (!isset($contexte['cfg_id']) && $this->param['cfg_id']) {
				$contexte['cfg_id'] = $this->param['cfg_id'];
			}
			// passer id aussi
			if (!isset($contexte['id']) && $this->param['cfg_id']) {
				$contexte['id'] = $this->param['cfg_id'];
			}
			// passer 'message_ok', 'message_erreur', 'erreurs'	
			if (!isset($contexte['message_ok']) && $this->messages['message_ok']) {
				$contexte['message_ok'] = join('<br />',$this->messages['message_ok']);
			}
			if (!isset($contexte['message_erreur']) && $this->messages['message_erreur']) {
				$contexte['message_erreur'] = join('<br />',$this->messages['message_erreur']);
			}
			if (!isset($contexte['erreurs']) && $this->messages['erreurs']) {
				$contexte['erreurs'] = $this->messages['erreurs'];
			}

			// cas particulier du formulaire generique 'configurer'
			if ($this->vue == 'configurer') {
				if (!isset($contexte['id'])) {
					$contexte['id'] = $this->param['nom'];
				}
			}
						
			$val = $this->val ? array_merge($contexte, $this->val) : $contexte;
	
			// si on est dans l'espace prive, $this->path_vue est
			// de la forme ../plugins/mon_plugin/fonds/toto, d'ou le replace
			$this->fond_compile = recuperer_fond(
				substr($this->path_vue, strlen(_DIR_RACINE)), $val);
		}
		return $this->fond_compile;
	}

	/**
	 * Verifie les autorisations 
	 * d'affichage du formulaire
	 * (parametre autoriser=faire)
	 *
	 * @staticvar int $autoriser
	 * @return int
	 */
	function autoriser()
	{
		static $autoriser=-1;
		if ($autoriser !== -1) return $autoriser;

		// on peut passer 'oui' ou 'non' directement au parametre autoriser
		if ($this->param['autoriser'] == 'oui')
			return $autoriser = 1;
		if ($this->param['autoriser'] == 'non') {
			$this->messages['message_refus'] = $this->param['refus'];
			return $autoriser = 0;
		}
		// sinon, test de l'autorisation
		// <!-- autoriser=webmestre -->
		// <!-- autoriser=configurer -->
		include_spip('inc/autoriser');
		if (!$autoriser = autoriser($this->param['autoriser'])){
			$this->messages['message_refus'] = $this->param['refus'];
		}
		return $autoriser;
	}

	/**
	 * Log le message passe en parametre
	 * $this->log('message');
	 *
	 * @param string $message
	 */
	function log($message)
	{
		($GLOBALS['auteur_session'] && ($qui = $GLOBALS['auteur_session']['login']))
		|| ($qui = $GLOBALS['ip']);
		spip_log('cfg (' . $this->nom_config() . ') par ' . $qui . ': ' . $message);
	}

	/**
	 * lit les donnees depuis le depot
	 * 
	 * @return boolean
	 */
	function lire(){
		list ($ok, $val, $messages) = $this->depot->lire($this->params);
		if ($messages) $this->messages = $messages;
		if ($ok) {
			$this->val = $val;	
		} else {
			$this->messages['message_erreur'][] = _T('cfg:erreur_lecture', array('nom' => $this->nom_config()));
		}
		return $ok;
	}
	
	
	/**
	 * Ecrit les donnees dans le depot
	 *
	 * @return string
	 */
	function ecrire() {
		list ($ok, $val, $messages) = $this->depot->ecrire($this->params);
		if ($messages) $this->messages = $messages;
		if ($ok){
			$this->val = $val;
			$this->messages['message_ok'][] = $msg = _T('cfg:config_enregistree', array('nom' => $this->nom_config()));
		} else {
			$this->messages['message_erreur'][] = $msg =  _T('cfg:erreur_enregistrement', array('nom' => $this->nom_config()));
		}
		$this->log($msg . ' ' . $this->log_modif);
		return $msg;
	}

	/**
	 * Efface les donnees dans le depot
	 *
	 * dans le cas d'une suppression, il faut vider $this->val qui
	 * contient encore les valeurs du formulaire, sinon elles sont
	 * passees dans le fond et le formulaire garde les informations
	 * d'avant la suppression
	 *
	 * @return string
	 */
	function effacer(){
		list ($ok, $val, $messages) = $this->depot->effacer($this->params);
		if ($messages) $this->messages = $messages;
		if ($ok) {
			$this->val = $val;
			$this->messages['message_ok'][] = $msg = _T('cfg:config_supprimee', array('nom' => $this->nom_config()));
		} else {
			$this->messages['message_erreur'][] = $msg = _T('cfg:erreur_suppression', array('nom' => $this->nom_config()));
		}
		$this->log($msg);	
		return $msg;	
	}

	/**
	 * Fabriquer les balises des champs d'apres un modele fonds/cfg_<driver>.html
	 * $contexte est un tableau (nom=>valeur)
	 * qui sera enrichi puis passe a recuperer_fond
	 *
	 * @param Array $contexte
	 * @return string
	 */
	function formulaire($contexte = array())
	{
		if (!$this->path_vue)
			return '';

		if (!$this->depuis_cvt)
			$contexte['_cfg_'] = $this->creer_hash_cfg();
	
		// recuperer le fond avec le contexte
		// forcer le calcul.
		$this->recuperer_fond($contexte, true);
		$this->recuperer_parametres();
		//$this->effacer_parametres(); // pour enlever les <!-- param=valeur --> ... sans dedoubler le contenu lorsque ce sont des tableau (param*=valeur)
		return $this->fond_compile;
	}
	
	
	/**
	 *
	 * @param string $action
	 * @return string
	 */
	function creer_hash_cfg($action=''){
		include_spip('inc/securiser_action');
	    $arg = 'cfg0.0.0-' . $this->param['nom'] . '-' . $this->vue;
		return 
			'?cfg=' . $this->vue .
			'&cfg_id=' . $this->param['cfg_id'] .
		    '&arg=' . $arg .
		    '&hash=' .  calculer_action_auteur($action . '-' . $arg);		
	}
	
	
	/**
	 * teste et charge les points d'entrees de CFG a travers certaines actions
	 *
	 * <ol>
	 * <li> : fonctions generales cfg_{nom}_{action}</li>
	 * <li> : actions sur les types de champs particuliers
	 *     notifies par 'type_XX' ou 'cfg_YY' sur les classes css
	 *     s'ils existent dans /cfg/classes/ par des fonctions
	 *     cfg_{action}_{classe}</li>
	 * <li> : actions en fonctions des parametres du formulaire
	 *     s'ils existent dans /cfg/params/ par des fonctions
	 *     cfg_{action}_{parametre}</li>
	 * </ol>
	 *
	 * les actions possibles sont :
	 * - pre_charger, charger,
	 * - pre_verifier, verifier,
	 * - pre_traiter, post_traiter
	 *
	 * @param string $action
	 */
	function actionner_extensions($action){
		// 1 - general : on transmet l'instance de cfg_formulaire
		if (function_exists($f = 'cfg_' . $this->vue . '_' . $action)) {
			$res = $f($this);
			// compat ascendante (1.7 a 1.10.2) : verifier retournait un array comme cvt
			// il faut envoyer le resultat dans la fonction d'ajout des erreurs
			if ($action == 'verifier' AND is_array($res))
				$this->ajouter_erreurs($res);
		} 
		// 2 - type de champ : on transmet le nom du champ et l'instance de cfg_formulaire
		if ($this->extensions) {
			foreach ($this->extensions as $type => $champs){
				// si un fichier de ce type existe, on lance la fonction 
				// demandee pour chaque champs possedant la classe css en question
				if (include_spip('cfg/classes/'.$type)) {
					foreach ($champs as $champ){
						if (function_exists($f = 'cfg_' . $action . '_' . $type)){ // absence possible normale
							$f($champ, $this);
						}
					}
				}	
			}
		}
		// 3 - parametre : on transmet la valeur du parametre et l'instance de cfg_formulaire
		if ($this->extensions_parametres){
			foreach ($this->extensions_parametres as $param){
				if (include_spip('cfg/params/'.$param)) {
					if (function_exists($f = 'cfg_' . $action . '_param_' . $param)){ // absence possible normale
						// artillerie lourde on passe
						// la valeur et la classe
						$f($this->param[$param], $this);						
					}
				}
			}
		}
	}
	
	/**
	 *callback pour interpreter les parametres objets du formulaire
	 * commun avec celui de set_vue()
	 *
	 * Parametres :
	 * - $regs[2] = 'parametre'
	 * - $regs[3] = '*' ou ''
	 * - $regs[4] = 'valeur'
	 *
	 * Lorsque des parametres sont passes dans le formulaire
	 * par <!-- param=valeur --><br>
	 * stocker $this->param['parametre']=valeur
	 *
	 * Si <!-- param*=valeur --><br>
	 * Stocker $this->param['parametre'][]=valeur
	 *
	 * @param Array $regs
	 * @return string
	 */
	function post_params($regs) {

		// $regs[3] peut valoir '*' pour signaler un tableau
		$regs[4] = trim($regs[4]);
		
		if (empty($regs[3])) {
		    $this->param[$regs[2]] = $regs[4];
		} elseif (is_array($this->param[$regs[2]])) {
		    $this->param[$regs[2]][] = $regs[4];
		}
		// plus besoin de garder ca
		return '';
	}
}

?>