Changeset 97712 in spip-zone


Ignore:
Timestamp:
May 11, 2016, 9:40:24 AM (4 years ago)
Author:
kent1@…
Message:

PSR SPIP

Location:
_plugins_/saisies/trunk
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/saisies/trunk/action/deplacer_saisie.php

    r87651 r97712  
    66 * @package SPIP\Saisies\Action
    77 */
    8  
    9 if (!defined("_ECRIRE_INC_VERSION")) return;
     8
     9if (!defined('_ECRIRE_INC_VERSION')) {
     10        return;
     11}
    1012
    1113/**
     
    2527
    2628        if (!$formulaire_actuel) {
    27                 return "";
     29                return '';
    2830        }
    2931
    3032        include_spip('inc/saisies');
    31        
     33
    3234        $saisies_actuelles = saisies_lister_par_identifiant($formulaire_actuel);
    3335        if (!isset($saisies_actuelles[$identifiant])) {
    34                 return "";
     36                return '';
    3537        }
    3638
    3739        // tester @id et [@id] (fieldset)
    38         if ($ou and !isset($saisies_actuelles[$ou]) and !isset($saisies_actuelles[ substr($ou,1,-1) ])) {
    39                 return "";
     40        if ($ou and !isset($saisies_actuelles[$ou]) and !isset($saisies_actuelles[ substr($ou, 1, -1) ])) {
     41                return '';
    4042        }
    4143
     
    4648        $formulaire_actuel = session_set($session, $formulaire_actuel);
    4749}
    48 
  • _plugins_/saisies/trunk/balise/configurer_saisie.php

    r93018 r97712  
    77
    88// Sécurité
    9 if (!defined("_ECRIRE_INC_VERSION")) return;
     9if (!defined('_ECRIRE_INC_VERSION')) {
     10        return;
     11}
    1012
    1113/**
     
    1517 * @uses Pile::creer_et_ajouter_argument_balise()
    1618 * @see balise_INCLURE_dist()
    17  * 
     19 *
    1820 * @param Champ $p
    1921 * @return Champ
    2022**/
    21 function balise_CONFIGURER_SAISIE_dist($p){
     23function balise_CONFIGURER_SAISIE_dist($p) {
    2224
    2325        // On recupere le premier argument : le nom de la saisie
     
    4143
    4244}
    43 
    44 
  • _plugins_/saisies/trunk/balise/generer_saisies.php

    r93018 r97712  
    1 <?php 
     1<?php
    22
    33/**
     
    88
    99// Sécurité
    10 if (!defined("_ECRIRE_INC_VERSION")) return;
     10if (!defined('_ECRIRE_INC_VERSION')) {
     11        return;
     12}
    1113
    1214/**
     
    2527 * @uses Pile::creer_et_ajouter_argument_balise()
    2628 * @see balise_INCLURE_dist()
    27  * 
     29 *
    2830 * @param Champ $p
    2931 *     Pile au niveau de la balise
     
    3133 *     Pile complété du code à générer
    3234**/
    33 function balise_GENERER_SAISIES_dist($p){
     35function balise_GENERER_SAISIES_dist($p) {
    3436
    3537        // On recupere le premier (et seul) argument : le tableau decrivant ce qu'on veut generer
     
    5355
    5456}
    55 
  • _plugins_/saisies/trunk/balise/saisie.php

    r93018 r97712  
    77**/
    88
    9 if (!defined("_ECRIRE_INC_VERSION")) return;
     9if (!defined('_ECRIRE_INC_VERSION')) {
     10        return;
     11}
    1012
    1113// pour ne pas interferer avec d'eventuelles futures fonctions du core
     
    2123 *     déjà existantes.
    2224 *     Voir un exemple d'utilisation dans `balise_SAISIE_dist()`.
    23  * 
     25 *
    2426 * @note
    2527 *     Les arguments sont stockés sont dans l'entree 0 de la propriété `param`
    2628 *     dans l'objet Champ (représenté par `$p`), donc dans `$p->param[0]`.
    27  * 
     29 *
    2830 *     `param[0][0]` vaut toujours '' (ou presque ?)
    2931 *
     
    3537        /**
    3638         * Récupère un argument de balise
    37          * 
     39         *
    3840         * @param int $pos
    3941         * @param Champ $p
     
    6365                if (!isset($p->param[0][$pos])) {
    6466                        return null;
    65                 }       
     67                }
    6668                if ($pos == 0) {
    6769                        array_shift($p->param[0]);
     
    8082         * @uses Pile::recuperer_argument_balise()
    8183         * @uses Pile::supprimer_argument_balise()
    82          * 
     84         *
    8385         * @param int $pos
    8486         * @param Champ $p
     
    9698         *
    9799         * Empile l'argument à la suite des arguments déjà existants pour la balise
    98          * 
     100         *
    99101         * @param mixed $element Élément de l'AST représentant l'argument à ajouter
    100102         * @param Champ $p
     
    123125         *     $nom = Pile::creer_argument_balise(nom);           // {nom}
    124126         *     $nom = Pile::creer_argument_balise(nom, 'coucou'); // {nom=coucou}
    125          *     
     127         *
    126128         *     $balise = Pile::creer_balise('BALISE');
    127129         *     $nom = Pile::creer_argument_balise(nom, $balise);  // {nom=#BALISE}
    128130         *     ```
    129          * 
     131         *
    130132         * @param string $nom
    131133         *     Nom de l'argument
     
    139141                $s->texte = $nom;
    140142                $s->ligne=0;
    141                
     143
    142144                // si #BALISE cree avec Pile::creer_balise(), le mettre en array, comme les autres
    143145                if (is_object($valeur)) {
    144146                        $valeur = array($valeur);
    145147                }
    146                
     148
    147149                $res = null;
    148                
     150
    149151                // {nom}
    150152                if (is_null($valeur)) {
    151153                        $res = array($s);
    152                 }
    153                 // {nom=coucou}
    154                 elseif (is_string($valeur)) {
     154                } elseif (is_string($valeur)) {
     155                        // {nom=coucou}
    155156                        $s->texte .= "=$valeur";
    156157                        $res = array($s);
    157                 }
    158                 // {nom=#BALISE}
    159                 elseif (is_array($valeur)) {
    160                         $s->texte .= "="; // /!\ sans cette toute petite chose, ça ne fait pas d'egalite :)
     158                } elseif (is_array($valeur)) {
     159                        // {nom=#BALISE}
     160                        $s->texte .= '='; // /!\ sans cette toute petite chose, ça ne fait pas d'egalite :)
    161161                        $res = array_merge(array($s), $valeur);
    162162                }
     
    171171         * @uses Pile::creer_argument_balise()
    172172         * @uses Pile::ajouter_argument_balise()
    173          * 
     173         *
    174174         * @param Champ $p
    175175         * @param string $nom
     
    180180        **/
    181181        static function creer_et_ajouter_argument_balise($p, $nom, $valeur = null) {
    182                 $new = Pile::creer_argument_balise($nom, $valeur); 
     182                $new = Pile::creer_argument_balise($nom, $valeur);
    183183                return Pile::ajouter_argument_balise($new, $p);
    184184        }
     
    192192         *     ```
    193193         *     // Crée : #ENV*{titre}
    194          *     $titre = Pile::recuperer_argument_balise(1, $p); // $titre, 1er argument de la balise actuelle 
     194         *     $titre = Pile::recuperer_argument_balise(1, $p); // $titre, 1er argument de la balise actuelle
    195195         *     $env = Pile::creer_balise('ENV', array('param' => array($titre), 'etoile' => '*'));
    196196         *     ```
    197          * 
     197         *
    198198         * @param string $nom
    199199         *     Nom de la balise
     
    206206                $b = new Champ;
    207207                $b->nom_champ = strtoupper($nom);
    208                 foreach ($opt as $o=>$val) {
    209                         if (property_exists($b,$o)) {
     208                foreach ($opt as $o => $val) {
     209                        if (property_exists($b, $o)) {
    210210                                if ($o == 'param') {
    211211                                        array_unshift($val, '');
     
    230230 * La balise calcule une série de paramètre récupérer et à transmettre à `#INCLURE`,
    231231 * en fonction des valeurs des 2 premiers paramètres transmis.
    232  * 
     232 *
    233233 * Les autres arguments sont transmis tels quels à la balise `#INCLURE`.
    234234 *
     
    271271        }
    272272}
    273 
    274 
  • _plugins_/saisies/trunk/balise/voir_saisie.php

    r93018 r97712  
    99
    1010// Sécurité
    11 if (!defined("_ECRIRE_INC_VERSION")) return;
     11if (!defined('_ECRIRE_INC_VERSION')) {
     12        return;
     13}
    1214
    1315/**
     
    1517 *
    1618 * Cette balise incluera le squelette `saisies-vues/_base.html` et lui-même `saisies-vues/{type}.html`
    17  * 
     19 *
    1820 * @syntaxe `#VOIR_SAISIE{type,nom[,option=valeur,...]}`
    1921 * @uses Pile::recuperer_et_supprimer_argument_balise()
     
    2123 * @uses Pile::creer_balise()
    2224 * @see balise_INCLURE_dist()
    23  * 
     25 *
    2426 * @param Champ $p
    2527 * @return Champ
    2628 */
    27 function balise_VOIR_SAISIE_dist ($p) {
     29function balise_VOIR_SAISIE_dist($p) {
    2830
    2931        // on recupere les parametres sans les traduire en code d'execution php
     
    4345        // on appelle la balise #INCLURE
    4446        // avec les arguments ajoutes
    45         if(function_exists('balise_INCLURE')) {
     47        if (function_exists('balise_INCLURE')) {
    4648                return balise_INCLURE($p);
    4749        } else {
  • _plugins_/saisies/trunk/balise/voir_saisies.php

    r93018 r97712  
    1 <?php 
     1<?php
    22/**
    33 * Déclaration de la balise `#VOIR_SAISIES`
     
    77
    88// Sécurité
    9 if (!defined("_ECRIRE_INC_VERSION")) return;
     9if (!defined('_ECRIRE_INC_VERSION')) {
     10        return;
     11}
    1012
    1113/**
     
    1921 * - `#VOIR_SAISIES{#TABLEAU_DE_SAISIES}` est équivalent à
    2022 * - `#INCLURE{fond=inclure/voir_saisies,env,saisies=#TABLEAU_DE_SAISIES}`
    21  * 
     23 *
    2224 * @syntaxe `#VOIR_SAISIE{#TABLEAU_DE_SAISIES}`
    2325 * @uses Pile::recuperer_et_supprimer_argument_balise()
    2426 * @uses Pile::creer_et_ajouter_argument_balise()
    2527 * @see balise_INCLURE_dist()
    26  * 
     28 *
    2729 * @param Champ $p
    2830 *     Pile au niveau de la balise
     
    3032 *     Pile complété du code à générer
    3133**/
    32 function balise_VOIR_SAISIES_dist($p){
     34function balise_VOIR_SAISIES_dist($p) {
    3335
    3436        // On recupere les arguments : les tableaux decrivant ce qu'on veut generer + les reponses
     
    4749
    4850        // On redirige vers la balise INCLURE
    49         if(function_exists('balise_INCLURE')) {
     51        if (function_exists('balise_INCLURE')) {
    5052                return balise_INCLURE($p);
    5153        } else {
  • _plugins_/saisies/trunk/formulaires/construire_formulaire.php

    r97268 r97712  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
    5 
    6 function formulaires_construire_formulaire_charger($identifiant, $formulaire_initial=array(), $options=array()){
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
     7
     8function formulaires_construire_formulaire_charger($identifiant, $formulaire_initial = array(), $options = array()) {
    79        include_spip('inc/saisies');
    810        $contexte = array();
    9        
     11
    1012        // On ajoute un préfixe devant l'identifiant, pour être sûr
    1113        $identifiant = 'constructeur_formulaire_'.$identifiant;
    1214        $contexte['_identifiant_session'] = $identifiant;
    13        
    14         // On vérifie ce qui a été passé en paramètre
    15         if (!is_array($formulaire_initial)) $formulaire_initial = array();
    16        
     15
     16        // On vérifie ce qui a été passé en paramètre
     17        if (!is_array($formulaire_initial)) {
     18                $formulaire_initial = array();
     19        }
     20
    1721        // On initialise la session si elle est vide
    18         if (is_null($formulaire_actuel = session_get($identifiant))){
     22        if (is_null($formulaire_actuel = session_get($identifiant))) {
    1923                session_set($identifiant, $formulaire_initial);
    2024                $formulaire_actuel = $formulaire_initial;
    2125        }
    22        
     26
    2327        // Si le formulaire actuel est différent du formulaire initial on agite un drapeau pour le dire
    24         if ($formulaire_actuel != $formulaire_initial){
     28        if ($formulaire_actuel != $formulaire_initial) {
    2529                $contexte['formulaire_modifie'] = true;
    2630        }
    2731        $contexte['_message_attention'] = _T('saisies:construire_attention_modifie');
    28        
     32
    2933        // On passe ça pour l'affichage
    3034        $contexte['_contenu'] = $formulaire_actuel;
     
    3337        $contexte['_saisies_par_nom'] = saisies_lister_par_nom($formulaire_actuel);
    3438        // Pour déclarer les champs modifiables à CVT
    35         foreach(array_keys($contexte['_saisies_par_nom']) as $nom){
     39        foreach (array_keys($contexte['_saisies_par_nom']) as $nom) {
    3640                $contexte["saisie_modifiee_$nom"] = array();
    3741        }
    38        
     42
    3943        // La liste des saisies
    4044        $saisies_disponibles = saisies_lister_disponibles();
    4145        $contexte['_saisies_disponibles'] = $saisies_disponibles;
    42        
     46
    4347        // La liste des groupes de saisies
    44         $saisies_groupes_disponibles = saisies_groupes_lister_disponibles("saisies/groupes");
     48        $saisies_groupes_disponibles = saisies_groupes_lister_disponibles('saisies/groupes');
    4549        $contexte['_saisies_groupes_disponibles'] = $saisies_groupes_disponibles;
    46        
     50
    4751        $contexte['fond_generer'] = 'formulaires/inc-generer_saisies_configurables';
    48        
     52
    4953        // On cherche jquery UI pour savoir si on pourra glisser-déplacer
    5054        // SPIP 3.1 - jquery_ui
    51         if (find_in_path('javascript/ui/sortable.js') and find_in_path('javascript/ui/draggable.js')){
     55        if (find_in_path('javascript/ui/sortable.js') and find_in_path('javascript/ui/draggable.js')) {
    5256                $contexte['_chemin_ui'] = 'javascript/ui/';
    53         }
    54         // SPIP 3 - jquery_ui
    55         elseif (find_in_path('javascript/ui/jquery.ui.sortable.js') and find_in_path('javascript/ui/jquery.ui.draggable.js')){
     57        } elseif (find_in_path('javascript/ui/jquery.ui.sortable.js') and find_in_path('javascript/ui/jquery.ui.draggable.js')) {
     58                // SPIP 3 - jquery_ui
    5659                $contexte['_chemin_ui'] = 'javascript/ui/jquery.ui.';
    57         }
    58         else{
     60        } else {
    5961                $contexte['_chemin_ui'] = false;
    6062        }
     
    6365}
    6466
    65 function formulaires_construire_formulaire_verifier($identifiant, $formulaire_initial=array(), $options=array()){
     67function formulaires_construire_formulaire_verifier($identifiant, $formulaire_initial = array(), $options = array()) {
    6668        include_spip('inc/saisies');
    6769        $erreurs = array();
     
    7173        // Pas d'erreur si l'on ne demande rien
    7274        if (!($nom_ou_id = $configurer_saisie  = _request('configurer_saisie')
    73         OR    $nom_ou_id = $enregistrer_saisie = _request('enregistrer_saisie'))) {
     75                or $nom_ou_id = $enregistrer_saisie = _request('enregistrer_saisie'))) {
    7476                return $erreurs;
    7577        }
     
    9496                return $erreurs;
    9597        }
    96        
     98
    9799        // La liste des saisies
    98100        $saisies_disponibles = saisies_lister_disponibles();
    99        
     101
    100102        $saisie = $saisies_actuelles[$nom_ou_id];
    101103        $formulaire_config = $saisies_disponibles[$saisie['saisie']]['options'];
     
    103105        $formulaire_config = saisie_identifier(array('saisies'=>$formulaire_config));
    104106        $formulaire_config = $formulaire_config['saisies'];
    105        
     107
    106108        // Si la saisie possede un identifiant, on l'ajoute
    107109        // au formulaire de configuration pour ne pas le perdre en route
     
    118120                );
    119121        }
    120        
     122
    121123        // S'il y a l'option adéquat, on ajoute le champ pour modifier le nom
    122124        if (isset($options['modifier_nom']) and $options['modifier_nom']
    123           and $chemin_nom = saisies_chercher($formulaire_config, "saisie_modifiee_${nom}[options][description]", true))
    124         {
     125                and $chemin_nom = saisies_chercher($formulaire_config, "saisie_modifiee_${nom}[options][description]", true)) {
    125126                $chemin_nom[] = 'saisies';
    126127                $chemin_nom[] = '0';
     
    152153
    153154        // S'il y a un groupe "validation" alors on va construire le formulaire des vérifications
    154         if ($chemin_validation = saisies_chercher($formulaire_config, "saisie_modifiee_${nom}[options][validation]", true)){
     155        if ($chemin_validation = saisies_chercher($formulaire_config, "saisie_modifiee_${nom}[options][validation]", true)) {
    155156                include_spip('inc/verifier');
    156157                $liste_verifications = verifier_lister_disponibles();
    157158                $chemin_validation[] = 'saisies';
    158159                $chemin_validation[] = 1000000; // à la fin
    159                
     160
    160161                // On construit la saisie à insérer et les fieldset des options
    161162                $saisie_liste_verif = array(
     
    170171                );
    171172
    172                 foreach ($liste_verifications as $type_verif => $verif){
     173                foreach ($liste_verifications as $type_verif => $verif) {
    173174                        $saisie_liste_verif['options']['datas'][$type_verif] = $verif['titre'];
    174175                        // Si le type de vérif a des options, on ajoute un fieldset
    175                         if (isset($verif['options']) and $verif['options'] and is_array($verif['options'])){
     176                        if (isset($verif['options']) and $verif['options'] and is_array($verif['options'])) {
    176177                                $groupe = array(
    177178                                        'saisie' => 'fieldset',
     
    205206        ));
    206207
    207         if ($enregistrer_saisie){
     208        if ($enregistrer_saisie) {
    208209                // La saisie modifié
    209210                $saisie_modifiee = _request("saisie_modifiee_${nom}");
     
    212213                // Si on autorise à modifier le nom ET qu'il doit être unique : on vérifie
    213214                if (isset($options['modifier_nom']) and $options['modifier_nom']
    214                   and isset($options['nom_unique']) and $options['nom_unique'])
    215                 {
     215                        and isset($options['nom_unique']) and $options['nom_unique']) {
    216216                        $nom_modifie = $saisie_modifiee['options']['nom'];
    217                         if ($nom_modifie != $enregistrer_saisie and saisies_chercher($formulaire_actuel, $nom_modifie))
     217                        if ($nom_modifie != $enregistrer_saisie and saisies_chercher($formulaire_actuel, $nom_modifie)) {
    218218                                $vraies_erreurs["saisie_modifiee_${nom}[options][nom]"] = _T('saisies:erreur_option_nom_unique');
     219                        }
    219220                }
    220221                // On regarde s'il a été demandé un type de vérif
    221222                if (isset($saisie_modifiee['verifier']['type'])
    222                   and (($type_verif = $saisie_modifiee['verifier']['type']) != '')
    223                   and $verif_options[$type_verif])
    224                 {
     223                        and (($type_verif = $saisie_modifiee['verifier']['type']) != '')
     224                        and $verif_options[$type_verif]) {
    225225                        // On ne vérifie que les options du type demandé
    226226                        $vraies_erreurs = array_merge($vraies_erreurs, saisies_verifier($verif_options[$type_verif]['saisies']));
     
    229229
    230230        // On insère chaque saisie des options de verification
    231         if ($verif_options){
    232                 foreach ($verif_options as $saisie_verif){
     231        if ($verif_options) {
     232                foreach ($verif_options as $saisie_verif) {
    233233                        $formulaire_config = saisies_inserer($formulaire_config, $saisie_verif, $chemin_validation);
    234234                }
     
    251251}
    252252
    253 function formulaires_construire_formulaire_traiter($identifiant, $formulaire_initial=array(), $options=array()){
     253function formulaires_construire_formulaire_traiter($identifiant, $formulaire_initial = array(), $options = array()) {
    254254        include_spip('inc/saisies');
    255255        $retours = array();
    256256        $saisies_disponibles = saisies_lister_disponibles();
    257        
     257
    258258        // On ajoute un préfixe devant l'identifiant
    259259        $identifiant = 'constructeur_formulaire_'.$identifiant;
    260260        // On récupère le formulaire à son état actuel
    261261        $formulaire_actuel = session_get($identifiant);
    262        
     262
    263263        // Si on demande à ajouter un groupe
    264         if ($ajouter_saisie = _request('ajouter_groupe_saisie')){
     264        if ($ajouter_saisie = _request('ajouter_groupe_saisie')) {
    265265                $formulaire_actuel = saisies_groupe_inserer($formulaire_actuel, $ajouter_saisie);
    266266        }
    267        
     267
    268268        // Si on demande à ajouter une saisie
    269         if ($ajouter_saisie = _request('ajouter_saisie')){
     269        if ($ajouter_saisie = _request('ajouter_saisie')) {
    270270                $nom = saisies_generer_nom($formulaire_actuel, $ajouter_saisie);
    271271                $saisie = array(
     
    276276                );
    277277                // S'il y a des valeurs par défaut pour ce type de saisie, on les ajoute
    278                 if (($defaut = $saisies_disponibles[$ajouter_saisie]['defaut']) and is_array($defaut)){
     278                if (($defaut = $saisies_disponibles[$ajouter_saisie]['defaut']) and is_array($defaut)) {
    279279                        $defaut = _T_ou_typo($defaut, 'multi');
    280280
    281                         //Compatibilite PHP<5.3.0 
     281                        //Compatibilite PHP<5.3.0
    282282                        //source : http://www.php.net/manual/en/function.array-replace-recursive.php#92574
    283                         if (!function_exists('array_replace_recursive'))
    284                         {
    285                                 function array_replace_recursive($array, $array1)
    286                                 {
    287                                         function recurse($array, $array1)
    288                                         {
    289                                                 foreach ($array1 as $key => $value)
    290                                                 {
     283                        if (!function_exists('array_replace_recursive')) {
     284                                function array_replace_recursive($array, $array1) {
     285                                        function recurse($array, $array1) {
     286                                                foreach ($array1 as $key => $value) {
    291287                                                        // create new key in $array, if it is empty or not an array
    292                                                         if (!isset($array[$key]) || (isset($array[$key]) && !is_array($array[$key])))
    293                                                         {
     288                                                        if (!isset($array[$key]) || (isset($array[$key]) && !is_array($array[$key]))) {
    294289                                                                $array[$key] = array();
    295290                                                        }
    296291                                                        // overwrite the value in the base array
    297                                                         if (is_array($value))
    298                                                         {
     292                                                        if (is_array($value)) {
    299293                                                                $value = recurse($array[$key], $value);
    300294                                                        }
     
    303297                                                return $array;
    304298                                        }
    305  
     299
    306300                                        // handle the arguments, merge one by one
    307301                                        $args = func_get_args();
    308302                                        $array = $args[0];
    309                                         if (!is_array($array))
    310                                         {
     303                                        if (!is_array($array)) {
    311304                                                return $array;
    312305                                        }
    313                                         for ($i = 1; $i < count($args); $i++)
    314                                         {
    315                                                 if (is_array($args[$i]))
    316                                                 {
     306                                        for ($i = 1; $i < count($args); $i++) {
     307                                                if (is_array($args[$i])) {
    317308                                                        $array = recurse($array, $args[$i]);
    318309                                                }
    319310                                        }
    320                                 return $array;
     311                                        return $array;
    321312                                }
    322313                        }
     
    328319        // Si on demande à dupliquer une saisie
    329320        if ($dupliquer_saisie = _request('dupliquer_saisie')) {
    330                 $formulaire_actuel = saisies_dupliquer($formulaire_actuel, $dupliquer_saisie); 
    331         }
    332        
     321                $formulaire_actuel = saisies_dupliquer($formulaire_actuel, $dupliquer_saisie);
     322        }
     323
    333324        // Si on demande à supprimer une saisie
    334         if ($supprimer_saisie = _request('supprimer_saisie')){
     325        if ($supprimer_saisie = _request('supprimer_saisie')) {
    335326                $formulaire_actuel = saisies_supprimer($formulaire_actuel, $supprimer_saisie);
    336327        }
    337        
     328
    338329        // Si on enregistre la conf d'une saisie
    339         if ($nom = _request('enregistrer_saisie')){
     330        if ($nom = _request('enregistrer_saisie')) {
    340331                // On récupère ce qui a été modifié
    341332                $saisie_modifiee = _request("saisie_modifiee_$nom");
    342                
     333
    343334                // On regarde s'il y a une position à modifier
    344                 if (isset($saisie_modifiee['position'])){
     335                if (isset($saisie_modifiee['position'])) {
    345336                        $position = $saisie_modifiee['position'];
    346337                        unset($saisie_modifiee['position']);
    347338                        // On ne déplace que si ce n'est pas la même chose
    348                         if ($position != $nom)
     339                        if ($position != $nom) {
    349340                                $formulaire_actuel = saisies_deplacer($formulaire_actuel, $nom, $position);
    350                 }
    351                
     341                        }
     342                }
     343
    352344                // On regarde s'il y a des options de vérification à modifier
    353345                if (isset($saisie_modifiee['verifier']['type'])
    354                   and ($type_verif = $saisie_modifiee['verifier']['type']) != '')
    355                 {
     346                        and ($type_verif = $saisie_modifiee['verifier']['type']) != '') {
    356347                        $saisie_modifiee['verifier'] = array(
    357348                                'type' => $type_verif,
    358349                                'options' => $saisie_modifiee['verifier'][$type_verif]
    359350                        );
    360                 }
    361                 else {
     351                } else {
    362352                        unset($saisie_modifiee['verifier']);
    363353                }
     
    368358                        $saisie_modifiee['verifier']['options'] = array_filter($saisie_modifiee['verifier']['options'], 'saisie_option_contenu_vide');
    369359                }
    370                
     360
    371361                // On désinfecte à la main
    372                 if (is_array($saisie_modifiee['options']))
     362                if (is_array($saisie_modifiee['options'])) {
    373363                        spip_desinfecte($saisie_modifiee['options']);
    374                
     364                }
     365
    375366                // On modifie enfin
    376367                $formulaire_actuel = saisies_modifier($formulaire_actuel, $nom, $saisie_modifiee);
     
    378369
    379370        // Si on demande à réinitialiser
    380         if (_request('reinitialiser') == 'oui'){
     371        if (_request('reinitialiser') == 'oui') {
    381372                $formulaire_actuel = $formulaire_initial;
    382373        }
     
    393384// À utiliser avec un array_walk_recursive()
    394385// Applique une transformation à la @valeur@ de tous les champs "nom" d'un formulaire, y compris loin dans l'arbo
    395 function formidable_transformer_nom(&$valeur, $cle, $transformation){
    396         if ($cle == 'nom' and is_string($valeur)){
     386function formidable_transformer_nom(&$valeur, $cle, $transformation) {
     387        if ($cle == 'nom' and is_string($valeur)) {
    397388                $valeur = str_replace('@valeur@', $valeur, $transformation);
    398389        }
     
    400391
    401392// Préparer une saisie pour la transformer en truc configurable
    402 function formidable_generer_saisie_configurable($saisie, $env){
     393function formidable_generer_saisie_configurable($saisie, $env) {
    403394        // On récupère le nom
    404395        $nom = $saisie['options']['nom'];
    405         $identifiant = isset($saisie['identifiant']) ? $saisie['identifiant'] : "";
     396        $identifiant = isset($saisie['identifiant']) ? $saisie['identifiant'] : '';
    406397        // On cherche si ya un formulaire de config
    407         $formulaire_config = isset($env['erreurs']['configurer_'.$nom]) ? $env['erreurs']['configurer_'.$nom] : "";
     398        $formulaire_config = isset($env['erreurs']['configurer_'.$nom]) ? $env['erreurs']['configurer_'.$nom] : '';
    408399        // On ajoute une classe
    409400        if (!isset($saisie['options']['conteneur_class'])) {
     
    412403        // Compat ancien nom li_class
    413404        if (isset($saisie['options']['li_class'])) {
    414                 $saisie['options']['conteneur_class'] .= " " . $saisie['options']['li_class']; // initialisation
     405                $saisie['options']['conteneur_class'] .= ' ' . $saisie['options']['li_class']; // initialisation
    415406        }
    416407        $saisie['options']['conteneur_class'] .= ' configurable';
     
    427418                                array(
    428419                                        'nom' => $nom,
    429                                         'identifiant' => $identifiant, 
     420                                        'identifiant' => $identifiant,
    430421                                        'formulaire_config' => $formulaire_config,
    431422                                        'deplacable' => $env['_chemin_ui']
     
    444435
    445436        // Si ya un form de config on l'ajoute à la fin
    446         if (is_array($formulaire_config)){
     437        if (is_array($formulaire_config)) {
    447438                // On double l'environnement
    448439                $env2 = $env;
     
    452443                // Si possible on met en readonly
    453444                $saisie['options']['readonly'] = 'oui';
    454                
     445
    455446                // On vire les sous-saisies s'il y en a
    456                 if (isset($saisie['saisies']) and $saisie['saisies'] and is_array($saisie['saisies'])){
     447                if (isset($saisie['saisies']) and $saisie['saisies'] and is_array($saisie['saisies'])) {
    457448                        $nb_champs_masques = count(saisies_lister_champs($saisie['saisies']));
    458449                        $saisie['saisies'] = array(
     
    466457                        );
    467458                }
    468                
     459
    469460                // On va ajouter le champ pour la position
    470                 if (!($chemin_description = saisies_chercher($formulaire_config, "saisie_modifiee_${nom}[options][description]", true))){
     461                if (!($chemin_description = saisies_chercher($formulaire_config, "saisie_modifiee_${nom}[options][description]", true))) {
    471462                        $chemin_description = array(0);
    472463                        $formulaire_config = saisies_inserer(
     
    499490                        $chemin_description
    500491                );
    501                
     492
    502493                $env2['saisies'] = $formulaire_config;
    503                
     494
    504495                // Un test pour savoir si on prend le _request ou bien
    505496                $erreurs_test = $env['erreurs'];
     
    508499                unset($erreurs_test['message_erreur']);
    509500
    510                 if ($erreurs_test){
     501                if ($erreurs_test) {
    511502                        // Là aussi on désinfecte à la main
    512503                        if (isset($env2["saisie_modifiee_$nom"]['options']) and is_array($env2["saisie_modifiee_$nom"]['options'])) {
    513504                                spip_desinfecte($env2["saisie_modifiee_$nom"]['options']);
    514505                        }
    515                 }
    516                 else{
     506                } else {
    517507                        $env2["saisie_modifiee_$nom"] = $env2['_saisies_par_nom'][$nom];
    518508                        // il n'y a pas toujours de verification...
     
    522512                        }
    523513                }
    524                
     514
    525515                $env2['fond_generer'] = 'inclure/generer_saisies';
    526516                $saisie = saisies_inserer_html(
     
    555545function saisie_option_contenu_vide($var) {
    556546        if (!$var) {
    557                 if (is_string($var) AND strlen($var)) {
     547                if (is_string($var) and strlen($var)) {
    558548                        return true;
    559549                }
     
    563553}
    564554
    565 function saisies_groupe_inserer($formulaire_actuel, $saisie){
     555function saisies_groupe_inserer($formulaire_actuel, $saisie) {
    566556        include_spip('inclure/configurer_saisie_fonctions');
    567        
     557
    568558                //le groupe de saisies
    569                 $saisies_charger_infos = saisies_charger_infos($saisie,$saisies_repertoire = "saisies/groupes");
    570                
     559                $saisies_charger_infos = saisies_charger_infos($saisie, $saisies_repertoire = 'saisies/groupes');
     560
    571561                //le tableau est-il en options ou en saisies ?
    572562                $classique_yaml=count($saisies_charger_infos['options']);
    573563                $formidable_yaml=count($saisies_charger_infos['saisies']);
    574                 if($classique_yaml>0) {
     564                if ($classique_yaml>0) {
    575565                        $champ_options = 'options';
    576566                }
    577                 if($formidable_yaml>0) {
     567                if ($formidable_yaml>0) {
    578568                        $champ_options = 'saisies';
    579569                }
    580                
    581                 //les champs du groupe 
    582                 foreach($saisies_charger_infos[$champ_options] as $info_saisie){
     570
     571                //les champs du groupe
     572                foreach ($saisies_charger_infos[$champ_options] as $info_saisie) {
    583573                        unset($info_saisie['identifiant']);
    584574                        $saisies_disponibles = saisies_lister_disponibles();
    585575                        $construire_nom = $info_saisie[$champ_options]['nom'] ? $info_saisie[$champ_options]['nom'] : $info_saisie['saisie'];
    586                         $nom = $info_saisie[$champ_options]['nom'] = saisies_generer_nom($formulaire_actuel,$construire_nom);
    587                        
     576                        $nom = $info_saisie[$champ_options]['nom'] = saisies_generer_nom($formulaire_actuel, $construire_nom);
     577
    588578                        $formulaire_actuel = saisies_inserer($formulaire_actuel, $info_saisie);
    589579                }
  • _plugins_/saisies/trunk/formulaires/saisies_cvt.php

    r87651 r97712  
    22
    33// Sécurité
    4 if (!defined('_ECRIRE_INC_VERSION')) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    6 function formulaires_saisies_cvt_saisies_dist(){
     8function formulaires_saisies_cvt_saisies_dist() {
    79        return array(
    810                array(
     
    3840        );
    3941}
    40 
  • _plugins_/saisies/trunk/inc/saisies.php

    r91257 r97712  
    88
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) return;
     10if (!defined('_ECRIRE_INC_VERSION')) {
     11        return;
     12}
    1113
    1214/*
     
    4850 * @return array Retourne les saisies du formulaire sinon false
    4951 */
    50 function saisies_chercher_formulaire($form, $args){
     52function saisies_chercher_formulaire($form, $args) {
    5153        if ($fonction_saisies = charger_fonction('saisies', 'formulaires/'.$form, true)
    5254                and $saisies = call_user_func_array($fonction_saisies, $args)
     
    6264                // Si c'est toujours un tableau après le pipeline
    6365                and is_array($saisies)
    64         ){
     66        ) {
    6567                return $saisies;
    66         }
    67         else{
     68        } else {
    6869                return false;
    6970        }
     
    7879 * @return array Retourne soit la saisie, soit son chemin, soit null
    7980 */
    80 function saisies_chercher($saisies, $id_ou_nom_ou_chemin, $retourner_chemin=false){
    81 
    82         if (is_array($saisies) and $id_ou_nom_ou_chemin){
    83                 if (is_string($id_ou_nom_ou_chemin)){
     81function saisies_chercher($saisies, $id_ou_nom_ou_chemin, $retourner_chemin = false) {
     82        if (is_array($saisies) and $id_ou_nom_ou_chemin) {
     83                if (is_string($id_ou_nom_ou_chemin)) {
    8484                        $nom = $id_ou_nom_ou_chemin;
    8585                        // identifiant ? premier caractere @
    8686                        $id = ($nom[0] == '@');
    8787
    88                         foreach($saisies as $cle => $saisie){
     88                        foreach ($saisies as $cle => $saisie) {
    8989                                $chemin = array($cle);
    9090                                // notre saisie est la bonne ?
     
    9696                                                return $retourner_chemin ? array_merge($chemin, array('saisies'), $retour) : $retour;
    9797                                }
    98 
    99                         }
    100                 }
    101                 elseif (is_array($id_ou_nom_ou_chemin)){
     98                        }
     99                } elseif (is_array($id_ou_nom_ou_chemin)) {
    102100                        $chemin = $id_ou_nom_ou_chemin;
    103101                        $saisie = $saisies;
    104102                        // On vérifie l'existence quand même
    105                         foreach ($chemin as $cle){
    106                                 if (isset($saisie[$cle])) $saisie = $saisie[$cle];
    107                                 else return null;
     103                        foreach ($chemin as $cle) {
     104                                if (isset($saisie[$cle])) {
     105                                        $saisie = $saisie[$cle];
     106                                } else {
     107                                        return null;
     108                                }
    108109                        }
    109110                        // Si c'est une vraie saisie
    110                         if ($saisie['saisie'] and $saisie['options']['nom'])
     111                        if ($saisie['saisie'] and $saisie['options']['nom']) {
    111112                                return $retourner_chemin ? $chemin : $saisie;
    112                 }
    113         }
    114        
     113                        }
     114                }
     115        }
     116
    115117        return null;
    116118}
     
    120122 *
    121123 * @param array $formulaire
    122  *     Le formulaire à analyser 
     124 *     Le formulaire à analyser
    123125 * @param string $type_saisie
    124  *     Le type de champ dont on veut un identifiant 
     126 *     Le type de champ dont on veut un identifiant
    125127 * @return string
    126128 *     Un nom unique par rapport aux autres champs du formulaire
    127129 */
    128 function saisies_generer_nom($formulaire, $type_saisie){
     130function saisies_generer_nom($formulaire, $type_saisie) {
    129131        $champs = saisies_lister_champs($formulaire);
    130        
     132
    131133        // Tant que type_numero existe, on incrémente le compteur
    132134        $compteur = 1;
    133         while (array_search($type_saisie.'_'.$compteur, $champs) !== false)
     135        while (array_search($type_saisie.'_'.$compteur, $champs) !== false) {
    134136                $compteur++;
    135        
     137        }
     138
    136139        // On a alors un compteur unique pour ce formulaire
    137140        return $type_saisie.'_'.$compteur;
     
    140143/**
    141144 * Crée un identifiant Unique
    142  * pour toutes les saisies donnees qui n'en ont pas 
     145 * pour toutes les saisies donnees qui n'en ont pas
    143146 *
    144147 * @param Array $saisies Tableau de saisies
     
    166169**/
    167170function saisie_identifier($saisie, $regenerer = false) {
    168         if (!isset($saisie['identifiant']) OR !$saisie['identifiant']) {
     171        if (!isset($saisie['identifiant']) or !$saisie['identifiant']) {
    169172                $saisie['identifiant'] = uniqid('@');
    170173        } elseif ($regenerer) {
    171174                $saisie['identifiant'] = uniqid('@');
    172175        }
    173         if (isset($saisie['saisies']) AND is_array($saisie['saisies'])) {
     176        if (isset($saisie['saisies']) and is_array($saisie['saisies'])) {
    174177                $saisie['saisies'] = saisies_identifier($saisie['saisies'], $regenerer);
    175178        }
     
    184187 * @return array Retourne un tableau d'erreurs
    185188 */
    186 function saisies_verifier($formulaire, $saisies_masquees_nulles=true){
     189function saisies_verifier($formulaire, $saisies_masquees_nulles = true) {
    187190        include_spip('inc/verifier');
    188191        $erreurs = array();
    189         $verif_fonction = charger_fonction('verifier','inc',true);
    190 
    191         if ($saisies_masquees_nulles)
     192        $verif_fonction = charger_fonction('verifier', 'inc', true);
     193
     194        if ($saisies_masquees_nulles) {
    192195                $formulaire = saisies_verifier_afficher_si($formulaire);
    193        
     196        }
     197
    194198        $saisies = saisies_lister_par_nom($formulaire);
    195         foreach ($saisies as $saisie){
     199        foreach ($saisies as $saisie) {
    196200                $obligatoire = isset($saisie['options']['obligatoire']) ? $saisie['options']['obligatoire'] : '';
    197201                $champ = $saisie['options']['nom'];
     
    200204
    201205                // Si le nom du champ est un tableau indexé, il faut parser !
    202                 if (preg_match('/([\w]+)((\[[\w]+\])+)/', $champ, $separe)){
     206                if (preg_match('/([\w]+)((\[[\w]+\])+)/', $champ, $separe)) {
    203207                        $valeur = _request($separe[1]);
    204208                        preg_match_all('/\[([\w]+)\]/', $separe[2], $index);
    205209                        // On va chercher au fond du tableau
    206                         foreach($index[1] as $cle){
     210                        foreach ($index[1] as $cle) {
    207211                                $valeur = isset($valeur[$cle]) ? $valeur[$cle] : null;
    208212                        }
    209                 }
    210                 // Sinon la valeur est juste celle du nom
    211                 else
     213                } else {
     214                        // Sinon la valeur est juste celle du nom
    212215                        $valeur = _request($champ);
    213                
     216                }
     217
    214218                // Pour la saisie "destinataires" il faut filtrer si jamais on a mis un premier choix vide
    215219                if ($saisie['saisie'] == 'destinataires') {
    216220                        $valeur = array_filter($valeur);
    217221                }
    218                
     222
    219223                // On regarde d'abord si le champ est obligatoire
    220224                if ($obligatoire
     
    236240
    237241                // On continue seulement si ya pas d'erreur d'obligation et qu'il y a une demande de verif
    238                 if ((!isset($erreurs[$champ]) or !$erreurs[$champ]) and is_array($verifier) and $verif_fonction){
     242                if ((!isset($erreurs[$champ]) or !$erreurs[$champ]) and is_array($verifier) and $verif_fonction) {
    239243                        $normaliser = null;
    240244                        // Si le champ n'est pas valide par rapport au test demandé, on ajoute l'erreur
     
    248252                }
    249253        }
    250        
     254
    251255        return $erreurs;
    252256}
     
    257261 * @return $nouveau_tab
    258262 */
    259 function saisies_aplatir_tableau($tab){
     263function saisies_aplatir_tableau($tab) {
    260264        $nouveau_tab = array();
    261         foreach($tab as $entree=>$contenu){
     265        foreach ($tab as $entree => $contenu) {
    262266                if (is_array($contenu)) {
    263267                        foreach ($contenu as $cle => $valeur) {
     
    276280 * @return $chaine
    277281 */
    278 function saisies_aplatir_chaine($chaine){
    279         return trim(preg_replace("#(?:^|\n)(\*(?:.*)|/\*)\n#i","\n",$chaine));
     282function saisies_aplatir_chaine($chaine) {
     283        return trim(preg_replace("#(?:^|\n)(\*(?:.*)|/\*)\n#i", "\n", $chaine));
    280284}
    281285
    282286/**
    283287 * Transforme une chaine en tableau avec comme principe :
    284  * 
     288 *
    285289 * - une ligne devient une case
    286290 * - si la ligne est de la forme truc|bidule alors truc est la clé et bidule la valeur
    287291 * - si la ligne commence par * alors on commence un sous-tableau
    288292 * - si la ligne est égale à /*, alors on fini le sous-tableau
    289  * 
     293 *
    290294 * @param string $chaine Une chaine à transformer
    291295 * @param string $separateur Séparateur utilisé
    292296 * @return array Retourne un tableau PHP
    293297 */
    294 function saisies_chaine2tableau($chaine, $separateur="\n"){
    295         if ($chaine and is_string($chaine)){
     298function saisies_chaine2tableau($chaine, $separateur = "\n") {
     299        if ($chaine and is_string($chaine)) {
    296300                $tableau = array();
    297                 $soustab = False;
     301                $soustab = false;
    298302                // On découpe d'abord en lignes
    299303                $lignes = explode($separateur, $chaine);
    300                 foreach ($lignes as $i=>$ligne){
     304                foreach ($lignes as $i => $ligne) {
    301305                        $ligne = trim(trim($ligne), '|');
    302306                        // Si ce n'est pas une ligne sans rien
    303                         if ($ligne !== ''){
     307                        if ($ligne !== '') {
    304308                                // si ca commence par * c'est qu'on va faire un sous tableau
    305                                 if (strpos($ligne,"*")===0) {
    306                                         $soustab=True;
    307                                         $soustab_cle    = _T_ou_typo(substr($ligne,1), 'multi');
    308                                         if (!isset($tableau[$soustab_cle])){
     309                                if (strpos($ligne, '*') === 0) {
     310                                        $soustab=true;
     311                                        $soustab_cle = _T_ou_typo(substr($ligne, 1), 'multi');
     312                                        if (!isset($tableau[$soustab_cle])) {
    309313                                                $tableau[$soustab_cle] = array();
    310314                                        }
    311                                 }
    312                                 elseif ($ligne=="/*") {//si on finit sous tableau
    313                                         $soustab=False;
    314                                 }
    315                                 else{//sinon c'est une entrée normale
    316                                 // Si on trouve un découpage dans la ligne on fait cle|valeur
     315                                } elseif ($ligne == '/*') {//si on finit sous tableau
     316                                        $soustab=false;
     317                                } else {
     318                                        //sinon c'est une entrée normale
     319                                        // Si on trouve un découpage dans la ligne on fait cle|valeur
    317320                                        if (strpos($ligne, '|') !== false) {
    318321                                                list($cle,$valeur) = explode('|', $ligne, 2);
    319322                                                // permettre les traductions de valeurs au passage
    320                                                 if ($soustab == True){
     323                                                if ($soustab == true) {
    321324                                                        $tableau[$soustab_cle][$cle] = _T_ou_typo($valeur, 'multi');
    322325                                                } else {
    323326                                                        $tableau[$cle] = _T_ou_typo($valeur, 'multi');
    324327                                                }
    325                                         }
    326                                 // Sinon on génère la clé
    327                                         else{
    328                                                 if ($soustab == True) {
    329                                                         $tableau[$soustab_cle][$i] = _T_ou_typo($ligne,'multi');
     328                                        } else {
     329                                                // Sinon on génère la clé
     330                                                if ($soustab == true) {
     331                                                        $tableau[$soustab_cle][$i] = _T_ou_typo($ligne, 'multi');
    330332                                                } else {
    331                                                         $tableau[$i] = _T_ou_typo($ligne,'multi');
     333                                                        $tableau[$i] = _T_ou_typo($ligne, 'multi');
    332334                                                }
    333335                                        }
     
    336338                }
    337339                return $tableau;
    338         }
    339         // Si c'est déjà un tableau on lui applique _T_ou_typo (qui fonctionne de manière récursive avant de le renvoyer
    340         elseif (is_array($chaine)){
     340        } elseif (is_array($chaine)) {
     341                // Si c'est déjà un tableau on lui applique _T_ou_typo (qui fonctionne de manière récursive avant de le renvoyer
    341342                return _T_ou_typo($chaine, 'multi');
    342343        } else {
     
    347348/**
    348349 * Transforme un tableau en chaine de caractères avec comme principe :
    349  * 
     350 *
    350351 * - une case de vient une ligne de la chaine
    351352 * - chaque ligne est générée avec la forme cle|valeur
     
    356357 * @return string Texte représentant les données du tableau
    357358 */
    358 function saisies_tableau2chaine($tableau){
    359         if ($tableau and is_array($tableau)){
     359function saisies_tableau2chaine($tableau) {
     360        if ($tableau and is_array($tableau)) {
    360361                $chaine = '';
    361                 $avant_est_tableau = False;
    362                 foreach($tableau as $cle=>$valeur){
    363                         if (is_array($valeur)){
    364                                 $avant_est_tableau = True;
     362                $avant_est_tableau = false;
     363                foreach ($tableau as $cle => $valeur) {
     364                        if (is_array($valeur)) {
     365                                $avant_est_tableau = true;
    365366                                $ligne=trim("*$cle");
    366367                                $chaine .= "$ligne\n";
    367368                                $chaine .= saisies_tableau2chaine($valeur)."\n";
     369                        } else {
     370                                if ($avant_est_tableau == true) {
     371                                        $avant_est_tableau = false;
     372                                        $chaine.="/*\n";
    368373                                }
    369                         else{   
    370                                 if ($avant_est_tableau == True){
    371                                                 $avant_est_tableau = False;
    372                                                 $chaine.="/*\n";
    373                                         }
    374374                                $ligne = trim("$cle|$valeur");
    375375                                $chaine .= "$ligne\n";
     
    377377                }
    378378                $chaine = trim($chaine);
    379        
     379
    380380                return $chaine;
    381         }
    382         // Si c'est déjà une chaine on la renvoie telle quelle
    383         elseif (is_string($tableau)){
     381        } elseif (is_string($tableau)) {
     382                // Si c'est déjà une chaine on la renvoie telle quelle
    384383                return $tableau;
    385         }
    386         else{
     384        } else {
    387385                return '';
    388386        }
    389387}
    390 
    391 
    392 
    393388
    394389/**
     
    421416}
    422417
    423 
    424418/**
    425419 * Pour les saisies multiples (type checkbox) proposant un choix alternatif,
     
    432426 * @return string choix_alternatif
    433427**/
    434 function saisies_trouver_choix_alternatif($data,$valeur) {
     428function saisies_trouver_choix_alternatif($data, $valeur) {
    435429        if (!is_array($valeur)) {
    436430                $valeur = saisies_chaine2tableau($valeur) ;
     
    440434        }
    441435        $choix_theorique = array_keys($data);
    442         $choix_alternatif = array_values(array_diff($valeur,$choix_theorique));
     436        $choix_alternatif = array_values(array_diff($valeur, $choix_theorique));
    443437        return $choix_alternatif[0];//on suppose que personne ne s'est amusé à proposer deux choix alternatifs
    444438}
     
    449443 * Retourne le résultat du squelette `inclure/saisies_aide` auquel
    450444 * on a transmis toutes les saisies connues.
    451  * 
     445 *
    452446 * @return string Code HTML
    453447 */
    454 function saisies_generer_aide(){
     448function saisies_generer_aide() {
    455449        // On a déjà la liste par saisie
    456450        $saisies = saisies_lister_disponibles();
     
    458452        // On construit une liste par options
    459453        $options = array();
    460         foreach ($saisies as $type_saisie=>$saisie){
     454        foreach ($saisies as $type_saisie => $saisie) {
    461455                $options_saisie = saisies_lister_par_nom($saisie['options'], false);
    462                 foreach ($options_saisie as $nom=>$option){
     456                foreach ($options_saisie as $nom => $option) {
    463457                        // Si l'option n'existe pas encore
    464                         if (!isset($options[$nom])){
     458                        if (!isset($options[$nom])) {
    465459                                $options[$nom] = _T_ou_typo($option['options']);
    466460                        }
     
    490484
    491485function saisies_afficher_si($saisies) {
    492         $saisies = saisies_lister_par_nom($saisies,true);
     486        $saisies = saisies_lister_par_nom($saisies, true);
    493487        // Dès qu'il y a au moins une option afficher_si, on l'active
    494488        foreach ($saisies as $saisie) {
    495                 if (isset($saisie['options']['afficher_si']))
     489                if (isset($saisie['options']['afficher_si'])) {
    496490                        return true;
     491                }
    497492        }
    498493        return false;
     
    507502 */
    508503function saisies_afficher_si_remplissage($saisies) {
    509         $saisies = saisies_lister_par_nom($saisies,true);
     504        $saisies = saisies_lister_par_nom($saisies, true);
    510505        // Dès qu'il y a au moins une option afficher_si_remplissage, on l'active
    511506        foreach ($saisies as $saisie) {
    512                 if (isset($saisie['options']['afficher_si_remplissage']))
     507                if (isset($saisie['options']['afficher_si_remplissage'])) {
    513508                        return true;
     509                }
    514510        }
    515511        return false;
    516512}
    517 
  • _plugins_/saisies/trunk/inc/saisies_afficher.php

    r93602 r97712  
    156156
    157157                $contexte = array_merge($env, $contexte);
    158         }
    159         // Sinon on ne sélectionne que quelques éléments importants
    160         else {
     158        } else {
     159                // Sinon on ne sélectionne que quelques éléments importants
    161160                // On récupère la liste des erreurs
    162161                $contexte['erreurs'] = $env['erreurs'];
     
    178177                        $contexte['valeur'] = isset($contexte['valeur'][$cle]) ? $contexte['valeur'][$cle] : null;
    179178                }
    180         }
    181         // Sinon la valeur est juste celle du nom si elle existe
    182         elseif (isset($contexte['nom']) and isset($env[$contexte['nom']])) {
     179        } elseif (isset($contexte['nom']) and isset($env[$contexte['nom']])) {
     180                // Sinon la valeur est juste celle du nom si elle existe
    183181                $contexte['valeur'] = $env[$contexte['nom']];
    184         }
    185         // Sinon rien
    186         else {
     182        } else {
     183                // Sinon rien
    187184                $contexte['valeur'] = null;
    188185        }
     
    269266        if ($env['valeurs'] and is_array($env['valeurs']) and isset($env['valeurs'][$contexte['nom']])) {
    270267                $contexte['valeur'] = $env['valeurs'][$contexte['nom']];
    271         }
    272         // Si le nom du champ est un tableau indexé, il faut parser !
    273         elseif (preg_match('/([\w]+)((\[[\w]+\])+)/', $contexte['nom'], $separe)) {
     268        } elseif (preg_match('/([\w]+)((\[[\w]+\])+)/', $contexte['nom'], $separe)) {
     269                // Si le nom du champ est un tableau indexé, il faut parser !
    274270                $contexte['valeur'] = $env[$separe[1]];
    275271                preg_match_all('/\[([\w]+)\]/', $separe[2], $index);
     
    278274                        $contexte['valeur'] = $contexte['valeur'][$cle];
    279275                }
    280         }
    281         // Sinon la valeur est juste celle du nom
    282         else {
     276        } else {
     277                // Sinon la valeur est juste celle du nom
    283278                // certains n'ont pas de nom (fieldset)
    284279                $contexte['valeur'] = isset($env[$contexte['nom']]) ? $env[$contexte['nom']] : '';
  • _plugins_/saisies/trunk/inc/saisies_manipuler.php

    r93579 r97712  
    141141                        $saisies = saisies_supprimer($saisies, $id_ou_nom_ou_chemin);
    142142                        $chemin = array(count($saisies));
    143                 }
    144                 // Si l'endroit est entre crochet, c'est un conteneur
    145                 elseif (preg_match('/^\[(@?[\w]*)\]$/', $ou, $match)) {
     143                } elseif (preg_match('/^\[(@?[\w]*)\]$/', $ou, $match)) {
     144                        // Si l'endroit est entre crochet, c'est un conteneur
    146145                        $parent = $match[1];
    147146                        // Si dans les crochets il n'y a rien, on met à la fin du formulaire
     
    149148                                $saisies = saisies_supprimer($saisies, $id_ou_nom_ou_chemin);
    150149                                $chemin = array(count($saisies));
    151                         }
    152                         // Sinon on vérifie que ce conteneur existe
    153                         elseif (saisies_chercher($saisies, $parent, true)) {
     150                        } elseif (saisies_chercher($saisies, $parent, true)) {
     151                                // Sinon on vérifie que ce conteneur existe
    154152                                // S'il existe on supprime la saisie et on recherche la nouvelle position
    155153                                $saisies = saisies_supprimer($saisies, $id_ou_nom_ou_chemin);
     
    159157                                $chemin = false;
    160158                        }
    161                 }
    162                 // Sinon ça sera devant un champ
    163                 else {
     159                } else {
     160                        // Sinon ça sera devant un champ
    164161                        // On vérifie que le champ existe
    165162                        if (saisies_chercher($saisies, $ou, true)) {
     
    206203        }
    207204        // On récupère les enfants tels quels s'il n'y a pas des enfants dans la modif
    208         if (
    209                 !isset($modifs['saisies'])
     205        if (!isset($modifs['saisies'])
    210206                and isset($parent[$position]['saisies'])
    211207                and is_array($parent[$position]['saisies'])
  • _plugins_/saisies/trunk/inclure/configurer_saisie_fonctions.php

    r87651 r97712  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    6 function construire_configuration_saisie($saisie, $avec_nom='non'){
     8function construire_configuration_saisie($saisie, $avec_nom = 'non') {
    79        include_spip('inc/yaml');
    810        $configuration_saisie = yaml_decode_file(find_in_path('saisies/'.$saisie.'.yaml'));
    9        
    10         if (is_array($configuration_saisie)){
     11
     12        if (is_array($configuration_saisie)) {
    1113                $configuration_saisie = $configuration_saisie['options'];
    1214                // On ne met le premier champ permettant de configurer le "name" seulement si on le demande explicitement
    13                 if ($avec_nom == 'oui')
    14                         array_unshift($configuration_saisie[0]['contenu'],
     15                if ($avec_nom == 'oui') {
     16                        array_unshift(
     17                                $configuration_saisie[0]['contenu'],
    1518                                array(
    1619                                        'saisie' => 'input',
     
    2932                                )
    3033                        );
     34                }
     35        } else {
     36                $configuration_saisie = array();
    3137        }
    32         else
    33                 $configuration_saisie = array();
    34        
    3538        return $configuration_saisie;
    3639}
    37 
  • _plugins_/saisies/trunk/saisies-vues/selecteur_article_fonctions.php

    r90290 r97712  
    11<?php
    22
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
     6
    37include_spip('prive/formulaires/selecteur/selecteur_fonctions');
  • _plugins_/saisies/trunk/saisies_fonctions.php

    r97706 r97712  
    77**/
    88
    9 if (!defined('_ECRIRE_INC_VERSION')) return;
     9if (!defined('_ECRIRE_INC_VERSION')) {
     10        return;
     11}
    1012
    1113include_spip('inc/saisies');
     
    2325 *   $tag initial ou div
    2426 */
    25 function saisie_balise_structure_formulaire($tag){
     27function saisie_balise_structure_formulaire($tag) {
    2628
    2729        // Pouvoir forcer l'utilisation de formulaire de type SPIP 3
     
    3032        }
    3133
    32         static $is_div=null;
    33         if (is_null($is_div)){
    34                 $version = explode(".",$GLOBALS['spip_version_branche']);
    35                 if ($version[0]>3 OR ($version[0]==3 AND $version[1]>0))
     34        static $is_div = null;
     35        if (is_null($is_div)) {
     36                $version = explode('.', $GLOBALS['spip_version_branche']);
     37                if ($version[0] > 3 or ($version[0] == 3 and $version[1] > 0)) {
    3638                        $is_div = true;
    37         }
    38         if ($is_div) return "div";
     39                }
     40        }
     41        if ($is_div) {
     42                return 'div';
     43        }
    3944        return $tag;
    4045}
     
    4247// [(#DIV|sinon{ul})]
    4348if (!function_exists('balise_DIV_dist')
    44   and $version = explode(".",$GLOBALS['spip_version_branche'])
    45   and ($version[0]>3 OR ($version[0]==3 AND $version[1]>0))){
    46         function balise_DIV_dist($p){
     49        and $version = explode('.', $GLOBALS['spip_version_branche'])
     50        and ($version[0]>3 or ($version[0]==3 and $version[1] > 0))) {
     51        function balise_DIV_dist($p) {
    4752                $p->code = "'div'";
    4853                $p->interdire_scripts = false;
     
    6065 * @return string
    6166 */
    62 function saisie_traitement_vue($valeur,$env){
    63         if (is_string($env))
     67function saisie_traitement_vue($valeur, $env) {
     68        if (is_string($env)) {
    6469                $env = unserialize($env);
    65         if (!function_exists('propre'))
     70        }
     71        if (!function_exists('propre')) {
    6672                include_spip('inc/texte');
     73        }
    6774
    6875        $valeur = trim($valeur);
     
    7481                if (in_array($env['type_saisie'], array('textarea'))) {
    7582                        $valeur = propre($valeur);
    76                 }
    77                 else {
    78                         $valeur = "<p>" . typo($valeur) . "</p>";
     83                } else {
     84                        $valeur = '<p>' . typo($valeur) . '</p>';
    7985                }
    8086        }
     
    8591/**
    8692 * Passer un nom en une valeur compatible avec une classe css
    87  * 
     93 *
    8894 * - toto => toto,
    8995 * - toto/truc => toto_truc,
     
    99105/**
    100106 * Passer un nom en une valeur compatible avec un `name` de formulaire
    101  * 
     107 *
    102108 * - toto => toto,
    103109 * - toto/truc => toto[truc],
     
    124130 *     #GLOBALS{debut_intertitre}
    125131 *     ```
    126  * 
     132 *
    127133 * @param Champ $p
    128134 *     Pile au niveau de la balise
     
    131137**/
    132138function balise_GLOBALS_dist($p) {
    133         if (function_exists('balise_ENV'))
     139        if (function_exists('balise_ENV')) {
    134140                return balise_ENV($p, '$GLOBALS');
    135         else
     141        } else {
    136142                return balise_ENV_dist($p, '$GLOBALS');
     143        }
    137144}
    138145
     
    141148 *
    142149 * Les éléments sont triés par objets puis par identifiants
    143  * 
     150 *
    144151 * @example
    145152 *     L'entrée :
     
    179186        // on remet tout en file
    180187        $liste = array();
    181         foreach ($res as $objet=>$ids) {
     188        foreach ($res as $objet => $ids) {
    182189                foreach ($ids as $id) {
    183190                        $liste[] = array('objet' => $objet, 'id_objet' => $id);
     
    198205 *               'texte_objets' : le nom humain de l'objet éditorial.
    199206 */
    200 function lister_tables_objets_edit()
    201 {
    202     include_spip('base/abstract_sql');
    203 
    204     $objets = lister_tables_objets_sql();
    205     $objets_edit = array();
    206 
    207     foreach ($objets as $objet => $definition) {
    208         if (isset($definition['editable']) and isset($definition['url_edit']) and $definition['url_edit'] != '') {
    209             $objets_edit[$objet] = array('type' => $definition['type'], 'url_edit' => $definition['url_edit'], 'texte_objets' => $definition['texte_objets']);
    210         }
    211     }
    212     $objets_edit = array_filter($objets_edit);
    213 
    214     return $objets_edit;
    215 }
     207function lister_tables_objets_edit() {
     208        include_spip('base/abstract_sql');
     209
     210        $objets = lister_tables_objets_sql();
     211        $objets_edit = array();
     212
     213        foreach ($objets as $objet => $definition) {
     214                if (isset($definition['editable']) and isset($definition['url_edit']) and $definition['url_edit'] != '') {
     215                        $objets_edit[$objet] = array('type' => $definition['type'], 'url_edit' => $definition['url_edit'], 'texte_objets' => $definition['texte_objets']);
     216                }
     217        }
     218        $objets_edit = array_filter($objets_edit);
     219
     220        return $objets_edit;
     221}
  • _plugins_/saisies/trunk/saisies_options.php

    r97706 r97712  
    88
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) return;
     10if (!defined('_ECRIRE_INC_VERSION')) {
     11        return;
     12}
    1113
    1214// Pouvoir forcer l'utilisation de formulaire de type SPIP 3
     
    1517}
    1618
    17 
    18 if (!function_exists('_T_ou_typo')){
     19if (!function_exists('_T_ou_typo')) {
    1920        /**
    2021         * une fonction qui regarde si $texte est une chaine de langue
     
    3031         *     Retourne la valeur éventuellement modifiée.
    3132         */
    32         function _T_ou_typo($valeur, $mode_typo='toujours') {
     33        function _T_ou_typo($valeur, $mode_typo = 'toujours') {
    3334                // Si la valeur est bien une chaine (et pas non plus un entier déguisé)
    34                 if (is_string($valeur) and !intval($valeur)){
     35                if (is_string($valeur) and !intval($valeur)) {
    3536                        // Si la chaine est du type <:truc:> on passe à _T()
    36                         if (preg_match('/^\<:(.*?):\>$/', $valeur, $match))
     37                        if (preg_match('/^\<:(.*?):\>$/', $valeur, $match)) {
    3738                                $valeur = _T($match[1]);
    38                         // Sinon on la passe a typo()
    39                         else {
    40                                 if (!in_array($mode_typo, array('toujours', 'multi', 'jamais')))
     39                        } else {
     40                                // Sinon on la passe a typo()
     41                                if (!in_array($mode_typo, array('toujours', 'multi', 'jamais'))) {
    4142                                        $mode_typo = 'toujours';
    42                        
    43                                 if ($mode_typo == 'toujours' or ($mode_typo == 'multi' and strpos($valeur, '<multi>') !== false)){
     43                                }
     44
     45                                if ($mode_typo == 'toujours' or ($mode_typo == 'multi' and strpos($valeur, '<multi>') !== false)) {
    4446                                        include_spip('inc/texte');
    4547                                        $valeur = typo($valeur);
    4648                                }
    4749                        }
    48                 }
    49                 // Si c'est un tableau, on reapplique la fonction récursivement
    50                 elseif (is_array($valeur)){
    51                         foreach ($valeur as $cle => $valeur2){
     50                } elseif (is_array($valeur)) {
     51                        // Si c'est un tableau, on reapplique la fonction récursivement
     52                        foreach ($valeur as $cle => $valeur2) {
    5253                                $valeur[$cle] = _T_ou_typo($valeur2, $mode_typo);
    5354                        }
     
    5758        }
    5859}
    59 
  • _plugins_/saisies/trunk/saisies_pipelines.php

    r94665 r97712  
    88
    99// Sécurité
    10 if (!defined("_ECRIRE_INC_VERSION")) return;
     10if (!defined('_ECRIRE_INC_VERSION')) {
     11        return;
     12}
    1113
    1214/**
    1315 * Ajoute les scripts JS et CSS de saisies dans l'espace privé
    1416 *
    15  * @param string $flux 
     17 * @param string $flux
    1618 * @return string
    1719**/
    18 function saisies_header_prive($flux){
     20function saisies_header_prive($flux) {
    1921        $js = find_in_path('javascript/saisies.js');
    2022        $flux .= "\n<script type='text/javascript' src='$js'></script>\n";
     
    3133 * Ajoute également de quoi gérer le datepicker de la saisie date si
    3234 * celle-ci est utilisée dans la page.
    33  * 
    34  * @param string $flux 
     35 *
     36 * @param string $flux
    3537 * @return string
    3638**/
    37 function saisies_affichage_final($flux){
    38         if (
    39                 $GLOBALS['html'] // si c'est bien du HTML
    40                 and ($p = strpos($flux,"<!--!inserer_saisie_editer-->")) !== false // et qu'on a au moins une saisie
    41                 and strpos($flux,'<head') !== false // et qu'on a la balise <head> quelque part
    42         ){
     39function saisies_affichage_final($flux) {
     40        if ($GLOBALS['html'] // si c'est bien du HTML
     41                and ($p = strpos($flux, '<!--!inserer_saisie_editer-->')) !== false // et qu'on a au moins une saisie
     42                and strpos($flux, '<head') !== false // et qu'on a la balise <head> quelque part
     43        ) {
    4344                // On insère la CSS devant le premier <link> trouvé
    44                 if (!$pi = strpos($flux, "<link") AND !$pi=strpos($flux, '</head')) {
     45                if (!$pi = strpos($flux, '<link') and !$pi = strpos($flux, '</head')) {
    4546                        $pi = $p; // si pas de <link inserer comme un goret entre 2 <li> de saisies
    4647                }
     
    4849                $ins_css = "\n<link rel='stylesheet' href='$css' type='text/css' media='all' />\n";
    4950
    50                 if (strpos($flux,"saisie_date")!==false){//si on a une saisie de type date, on va charger les css de jquery_ui
    51                     include_spip("jqueryui_pipelines");
    52                         if (function_exists("jqueryui_dependances")){
    53                                 $ui_plugins = jqueryui_dependances(array("jquery.ui.datepicker"));
    54                                 $theme_css = "jquery.ui.theme";
    55                                 $ui_css_dir = "css";
     51                if (strpos($flux, 'saisie_date') !==false) {//si on a une saisie de type date, on va charger les css de jquery_ui
     52                        include_spip('jqueryui_pipelines');
     53                        if (function_exists('jqueryui_dependances')) {
     54                                $ui_plugins = jqueryui_dependances(array('jquery.ui.datepicker'));
     55                                $theme_css = 'jquery.ui.theme';
     56                                $ui_css_dir = 'css';
    5657                                // compatibilité SPIP 3.1 et jQuery UI 1.11
    57                                 $version = explode(".",$GLOBALS['spip_version_branche']);
    58                                 if ($version[0]>3 OR ($version[0]==3 AND $version[1]>0)) {
    59                                         $theme_css = "theme";
    60                                         $ui_css_dir = "css/ui";
     58                                $version = explode('.', $GLOBALS['spip_version_branche']);
     59                                if ($version[0] > 3 or ($version[0] == 3 and $version[1] > 0)) {
     60                                        $theme_css = 'theme';
     61                                        $ui_css_dir = 'css/ui';
    6162                                }
    62                                 array_push($ui_plugins,$theme_css);
    63                                 foreach ($ui_plugins as $ui_plug){
     63                                array_push($ui_plugins, $theme_css);
     64                                foreach ($ui_plugins as $ui_plug) {
    6465                                        $ui_plug_css = find_in_path("$ui_css_dir/$ui_plug.css");
    65                                         if (strpos($flux,"$ui_css_dir/$ui_plug.css")===false){// si pas déjà chargé
     66                                        if (strpos($flux, "$ui_css_dir/$ui_plug.css") === false) {// si pas déjà chargé
    6667                                                $ins_css .= "\n<link rel='stylesheet' href='$ui_plug_css' type='text/css' media='all' />\n";
    6768                                        }
     
    8788 * est présente. Cette fonction doit retourner une liste de saisies dont on se
    8889 * sert alors pour calculer les champs utilisés dans le formulaire.
    89  * 
    90  * @param array $flux 
     90 *
     91 * @param array $flux
    9192 * @return array
    9293**/
    93 function saisies_formulaire_charger($flux){
     94function saisies_formulaire_charger($flux) {
    9495        // Si le flux data est inexistant, on quitte : Le CVT d'origine a décidé de ne pas continuer
    95         if (!is_array($flux['data'])){
     96        if (!is_array($flux['data'])) {
    9697                return $flux;
    9798        }
     
    119120 * alors on utilise le formulaire générique intégré au plugin saisie, qui calculera le HTML
    120121 * à partir de la déclaration des saisies indiquées.
    121  * 
     122 *
    122123 * @see saisies_formulaire_charger()
    123  * 
     124 *
    124125 * @param array $flux
    125126 * @return array
    126127**/
    127 function saisies_styliser($flux){
     128function saisies_styliser($flux) {
    128129        // Si on cherche un squelette de formulaire
    129         if (strncmp($flux['args']['fond'],'formulaires/',12)==0
     130        if (strncmp($flux['args']['fond'], 'formulaires/', 12) == 0
    130131                // Et qu'il y a des saisies dans le contexte
    131132                and isset($flux['args']['contexte']['_saisies'])
     
    135136                and lire_fichier($flux['data'].'.'.$ext, $contenu_squelette)
    136137                and !trim($contenu_squelette)
    137         ){
     138        ) {
    138139                $flux['data'] = preg_replace("/\.$ext$/", '', find_in_path("formulaires/inc-saisies-cvt.$ext"));
    139140        }
     
    150151 * @see saisies_formulaire_charger()
    151152 * @uses saisies_verifier()
    152  * 
     153 *
    153154 * @param array $flux
    154155 *     Liste des erreurs du formulaire
     
    156157 *     iste des erreurs
    157158 */
    158 function saisies_formulaire_verifier($flux){
     159function saisies_formulaire_verifier($flux) {
    159160        // Il faut que la fonction existe et qu'elle retourne bien un tableau
    160161        include_spip('inc/saisies');
     
    163164                // On ajoute au contexte les champs à déclarer
    164165                $erreurs = saisies_verifier($saisies);
    165                 if ($erreurs and !isset($erreurs['message_erreur']))
     166                if ($erreurs and !isset($erreurs['message_erreur'])) {
    166167                        $erreurs['message_erreur'] = _T('saisies:erreur_generique');
     168                }
    167169                $flux['data'] = array_merge($erreurs, $flux['data']);
    168170        }
     
    170172        return $flux;
    171173}
    172 
    173 
Note: See TracChangeset for help on using the changeset viewer.