Changeset 119900 in spip-zone


Ignore:
Timestamp:
Jan 22, 2020, 1:27:53 PM (4 weeks ago)
Author:
cedric@…
Message:

PSR

Location:
_plugins_/dictionnaires/trunk
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/dictionnaires/trunk/action/editer_definition.php

    r115393 r119900  
    286286}
    287287
    288 ?>
  • _plugins_/dictionnaires/trunk/action/editer_dictionnaire.php

    r115393 r119900  
    201201}
    202202
    203 ?>
  • _plugins_/dictionnaires/trunk/action/supprimer_dictionnaire.php

    r65485 r119900  
    4141}
    4242
    43 ?>
  • _plugins_/dictionnaires/trunk/dictionnaires_administrations.php

    r115394 r119900  
    55 *
    66 * @package SPIP\Dictionnaire\Installation
    7 **/
     7 **/
    88
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) {
     10if (!defined('_ECRIRE_INC_VERSION')){
    1111        return;
    1212}
     
    2121 * @return void
    2222 */
    23 function dictionnaires_upgrade($nom_meta_base_version, $version_cible) {
     23function dictionnaires_upgrade($nom_meta_base_version, $version_cible){
    2424
    2525        include_spip('inc/config');
     
    4040        $maj['0.4.0'] = array(
    4141                array('maj_tables', 'spip_dictionnaires'),
    42                 array('sql_update', 'spip_dictionnaires', array('statut'=>'actif'), 'actif=1'),
    43                 array('sql_update', 'spip_dictionnaires', array('statut'=>'inactif'), 'actif=0'),
     42                array('sql_update', 'spip_dictionnaires', array('statut' => 'actif'), 'actif=1'),
     43                array('sql_update', 'spip_dictionnaires', array('statut' => 'inactif'), 'actif=0'),
    4444                array('sql_alter', 'TABLE spip_dictionnaires DROP COLUMN actif'),
    4545        );
     
    5050        // Ajout du champ url_extense dans la table spip_definitions
    5151        $maj['0.4.2'] = array(array('maj_tables', 'spip_definitions'));
    52        
     52
    5353        // Ajout du champ id_trad sur les définitions
    5454        $maj['0.4.3'] = array(array('maj_tables', 'spip_definitions'));
     
    6262
    6363function definitions_langues(){
    64         sql_updateq('spip_definitions',array('lang'=>$GLOBALS['meta']['langue_site']),'lang = ""');
    65        
     64        sql_updateq('spip_definitions', array('lang' => $GLOBALS['meta']['langue_site']), 'lang = ""');
     65
    6666}
     67
    6768/**
    6869 * Migre les acronymes du plugins Forms & Tables (s'il est actif)
    6970 * dans ce plugin.
    70 **/
    71 function dictionnaires_migrer_acronymes() {
     71 **/
     72function dictionnaires_migrer_acronymes(){
    7273        // Si F&T contient une table d'acronymes
    7374        $trouver_table = charger_fonction('trouver_table', 'base');
    7475        $desc = $trouver_table('spip_forms');
    75         if (!is_array($desc)) return;
    76         if (count($liste = sql_fetsel('id_form', 'spip_forms', "type_form='acronymes_sigles'"))) {
     76        if (!is_array($desc)){
     77                return;
     78        }
     79        if (count($liste = sql_fetsel('id_form', 'spip_forms', "type_form='acronymes_sigles'"))){
    7780                $id_form = intval(reset($liste));
    78                 $acronymes = sql_allfetsel('id_donnee, statut, date', 'spip_forms_donnees', 'id_form = '.$id_form);
     81                $acronymes = sql_allfetsel('id_donnee, statut, date', 'spip_forms_donnees', 'id_form = ' . $id_form);
    7982                if ($acronymes and is_array($acronymes)){
    8083                        // On commence par créer un dictionnaire pour l'importation
     
    9093                                ));
    9194                                autoriser_exception('modifier', 'dictionnaire', $id_dictionnaire, false);
    92                                
     95
    9396                                // On parcourt ensuite les acronymes à importer pour récupérer leurs infos
    9497                                foreach ($acronymes as $acronyme){
    95                                         if ($titre = trim(str_replace("." , "", reset(sql_fetsel("valeur", "spip_forms_donnees_champs", array('id_donnee='.$acronyme['id_donnee'], "champ='ligne_1'")))))){
    96                                                 $lang_select = reset(sql_fetsel("valeur", "spip_forms_donnees_champs", array('id_donnee='.$acronyme['id_donnee'], "champ='select_2'")));
     98                                        if ($titre = trim(str_replace(".", "", reset(sql_fetsel("valeur", "spip_forms_donnees_champs", array('id_donnee=' . $acronyme['id_donnee'], "champ='ligne_1'")))))){
     99                                                $lang_select = reset(sql_fetsel("valeur", "spip_forms_donnees_champs", array('id_donnee=' . $acronyme['id_donnee'], "champ='select_2'")));
    97100                                                $lang = reset(sql_fetsel("titre", "spip_forms_champs_choix", array("champ='select_2'", "choix='$lang_select'")));
    98101                                                $definition = array(
    99102                                                        'id_dictionnaire' => $id_dictionnaire,
    100103                                                        'titre' => $titre,
    101                                                         'texte' => reset(sql_fetsel("valeur", "spip_forms_donnees_champs", array('id_donnee='.$acronyme['id_donnee'], "champ='texte_1'"))),
     104                                                        'texte' => reset(sql_fetsel("valeur", "spip_forms_donnees_champs", array('id_donnee=' . $acronyme['id_donnee'], "champ='texte_1'"))),
    102105                                                        'type' => 'abbr',
    103106                                                        'casse' => 1,
    104107                                                        'date' => $acronyme['date'],
    105                                                         'statut' => ($acronyme['statut'] == 'publie') ? 'publie' : 'prop',
     108                                                        'statut' => ($acronyme['statut']=='publie') ? 'publie' : 'prop',
    106109                                                        'lang' => $lang
    107110                                                );
    108                                                
     111
    109112                                                // On crée la définition dans la base SANS calculer le cache
    110113                                                include_spip('action/editer_definition');
     
    120123                                        }
    121124                                }
    122                                
     125
    123126                                // On calcule le cache des définitions une seule fois à la fin
    124127                                include_spip('inc/dictionnaires');
     
    136139 * @return void
    137140 */
    138 function dictionnaires_vider_tables($nom_meta_base_version) {
     141function dictionnaires_vider_tables($nom_meta_base_version){
    139142
    140143        include_spip('base/abstract_sql');
  • _plugins_/dictionnaires/trunk/dictionnaires_autoriser.php

    r112354 r119900  
    22
    33/**
    4  * Définit les autorisations du plugin dictionnaires 
     4 * Définit les autorisations du plugin dictionnaires
    55 *
    66 * @package SPIP\Dictionnaires\Autorisations
    7 **/
     7 **/
    88
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) {
     10if (!defined('_ECRIRE_INC_VERSION')){
    1111        return;
    1212}
     
    1616 * @pipeline autoriser
    1717 */
    18 function dictionnaires_autoriser(){}
     18function dictionnaires_autoriser(){
     19}
    1920
    2021/**
     
    2223 *
    2324 * Tout le monde
    24  * 
    25  * @param  string $faire Action demandée
    26  * @param  string $type Type d'objet sur lequel appliquer l'action
    27  * @param  int    $id    Identifiant de l'objet
    28  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    29  * @param  array  $opt  Options de cette autorisation
     25 *
     26 * @param string $faire Action demandée
     27 * @param string $type Type d'objet sur lequel appliquer l'action
     28 * @param int $id Identifiant de l'objet
     29 * @param array $qui Description de l'auteur demandant l'autorisation
     30 * @param array $opt Options de cette autorisation
    3031 * @return bool          true s'il a le droit, false sinon
    31 **/
     32 **/
    3233function autoriser_dictionnaires_menu_dist($faire, $type, $id, $qui, $opt){
    3334        return true;
     
    3839 *
    3940 * Tous les rédacteurs, lorsqu'il y a un dictionnaire
    40  * 
    41  * @param  string $faire Action demandée
    42  * @param  string $type Type d'objet sur lequel appliquer l'action
    43  * @param  int    $id    Identifiant de l'objet
    44  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    45  * @param  array  $opt  Options de cette autorisation
     41 *
     42 * @param string $faire Action demandée
     43 * @param string $type Type d'objet sur lequel appliquer l'action
     44 * @param int $id Identifiant de l'objet
     45 * @param array $qui Description de l'auteur demandant l'autorisation
     46 * @param array $opt Options de cette autorisation
    4647 * @return bool          true s'il a le droit, false sinon
    47 **/
    48 function autoriser_definition_creer_menu_dist($faire, $type, $id, $qui, $opt) {
     48 **/
     49function autoriser_definition_creer_menu_dist($faire, $type, $id, $qui, $opt){
    4950        return autoriser('creer', 'definition', $id, $qui, $opt);
    5051}
    5152
    5253/**
    53  * Autorisation de créer un dictionnaire 
     54 * Autorisation de créer un dictionnaire
    5455 *
    5556 * Ceux qui peuvent configurer le site
    56  * 
    57  * @param  string $faire Action demandée
    58  * @param  string $type Type d'objet sur lequel appliquer l'action
    59  * @param  int    $id    Identifiant de l'objet
    60  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    61  * @param  array  $opt  Options de cette autorisation
     57 *
     58 * @param string $faire Action demandée
     59 * @param string $type Type d'objet sur lequel appliquer l'action
     60 * @param int $id Identifiant de l'objet
     61 * @param array $qui Description de l'auteur demandant l'autorisation
     62 * @param array $opt Options de cette autorisation
    6263 * @return bool          true s'il a le droit, false sinon
    63 **/
     64 **/
    6465function autoriser_dictionnaire_creer_dist($faire, $type, $id, $qui, $opt){
    6566        return autoriser('configurer', $type, $id, $qui, $opt);
     
    7172 *
    7273 * Ceux qui peuvent configurer le site
    73  * 
    74  * @param  string $faire Action demandée
    75  * @param  string $type Type d'objet sur lequel appliquer l'action
    76  * @param  int    $id    Identifiant de l'objet
    77  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    78  * @param  array  $opt  Options de cette autorisation
     74 *
     75 * @param string $faire Action demandée
     76 * @param string $type Type d'objet sur lequel appliquer l'action
     77 * @param int $id Identifiant de l'objet
     78 * @param array $qui Description de l'auteur demandant l'autorisation
     79 * @param array $opt Options de cette autorisation
    7980 * @return bool          true s'il a le droit, false sinon
    80 **/
     81 **/
    8182function autoriser_dictionnaire_modifier_dist($faire, $type, $id, $qui, $opt){
    8283        return autoriser('configurer', $type, $id, $qui, $opt);
     
    8889 * Ceux qui peuvent configurer le site,
    8990 * s'il n'y a plus aucune définition dedans !
    90  * 
    91  * @param  string $faire Action demandée
    92  * @param  string $type Type d'objet sur lequel appliquer l'action
    93  * @param  int    $id    Identifiant de l'objet
    94  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    95  * @param  array  $opt  Options de cette autorisation
     91 *
     92 * @param string $faire Action demandée
     93 * @param string $type Type d'objet sur lequel appliquer l'action
     94 * @param int $id Identifiant de l'objet
     95 * @param array $qui Description de l'auteur demandant l'autorisation
     96 * @param array $opt Options de cette autorisation
    9697 * @return bool          true s'il a le droit, false sinon
    97 **/
     98 **/
    9899function autoriser_dictionnaire_supprimer_dist($faire, $type, $id, $qui, $opt){
    99         return ($id > 0)
     100        return ($id>0)
    100101                and autoriser('configurer', $type, $id, $qui, $opt)
    101102                and !sql_fetsel(
     
    103104                        'spip_definitions',
    104105                        array(
    105                                 'id_dictionnaire = '.$id,
     106                                'id_dictionnaire = ' . $id,
    106107                                sql_in('statut', array('publie', 'prop'))
    107108                        )
     
    111112
    112113/**
    113  * Autorisation de créer une définition dans un dictionnaire 
     114 * Autorisation de créer une définition dans un dictionnaire
    114115 *
    115116 * Les rédacteurs
    116  * 
    117  * @param  string $faire Action demandée
    118  * @param  string $type Type d'objet sur lequel appliquer l'action
    119  * @param  int    $id    Identifiant de l'objet
    120  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    121  * @param  array  $opt  Options de cette autorisation
     117 *
     118 * @param string $faire Action demandée
     119 * @param string $type Type d'objet sur lequel appliquer l'action
     120 * @param int $id Identifiant de l'objet
     121 * @param array $qui Description de l'auteur demandant l'autorisation
     122 * @param array $opt Options de cette autorisation
    122123 * @return bool          true s'il a le droit, false sinon
    123 **/
     124 **/
    124125function autoriser_dictionnaire_creerdefinitiondans_dist($faire, $type, $id, $qui, $opt){
    125         return $qui['statut'] <= '1comite';
     126        return $qui['statut']<='1comite';
    126127}
    127128
    128129/**
    129  * Autorisation de créer une définition 
     130 * Autorisation de créer une définition
    130131 *
    131132 * Les rédacteurs, et au moins un dictionnaire
    132  * 
    133  * @param  string $faire Action demandée
    134  * @param  string $type Type d'objet sur lequel appliquer l'action
    135  * @param  int    $id    Identifiant de l'objet
    136  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    137  * @param  array  $opt  Options de cette autorisation
     133 *
     134 * @param string $faire Action demandée
     135 * @param string $type Type d'objet sur lequel appliquer l'action
     136 * @param int $id Identifiant de l'objet
     137 * @param array $qui Description de l'auteur demandant l'autorisation
     138 * @param array $opt Options de cette autorisation
    138139 * @return bool          true s'il a le droit, false sinon
    139 **/
     140 **/
    140141function autoriser_definition_creer_dist($faire, $type, $id, $qui, $opt){
    141         return $qui['statut'] <= '1comite' and sql_countsel('spip_dictionnaires');
     142        return $qui['statut']<='1comite' and sql_countsel('spip_dictionnaires');
    142143}
    143144
     
    147148 *
    148149 * Un rédacteur si pas publié, un admin sinon
    149  * 
    150  * @param  string $faire Action demandée
    151  * @param  string $type Type d'objet sur lequel appliquer l'action
    152  * @param  int    $id    Identifiant de l'objet
    153  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    154  * @param  array  $opt  Options de cette autorisation
     150 *
     151 * @param string $faire Action demandée
     152 * @param string $type Type d'objet sur lequel appliquer l'action
     153 * @param int $id Identifiant de l'objet
     154 * @param array $qui Description de l'auteur demandant l'autorisation
     155 * @param array $opt Options de cette autorisation
    155156 * @return bool          true s'il a le droit, false sinon
    156 **/
     157 **/
    157158function autoriser_definition_modifier_dist($faire, $type, $id, $qui, $opt){
    158         if ($id > 0
    159                 and $statut = sql_getfetsel('statut', 'spip_definitions', 'id_definition = '.$id)
     159        if ($id>0
     160                and $statut = sql_getfetsel('statut', 'spip_definitions', 'id_definition = ' . $id)
    160161                and (
    161                         ($statut == 'publie' and $qui['statut'] <= '0minirezo')
     162                        ($statut=='publie' and $qui['statut']<='0minirezo')
    162163                        or
    163                         ($statut != 'publie' and $qui['statut'] <= '1comite')
     164                        ($statut!='publie' and $qui['statut']<='1comite')
    164165                )
    165166        ){
    166167                return true;
    167168        }
    168        
     169
    169170        return false;
    170171}
     
    175176 *
    176177 * Pareil que pour modifier une définition
    177  * 
    178  * @param  string $faire Action demandée
    179  * @param  string $type Type d'objet sur lequel appliquer l'action
    180  * @param  int    $id    Identifiant de l'objet
    181  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    182  * @param  array  $opt  Options de cette autorisation
     178 *
     179 * @param string $faire Action demandée
     180 * @param string $type Type d'objet sur lequel appliquer l'action
     181 * @param int $id Identifiant de l'objet
     182 * @param array $qui Description de l'auteur demandant l'autorisation
     183 * @param array $opt Options de cette autorisation
    183184 * @return bool          true s'il a le droit, false sinon
    184 **/
     185 **/
    185186function autoriser_definition_supprimer_dist($faire, $type, $id, $qui, $opt){
    186187        return autoriser('modifier', $type, $id, $qui, $opt);
  • _plugins_/dictionnaires/trunk/dictionnaires_fonctions.php

    r115309 r119900  
    33/**
    44 * Filtres pour les squelettes
    5  * 
     5 *
    66 * @package SPIP\Dictionnaires\Fonctions
    7 **/
     7 **/
    88
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) {
     10if (!defined('_ECRIRE_INC_VERSION')){
    1111        return;
    1212}
     
    1818 * N'ajoute pas de définition si les termes à définir sont déjà
    1919 * dans des balises de définition ou de code, genre <abbr> ou <code>
    20  * 
    21  * @param string $texte  Texte
     20 *
     21 * @param string $texte Texte
    2222 * @return string        Texte
    23 **/
    24 function filtre_definitions_dist($texte) {
     23 **/
     24function filtre_definitions_dist($texte){
    2525        /**
    2626         * Eviter d'être considéré comme spam lors du post si on met un mot considéré comme définition
    2727         * par exemple dans le titre d'un commentaire (plugin forum) ou d'un ticket (plugin tickets)
    2828         */
    29         if(_request('formulaire_action') && (substr(_request('formulaire_action'),0,7) == 'editer_'))
     29        if (_request('formulaire_action') && (substr(_request('formulaire_action'), 0, 7)=='editer_')){
    3030                return $texte;
     31        }
    3132        $GLOBALS['dictionnaires_id_texte'] = uniqid();
    3233        include_spip('inc/dictionnaires');
     
    3637                $masques[] = $definition['masque'];
    3738        }
    38        
     39
    3940        // Quelque soit le type de définition
    4041        // on ne fait rien à l'intérieur de certaines balises
     
    4243        preg_match_all($masque_echap, $texte, $balises_echap, PREG_SET_ORDER);
    4344        $morceaux_a_traiter = preg_split($masque_echap, $texte);
    44        
     45
    4546        // On parcours uniquement les textes hors balises <abbr>
    4647        foreach ($morceaux_a_traiter as $cle => $morceau_a_traiter){
     
    5051                $textes_a_traiter = preg_split($masque_balises, $morceau_a_traiter);
    5152                $textes_a_traiter = preg_replace_callback($masques, 'dictionnaires_replace_callback', $textes_a_traiter);
    52                
     53
    5354                foreach ($textes_a_traiter as $cle2 => $texte_a_traiter){
    54                         $textes_a_traiter[$cle2] = $texte_a_traiter ;
    55                         if (isset($balises[$cle2][0])) 
     55                        $textes_a_traiter[$cle2] = $texte_a_traiter;
     56                        if (isset($balises[$cle2][0])){
    5657                                $textes_a_traiter[$cle2] .= $balises[$cle2][0];
     58                        }
    5759                }
    58                
     60
    5961                $morceaux_a_traiter[$cle] = join('', $textes_a_traiter);
    60                 if (isset($balises_echap[$cle][0])) 
     62                if (isset($balises_echap[$cle][0])){
    6163                        $morceaux_a_traiter[$cle] .= $balises_echap[$cle][0];
     64                }
    6265        }
    6366        $texte = join('', $morceaux_a_traiter);
    64        
     67
    6568        $texte = echappe_retour($texte, 'dictionnaires');
    6669        return $texte;
    6770}
    68 
    6971
    7072
     
    7880 * @param string $captures Terme trouvé
    7981 * @return string          HTML du terme et de sa définition
    80 **/
    81 function dictionnaires_replace_callback($captures) {
     82 **/
     83function dictionnaires_replace_callback($captures){
    8284        include_spip('inc/config');
    8385        static $deja_remplaces = array();
     
    8587        $definitions = dictionnaires_lister_definitions_par_terme();
    8688        $remplacer_celui_la = true;
    87        
     89
    8890        // Si c'est un nouveau texte, on vide la liste des déjà remplacés
    89         $nouveau_texte = ((!$id_texte) or ($id_texte != $GLOBALS['dictionnaires_id_texte']));
     91        $nouveau_texte = ((!$id_texte) or ($id_texte!=$GLOBALS['dictionnaires_id_texte']));
    9092        if ($nouveau_texte){
    9193                $id_texte = $GLOBALS['dictionnaires_id_texte'];
    9294                $deja_remplaces = array();
    9395        }
    94        
     96
    9597        // Par défaut rien
    9698        $retour = $captures[0];
    97        
     99
    98100        // On cherche la définition du terme trouvé
    99         if ((isset($definitions[$captures[2]]) AND $definition = $definitions[$captures[2]]) 
     101        if ((isset($definitions[$captures[2]]) AND $definition = $definitions[$captures[2]])
    100102                or (isset($definitions[strtolower($captures[2])]) AND ($definition = $definitions[strtolower($captures[2])]))){
    101103                $type = $definition['type'];
    102                
     104
    103105                // Si on a demandé à remplacer uniquement le premier mot trouvé
    104106                if (
    105                         ($type and lire_config('dictionnaires/remplacer_premier_'.$type))
     107                        ($type and lire_config('dictionnaires/remplacer_premier_' . $type))
    106108                        or (!$type and lire_config('dictionnaires/remplacer_premier_defaut'))
    107109                ){
     
    112114                        }
    113115                }
    114                
     116
    115117                // On ne travaille pas pour rien !
    116118                if ($remplacer_celui_la){
    117                         if (function_exists("dictionnaires_remplacer_$type")) { $remplacer = "dictionnaires_remplacer_$type"; }
    118                         elseif (function_exists("dictionnaires_remplacer_${type}_dist")) { $remplacer = "dictionnaires_remplacer_${type}_dist"; }
    119                         elseif (function_exists("dictionnaires_remplacer_defaut")) { $remplacer = "dictionnaires_remplacer_defaut"; }
    120                         else { $remplacer = "dictionnaires_remplacer_defaut_dist"; }
    121                
    122                         $retour = $captures[1].code_echappement($remplacer($captures[2], $definition), 'dictionnaires');
     119                        if (function_exists("dictionnaires_remplacer_$type")){
     120                                $remplacer = "dictionnaires_remplacer_$type";
     121                        } elseif (function_exists("dictionnaires_remplacer_${type}_dist")) {
     122                                $remplacer = "dictionnaires_remplacer_${type}_dist";
     123                        } elseif (function_exists("dictionnaires_remplacer_defaut")) {
     124                                $remplacer = "dictionnaires_remplacer_defaut";
     125                        } else {
     126                                $remplacer = "dictionnaires_remplacer_defaut_dist";
     127                        }
     128
     129                        $retour = $captures[1] . code_echappement($remplacer($captures[2], $definition), 'dictionnaires');
    123130                        $deja_remplaces = array_merge($deja_remplaces, $definition['termes']);
    124131                }
    125132        }
    126        
     133
    127134        return $retour;
    128135}
  • _plugins_/dictionnaires/trunk/dictionnaires_pipelines.php

    r115393 r119900  
    33/**
    44 * Usage de pipelines
    5  * 
     5 *
    66 * @package SPIP\Dictionnaires\Pipelines
    7 **/
     7 **/
    88
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) {
     10if (!defined('_ECRIRE_INC_VERSION')){
    1111        return;
    1212}
     
    1717 * Pour chaque objet édité, regarde si les contenus possèdent des définitions
    1818 * que l'on connaît et dans ce cas crée une liaison entre l'objet et la définition.
    19  * 
     19 *
    2020 * Cela permet de connaître, pour une définition donnée, la liste des
    2121 * objets sur lesquels est rattaché une définition. À l'inverse, cela
    2222 * permet, pour un objet de connaître les définitions qu'il possède.
    2323 *
    24  * @todo
     24 * @param array $flux Données du pipeline
     25 * @return array        Données du pipeline
     26 **@todo
    2527 *     Tout cela est à faire !!!
    26  *
    27  * @pipeline post_edition
    2828 *
    29  * @param array $flux   Données du pipeline
    30  * @return array        Données du pipeline
    31 **/
    32 function dictionnaires_post_edition($flux) {
    33         // TOUT CELA EST A FAIRE
     29 * @pipeline post_edition
     30 *
     31 */
     32function dictionnaires_post_edition($flux){
     33        // TODO: TOUT CELA EST A FAIRE
    3434        return $flux;
    3535
    3636        // Seulement si c'est une modif d'objet
    37         if ($flux['args']['action'] == 'modifier' and $id_objet = $flux['args']['id_objet']){
     37        if ($flux['args']['action']=='modifier' and $id_objet = $flux['args']['id_objet']){
    3838                $trouver_table = charger_fonction('trouver_table', 'base/');
    3939                $desc = $trouver_table($flux['args']['table_objet'], $flux['args']['serveur']);
    4040                $id_table_objet = id_table_objet($flux['args']['type']);
    41                
     41
    4242                // On cherche les champs textuels
    4343                $champs_texte = array();
    44                 foreach ($desc['field'] as $champ=>$sql){
     44                foreach ($desc['field'] as $champ => $sql){
    4545                        if (preg_match('/(text|blob|varchar)/', $sql)){
    4646                                $champs_texte[] = $champ;
    4747                        }
    4848                }
    49                
     49
    5050                // On récupère ces champs
    5151                $textes = sql_fetsel($champs_texte, $flux['args']['spip_table_objet'], "$id_table_objet = $id_objet");
     
    5353                include_spip('inc/dictionnaires');
    5454                $definitions = dictionnaires_lister_definitions();
    55                
     55
    5656                // On les scanne
    5757                foreach ($textes as $texte){
    58                        
     58
    5959                }
    6060        }
     
    6868 * n'est pas en mode manuel. Ce mode est activable par la constante
    6969 * DICTIONNAIRES_DETECTION_MANUELLE mise à TRUE.
    70  *
    71  * @pipeline post_edition
    7270 *
    73  * @param string $texte  Texte
     71 * @pipeline post_edition
     72 *
     73 * @param string $texte Texte
    7474 * @return string        Texte
    75 **/
    76 function dictionnaires_post_propre($texte) {
     75 **/
     76function dictionnaires_post_propre($texte){
    7777        static $filtre_definitions = false;
    7878
     
    8080        // manuel, appliquer automatiquement la recherche de terme
    8181        if (!defined('DICTIONNAIRES_DETECTION_MANUELLE')
    82                 OR !DICTIONNAIRES_DETECTION_MANUELLE)
    83         {
    84                 if (!$filtre_definitions) {
     82                OR !DICTIONNAIRES_DETECTION_MANUELLE){
     83                if (!$filtre_definitions){
    8584                        $filtre_definitions = charger_filtre('definitions');
    8685                }
     
    9796 *
    9897 * @pipeline optimiser_base_disparus
    99  * @param  array $flux Données du pipeline
     98 * @param array $flux Données du pipeline
    10099 * @return array       Données du pipeline
    101100 */
    102 function dictionnaires_optimiser_base_disparus($flux) {
     101function dictionnaires_optimiser_base_disparus($flux){
    103102
    104103        sql_delete('spip_definitions', "statut='poubelle' AND maj < " . $flux['args']['date']);
  • _plugins_/dictionnaires/trunk/exec/puce_statut_definitions.php

    r65665 r119900  
    5959}
    6060
    61 ?>
  • _plugins_/dictionnaires/trunk/exec/puce_statut_dictionnaires.php

    r65665 r119900  
    5959}
    6060
    61 ?>
  • _plugins_/dictionnaires/trunk/formulaires/configurer_dictionnaires.php

    r65485 r119900  
    33/**
    44 * Gestion du formulaire de configuration des dictionnaires
    5  * 
     5 *
    66 * @package SPIP\Dictionnaires\Formulaires
    7 **/
     7 **/
    88
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) return;
     10if (!defined('_ECRIRE_INC_VERSION')){
     11        return;
     12}
    1113
    1214/**
     
    1517 * @return array
    1618 *     Liste des saisies du formulaire
    17 **/
     19 **/
    1820function formulaires_configurer_dictionnaires_saisies_dist(){
    1921        include_spip('inc/config');
    20        
     22
    2123        $saisies = array(
    2224                array(
     
    3537                ),
    3638        );
    37        
     39
    3840        return $saisies;
    3941}
     
    4446 * @return array
    4547 *     Environnement du formulaire
    46 **/
     48 **/
    4749function formulaires_configurer_dictionnaires_charger_dist(){
    4850        return array(
     
    5153        );
    5254}
    53 
    54 ?>
  • _plugins_/dictionnaires/trunk/formulaires/editer_definition.php

    r92115 r119900  
    55 *
    66 * @package SPIP\Dictionnaires\Formulaires
    7 **/
     7 **/
    88
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) return;
     10if (!defined('_ECRIRE_INC_VERSION')){
     11        return;
     12}
    1113
    1214include_spip('inc/editer');
     
    2426 * @return array
    2527 *     Liste de saisies et leurs options
    26 **/
    27 function formulaires_editer_definition_saisies_dist($id_definition='new', $id_dictionnaire=0, $retour='', $lier_trad=0){
     28 **/
     29function formulaires_editer_definition_saisies_dist($id_definition = 'new', $id_dictionnaire = 0, $retour = '', $lier_trad = 0){
    2830        $saisies = array(
    2931                array(
     
    9395                ),
    9496        );
    95        
     97
    9698        return $saisies;
    9799}
     
    100102 * Chargement du formulaire d'édition de définition
    101103 *
    102  * @see formulaires_editer_objet_charger()
    103  *
    104104 * @param int|string $id_definition
    105105 *     Identifiant de la définition. 'new' pour une nouvelle définition.
     
    110110 * @return array
    111111 *     Environnement du formulaire
    112 **/
    113 function formulaires_editer_definition_charger_dist($id_definition='new',  $id_dictionnaire=0, $retour='',$lier_trad=0){
     112 **@see formulaires_editer_objet_charger()
     113 *
     114 */
     115function formulaires_editer_definition_charger_dist($id_definition = 'new', $id_dictionnaire = 0, $retour = '', $lier_trad = 0){
    114116        $contexte = formulaires_editer_objet_charger('definition', $id_definition, $id_dictionnaire, $lier_trad, $retour, '');
    115        
     117
    116118        // Pour une case à cocher on est obligé de faire ça ici car la valeur "defaut" de la saisie ne marche pas
    117119        if (!($id_definition>0) and $id_dictionnaire>0){
    118                 $contexte['type'] = sql_getfetsel('type_defaut', 'spip_dictionnaires', 'id_dictionnaire = '.$id_dictionnaire);
     120                $contexte['type'] = sql_getfetsel('type_defaut', 'spip_dictionnaires', 'id_dictionnaire = ' . $id_dictionnaire);
    119121        }
    120        
     122
    121123        return $contexte;
    122124}
     
    127129 * ne representent pas l'objet edite
    128130 */
    129 function formulaires_editer_definition_identifier_dist($id_definition='new',  $id_dictionnaire=0, $retour='',$lier_trad=0){
    130         return serialize(array(intval($id_definition),$lier_trad));
     131function formulaires_editer_definition_identifier_dist($id_definition = 'new', $id_dictionnaire = 0, $retour = '', $lier_trad = 0){
     132        return serialize(array(intval($id_definition), $lier_trad));
    131133}
    132134
     
    134136 * Vérifications du formulaire d'édition de définition
    135137 *
    136  * @see formulaires_editer_objet_verifier()
    137  *
    138138 * @param int|string $id_definition
    139139 *     Identifiant de la définition. 'new' pour une nouvelle définition.
     
    144144 * @return array
    145145 *     Tableau des erreurs
    146 **/
    147 function formulaires_editer_definition_verifier_dist($id_definition='new',  $id_dictionnaire=0, $retour='',$lier_trad=0){
     146 **@see formulaires_editer_objet_verifier()
     147 *
     148 */
     149function formulaires_editer_definition_verifier_dist($id_definition = 'new', $id_dictionnaire = 0, $retour = '', $lier_trad = 0){
    148150        $erreurs = formulaires_editer_objet_verifier('definition', $id_definition);
    149151        return $erreurs;
     
    153155 * Traitements du formulaire d'édition de définition
    154156 *
    155  * @see formulaires_editer_objet_traiter()
    156  *
    157157 * @param int|string $id_definition
    158158 *     Identifiant de la définition. 'new' pour une nouvelle définition.
     
    163163 * @return array
    164164 *     Retour des traitements
    165 **/
    166 function formulaires_editer_definition_traiter_dist($id_definition='new',  $id_dictionnaire=0, $retour='',$lier_trad=0){
     165 **@see formulaires_editer_objet_traiter()
     166 *
     167 */
     168function formulaires_editer_definition_traiter_dist($id_definition = 'new', $id_dictionnaire = 0, $retour = '', $lier_trad = 0){
    167169
    168         if (is_null(_request('type'))){ set_request('type', ''); }
    169         if (is_null(_request('casse'))){ set_request('casse', ''); }
     170        if (is_null(_request('type'))){
     171                set_request('type', '');
     172        }
     173        if (is_null(_request('casse'))){
     174                set_request('casse', '');
     175        }
    170176
    171177        $retours = formulaires_editer_objet_traiter('definition', $id_definition, $id_dictionnaire, $lier_trad, $retour, '');
    172178        return $retours;
    173179}
    174 
    175 ?>
  • _plugins_/dictionnaires/trunk/formulaires/editer_dictionnaire.php

    r65485 r119900  
    55 *
    66 * @package SPIP\Dictionnaires\Formulaires
    7 **/
     7 **/
    88
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) return;
     10if (!defined('_ECRIRE_INC_VERSION')){
     11        return;
     12}
    1113
    1214include_spip('inc/editer');
     
    2123 * @return array
    2224 *     Liste de saisies et leurs options
    23 **/
    24 function formulaires_editer_dictionnaire_saisies_dist($id_dictionnaire='new', $retour=''){
     25 **/
     26function formulaires_editer_dictionnaire_saisies_dist($id_dictionnaire = 'new', $retour = ''){
    2527        $saisies = array(
    2628                array(
     
    6466                                'datas' => array(
    6567                                        'inactif' => _T('dictionnaire:champ_actif_non'),
    66                                         'actif'   => _T('dictionnaire:champ_actif_oui'),
     68                                        'actif' => _T('dictionnaire:champ_actif_oui'),
    6769                                ),
    6870                                'cacher_option_intro' => 'on'
     
    7072                ),
    7173        );
    72        
     74
    7375        return $saisies;
    7476}
     
    7880 * Chargement du formulaire d'édition de dictionnaire
    7981 *
    80  * @see formulaires_editer_objet_charger()
    81  *
    8282 * @param int|string $id_dictionnaire
    8383 *     Identifiant du dictionnaire. 'new' pour un nouveau dictionnaire.
     
    8686 * @return array
    8787 *     Environnement du formulaire
    88 **/
    89 function formulaires_editer_dictionnaire_charger_dist($id_dictionnaire='new', $retour=''){
     88 **@see formulaires_editer_objet_charger()
     89 *
     90 */
     91function formulaires_editer_dictionnaire_charger_dist($id_dictionnaire = 'new', $retour = ''){
    9092        $contexte = formulaires_editer_objet_charger('dictionnaire', $id_dictionnaire, 0, 0, $retour, '');
    9193        return $contexte;
     
    9597 * Vérifications du formulaire d'édition de dictionnaire
    9698 *
    97  * @see formulaires_editer_objet_verifier()
    98  *
    9999 * @param int|string $id_dictionnaire
    100100 *     Identifiant du dictionnaire. 'new' pour un nouveau dictionnaire.
     
    103103 * @return array
    104104 *     Tableau des erreurs
    105 **/
    106 function formulaires_editer_dictionnaire_verifier_dist($id_dictionnaire='new', $retour=''){
     105 **@see formulaires_editer_objet_verifier()
     106 *
     107 */
     108function formulaires_editer_dictionnaire_verifier_dist($id_dictionnaire = 'new', $retour = ''){
    107109        $erreurs = formulaires_editer_objet_verifier('dictionnaire', $id_dictionnaire);
    108110        return $erreurs;
     
    112114 * Traitements du formulaire d'édition de dictionnaire
    113115 *
    114  * @see formulaires_editer_objet_traiter()
    115  *
    116116 * @param int|string $id_dictionnaire
    117117 *     Identifiant du dictionnaire. 'new' pour un nouveau dictionnaire.
     
    120120 * @return array
    121121 *     Retour des traitements
    122 **/
    123 function formulaires_editer_dictionnaire_traiter_dist($id_dictionnaire='new', $retour=''){
    124         if (is_null(_request('type_defaut'))){ set_request('type_defaut', ''); }
     122 **@see formulaires_editer_objet_traiter()
     123 *
     124 */
     125function formulaires_editer_dictionnaire_traiter_dist($id_dictionnaire = 'new', $retour = ''){
     126        if (is_null(_request('type_defaut'))){
     127                set_request('type_defaut', '');
     128        }
    125129        $retours = formulaires_editer_objet_traiter('dictionnaire', $id_dictionnaire, 0, 0, $retour, '');
    126130        return $retours;
    127131}
    128132
    129 ?>
  • _plugins_/dictionnaires/trunk/inc/dictionnaires.php

    r115378 r119900  
    66 * @package SPIP\Dictionnaires\Fonctions
    77 */
    8  
     8
    99// Sécurité
    10 if (!defined('_ECRIRE_INC_VERSION')) return;
     10if (!defined('_ECRIRE_INC_VERSION')){
     11        return;
     12}
    1113
    1214/**
    1315 * Liste les définitions en activité
    14  * 
     16 *
    1517 * Récupére un tableau facilement utilisable de toutes les définitions en activité sur le site
    1618 * Une définition active est une définition publié ET dans un dico actif
     
    2022 * @return array
    2123 *     Tableau des définitions
    22  *      array(
    23  *              array(
    24  *                      'titre' => 'Truc',
    25  *                      'texte' => 'Ma définition',
    26  *                      'termes' => array('trucs', 'bidule'), // autres termes qui seront reconnus
    27  *                      'type' => '' | 'abbr',
    28  *              ),
    29  *              array(
    30  *                      ...
    31  *              )
    32  *      )
    33  */
    34 function dictionnaires_lister_definitions($purger=false){
     24 *  array(
     25 *    array(
     26 *      'titre' => 'Truc',
     27 *      'texte' => 'Ma définition',
     28 *      'termes' => array('trucs', 'bidule'), // autres termes qui seront reconnus
     29 *      'type' => '' | 'abbr',
     30 *    ),
     31 *    array(
     32 *      ...
     33 *    )
     34 *  )
     35 */
     36function dictionnaires_lister_definitions($purger = false){
    3537        // Le nom du fichier de cache
    3638        $langue = false;
    37         if(in_array('spip_definitions',explode(',',(isset($GLOBALS['meta']['multi_objets'])?$GLOBALS['meta']['multi_objets']:'')))){
     39        if (in_array('spip_definitions', explode(',', (isset($GLOBALS['meta']['multi_objets']) ? $GLOBALS['meta']['multi_objets'] : '')))){
    3840                $langue = _request('lang') ? _request('lang') : ($GLOBALS['spip_lang'] ? $GLOBALS['spip_lang'] : $GLOBALS['meta']['langue_site']);
    39                 if(!in_array($langue,explode(',', $GLOBALS['meta']['langues_multilingue'])))
     41                if (!in_array($langue, explode(',', $GLOBALS['meta']['langues_multilingue']))){
    4042                        $langue = $GLOBALS['meta']['langue_site'];
    41                 $fichier_cache =  _DIR_CACHE.'definitions_'.$langue.'.txt';
    42         }
    43         else{
    44                 $fichier_cache =  _DIR_CACHE.'definitions.txt';
     43                }
     44                $fichier_cache = _DIR_CACHE . 'definitions_' . $langue . '.txt';
     45        } else {
     46                $fichier_cache = _DIR_CACHE . 'definitions.txt';
    4547        }
    4648
    4749        // Par défaut rien
    4850        static $definitions_actives;
    49        
     51
    5052        // Si ça contient déjà quelque chose à ce stade, c'est avec le static donc on ne fait rien d'autre
    5153        if (!$purger and is_array($definitions_actives)){
    5254                return $definitions_actives;
    53         }
    54         else{
     55        } else {
    5556                $definitions_actives = array();
    5657        }
    57        
     58
    5859        // Si on le demande explicitement où si la lecture du fichier ne marche pas, on recalcule
    5960        if (
    60                 $purger == true
     61                $purger==true
    6162                or !lire_fichier($fichier_cache, $definitions_actives)
    6263                or !(is_array($definitions_actives = unserialize($definitions_actives)))
     
    6566
    6667                // On récupère tous les dictionnaires actifs
    67                 $dicos_actifs = sql_allfetsel('id_dictionnaire', 'spip_dictionnaires', 'statut = '. sql_quote('actif'));
     68                $dicos_actifs = sql_allfetsel('id_dictionnaire', 'spip_dictionnaires', 'statut = ' . sql_quote('actif'));
    6869                if ($dicos_actifs and is_array($dicos_actifs)){
    6970                        $dicos_actifs = array_map('reset', $dicos_actifs);
    7071                        $where = array(
    71                                         sql_in('id_dictionnaire', $dicos_actifs),
    72                                         'statut ='.sql_quote('publie')
    73                                 );
    74                         if($langue){
    75                                 $where[] = "lang =".sql_quote($langue);
     72                                sql_in('id_dictionnaire', $dicos_actifs),
     73                                'statut =' . sql_quote('publie')
     74                        );
     75                        if ($langue){
     76                                $where[] = "lang =" . sql_quote($langue);
    7677                        }
    7778                        // À l'intérieur on récupère toutes les définitions publiées
     
    8182                                $where
    8283                        );
    83                        
     84
    8485                        if ($definitions_publiees and is_array($definitions_publiees)){
    8586                                $definitions_actives = $definitions_publiees;
    8687                        }
    8788                }
    88                
     89
    8990                // On passe la liste des définitions actives dans un pipeline
    9091                $definitions_actives = pipeline('lister_definitions', $definitions_actives);
     
    9293                include_spip('inc/charsets');
    9394                // On traite maintenant le tableau pour ajouter des infos prêtes à l'emploi
    94                 foreach ($definitions_actives as $cle=>$definition){
     95                foreach ($definitions_actives as $cle => $definition){
    9596                        // Si les termes sont données en chaine, on coupe avec les virgules
    9697                        if (is_string($definition['termes'])){
    9798                                $definition['termes'] = array_map('trim', explode(',', $definition['termes']));
    98                         }
    99                         // Si c'est ni une string ni un tableau on met un tableau vide
    100                         elseif (!is_array($definition['termes'])){
     99                        } // Si c'est ni une string ni un tableau on met un tableau vide
     100                        elseif (!is_array($definition['termes'])) {
    101101                                $definition['termes'] = array();
    102102                        }
    103                        
     103
    104104                        // On ajoute le titre à la liste des termes reconnus
    105105                        $definition['termes'][] = $definition['titre'];
    106                        
     106
    107107                        // Si c'est une abbréviation, on reconnait automatique une version avec des p.o.i.n.t.s.?
    108                         if ($definition['type'] == 'abbr'){
     108                        if ($definition['type']=='abbr'){
    109109                                $titre = $definition['casse'] ? $definition['titre'] : strtolower($definition['titre']);
    110                                 $avec_points = spip_substr($titre,0,1);
     110                                $avec_points = spip_substr($titre, 0, 1);
    111111                                $length = spip_strlen($titre);
    112                                 for ($i=1 ; $i<$length ; $i++){
    113                                         $avec_points .= '.'.spip_substr($titre,$i,1);
     112                                for ($i = 1; $i<$length; $i++){
     113                                        $avec_points .= '.' . spip_substr($titre, $i, 1);
    114114                                }
    115                                 $definition['termes'][] = $avec_points.'.';
     115                                $definition['termes'][] = $avec_points . '.';
    116116                                $definition['termes'][] = $avec_points;
    117117                        }
    118                        
     118
    119119                        // On nettoie les termes = pas de truc vide, tout en minuscule, pas de doublons
    120120                        $definition['termes'] = array_filter($definition['termes']);
     
    123123                        }
    124124                        $definition['termes'] = array_unique($definition['termes']);
    125                        
     125
    126126                        // On génère le masque de recherche
    127127                        $definition['masque'] = '{([^\w@\.]|^)('
    128                                 .join(
     128                                . join(
    129129                                        '|',
    130130                                        array_map(
     
    133133                                        )
    134134                                )
    135                                 .')(?=([^\w]|\s|&nbsp;|$))}su'.($definition['casse']?'':'i');
    136                        
     135                                . ')(?=([^\w]|\s|&nbsp;|$))}su' . ($definition['casse'] ? '' : 'i');
     136
    137137                        // Et voilà
    138138                        $definitions_actives[$cle] = $definition;
    139139                }
    140                
     140
    141141                // Si on a des définitions à mettre en cache, on les écrit
    142142                if (is_writeable(_DIR_CACHE)){
     
    149149/**
    150150 * Lister les définitions par terme.
    151  * 
     151 *
    152152 * Chaque clé du tableau est alors un terme reconnu, en minuscule.
    153153 * Une même définition peut donc se trouver plusieurs fois dans la liste, avec différentes clés.
     
    158158        static $definitions_par_terme = array();
    159159        $definitions = dictionnaires_lister_definitions();
    160        
     160
    161161        if (!$definitions_par_terme and $definitions){
    162162                foreach ($definitions as $definition){
     
    166166                }
    167167        }
    168        
     168
    169169        return $definitions_par_terme;
    170170}
     
    180180 *     Code HTML de remplacement de la définition
    181181 */
    182 function dictionnaires_remplacer_defaut_dist($mot, $definition) {
    183         $class="";
    184         if ((!isset($definition['url']) OR !$url = $definition['url']) && (!isset($definition['url_externe']) OR !$url = $definition['url_externe'])) {
    185                 $url = generer_url_entite($definition['id_definition'],'definition');
    186         }else{
    187                 if(strpos($url,'http') == 0)
    188                         $class="spip_out";
    189         }
    190         $class = (strlen($class) > 0) ? " class='$class' " : "";
     182function dictionnaires_remplacer_defaut_dist($mot, $definition){
     183        $class = "";
     184        if ((!isset($definition['url']) OR !$url = $definition['url']) && (!isset($definition['url_externe']) OR !$url = $definition['url_externe'])){
     185                $url = generer_url_entite($definition['id_definition'], 'definition');
     186        } else {
     187                if (strpos($url, 'http')==0){
     188                        $class = "spip_out";
     189                }
     190        }
     191        $class = (strlen($class)>0) ? " class='$class' " : "";
    191192        return $mot
    192                 .'<sup><a href="'.$url.'"'.$class.'title="'._T('definition:titre_definition').': '
    193                         . couper(trim(attribut_html(supprimer_tags(typo(expanser_liens($definition['texte']))))),80).'">'
    194                 .'?'
    195                 .'</a></sup>';
     193                . '<sup><a href="' . $url . '"' . $class . 'title="' . _T('definition:titre_definition') . ': '
     194                . couper(trim(attribut_html(supprimer_tags(typo(expanser_liens($definition['texte']))))), 80) . '">'
     195                . '?'
     196                . '</a></sup>';
    196197}
    197198
     
    206207#}
    207208
    208 
    209 ?>
  • _plugins_/dictionnaires/trunk/inc/precharger_definition.php

    r92123 r119900  
    77 */
    88
    9 if (!defined('_ECRIRE_INC_VERSION')) return;
     9if (!defined('_ECRIRE_INC_VERSION')){
     10        return;
     11}
    1012
    1113include_spip('inc/precharger_objet');
     
    1517 *
    1618 * Lors d'une création, certains champs peuvent être préremplis
    17  * (c'est le cas des traductions) 
     19 * (c'est le cas des traductions)
    1820 *
    1921 * @param string|int $id
     
    2527 * @return array
    2628 *     Couples clés / valeurs des champs du formulaire à charger.
    27 **/
    28 function inc_precharger_definition_dist($id, $id_dictionnaire=0, $lier_trad=0) {
     29 **/
     30function inc_precharger_definition_dist($id, $id_dictionnaire = 0, $lier_trad = 0){
    2931        return precharger_objet('definition', $id, $id_dictionnaire, $lier_trad, 'titre');
    3032}
     
    3234/**
    3335 * Récupère les valeurs d'une traduction de référence pour la création
    34  * d'une definition (préremplissage du formulaire). 
     36 * d'une definition (préremplissage du formulaire).
    3537 *
    3638 * @note Fonction facultative si pas de changement dans les traitements
    37  * 
     39 *
    3840 * @param string|int $id
    3941 *     Identifiant de la definition, ou "new" pour une création
     
    4446 * @return array
    4547 *     Couples clés / valeurs des champs du formulaire à charger
    46 **/
    47 function inc_precharger_traduction_definition_dist($id, $id_dictionnaire=0, $lier_trad=0) {
     48 **/
     49function inc_precharger_traduction_definition_dist($id, $id_dictionnaire = 0, $lier_trad = 0){
    4850        return precharger_traduction_objet('definition', $id, $id_dictionnaire, $lier_trad, 'titre');
    4951}
    5052
    51 ?>
  • _plugins_/dictionnaires/trunk/paquet.xml

    r117696 r119900  
    22        prefix="dictionnaires"
    33        categorie="divers"
    4         version="1.3.0"
     4        version="1.3.1"
    55        etat="stable"
    66        compatibilite="[3.0.0;3.2.*]"
  • _plugins_/dictionnaires/trunk/puce_statut/definition.php

    r65665 r119900  
    55 *
    66 * @package SPIP\Dictionnaire\Puce_statut
    7 **/
     7 **/
    88
    99/**
    1010 * Gestion des puces statuts des définitions
    11  * 
     11 *
    1212 * Retourne le contenu d'une puce avec changement de statut possible
    1313 * si on en a l'autorisation, sinon simplement l'image de la puce
     
    2828 * @return string
    2929 *     Code HTML de l'image de puce de statut à insérer (et du menu de changement si présent)
    30 **/
    31 function puce_statut_definition_dist($id, $statut, $id_parent, $type='article', $ajax = false, $menu_rapide=_ACTIVER_PUCE_RAPIDE) {
     30 **/
     31function puce_statut_definition_dist($id, $statut, $id_parent, $type = 'article', $ajax = false, $menu_rapide = _ACTIVER_PUCE_RAPIDE){
    3232
    3333        $src = statut_image($type, $statut);
    34         if (!$src)
     34        if (!$src){
    3535                return $src;
     36        }
    3637
    3738        if (!$id
    38           OR !_SPIP_AJAX
    39           OR !$menu_rapide
    40           OR !autoriser('instituer', $type, $id)) {
    41           $ajax_node ='';
     39                OR !_SPIP_AJAX
     40                OR !$menu_rapide
     41                OR !autoriser('instituer', $type, $id)){
     42                $ajax_node = '';
     43        } else {
     44                $ajax_node = " class='imgstatut$type$id'";
    4245        }
    43         else
    44                 $ajax_node = " class='imgstatut$type$id'";
    4546
    46         $inser_puce = http_img_pack($src,statut_titre($type, $statut),$ajax_node);
     47        $inser_puce = http_img_pack($src, statut_titre($type, $statut), $ajax_node);
    4748
    48         if (!$ajax_node)
     49        if (!$ajax_node){
    4950                return $inser_puce;
     51        }
    5052
    5153        $table = table_objet_sql($type);
    5254        $desc = lister_tables_objets_sql($table);
    53         if (!isset($desc['statut_textes_instituer']))
     55        if (!isset($desc['statut_textes_instituer'])){
    5456                return $inser_puce;
     57        }
    5558
    5659        $coord = array_flip(array_keys($desc['statut_textes_instituer']));
    57         if (!isset($coord[$statut]))
     60        if (!isset($coord[$statut])){
    5861                return $inser_puce;
     62        }
    5963
    60         $unit = 8/*widh de img*/+4/*padding*/;
     64        $unit = 8/*widh de img*/+4/*padding*/
     65        ;
    6166        $margin = 4; /* marge a gauche + droite */
    62         $zero = 1 /*border*/ + $margin/2 + 2 /*padding*/;
    63         $clip = $zero+ ($unit*$coord[$statut]);
     67        $zero = 1 /*border*/+$margin/2+2 /*padding*/
     68        ;
     69        $clip = $zero+($unit*$coord[$statut]);
    6470        if ($ajax){
    6571
    6672                $width = $unit*count($desc['statut_textes_instituer'])+$margin;
    6773                $out = "<span class='puce_objet_fixe $type'>"
    68                 . $inser_puce
    69                 . "</span>"
    70                 . "<span class='puce_objet_popup $type statutdecal$type$id' style='width:{$width}px;margin-left:-{$clip}px;'>";
    71                 $i=0;
    72                 foreach($desc['statut_textes_instituer'] as $s=>$t){
    73                         $out .= afficher_script_statut($id, $type, -$zero-$i++*$unit, statut_image($type,$s), $s, _T($t));
     74                        . $inser_puce
     75                        . "</span>"
     76                        . "<span class='puce_objet_popup $type statutdecal$type$id' style='width:{$width}px;margin-left:-{$clip}px;'>";
     77                $i = 0;
     78                foreach ($desc['statut_textes_instituer'] as $s => $t){
     79                        $out .= afficher_script_statut($id, $type, -$zero-$i++*$unit, statut_image($type, $s), $s, _T($t));
    7480                }
    7581                $out .= "</span>";
    7682                return $out;
    77         }
    78         else {
     83        } else {
    7984
    8085                $nom = "puce_statut_";
    81                 $action = generer_url_ecrire('puce_statut_definitions',"",true);
     86                $action = generer_url_ecrire('puce_statut_definitions', "", true);
    8287                $action = "if (!this.puce_loaded) { this.puce_loaded = true; prepare_selec_statut(this, '$nom', '$type', '$id', '$action'); }";
    8388                $over = " onmouseover=\"$action\"";
    8489
    8590                $lang_dir = lang_dir(isset($GLOBALS['lang_objet']) ? $GLOBALS['lang_objet'] : "");
    86                 return  "<span class='puce_objet $type' id='$nom$type$id' dir='$lang_dir'$over>"
    87                 . $inser_puce
    88                 . '</span>';
     91                return "<span class='puce_objet $type' id='$nom$type$id' dir='$lang_dir'$over>"
     92                        . $inser_puce
     93                        . '</span>';
    8994        }
    9095}
  • _plugins_/dictionnaires/trunk/puce_statut/dictionnaire.php

    r65665 r119900  
    55 *
    66 * @package SPIP\Dictionnaire\Puce_statut
    7 **/
     7 **/
    88
    99/**
    1010 * Gestion des puces statuts des dictionnaires
    11  * 
     11 *
    1212 * Retourne le contenu d'une puce avec changement de statut possible
    1313 * si on en a l'autorisation, sinon simplement l'image de la puce
     
    2828 * @return string
    2929 *     Code HTML de l'image de puce de statut à insérer (et du menu de changement si présent)
    30 **/
    31 function puce_statut_dictionnaire_dist($id, $statut, $id_parent, $type='article', $ajax = false, $menu_rapide=_ACTIVER_PUCE_RAPIDE) {
     30 **/
     31function puce_statut_dictionnaire_dist($id, $statut, $id_parent, $type = 'article', $ajax = false, $menu_rapide = _ACTIVER_PUCE_RAPIDE){
    3232
    3333        $src = statut_image($type, $statut);
    34         if (!$src)
     34        if (!$src){
    3535                return $src;
     36        }
    3637
    3738        if (!$id
    38           OR !_SPIP_AJAX
    39           OR !$menu_rapide
    40           OR !autoriser('instituer', $type, $id)) {
    41           $ajax_node ='';
     39                OR !_SPIP_AJAX
     40                OR !$menu_rapide
     41                OR !autoriser('instituer', $type, $id)){
     42                $ajax_node = '';
     43        } else {
     44                $ajax_node = " class='imgstatut$type$id'";
    4245        }
    43         else
    44                 $ajax_node = " class='imgstatut$type$id'";
    4546
    46         $inser_puce = http_img_pack($src,statut_titre($type, $statut),$ajax_node);
     47        $inser_puce = http_img_pack($src, statut_titre($type, $statut), $ajax_node);
    4748
    48         if (!$ajax_node)
     49        if (!$ajax_node){
    4950                return $inser_puce;
     51        }
    5052
    5153        $table = table_objet_sql($type);
    5254        $desc = lister_tables_objets_sql($table);
    53         if (!isset($desc['statut_textes_instituer']))
     55        if (!isset($desc['statut_textes_instituer'])){
    5456                return $inser_puce;
     57        }
    5558
    5659        $coord = array_flip(array_keys($desc['statut_textes_instituer']));
    57         if (!isset($coord[$statut]))
     60        if (!isset($coord[$statut])){
    5861                return $inser_puce;
     62        }
    5963
    60         $unit = 8/*widh de img*/+4/*padding*/;
     64        $unit = 8/*widh de img*/+4/*padding*/
     65        ;
    6166        $margin = 4; /* marge a gauche + droite */
    62         $zero = 1 /*border*/ + $margin/2 + 2 /*padding*/;
    63         $clip = $zero+ ($unit*$coord[$statut]);
     67        $zero = 1 /*border*/+$margin/2+2 /*padding*/
     68        ;
     69        $clip = $zero+($unit*$coord[$statut]);
    6470        if ($ajax){
    6571
    6672                $width = $unit*count($desc['statut_textes_instituer'])+$margin;
    6773                $out = "<span class='puce_objet_fixe $type'>"
    68                 . $inser_puce
    69                 . "</span>"
    70                 . "<span class='puce_objet_popup $type statutdecal$type$id' style='width:{$width}px;margin-left:-{$clip}px;'>";
    71                 $i=0;
    72                 foreach($desc['statut_textes_instituer'] as $s=>$t){
    73                         $out .= afficher_script_statut($id, $type, -$zero-$i++*$unit, statut_image($type,$s), $s, _T($t));
     74                        . $inser_puce
     75                        . "</span>"
     76                        . "<span class='puce_objet_popup $type statutdecal$type$id' style='width:{$width}px;margin-left:-{$clip}px;'>";
     77                $i = 0;
     78                foreach ($desc['statut_textes_instituer'] as $s => $t){
     79                        $out .= afficher_script_statut($id, $type, -$zero-$i++*$unit, statut_image($type, $s), $s, _T($t));
    7480                }
    7581                $out .= "</span>";
    7682                return $out;
    77         }
    78         else {
     83        } else {
    7984
    8085                $nom = "puce_statut_";
    81                 $action = generer_url_ecrire('puce_statut_dictionnaires',"",true);
     86                $action = generer_url_ecrire('puce_statut_dictionnaires', "", true);
    8287                $action = "if (!this.puce_loaded) { this.puce_loaded = true; prepare_selec_statut(this, '$nom', '$type', '$id', '$action'); }";
    8388                $over = " onmouseover=\"$action\"";
    8489
    8590                $lang_dir = lang_dir(isset($GLOBALS['lang_objet']) ? $GLOBALS['lang_objet'] : "");
    86                 return  "<span class='puce_objet $type' id='$nom$type$id' dir='$lang_dir'$over>"
    87                 . $inser_puce
    88                 . '</span>';
     91                return "<span class='puce_objet $type' id='$nom$type$id' dir='$lang_dir'$over>"
     92                        . $inser_puce
     93                        . '</span>';
    8994        }
    9095}
Note: See TracChangeset for help on using the changeset viewer.