www/plugins/saisies/balise/saisie.php

   1 <?php
   2
   3 if (!defined("_ECRIRE_INC_VERSION")) return;
   4
   5 // pour ne pas interferer avec d'eventuelles futures fonctions du core
   6 // on met le tout dans un namespace ; les fonctions sont autonomes.
   7
   8 class Pile {
   9
  10
  11         // les arguments sont dans l'entree 0 du tableau param.
  12         // param[0][0] vaut toujours '' (ou presque ?)
  13         static function recuperer_argument_balise($pos, $p) {
  14                 if (!isset($p->param[0])) {
  15                         return null;
  16                 }
  17                 if (!isset($p->param[0][$pos])) {
  18                         return null;
  19                 }
  20                 return $p->param[0][$pos];
  21         }
  22
  23
  24
  25         // les arguments sont dans l'entree 0 du tableau param.
  26         // param[0][0] vaut toujours '' (ou presque ?)
  27         static function supprimer_argument_balise($pos, $p) {
  28                 if (!isset($p->param[0])) {
  29                         return null;
  30                 }
  31                 if (!isset($p->param[0][$pos])) {
  32                         return null;
  33                 }
  34                 if ($pos == 0) {
  35                         array_shift($p->param[0]);
  36                 } else {
  37                         $debut = array_slice($p->param[0], 0, $pos);
  38                         $fin   = array_slice($p->param[0], $pos+1);
  39                         $p->param[0] = array_merge($debut, $fin);
  40                 }
  41                 return $p;
  42         }
  43
  44
  45
  46         static function recuperer_et_supprimer_argument_balise($pos, &$p) {
  47                 $arg = Pile::recuperer_argument_balise($pos, $p);
  48                 $p   = Pile::supprimer_argument_balise($pos, $p);
  49                 return $arg;
  50         }
  51
  52
  53
  54
  55         // les arguments sont dans l'entree 0 du tableau param.
  56         // param[0][0] vaut toujours '' (ou presque ?)
  57         static function ajouter_argument_balise($element, $p) {
  58                 if (isset($p->param[0][0])) {
  59                         $zero = array_shift($p->param[0]);
  60                         array_unshift($p->param[0], $element);
  61                         array_unshift($p->param[0], $zero);
  62                 } else {
  63                         if (!is_array($p->param[0])) {
  64                                 $p->param[0] = array();
  65                         }
  66                         array_unshift($p->param[0], $element);
  67                 }
  68                 return $p;
  69         }
  70
  71
  72
  73         // creer_argument_balise(nom) = {nom}
  74         // creer_argument_balise(nom, 'coucou') = {nom=coucou}
  75         // creer_argument_balise(nom, $balise) = {nom=#BALISE}
  76         static function creer_argument_balise($nom, $valeur = null) {
  77                 include_spip('public/interfaces');
  78                 $s = new Texte;
  79                 $s->texte = $nom;
  80                 $s->ligne=0;
  81
  82                 // si #BALISE cree avec Pile::creer_balise(), le mettre en array, comme les autres
  83                 if (is_object($valeur)) {
  84                         $valeur = array($valeur);
  85                 }
  86
  87                 $res = null;
  88
  89                 // {nom}
  90                 if (is_null($valeur)) {
  91                         $res = array($s);
  92                 }
  93                 // {nom=coucou}
  94                 elseif (is_string($valeur)) {
  95                         $s->texte .= "=$valeur";
  96                         $res = array($s);
  97                 }
  98                 // {nom=#BALISE}
  99                 elseif (is_array($valeur)) {
 100                         $s->texte .= "="; // /!\ sans cette toute petite chose, ça ne fait pas d'egalite :)
 101                         $res = array_merge(array($s), $valeur);
 102                 }
 103
 104                 return $res;
 105         }
 106
 107
 108
 109         static function creer_et_ajouter_argument_balise($p, $nom, $valeur = null) {
 110                 $new = Pile::creer_argument_balise($nom, $valeur);
 111                 return Pile::ajouter_argument_balise($new, $p);
 112         }
 113
 114
 115
 116         // creer une balise
 117         static function creer_balise($nom, $opt) {
 118                 include_spip('public/interfaces');
 119                 $b = new Champ;
 120                 $b->nom_champ = strtoupper($nom);
 121                 $vars = get_class_vars('Champ'); // property_exists($b, $o); est en php 5
 122                 foreach ($opt as $o=>$val) {
 123                         #if (property_exists($b,$o)) {
 124                         if (array_key_exists($o, $vars)) {
 125                                 if ($o == 'param') {
 126                                         array_unshift($val, '');
 127                                         $b->$o = array($val);
 128                                 } else {
 129                                         $b->$o = $val;
 130                                 }
 131                         }
 132                 }
 133                 return $b;
 134         }
 135 }
 136
 137
 138
 139 /*
 140  * #saisie{type,nom} : champs obligatoires
 141  *
 142  * collecte des arguments en fonctions du parametre "nom"
 143  * ajoute des arguments
 144  * appelle #INCLURE avec les arguments collectes en plus
 145  *
 146  * il faudrait en faire une balise dynamique (?)
 147  * pour avoir un code plus propre
 148  * mais je n'ai pas reussi a trouver comment recuperer "valeur=#ENV{$nom}"
 149  *
 150  */
 151 function balise_SAISIE_dist ($p) {
 152
 153         // on recupere les parametres sans les traduire en code d'execution php
 154         $type_saisie = Pile::recuperer_et_supprimer_argument_balise(1, $p); // $type
 155         $titre       = Pile::recuperer_et_supprimer_argument_balise(1, $p); // $titre
 156
 157         // creer #ENV*{$titre} (* pour les cas de tableau serialises par exemple, que l'on veut reutiliser)
 158         $env_titre   = Pile::creer_balise('ENV', array('param' => array($titre), 'etoile' => '*')); // #ENV*{titre}
 159
 160         // on modifie $p pour ajouter des arguments
 161         // {nom=$titre, valeur=#ENV{$titre}, erreurs, type_saisie=$type, fond=saisies/_base}
 162         $p = Pile::creer_et_ajouter_argument_balise($p, 'nom', $titre);
 163         $p = Pile::creer_et_ajouter_argument_balise($p, 'valeur', $env_titre);
 164         $p = Pile::creer_et_ajouter_argument_balise($p, 'type_saisie', $type_saisie);
 165         $p = Pile::creer_et_ajouter_argument_balise($p, 'erreurs');
 166         $p = Pile::creer_et_ajouter_argument_balise($p, 'fond', 'saisies/_base');
 167
 168         // on appelle la balise #INCLURE
 169         // avec les arguments ajoutes
 170         if(function_exists('balise_INCLURE'))
 171                 return balise_INCLURE($p);
 172         else
 173                 return balise_INCLURE_dist($p);
 174
 175 }
 176
 177
 178
 179
 180 ?>