Changeset 93111 in spip-zone


Ignore:
Timestamp:
Nov 23, 2015, 8:30:17 PM (5 years ago)
Author:
teddy.spip@…
Message:

Formatage et indentation

Location:
_plugins_/noizetier/trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/noizetier/trunk/action/deplacer_noisette.php

    r66152 r93111  
    11<?php
    2 if (!defined("_ECRIRE_INC_VERSION")) return;
    32
    4 function action_deplacer_noisette_dist($arg=NULL){
    5         if (is_null($arg)){
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
     6
     7function action_deplacer_noisette_dist($arg = null)
     8{
     9        if (is_null($arg)) {
    610                $securiser_action = charger_fonction('securiser_action', 'inc');
    711                $arg = $securiser_action();
    812        }
    9        
     13
    1014        if ($arg) {
    1115                include_spip('noizetier_fonctions');
     
    1620        }
    1721}
    18 ?>
  • _plugins_/noizetier/trunk/action/supprimer_composition_noizetier.php

    r66152 r93111  
    1 <?php 
     1<?php
    22
    3 if (!defined("_ECRIRE_INC_VERSION")) return;
    43
    5 function action_supprimer_composition_noizetier_dist($page=NULL){
    6         if (is_null($page)){
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
     7
     8function action_supprimer_composition_noizetier_dist($page = null)
     9{
     10        if (is_null($page)) {
    711                $securiser_action = charger_fonction('securiser_action', 'inc');
    812                $page = $securiser_action();
    913        }
    10        
     14
    1115        if ($page) {
    1216                include_spip('noizetier_fonctions');
     
    1418        }
    1519}
    16 
    17 ?>
  • _plugins_/noizetier/trunk/action/supprimer_noisette.php

    r66152 r93111  
    11<?php
    2 if (!defined("_ECRIRE_INC_VERSION")) return;
    32
    4 function action_supprimer_noisette_dist($id_noisette=NULL){
    5         if (is_null($id_noisette)){
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
     6
     7function action_supprimer_noisette_dist($id_noisette = null)
     8{
     9        if (is_null($id_noisette)) {
    610                $securiser_action = charger_fonction('securiser_action', 'inc');
    711                $id_noisette = $securiser_action();
    812        }
    9        
     13
    1014        if (intval($id_noisette)) {
    1115                include_spip('noizetier_fonctions');
     
    1317        }
    1418}
    15 ?>
  • _plugins_/noizetier/trunk/action/supprimer_noisettes_page.php

    r66152 r93111  
    11<?php
    2 if (!defined("_ECRIRE_INC_VERSION")) return;
    32
    4 function action_supprimer_noisettes_page_dist($page=NULL){
    5         if (is_null($page)){
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
     6
     7function action_supprimer_noisettes_page_dist($page = null)
     8{
     9        if (is_null($page)) {
    610                $securiser_action = charger_fonction('securiser_action', 'inc');
    711                $page = $securiser_action();
    812        }
    9        
     13
    1014        if ($page) {
    1115                include_spip('noizetier_fonctions');
     
    1317        }
    1418}
    15 ?>
  • _plugins_/noizetier/trunk/balise/noizetier_afficher_noisette.php

    r77611 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    6 
    7 
    8 function balise_NOIZETIER_AFFICHER_NOISETTE_dist($p) {
    9        
     8function balise_NOIZETIER_AFFICHER_NOISETTE_dist($p)
     9{
    1010        $id_noisette = champ_sql('id_noisette', $p);
    1111        $noisette = champ_sql('noisette', $p);
    1212        $parametres = champ_sql('parametres', $p);
    13        
     13
    1414        // As-t-on demandé explicitement à ne pas ajaxifier ? #NOIZETIER_AFFICHER_NOISETTE{noajax}
    1515        $_ajax = 'true';
    16         if (($v = interprete_argument_balise(1,$p))!==NULL)
     16        if (($v = interprete_argument_balise(1, $p)) !== null) {
    1717                $_ajax = 'false';
    18                
     18        }
    1919
    2020        // si pas de contexte attribuer, on passe tout le contexte que l'on recoit
     
    2424        // $id_noisette est toujours transmis dans l'environnement
    2525        $environnement = "array_merge(\$Pile[0],array('id_noisette' => $id_noisette))";
    26        
     26
    2727        $inclusion_dynamique = "\"<?php echo recuperer_fond(
    2828                'noisettes/\".$noisette.\"',
     
    3131        );?>\"";
    3232
    33         $inclusion_statique =  "recuperer_fond(
     33        $inclusion_statique = "recuperer_fond(
    3434                'noisettes/'.$noisette,
    3535                array_merge(unserialize($parametres), noizetier_choisir_contexte($noisette, $environnement, $id_noisette)),
    3636                array('ajax'=>($_ajax && noizetier_ajaxifier_noisette($noisette)))
    3737        )";
    38        
     38
    3939        $code = "((noizetier_inclusion_dynamique($noisette)) ? $inclusion_dynamique : $inclusion_statique)";
    40        
    41         $p->code =  "((!$id_noisette) ? _T('zbug_champ_hors_motif', array('champ'=>'ID_NOISETTE', 'motif'=>'NOISETTES')) : $code)";
     40
     41        $p->code = "((!$id_noisette) ? _T('zbug_champ_hors_motif', array('champ'=>'ID_NOISETTE', 'motif'=>'NOISETTES')) : $code)";
    4242        $p->interdire_scripts = false;
    43        
     43
    4444        return $p;
    45    
    4645}
  • _plugins_/noizetier/trunk/balise/noizetier_info_noisette.php

    r66152 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    68// Cette balise renvoie le tableau de description d'une noisette particulière
    7 function balise_NOIZETIER_INFO_NOISETTE_dist($p) {
    8                 $noisette = interprete_argument_balise(1,$p);
    9                 $p->code = "noizetier_info_noisette($noisette)";
     9function balise_NOIZETIER_INFO_NOISETTE_dist($p)
     10{
     11        $noisette = interprete_argument_balise(1, $p);
     12        $p->code = "noizetier_info_noisette($noisette)";
     13
    1014        return $p;
    1115}
    12 
    13 
    14 ?>
  • _plugins_/noizetier/trunk/balise/noizetier_liste_icones.php

    r36486 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    68// Cette balise renvoie le tableau de la liste des icones
    7 function balise_NOIZETIER_LISTE_ICONES_dist($p) {
    8                 $p->code = "noizetier_lister_icones()";
     9function balise_NOIZETIER_LISTE_ICONES_dist($p)
     10{
     11        $p->code = 'noizetier_lister_icones()';
     12
    913        return $p;
    1014}
    11 
    12 
    13 ?>
  • _plugins_/noizetier/trunk/balise/noizetier_liste_noisettes.php

    r66152 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    68// Cette balise renvoie le tableau de la liste des noisettes disponibles
    7 function balise_NOIZETIER_LISTE_NOISETTES_dist($p) {
    8                 $type = interprete_argument_balise(1,$p);
    9                 if (is_null($type))
    10                         $p->code = "noizetier_lister_noisettes()";
    11                 else
    12                         $p->code = "noizetier_lister_noisettes($type)";
     9function balise_NOIZETIER_LISTE_NOISETTES_dist($p)
     10{
     11        $type = interprete_argument_balise(1, $p);
     12        if (is_null($type)) {
     13                $p->code = 'noizetier_lister_noisettes()';
     14        } else {
     15                $p->code = "noizetier_lister_noisettes($type)";
     16        }
     17
    1318        return $p;
    1419}
    15 
    16 
    17 ?>
  • _plugins_/noizetier/trunk/balise/noizetier_liste_pages.php

    r66152 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    68// Cette balise renvoie le tableau de la liste des pages
    7 function balise_NOIZETIER_LISTE_PAGES_dist($p) {
    8                 $page_specifique = interprete_argument_balise(1,$p);
    9                 $p->code = "noizetier_lister_pages($page_specifique)";
     9function balise_NOIZETIER_LISTE_PAGES_dist($p)
     10{
     11        $page_specifique = interprete_argument_balise(1, $p);
     12        $p->code = "noizetier_lister_pages($page_specifique)";
     13
    1014        return $p;
    1115}
    12 
    13 
    14 ?>
  • _plugins_/noizetier/trunk/balise/noizetier_noisette_preview.php

    r66152 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    6 
    7 
    8 function balise_NOIZETIER_NOISETTE_PREVIEW_dist($p) {
    9        
     8function balise_NOIZETIER_NOISETTE_PREVIEW_dist($p)
     9{
    1010        $id_noisette = champ_sql('id_noisette', $p);
    1111        $noisette = champ_sql('noisette', $p);
    1212        $parametres = champ_sql('parametres', $p);
    13        
    14         $inclusion =  "recuperer_fond(
     13
     14        $inclusion = "recuperer_fond(
    1515                'noisette_preview',
    1616                array_merge(unserialize($parametres), array('noisette' => $noisette))
    1717        )";
    18        
    19         $p->code =  "$inclusion";
     18
     19        $p->code = "$inclusion";
    2020        $p->interdire_scripts = false;
     21
    2122        return $p;
    2223}
    23 
    24 ?>
  • _plugins_/noizetier/trunk/base/noizetier_tables.php

    r44084 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    6 function noizetier_declarer_tables_interfaces($interface){
     8function noizetier_declarer_tables_interfaces($interface)
     9{
    710        // 'spip_' dans l'index de $tables_principales
    8         $interface['table_des_tables']['noisettes']='noisettes';
    9        
     11        $interface['table_des_tables']['noisettes'] = 'noisettes';
     12
    1013        return $interface;
    1114}
    1215
    13 function noizetier_declarer_tables_principales($tables_principales){
     16function noizetier_declarer_tables_principales($tables_principales)
     17{
    1418        //-- Table noisettes -----------------------------------------------------------
    1519        $noisettes = array(
    16                 "id_noisette" => "bigint(21) NOT NULL",
    17                 "rang" => "smallint DEFAULT '1' NOT NULL",
    18                 "type" => "tinytext DEFAULT '' NOT NULL",
    19                 "composition" => "tinytext DEFAULT '' NOT NULL",
    20                 "bloc" => "tinytext DEFAULT '' NOT NULL",
    21                 "noisette" => "tinytext DEFAULT '' NOT NULL",
    22                 "parametres" => "text DEFAULT '' NOT NULL",
    23                 "css" => "tinytext DEFAULT '' NOT NULL"
     20                'id_noisette' => 'bigint(21) NOT NULL',
     21                'rang' => "smallint DEFAULT '1' NOT NULL",
     22                'type' => "tinytext DEFAULT '' NOT NULL",
     23                'composition' => "tinytext DEFAULT '' NOT NULL",
     24                'bloc' => "tinytext DEFAULT '' NOT NULL",
     25                'noisette' => "tinytext DEFAULT '' NOT NULL",
     26                'parametres' => "text DEFAULT '' NOT NULL",
     27                'css' => "tinytext DEFAULT '' NOT NULL",
    2428        );
    25        
     29
    2630        $noisettes_cles = array(
    27                 "PRIMARY KEY" => "id_noisette"
     31                'PRIMARY KEY' => 'id_noisette',
    2832        );
    29        
     33
    3034        $tables_principales['spip_noisettes'] = array(
    3135                'field' => &$noisettes,
    32                 'key' => &$noisettes_cles
     36                'key' => &$noisettes_cles,
    3337        );
    34        
     38
    3539        return $tables_principales;
    3640}
    37 
    38 ?>
  • _plugins_/noizetier/trunk/formulaires/ajouter_noisette.php

    r66152 r93111  
    11<?php
    22
    3 if (!defined('_ECRIRE_INC_VERSION')) return;
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
    46
    57include_spip('noizetier_fonctions');
    68include_spip('base/abstract_sql');
    7 if (!function_exists('autoriser'))
    8         include_spip('inc/autoriser');   // si on utilise le formulaire dans le public
     9if (!function_exists('autoriser')) {
     10        include_spip('inc/autoriser');
     11}     // si on utilise le formulaire dans le public
    912
    1013// Note : $retour indique la page à charger en cas d'ajout
    1114//        @id_noisette@ étant alors remplacer par la bonne valeur, connue seulement après ajout de la noisette
    1215
    13 function formulaires_ajouter_noisette_charger_dist($page, $bloc, $retour=''){
     16function formulaires_ajouter_noisette_charger_dist($page, $bloc, $retour = '')
     17{
    1418        return array(
    1519                'page' => $page,
    1620                'bloc' => $bloc,
    17                 'editable' => autoriser('configurer','noizetier') ? 'on' : ''
     21                'editable' => autoriser('configurer', 'noizetier') ? 'on' : '',
    1822        );
    1923}
    2024
    21 function formulaires_ajouter_noisette_traiter_dist($page, $bloc, $retour=''){
    22         if (!autoriser('configurer','noizetier'))
     25function formulaires_ajouter_noisette_traiter_dist($page, $bloc, $retour = '')
     26{
     27        if (!autoriser('configurer', 'noizetier')) {
    2328                return array('message_erreur' => _T('noizetier:probleme_droits'));
    24        
     29        }
     30
    2531        $res = array();
    2632        $noisette = _request('noisette');
    27        
    28         if (!$noisette)
     33
     34        if (!$noisette) {
    2935                return array('message_erreur' => _T('noizetier:erreur_aucune_noisette_selectionnee'));
    30        
     36        }
     37
    3138        if ($noisette) {
    32                 if( $id_noisette = noizetier_ajouter_noisette($noisette, $page, $bloc)) {
     39                if ($id_noisette = noizetier_ajouter_noisette($noisette, $page, $bloc)) {
    3340                        $res['message_ok'] = _T('info_modification_enregistree');
    3441                        if ($retour) {
    3542                                $retour = str_replace('&amp;', '&', $retour); // Grrr, y a surement plus propre
    3643                                $retour = str_replace('@id_noisette@', $id_noisette, $retour);
    37                                 if (strncmp($retour,'javascript:',11)==0){
    38                                         $res['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($retour,11).'/*]]>*/</script>';
     44                                if (strncmp($retour, 'javascript:', 11) == 0) {
     45                                        $res['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($retour, 11).'/*]]>*/</script>';
    3946                                        $res['editable'] = true;
     47                                } else {
     48                                        $res['redirect'] = $retour;
    4049                                }
    41                                 else
    42                                         $res['redirect'] = $retour;
    4350                        }
     51                } else {
     52                        $res['message_erreur'] = _T('noizetier:erreur_mise_a_jour');
    4453                }
    45                 else
    46                         $res['message_erreur'] = _T('noizetier:erreur_mise_a_jour');
    4754        }
     55
    4856        return $res;
    4957}
    50 
    51 ?>
  • _plugins_/noizetier/trunk/formulaires/editer_noisette.php

    r68068 r93111  
    11<?php
    22
    3 if (!defined('_ECRIRE_INC_VERSION')) return;
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
    46
    57include_spip('noizetier_fonctions');
    68include_spip('base/abstract_sql');
    79include_spip('inc/saisies');
    8 if (!function_exists('autoriser'))
    9         include_spip('inc/autoriser');   // si on utilise le formulaire dans le public
     10if (!function_exists('autoriser')) {
     11        include_spip('inc/autoriser');
     12}     // si on utilise le formulaire dans le public
    1013
    11 function formulaires_editer_noisette_charger_dist($id_noisette, $retour=''){
     14function formulaires_editer_noisette_charger_dist($id_noisette, $retour = '')
     15{
    1216        $valeurs = array();
    1317        $valeurs['id_noisette'] = $id_noisette;
     
    1923        $noisette = $entree['noisette'];
    2024        $valeurs['noisette'] = $noisette;
    21        
     25
    2226        // Il faut aller recherche les parametres par defaut de la noisette
    2327        // pour generer le tableau de saisie
     
    3034                        'label' => _T('noizetier:label_noizetier_css'),
    3135                        'explication' => _T('noizetier:explication_noizetier_css'),
    32                         'defaut' => $entree['css']
    33                 )
     36                        'defaut' => $entree['css'],
     37                ),
    3438        );
    35         $valeurs['editable'] = autoriser('configurer','noizetier') ? 'on' : '';
    36        
     39        $valeurs['editable'] = autoriser('configurer', 'noizetier') ? 'on' : '';
     40
    3741        // Inserer dans le contexte les valeurs des parametres
    3842        // NB : on doit passer par saisies_charger_champs() au cas ou la definition de la noisette a change et qu'il y a de nouveau champs a prendre en compte
    3943        $parametres = unserialize($entree['parametres']);
    40         if (is_array($parametres))
     44        if (is_array($parametres)) {
    4145                $valeurs = array_merge($valeurs, saisies_charger_champs($infos_noisette['parametres']), $parametres);
     46        }
    4247        $valeurs['css'] = $entree['css'];
    43        
     48
    4449        return $valeurs;
    4550}
    4651
    47 function formulaires_editer_noisette_verifier_dist($id_noisette, $retour=''){
     52function formulaires_editer_noisette_verifier_dist($id_noisette, $retour = '')
     53{
    4854        $noisette = _request('noisette');
    4955        $infos_noisette = noizetier_info_noisette($noisette);
    50         return saisies_verifier($infos_noisette['parametres'],false);
     56
     57        return saisies_verifier($infos_noisette['parametres'], false);
    5158}
    5259
    53 function formulaires_editer_noisette_traiter_dist($id_noisette, $retour=''){
    54         if (!autoriser('configurer','noizetier'))
     60function formulaires_editer_noisette_traiter_dist($id_noisette, $retour = '')
     61{
     62        if (!autoriser('configurer', 'noizetier')) {
    5563                return array('message_erreur' => _T('noizetier:probleme_droits'));
    56        
     64        }
     65
    5766        $res = array();
    5867        $css = _request('css');
     
    6069        $infos_noisette = noizetier_info_noisette($noisette);
    6170        $parametres = array();
    62         foreach (saisies_lister_champs($infos_noisette['parametres'],false) as $champ)
     71        foreach (saisies_lister_champs($infos_noisette['parametres'], false) as $champ) {
    6372                $parametres[$champ] = _request($champ);
    64         if (sql_updateq('spip_noisettes',array('parametres' => serialize($parametres),'css' => $css),'id_noisette='.$id_noisette)) {
     73        }
     74        if (sql_updateq('spip_noisettes', array('parametres' => serialize($parametres), 'css' => $css), 'id_noisette='.$id_noisette)) {
    6575                // On invalide le cache
    6676                include_spip('inc/invalideur');
     
    6878                $res['message_ok'] = _T('info_modification_enregistree');
    6979                if ($retour) {
    70                         if (strncmp($retour,'javascript:',11)==0){
    71                                 $res['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($retour,11).'/*]]>*/</script>';
     80                        if (strncmp($retour, 'javascript:', 11) == 0) {
     81                                $res['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($retour, 11).'/*]]>*/</script>';
    7282                                $res['editable'] = true;
     83                        } else {
     84                                $res['redirect'] = $retour;
    7385                        }
    74                         else
    75                                 $res['redirect'] = $retour;
    7686                }
     87        } else {
     88                $res['message_erreur'] = _T('noizetier:erreur_mise_a_jour');
    7789        }
    78         else
    79                 $res['message_erreur'] = _T('noizetier:erreur_mise_a_jour');
     90
    8091        return $res;
    8192}
    82 
    83 ?>
  • _plugins_/noizetier/trunk/formulaires/editer_page.php

    r92075 r93111  
    11<?php
    22
    3 if (!defined('_ECRIRE_INC_VERSION')) return;
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
    46
    57include_spip('noizetier_fonctions');
    6 if (!function_exists('autoriser'))
    7         include_spip('inc/autoriser');   // si on utilise le formulaire dans le public
     8if (!function_exists('autoriser')) {
     9        include_spip('inc/autoriser');
     10}     // si on utilise le formulaire dans le public
    811
    912
    1013// Détermine les compositions héritables par ce type de page
    11 function heritiers($type){
     14function heritiers($type)
     15{
    1216        $heritiers = array();
    13         foreach (compositions_recuperer_heritage() as $enfant => $parent)
    14                 if ($parent == $type)
    15                         $heritiers = array_merge($heritiers,compositions_lister_disponibles($enfant));
     17        foreach (compositions_recuperer_heritage() as $enfant => $parent) {
     18                if ($parent == $type) {
     19                        $heritiers = array_merge($heritiers, compositions_lister_disponibles($enfant));
     20                }
     21        }
     22
    1623        return $heritiers;
    1724}
    1825
    19 
    2026/**
    21  * Formulaire d'édition d'une page de composition de noisettes
     27 * Formulaire d'édition d'une page de composition de noisettes.
    2228 *
    2329 * Déclarer les champs postés et y intégrer les valeurs par défaut
     
    3036 *
    3137 * @param string $page
    32  *     identifiant d'une composition
     38 *                       identifiant d'une composition
    3339 * @param string $new
    34  *     pour créer une nouvelle composition
     40 *                       pour créer une nouvelle composition
    3541 * @param string $retour
    36  *     URL de redirection
     42 *                       URL de redirection
    3743 */
    38 function formulaires_editer_page_charger_dist($page, $new, $retour=''){
     44function formulaires_editer_page_charger_dist($page, $new, $retour = '')
     45{
    3946        $valeurs = array();
    40         $valeurs['editable'] = autoriser('configurer','noizetier') ? 'on' : '';
     47        $valeurs['editable'] = autoriser('configurer', 'noizetier') ? 'on' : '';
    4148        $noizetier_compositions = isset($GLOBALS['meta']['noizetier_compositions']) && unserialize($GLOBALS['meta']['noizetier_compositions']) ? unserialize($GLOBALS['meta']['noizetier_compositions']) : array();
    4249
     
    4552        // $page :        modification d'une page existante
    4653        // $page + $new : création d'une nouvelle page prépeuplée avec le contenu d'une page existante = duplication
    47         $acte = ($page AND $new) ? 'dupliquer' : ($page ? 'modifier' : ($new ? 'creer' : ''));
     54        $acte = ($page and $new) ? 'dupliquer' : ($page ? 'modifier' : ($new ? 'creer' : ''));
    4855        // on ne duplique pas les compositions mères
    4956        //if ($acte == 'dupliquer' AND is_null(noizetier_page_composition($page))) $acte = 'creer';
    5057
    5158        // modification ou duplication
    52         if (in_array($acte, array('modifier','dupliquer'))) {
     59        if (in_array($acte, array('modifier', 'dupliquer'))) {
    5360                $type_page = noizetier_page_type($page);          // objet ou page
    5461                $composition = noizetier_page_composition($page); // identifiant de la composition
    5562                // On vérifie que cette composition existe
    5663                // et si elle n'existe pas
    57                 if (!is_array($noizetier_compositions[$type_page][$composition])){
     64                if (!is_array($noizetier_compositions[$type_page][$composition])) {
    5865                        $contexte['editable'] = false;
    5966                        $contexte['message_erreur'] = _T('spip:erreur');
     
    6471                if ($acte == 'dupliquer') {
    6572                        $infos_xml_page = noizetier_lister_pages($page);
    66                         $infos_compo_xml = array( $composition => array (
     73                        $infos_compo_xml = array($composition => array(
    6774                                        'nom' => $infos_xml_page['nom'],
    6875                                        'description' => $infos_xml_page['description'],
    69                                         'icon' => $infos_xml_page['icon']
     76                                        'icon' => $infos_xml_page['icon'],
    7077                        ));
    7178                        $infos_compo_meta = $noizetier_compositions[$type_page];
    72                         if (is_null($infos_compo_meta)) $infos_compo_meta = array();
     79                        if (is_null($infos_compo_meta)) {
     80                                $infos_compo_meta = array();
     81                        }
    7382                        $infos_compo = array_merge($infos_compo_meta, $infos_compo_xml);
    7483                        $noizetier_compositions = array_merge($noizetier_compositions, array($type_page => $infos_compo));
     
    7887                $valeurs['type_page'] = $type_page;
    7988                $valeurs['composition'] = ($acte == 'modifier') ? $composition : ''; // si on duplique, nouvelle valeur
    80                 if ($acte == 'dupliquer') $valeurs['composition_ref'] = $composition;
     89                if ($acte == 'dupliquer') {
     90                        $valeurs['composition_ref'] = $composition;
     91                }
    8192                $valeurs['nom'] = $noizetier_compositions[$type_page][$composition]['nom'];
    8293                $valeurs['description'] = $noizetier_compositions[$type_page][$composition]['description'];
    8394                $valeurs['icon'] = $noizetier_compositions[$type_page][$composition]['icon'];
    8495                $valeurs['_heritiers'] = heritiers($type_page);
    85                 foreach($valeurs['_heritiers'] as $t => $i)
    86                         if (isset($noizetier_compositions[$type_page][$composition]['branche'][$t]))
     96                foreach ($valeurs['_heritiers'] as $t => $i) {
     97                        if (isset($noizetier_compositions[$type_page][$composition]['branche'][$t])) {
    8798                                $valeurs['heritage-'.$t] = $noizetier_compositions[$type_page][$composition]['branche'][$t];
     99                        }
     100                }
    88101        }
    89102
     
    97110                // Définir la liste des objets avec compositions
    98111                $valeurs['_objets_avec_compos'] = array();
    99                 if(defined('_NOIZETIER_COMPOSITIONS_TYPE_PAGE') AND _NOIZETIER_COMPOSITIONS_TYPE_PAGE)
     112                if (defined('_NOIZETIER_COMPOSITIONS_TYPE_PAGE') and _NOIZETIER_COMPOSITIONS_TYPE_PAGE) {
    100113                        $valeurs['_objets_avec_compos'][] = 'page';
     114                }
    101115                // Si on voulait se baser sur la config de compositions, on utiliserait compositions_objets_actives().
    102116                // En fait, à la création d'une compo du noizetier, on modifiera la config de compositions.
     
    104118                $liste_pages = noizetier_lister_pages();
    105119                include_spip('base/objets');
    106                 foreach(lister_tables_objets_sql() as $objet)
    107                         if (isset($objet['page']) && ($obj = $objet['page']) && isset($liste_pages[$obj]))
     120                foreach (lister_tables_objets_sql() as $objet) {
     121                        if (isset($objet['page']) && ($obj = $objet['page']) && isset($liste_pages[$obj])) {
    108122                                $valeurs['_objets_avec_compos'][] = $obj;
     123                        }
     124                }
    109125                // Hack pour les groupes de mots-clés (car ils n'ont pas d'entrée page dans lister_tables_objets_sql()).
    110                 if (isset($liste_pages['groupe_mots']))
     126                if (isset($liste_pages['groupe_mots'])) {
    111127                        $valeurs['_objets_avec_compos'][] = 'groupe_mots';
     128                }
    112129        }
    113130
     
    119136}
    120137
    121 
    122138/**
    123  * Formulaire d'édition d'une page de composition de noisettes
     139 * Formulaire d'édition d'une page de composition de noisettes.
    124140 *
    125141 * Vérifier les champs postés et signaler d'éventuelles erreurs
    126142 *
    127143 * @param string $page
    128  *     identifiant d'une composition
     144 *                       identifiant d'une composition
    129145 * @param string $new
    130  *     pour créer une nouvelle composition
     146 *                       pour créer une nouvelle composition
    131147 * @param string $retour
    132  *     URL de redirection
     148 *                       URL de redirection
    133149 */
    134 function formulaires_editer_page_verifier_dist($page, $new, $retour=''){
     150function formulaires_editer_page_verifier_dist($page, $new, $retour = '')
     151{
    135152        $erreurs = array();
    136         foreach(array('type_page','composition','nom') as $champ)
    137                 if (!_request($champ))
     153        foreach (array('type_page', 'composition', 'nom') as $champ) {
     154                if (!_request($champ)) {
    138155                        $erreurs[$champ] = _T('noizetier:formulaire_obligatoire');
     156                }
     157        }
    139158        // On vérifie, dans le cas d'une nouvelle composition que $composition n'est pas déjà pris
    140159        // On vérifie aussi que $composition ne contient ni espace, ni tiret
    141         if (_request('new') AND _request('composition')) {
     160        if (_request('new') and _request('composition')) {
    142161                $type_page = _request('type_page');
    143162                $composition = _request('composition');
    144163                $liste_pages = noizetier_lister_pages();
    145                 if (is_array($liste_pages[$type_page.'-'.$composition]))
     164                if (is_array($liste_pages[$type_page.'-'.$composition])) {
    146165                        $erreurs['composition'] = _T('noizetier:formulaire_identifiant_deja_pris');
    147                 if (preg_match('#^[a-z0-9_]+$#',$composition)==0)
     166                }
     167                if (preg_match('#^[a-z0-9_]+$#', $composition) == 0) {
    148168                        $erreurs['composition'] = _T('noizetier:formulaire_erreur_format_identifiant');
    149         }
     169                }
     170        }
     171
    150172        return $erreurs;
    151173}
    152174
    153 
    154175/**
    155  * Formulaire d'édition d'une page de composition de noisettes
     176 * Formulaire d'édition d'une page de composition de noisettes.
    156177 *
    157178 * Traiter les champs postés
    158179 *
    159180 * @param string $page
    160  *     identifiant d'une composition
     181 *                       identifiant d'une composition
    161182 * @param string $new
    162  *     pour créer une nouvelle composition
     183 *                       pour créer une nouvelle composition
    163184 * @param string $retour
    164  *     URL de redirection
     185 *                       URL de redirection
    165186 */
    166 function formulaires_editer_page_traiter_dist($page, $new, $retour=''){
    167         if (!autoriser('configurer','noizetier'))
     187function formulaires_editer_page_traiter_dist($page, $new, $retour = '')
     188{
     189        if (!autoriser('configurer', 'noizetier')) {
    168190                return array('message_erreur' => _T('noizetier:probleme_droits'));
     191        }
    169192
    170193        $res = array();
     
    172195        $type_page = _request('type_page');
    173196        $composition = _request('composition');
    174         $acte = ($page AND $new) ? 'dupliquer' : ($page ? 'modifier' : ($new ? 'creer' : ''));
    175         $peupler = ($acte == 'dupliquer') ? true : ( ($acte == 'creer' AND _request('peupler')) ? true : false );
     197        $acte = ($page and $new) ? 'dupliquer' : ($page ? 'modifier' : ($new ? 'creer' : ''));
     198        $peupler = ($acte == 'dupliquer') ? true : (($acte == 'creer' and _request('peupler')) ? true : false);
    176199
    177200        // Au cas où on n'a pas encore configuré de compositions
    178         if (!is_array($noizetier_compositions))
     201        if (!is_array($noizetier_compositions)) {
    179202                $noizetier_compositions = array();
     203        }
    180204
    181205        $noizetier_compositions[$type_page][$composition] = array(
    182206                'nom' => _request('nom'),
    183207                'description' => _request('description'),
    184                 'icon' => _request('icon')
     208                'icon' => _request('icon'),
    185209        );
    186210
    187211        $branche = array();
    188         foreach(heritiers($type_page) as $t => $i)
    189                 if ($h = _request('heritage-'.$t))
     212        foreach (heritiers($type_page) as $t => $i) {
     213                if ($h = _request('heritage-'.$t)) {
    190214                        $branche[$t] = $h;
    191         if (count($branche)>0)
     215                }
     216        }
     217        if (count($branche) > 0) {
    192218                $noizetier_compositions[$type_page][$composition]['branche'] = $branche;
    193 
    194         ecrire_meta('noizetier_compositions',serialize($noizetier_compositions));
     219        }
     220
     221        ecrire_meta('noizetier_compositions', serialize($noizetier_compositions));
    195222        $retours['message_ok'] = _T('noizetier:formulaire_composition_mise_a_jour');
    196223
     
    199226        if (
    200227                $peupler
    201                 AND $type_page != 'page'
     228                and $type_page != 'page'
    202229        ) {
    203230                $composition_ref = ($acte == 'creer') ? '' : noizetier_page_composition($page); // si on ne créé pas, c'est qu'on duplique
     
    208235                        'type='.sql_quote($type_page).' AND composition="'.$composition_ref.'"'
    209236                );
    210                 if (count($config_mere)>0) {
    211                         foreach($config_mere as $cle => $noisette)
     237                if (count($config_mere) > 0) {
     238                        foreach ($config_mere as $cle => $noisette) {
    212239                                $config_mere[$cle]['composition'] = $composition;
    213                         sql_insertq_multi('spip_noisettes',$config_mere);
     240                        }
     241                        sql_insertq_multi('spip_noisettes', $config_mere);
    214242                }
    215243                // On vérifie également que les compositions sont actives sur ce type d'objet
    216244                $compositions_actives = compositions_objets_actives();
    217                 if (!in_array($type_page,$compositions_actives)) {
     245                if (!in_array($type_page, $compositions_actives)) {
    218246                        $compositions_config = unserialize($GLOBALS['meta']['compositions']);
    219247                        include_spip('base/objets');
    220248                        $compositions_config['objets'][] = table_objet_sql($type_page);
    221                         ecrire_meta('compositions',serialize($compositions_config));
     249                        ecrire_meta('compositions', serialize($compositions_config));
    222250                }
    223251        }
    224252
    225253        // On invalide le cache en cas de création ou  de dpulication
    226         if (in_array($acte, array('creer','dupliquer'))) {
     254        if (in_array($acte, array('creer', 'dupliquer'))) {
    227255                include_spip('inc/invalideur');
    228256                suivre_invalideur("id='page/$type_page-$composition'");
     
    230258
    231259        $res['message_ok'] = _T('info_modification_enregistree');
    232         if (in_array($acte,array('creer','dupliquer'))) {
    233                 $res['redirect'] = parametre_url(parametre_url(self(),'new',''),'page',$type_page.'-'.$composition);
    234         }
    235         elseif ($retour) {
    236                 if (strncmp($retour,'javascript:',11)==0){
    237                         $res['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($retour,11).'/*]]>*/</script>';
     260        if (in_array($acte, array('creer', 'dupliquer'))) {
     261                $res['redirect'] = parametre_url(parametre_url(self(), 'new', ''), 'page', $type_page.'-'.$composition);
     262        } elseif ($retour) {
     263                if (strncmp($retour, 'javascript:', 11) == 0) {
     264                        $res['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($retour, 11).'/*]]>*/</script>';
    238265                        $res['editable'] = true;
    239                 }
    240                 else
     266                } else {
    241267                        $res['redirect'] = $retour;
     268                }
    242269        }
    243270
    244271        return $res;
    245272}
    246 
    247 ?>
  • _plugins_/noizetier/trunk/formulaires/lister_noisettes_page.php

    r66152 r93111  
    11<?php
    22
    3 if (!defined('_ECRIRE_INC_VERSION')) return;
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
    46
    57include_spip('noizetier_fonctions');
    68include_spip('base/abstract_sql');
    79
    8 function formulaires_lister_noisettes_page_charger_dist($page){
     10function formulaires_lister_noisettes_page_charger_dist($page)
     11{
    912        return array('page' => $page);
    1013}
    1114
     15function formulaires_lister_noisettes_page_traiter_dist($page)
     16{
     17        if (_request('cancel')) {
     18                return array('message_erreur' => _T('noizetier:operation_annulee'));
     19        }
    1220
    13 function formulaires_lister_noisettes_page_traiter_dist($page){
    14         if (_request('cancel'))
    15                 return array('message_erreur' => _T('noizetier:operation_annulee'));
    16        
    17         if (!autoriser('configurer','noizetier'))
     21        if (!autoriser('configurer', 'noizetier')) {
    1822                return array('message_erreur' => _T('noizetier:probleme_droits'));
    19        
     23        }
     24
    2025        $ordre = _request('ordre');
    2126        if (_request('save') && $ordre) {
    22                 if(noizetier_trier_noisette($page, $ordre))
     27                if (noizetier_trier_noisette($page, $ordre)) {
    2328                        return array('message_ok' => _T('info_modification_enregistree'));
     29                }
    2430        }
     31
    2532        return array('message_erreur' => _T('noizetier:erreur_mise_a_jour'));
    2633}
    27 
    28 ?>
  • _plugins_/noizetier/trunk/formulaires/noizetier_valider_tri.php

    r66179 r93111  
    11<?php
    22
    3 if (!defined('_ECRIRE_INC_VERSION')) return;
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
    46
    57include_spip('noizetier_fonctions');
    68include_spip('base/abstract_sql');
    7 if (!function_exists('autoriser'))
    8         include_spip('inc/autoriser');   // si on utilise le formulaire dans le public
     9if (!function_exists('autoriser')) {
     10        include_spip('inc/autoriser');
     11}     // si on utilise le formulaire dans le public
    912
    10 function formulaires_noizetier_valider_tri_traiter_dist($retour){
     13function formulaires_noizetier_valider_tri_traiter_dist($retour)
     14{
    1115        $res = array('redirect' => $retour);
    12         if (_request('cancel'))
     16        if (_request('cancel')) {
    1317                $res['message_ok'] = _T('noizetier:operation_annulee');
    14        
    15         if (!autoriser('configurer','noizetier'))
     18        }
     19
     20        if (!autoriser('configurer', 'noizetier')) {
    1621                $res['message_erreur'] = _T('noizetier:probleme_droits');
    17        
     22        }
     23
    1824        $ordre = _request('ordre');
    19        
    20         if (_request('save') && $ordre)
    21                 if(noizetier_trier_noisette('', $ordre))
     25
     26        if (_request('save') && $ordre) {
     27                if (noizetier_trier_noisette('', $ordre)) {
    2228                        $res['message_ok'] = _T('info_modification_enregistree');
    23        
     29                }
     30        }
     31
    2432        return $res;
    2533}
    26 
    27 ?>
  • _plugins_/noizetier/trunk/noizetier_administrations.php

    r66968 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    68include_spip('inc/meta');
    79
    810// Installation et mise à jour
    9 function noizetier_upgrade($nom_meta_base_version,$version_cible){
     11function noizetier_upgrade($nom_meta_base_version, $version_cible)
     12{
    1013        $maj = array();
    11        
     14
    1215        $maj['create'] = array(
    13                 array('maj_tables',array('spip_noisettes'))
     16                array('maj_tables',array('spip_noisettes')),
    1417        );
    15        
    16         $maj['0.2'] = array(
    17                 array('maj_tables',array('spip_noisettes'))
     18
     19        $maj['0.2.0'] = array(
     20                array('maj_tables',array('spip_noisettes')),
    1821        );
    19        
    20         $maj['0.3'] = array(
    21                 array('sql_alter',"TABLE spip_noisettes DROP COLUMN contexte")
     22
     23        $maj['0.3.0'] = array(
     24                array('sql_alter','TABLE spip_noisettes DROP COLUMN contexte'),
    2225        );
    23        
    24         $maj['0.4'] = array(
    25                 array('maj_tables',array('spip_noisettes'))
     26
     27        $maj['0.4.0'] = array(
     28                array('maj_tables',array('spip_noisettes')),
    2629        );
    27        
     30
    2831        include_spip('base/upgrade');
    2932        maj_plugin($nom_meta_base_version, $version_cible, $maj);
     
    3134
    3235// Désinstallation
    33 function noizetier_vider_tables($nom_meta_version_base){
     36function noizetier_vider_tables($nom_meta_version_base)
     37{
    3438        // On efface les tables du plugin
    3539        sql_drop_table('spip_noisettes');
     
    4145        include_spip('inc/flock');
    4246        include_spip('noizetier_fonctions');
    43         supprimer_fichier(_DIR_CACHE . _CACHE_AJAX_NOISETTES);
    44         supprimer_fichier(_DIR_CACHE . _CACHE_CONTEXTE_NOISETTES);
    45         supprimer_fichier(_DIR_CACHE . _CACHE_INCLUSIONS_NOISETTES);
    46         supprimer_fichier(_DIR_CACHE . _CACHE_DESCRIPTIONS_NOISETTES);
     47        supprimer_fichier(_DIR_CACHE._CACHE_AJAX_NOISETTES);
     48        supprimer_fichier(_DIR_CACHE._CACHE_CONTEXTE_NOISETTES);
     49        supprimer_fichier(_DIR_CACHE._CACHE_INCLUSIONS_NOISETTES);
     50        supprimer_fichier(_DIR_CACHE._CACHE_DESCRIPTIONS_NOISETTES);
    4751}
    48 
    49 ?>
  • _plugins_/noizetier/trunk/noizetier_autoriser.php

    r66971 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    68// Fonction appelé par le pipeline
    7 function noizetier_autoriser(){}
     9function noizetier_autoriser()
     10{
     11}
    812
    9 
    10 function autoriser_noizetier_configurer_dist($faire, $type, $id, $qui, $opt) {
     13function autoriser_noizetier_configurer_dist($faire, $type, $id, $qui, $opt)
     14{
    1115        return autoriser('webmestre');
    1216}
    1317
    14 function autoriser_noizetier_menu_dist($faire, $type, $id, $qui, $opt) {
     18function autoriser_noizetier_menu_dist($faire, $type, $id, $qui, $opt)
     19{
    1520        return autoriser('configurer', 'noizetier', $id, $qui,  $opt);
    1621}
    17 
    18 ?>
  • _plugins_/noizetier/trunk/noizetier_fonctions.php

    r82157 r93111  
    22
    33// Securite
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
    57
    68define('_CACHE_AJAX_NOISETTES', 'noisettes_ajax.php');
     
    1012
    1113/**
    12  * Lister les noisettes disponibles dans les dossiers noisettes/
     14 * Lister les noisettes disponibles dans les dossiers noisettes/.
    1315 *
    1416 * @staticvar array $liste_noisettes
    15  * @param text $type renvoyer seulement un type de noisettes
     17 *
     18 * @param text $type     renvoyer seulement un type de noisettes
    1619 * @param text $noisette renvoyer spécifiquement une noisette données
     20 *
    1721 * @return array
    1822 */
    19 function noizetier_lister_noisettes($type='tout'){
     23function noizetier_lister_noisettes($type = 'tout')
     24{
    2025        static $liste_noisettes = array();
    2126        if ($type == 'tout') {
     
    2530                return $liste_noisettes[$type];
    2631        }
    27        
     32
    2833        $noisettes = noizetier_obtenir_infos_noisettes();
    2934        if ($type == '') {
    30                 $match = "^[^-]*$";
     35                $match = '^[^-]*$';
    3136        } else {
    32                 $match = $type."-[^-]*$";
    33         }
    34        
    35         foreach($noisettes as $noisette => $description) {
     37                $match = $type.'-[^-]*$';
     38        }
     39
     40        foreach ($noisettes as $noisette => $description) {
    3641                if (preg_match("/$match/", $noisette)) {
    3742                        $liste_noisettes[$type][$noisette] = $description;
    3843                }
    3944        }
    40        
     45
    4146        return $liste_noisettes[$type];
    4247}
    4348
    44 
    45 /**
    46  * Renvoie les info d'une seule noisette
     49/**
     50 * Renvoie les info d'une seule noisette.
    4751 *
    4852 * @param text $noisette renvoyer spécifiquement une noisette données
     53 *
    4954 * @return array
    5055 */
    51 function noizetier_info_noisette($noisette) {
     56function noizetier_info_noisette($noisette)
     57{
    5258        $noisettes = noizetier_obtenir_infos_noisettes();
     59
    5360        return $noisettes[$noisette];
    5461}
     
    5865 * On utilise un cache php pour alleger le calcul.
    5966 *
    60  * @param
    61  * @return
    62 **/
    63 function noizetier_obtenir_infos_noisettes() {
     67 * @param
     68 *
     69 * @return
     70 **/
     71function noizetier_obtenir_infos_noisettes()
     72{
    6473        static $noisettes = false;
    65        
     74
    6675        // seulement 1 fois par appel, on lit ou calcule tous les contextes
    6776        if ($noisettes === false) {
    6877                // lire le cache des descriptions sauvees
    69                 lire_fichier_securise(_DIR_CACHE . _CACHE_DESCRIPTIONS_NOISETTES, $noisettes);
     78                lire_fichier_securise(_DIR_CACHE._CACHE_DESCRIPTIONS_NOISETTES, $noisettes);
    7079                $noisettes = @unserialize($noisettes);
    7180                // s'il en mode recalcul, on recalcule toutes les descriptions des noisettes trouvees.
    7281                // ou si le cache est desactive
    73                 if (!$noisettes or (_request('var_mode') == 'recalcul') or (defined('_NO_CACHE') and _NO_CACHE!=0)) {
     82                if (!$noisettes or (_request('var_mode') == 'recalcul') or (defined('_NO_CACHE') and _NO_CACHE != 0)) {
    7483                        $noisettes = noizetier_obtenir_infos_noisettes_direct();
    75                         ecrire_fichier_securise(_DIR_CACHE . _CACHE_DESCRIPTIONS_NOISETTES, serialize($noisettes));
    76                 }
    77         }
    78        
     84                        ecrire_fichier_securise(_DIR_CACHE._CACHE_DESCRIPTIONS_NOISETTES, serialize($noisettes));
     85                }
     86        }
     87
    7988        return $noisettes;
    8089}
    81 
    8290
    8391/**
     
    8795 * @return array
    8896 */
    89 function noizetier_obtenir_infos_noisettes_direct(){
    90 
     97function noizetier_obtenir_infos_noisettes_direct()
     98{
    9199        $liste_noisettes = array();
    92                
    93         $match = "[^-]*[.]html$";
     100
     101        $match = '[^-]*[.]html$';
    94102        $liste = find_all_in_path('noisettes/', $match);
    95                
    96         if (count($liste)){
    97                 foreach($liste as $squelette=>$chemin) {
     103
     104        if (count($liste)) {
     105                foreach ($liste as $squelette => $chemin) {
    98106                        $noisette = preg_replace(',[.]html$,i', '', $squelette);
    99107                        $dossier = str_replace($squelette, '', $chemin);
    100108                        // On ne garde que les squelettes ayant un fichier YAML de config
    101109                        if (file_exists("$dossier$noisette.yaml")
    102                                 AND ($infos_noisette = noizetier_charger_infos_noisette_yaml($dossier.$noisette))
    103                         ){
     110                                and ($infos_noisette = noizetier_charger_infos_noisette_yaml($dossier.$noisette))
     111                        ) {
    104112                                $liste_noisettes[$noisette] = $infos_noisette;
    105113                        }
    106114                }
    107115        }
    108        
     116
    109117        // supprimer de la liste les noisettes necissant un plugin qui n'est pas actif
    110         foreach ($liste_noisettes as $noisette => $infos_noisette)
    111                 if (isset($infos_noisette['necessite']))
    112                         foreach ($infos_noisette['necessite'] as $plugin)
    113                                 if (!defined('_DIR_PLUGIN_'.strtoupper($plugin)))
     118        foreach ($liste_noisettes as $noisette => $infos_noisette) {
     119                if (isset($infos_noisette['necessite'])) {
     120                        foreach ($infos_noisette['necessite'] as $plugin) {
     121                                if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
    114122                                        unset($liste_noisettes[$noisette]);
    115        
     123                                }
     124                        }
     125                }
     126        }
     127
    116128        return $liste_noisettes;
    117129}
    118130
    119 
    120 /**
    121  * Charger les informations contenues dans le YAML d'une noisette
     131/**
     132 * Charger les informations contenues dans le YAML d'une noisette.
    122133 *
    123134 * @param string $noisette
    124135 * @param string $info
     136 *
    125137 * @return array
    126138 */
    127 function noizetier_charger_infos_noisette_yaml($noisette, $info=""){
    128                 // on peut appeler avec le nom du squelette
    129                 $fichier = preg_replace(',[.]html$,i','',$noisette).".yaml";
    130                 include_spip('inc/yaml');
    131                 include_spip('inc/texte');
    132                 $infos_noisette = array();
    133                 if ($infos_noisette = yaml_charger_inclusions(yaml_decode_file($fichier))) {
    134                         if (isset($infos_noisette['nom']))
    135                                 $infos_noisette['nom'] = _T_ou_typo($infos_noisette['nom']);
    136                         if (isset($infos_noisette['description']))
    137                                 $infos_noisette['description'] = _T_ou_typo($infos_noisette['description']);
    138                         if (isset($infos_noisette['icon']))
    139                                 $infos_noisette['icon'] = $infos_noisette['icon'];
    140                                
    141                         if (!isset($infos_noisette['parametres']))
    142                                 $infos_noisette['parametres'] = array();
    143                                
     139function noizetier_charger_infos_noisette_yaml($noisette, $info = '')
     140{
     141        // on peut appeler avec le nom du squelette
     142                $fichier = preg_replace(',[.]html$,i', '', $noisette).'.yaml';
     143        include_spip('inc/yaml');
     144        include_spip('inc/texte');
     145        $infos_noisette = array();
     146        if ($infos_noisette = yaml_charger_inclusions(yaml_decode_file($fichier))) {
     147                if (isset($infos_noisette['nom'])) {
     148                        $infos_noisette['nom'] = _T_ou_typo($infos_noisette['nom']);
     149                }
     150                if (isset($infos_noisette['description'])) {
     151                        $infos_noisette['description'] = _T_ou_typo($infos_noisette['description']);
     152                }
     153                if (isset($infos_noisette['icon'])) {
     154                        $infos_noisette['icon'] = $infos_noisette['icon'];
     155                }
     156
     157                if (!isset($infos_noisette['parametres'])) {
     158                        $infos_noisette['parametres'] = array();
     159                }
     160
    144161                        // contexte
    145162                        if (!isset($infos_noisette['contexte'])) {
    146163                                $infos_noisette['contexte'] = array();
    147164                        }
    148                         if (is_string($infos_noisette['contexte'])) {
    149                                 $infos_noisette['contexte'] = array($infos_noisette['contexte']);
    150                         }
    151                        
     165                if (is_string($infos_noisette['contexte'])) {
     166                        $infos_noisette['contexte'] = array($infos_noisette['contexte']);
     167                }
     168
    152169                        // ajax
    153170                        if (!isset($infos_noisette['ajax'])) {
     
    158175                                $infos_noisette['inclusion'] = 'statique';
    159176                        }
    160                 }
    161 
    162                 if (!$info)
    163                         return $infos_noisette;
    164                 else
    165                         return isset($infos_noisette[$info]) ? $infos_noisette[$info] : "";
    166 }
    167 
    168 
    169 /**
    170  * Charger les informations des contexte pour une noisette
     177        }
     178
     179        if (!$info) {
     180                return $infos_noisette;
     181        } else {
     182                return isset($infos_noisette[$info]) ? $infos_noisette[$info] : '';
     183        }
     184}
     185
     186/**
     187 * Charger les informations des contexte pour une noisette.
    171188 *
    172189 * @param string $noisette
    173190 * @staticvar array $params_noisettes
     191 *
    174192 * @return array
    175193 */
    176 function noizetier_charger_contexte_noisette($noisette){
     194function noizetier_charger_contexte_noisette($noisette)
     195{
    177196        static $contexte_noisettes = null;
    178197
    179         if (is_null($contexte_noisettes[$noisette])){
     198        if (is_null($contexte_noisettes[$noisette])) {
    180199                $noisettes = noizetier_lister_noisettes();
    181200                $contexte_noisettes[$noisette] = $noisettes[$noisette]['contexte'];
    182201        }
     202
    183203        return $contexte_noisettes[$noisette];
    184204}
    185 
    186205
    187206/**
     
    192211 * @param string $page_specifique (renvoyer les données d'une page spécifique)
    193212 * @staticvar array $liste_pages
     213 *
    194214 * @return array
    195215 */
    196 function noizetier_lister_pages($page_specifique=''){
     216function noizetier_lister_pages($page_specifique = '')
     217{
    197218        static $liste_pages = null;
    198219
    199         if (is_null($liste_pages)){
     220        if (is_null($liste_pages)) {
    200221                $liste_pages = array();
    201                 $match = ".+[.]html$";
     222                $match = '.+[.]html$';
    202223
    203224                // lister les fonds disponibles dans le repertoire contenu
    204                 $rep = defined('_NOIZETIER_REPERTOIRE_PAGES')?_NOIZETIER_REPERTOIRE_PAGES:'contenu/';
     225                $rep = defined('_NOIZETIER_REPERTOIRE_PAGES') ? _NOIZETIER_REPERTOIRE_PAGES : 'contenu/';
    205226                $liste = find_all_in_path($rep, $match);
    206                 if (count($liste)){
    207                         foreach($liste as $squelette=>$chemin) {
     227                if (count($liste)) {
     228                        foreach ($liste as $squelette => $chemin) {
    208229                                $page = preg_replace(',[.]html$,i', '', $squelette);
    209230                                $dossier = str_replace($squelette, '', $chemin);
    210231                                // Les elements situes dans prive/contenu sont ecartes
    211                                 if (substr($dossier,-14)!='prive/contenu/')
    212                                         if(count($infos_page = noizetier_charger_infos_page($dossier,$page))>0)
     232                                if (substr($dossier, -14) != 'prive/contenu/') {
     233                                        if (count($infos_page = noizetier_charger_infos_page($dossier, $page)) > 0) {
    213234                                                $liste_pages[$page] = $infos_page;
    214                         }
    215                 }
    216                
     235                                        }
     236                                }
     237                        }
     238                }
     239
    217240                // Dans le cas de Zpip, il faut supprimer la page 'page.html' et la page 'z_apl.html'
    218                 if (defined('_DIR_PLUGIN_Z') OR defined('_DIR_PLUGIN_ZCORE')) {
     241                if (defined('_DIR_PLUGIN_Z') or defined('_DIR_PLUGIN_ZCORE')) {
    219242                        unset($liste_pages['page']);
    220243                        unset($liste_pages['z_apl']);
    221244                }
    222                
     245
    223246                // supprimer de la liste les pages necissant un plugin qui n'est pas actif
    224                 foreach ($liste_pages as $page => $infos_page)
    225                         if (isset($infos_page['necessite']))
    226                                 foreach ($infos_page['necessite'] as $plugin)
    227                                         if (!defined('_DIR_PLUGIN_'.strtoupper($plugin)))
     247                foreach ($liste_pages as $page => $infos_page) {
     248                        if (isset($infos_page['necessite'])) {
     249                                foreach ($infos_page['necessite'] as $plugin) {
     250                                        if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
    228251                                                unset($liste_pages[$page]);
    229                
    230                 $liste_pages = pipeline('noizetier_lister_pages',$liste_pages);
    231                
     252                                        }
     253                                }
     254                        }
     255                }
     256
     257                $liste_pages = pipeline('noizetier_lister_pages', $liste_pages);
     258
    232259                // On ajoute les compositions du noizetier
    233                 if(defined('_DIR_PLUGIN_COMPOSITIONS')){
     260                if (defined('_DIR_PLUGIN_COMPOSITIONS')) {
    234261                        $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
    235262                        // On doit transformer le tableau de [type][compo] en [type-compo]
    236263                        $liste_compos = array();
    237264                        if (is_array($noizetier_compositions)) {
    238                                 foreach($noizetier_compositions as $type => $compos_type)
    239                                         foreach($compos_type as $compo => $infos_compo) {
     265                                foreach ($noizetier_compositions as $type => $compos_type) {
     266                                        foreach ($compos_type as $compo => $infos_compo) {
    240267                                                $infos_compo['nom'] = typo($infos_compo['nom']);
    241268                                                $infos_compo['description'] = propre($infos_compo['description']);
    242                                                 if ($infos_compo['icon']=='')
    243                                                         $infos_compo['icon'] = (isset($liste_pages[$type]) && isset($liste_pages[$type]['icon']) && $liste_pages[$type]['icon']!='') ? $liste_pages[$type]['icon'] : 'composition-24.png';
    244                                                 if (isset($liste_pages[$type]))
     269                                                if ($infos_compo['icon'] == '') {
     270                                                        $infos_compo['icon'] = (isset($liste_pages[$type]) && isset($liste_pages[$type]['icon']) && $liste_pages[$type]['icon'] != '') ? $liste_pages[$type]['icon'] : 'composition-24.png';
     271                                                }
     272                                                if (isset($liste_pages[$type])) {
    245273                                                        $infos_compo['blocs'] = $liste_pages[$type]['blocs'];
    246                                                 else
     274                                                } else {
    247275                                                        $infos_compo['blocs'] = noizetier_blocs_defaut();
     276                                                }
    248277                                                $liste_compos[$type.'-'.$compo] = $infos_compo;
    249                                                 }
    250                         }
    251                         $liste_pages = array_merge($liste_pages,$liste_compos);
    252                 }
    253         }
    254         if ($page_specifique)
     278                                        }
     279                                }
     280                        }
     281                        $liste_pages = array_merge($liste_pages, $liste_compos);
     282                }
     283        }
     284        if ($page_specifique) {
    255285                return $liste_pages[$page_specifique];
    256         else
     286        } else {
    257287                return $liste_pages;
    258 }
    259 
    260 /**
    261  * Charger les informations d'une page, contenues dans un xml de config s'il existe
     288        }
     289}
     290
     291/**
     292 * Charger les informations d'une page, contenues dans un xml de config s'il existe.
    262293 *
    263294 * @param string $dossier
    264295 * @param string $page
    265296 * @param string $info
     297 *
    266298 * @return array
    267299 */
    268 function noizetier_charger_infos_page($dossier,$page, $info=""){
    269                 // on peut appeler avec le nom du squelette
    270                 $page = preg_replace(',[.]html$,i','',$page);
    271                
     300function noizetier_charger_infos_page($dossier, $page, $info = '')
     301{
     302        // on peut appeler avec le nom du squelette
     303                $page = preg_replace(',[.]html$,i', '', $page);
     304
    272305                // On autorise le fait que le fichier xml ne soit pas dans le meme plugin que le fichier .html
    273306                // Au cas ou le fichier .html soit surcharge sans que le fichier .xml ne le soit
    274                 $rep = defined('_NOIZETIER_REPERTOIRE_PAGES')?_NOIZETIER_REPERTOIRE_PAGES:'contenu/';
    275                 $fichier = find_in_path("$rep$page.xml");
    276                
    277                 include_spip('inc/xml');
    278                 include_spip('inc/texte');
    279                 $infos_page = array();
     307                $rep = defined('_NOIZETIER_REPERTOIRE_PAGES') ? _NOIZETIER_REPERTOIRE_PAGES : 'contenu/';
     308        $fichier = find_in_path("$rep$page.xml");
     309
     310        include_spip('inc/xml');
     311        include_spip('inc/texte');
     312        $infos_page = array();
    280313                // S'il existe un fichier xml de configuration (s'il s'agit d'une composition on utilise l'info de la composition)
    281                 if (file_exists($fichier) AND $xml = spip_xml_load($fichier, false) AND count($xml['page']))
     314                if (file_exists($fichier) and $xml = spip_xml_load($fichier, false) and count($xml['page'])) {
    282315                        $xml = reset($xml['page']);
    283                 elseif (file_exists($fichier) AND $xml = spip_xml_load($fichier, false) AND count($xml['composition']))
     316                } elseif (file_exists($fichier) and $xml = spip_xml_load($fichier, false) and count($xml['composition'])) {
    284317                        $xml = reset($xml['composition']);
    285                 else
     318                } else {
    286319                        $xml = '';
    287                 if ($xml != '') {
    288                         $infos_page['nom'] = _T_ou_typo(spip_xml_aplatit($xml['nom']));
    289                         $infos_page['description'] = isset($xml['description']) ? _T_ou_typo(spip_xml_aplatit($xml['description'])) : '';
    290                         $infos_page['icon'] = isset($xml['icon']) ? reset($xml['icon']) : 'page-24.png';
     320                }
     321        if ($xml != '') {
     322                $infos_page['nom'] = _T_ou_typo(spip_xml_aplatit($xml['nom']));
     323                $infos_page['description'] = isset($xml['description']) ? _T_ou_typo(spip_xml_aplatit($xml['description'])) : '';
     324                $infos_page['icon'] = isset($xml['icon']) ? reset($xml['icon']) : 'page-24.png';
    291325                        // Decomposition des blocs
    292                         if (spip_xml_match_nodes(',^bloc,', $xml, $blocs)){
     326                        if (spip_xml_match_nodes(',^bloc,', $xml, $blocs)) {
    293327                                $infos_page['blocs'] = array();
    294                                 foreach (array_keys($blocs) as $bloc){
     328                                foreach (array_keys($blocs) as $bloc) {
    295329                                        list($balise, $attributs) = spip_xml_decompose_tag($bloc);
    296330                                        $infos_page['blocs'][$attributs['id']] = array(
    297331                                                'nom' => $attributs['nom'] ? _T($attributs['nom']) : $attributs['id'],
    298332                                                'icon' => isset($attributs['icon']) ? $attributs['icon'] : '',
    299                                                 'description' => _T($attributs['description'])
     333                                                'description' => _T($attributs['description']),
    300334                                        );
    301335                                }
    302336                        }
    303                         if (spip_xml_match_nodes(',^necessite,', $xml, $necessites)){
    304                                 $infos_page['necessite'] = array();
    305                                 foreach (array_keys($necessites) as $necessite){
    306                                         list($balise, $attributs) = spip_xml_decompose_tag($necessite);
    307                                         $infos_page['necessite'][] = $attributs['id'];
    308                                 }
    309                         }
    310                 }
     337                if (spip_xml_match_nodes(',^necessite,', $xml, $necessites)) {
     338                        $infos_page['necessite'] = array();
     339                        foreach (array_keys($necessites) as $necessite) {
     340                                list($balise, $attributs) = spip_xml_decompose_tag($necessite);
     341                                $infos_page['necessite'][] = $attributs['id'];
     342                        }
     343                }
     344        }
    311345                // S'il n'y a pas de fichier XML de configuration
    312                 elseif (defined('_NOIZETIER_LISTER_PAGES_SANS_XML')?_NOIZETIER_LISTER_PAGES_SANS_XML:true) {
     346                elseif (defined('_NOIZETIER_LISTER_PAGES_SANS_XML') ? _NOIZETIER_LISTER_PAGES_SANS_XML : true) {
    313347                        $infos_page['nom'] = $page;
    314348                        $infos_page['icon'] = 'img/ic_page.png';
    315349                }
    316                
     350
    317351                // Si les blocs n'ont pas ete definis, on applique les blocs par defaut
    318                 if (count($infos_page)>0 AND !isset($infos_page['blocs']))
     352                if (count($infos_page) > 0 and !isset($infos_page['blocs'])) {
    319353                        $infos_page['blocs'] = noizetier_blocs_defaut();
    320                
     354                }
     355
    321356                // On renvoie les infos
    322                 if (!$info)
     357                if (!$info) {
    323358                        return $infos_page;
    324                 else
    325                         return isset($infos_page[$info]) ? $infos_page[$info] : "";
    326 }
    327 
    328 /**
    329  *
     359                } else {
     360                        return isset($infos_page[$info]) ? $infos_page[$info] : '';
     361                }
     362}
     363
     364/**
    330365 * La liste des blocs par defaut d'une page peut etre modifiee via le pipeline noizetier_blocs_defaut.
    331366 *
    332367 * @staticvar array $blocs_defaut
     368 *
    333369 * @return array
    334370 */
    335 function noizetier_blocs_defaut(){
     371function noizetier_blocs_defaut()
     372{
    336373        static $blocs_defaut = null;
    337374
    338         if (is_null($blocs_defaut)){
    339                 $blocs_defaut = array (
     375        if (is_null($blocs_defaut)) {
     376                $blocs_defaut = array(
    340377                        'contenu' => array(
    341378                                'nom' => _T('noizetier:nom_bloc_contenu'),
    342379                                'description' => _T('noizetier:description_bloc_contenu'),
    343                                 'icon' => 'bloc-contenu-24.png'
     380                                'icon' => 'bloc-contenu-24.png',
    344381                                ),
    345382                        'navigation' => array(
    346383                                'nom' => _T('noizetier:nom_bloc_navigation'),
    347384                                'description' => _T('noizetier:description_bloc_navigation'),
    348                                 'icon' => 'bloc-navigation-24.png'
     385                                'icon' => 'bloc-navigation-24.png',
    349386                                ),
    350387                        'extra' => array(
    351388                                'nom' => _T('noizetier:nom_bloc_extra'),
    352389                                'description' => _T('noizetier:description_bloc_extra'),
    353                                 'icon' => 'bloc-extra-24.png'
     390                                'icon' => 'bloc-extra-24.png',
    354391                                ),
    355392                );
    356                 $blocs_defaut = pipeline('noizetier_blocs_defaut',$blocs_defaut);
    357         }
     393                $blocs_defaut = pipeline('noizetier_blocs_defaut', $blocs_defaut);
     394        }
     395
    358396        return $blocs_defaut;
    359397}
    360398
    361399/**
    362  * Supprime de spip_noisettes les noisettes liees a une page
     400 * Supprime de spip_noisettes les noisettes liees a une page.
    363401 *
    364402 * @param text $page
    365  * 
    366  */
    367 function noizetier_supprimer_noisettes_page($page) {
    368         $type_compo = explode ('-',$page,2);
     403 */
     404function noizetier_supprimer_noisettes_page($page)
     405{
     406        $type_compo = explode('-', $page, 2);
    369407        $type = $type_compo[0];
    370         if(isset($type_compo[1]))
     408        if (isset($type_compo[1])) {
    371409                $composition = $type_compo[1];
    372         else
     410        } else {
    373411                $composition = '';
    374         if (autoriser('configurer','noizetier')) {
    375                 sql_delete('spip_noisettes','type='.sql_quote($type).' AND composition='.sql_quote($composition));
     412        }
     413        if (autoriser('configurer', 'noizetier')) {
     414                sql_delete('spip_noisettes', 'type='.sql_quote($type).' AND composition='.sql_quote($composition));
    376415                // On invalide le cache
    377416                include_spip('inc/invalideur');
     
    381420
    382421/**
    383  * Supprime de spip_noisettes une noisette particuliere
     422 * Supprime de spip_noisettes une noisette particuliere.
    384423 *
    385424 * @param text $id_noisette
    386  * 
    387  */
    388 function noizetier_supprimer_noisette($id_noisette) {
    389         if (autoriser('configurer','noizetier') and intval($id_noisette)) {
    390                 sql_delete('spip_noisettes','id_noisette='.intval($id_noisette));
     425 */
     426function noizetier_supprimer_noisette($id_noisette)
     427{
     428        if (autoriser('configurer', 'noizetier') and intval($id_noisette)) {
     429                sql_delete('spip_noisettes', 'id_noisette='.intval($id_noisette));
    391430                // On invalide le cache
    392431                include_spip('inc/invalideur');
     
    397436/**
    398437 * Ajoute une noisette à un bloc d'une page
    399  * Renvoie l'id_noisette de la noisette ajoutée
     438 * Renvoie l'id_noisette de la noisette ajoutée.
    400439 *
    401440 * @param text $noisette
    402441 * @param text $page
    403442 * @param text $bloc
    404  * @return integer
    405  *
    406  */
    407 function noizetier_ajouter_noisette($noisette, $page, $bloc) {
    408         if (autoriser('configurer','noizetier') && $noisette) {
     443 *
     444 * @return int
     445 */
     446function noizetier_ajouter_noisette($noisette, $page, $bloc)
     447{
     448        if (autoriser('configurer', 'noizetier') && $noisette) {
    409449                $info_noisette = noizetier_info_noisette($noisette);
    410450                include_spip('inc/saisies');
     
    424464                        'noisette' => $noisette,
    425465                        'rang' => $rang,
    426                         'parametres' => serialize($parametres)
     466                        'parametres' => serialize($parametres),
    427467                        ));
    428                
     468
    429469                if ($id_noisette) {
    430470                        // On invalide le cache
    431471                        include_spip('inc/invalideur');
    432472                        suivre_invalideur("id='noisette/$id_noisette'");
     473
    433474                        return $id_noisette;
    434475                }
    435         }
    436         else
     476        } else {
    437477                return 0;
     478        }
    438479}
    439480
    440481/**
    441482 * Tri les noisettes d'une page
    442  * Attention : parfois la page est transmise dans $ordre (et peu éventuellement changer en cours, cas de la page-dist de Zpip-vide)
    443  *
    444  * @param text $page
     483 * Attention : parfois la page est transmise dans $ordre (et peu éventuellement changer en cours, cas de la page-dist de Zpip-vide).
     484 *
     485 * @param text  $page
    445486 * @param array $ordre
    446  * @return boolean
    447  *
    448  */
    449 function noizetier_trier_noisette($page, $ordre) {
     487 *
     488 * @return bool
     489 */
     490function noizetier_trier_noisette($page, $ordre)
     491{
    450492        // Vérifications
    451         if (!autoriser('configurer','noizetier'))
     493        if (!autoriser('configurer', 'noizetier')) {
    452494                return false;
    453         if (!is_array($ordre))
     495        }
     496        if (!is_array($ordre)) {
    454497                return false;
    455         if (substr($ordre[0],0,4)!='bloc')
     498        }
     499        if (substr($ordre[0], 0, 4) != 'bloc') {
    456500                return $false;
     501        }
    457502
    458503        if ($page) {
     
    461506        }
    462507        $modifs = array();
    463         foreach($ordre as $entree) {
    464                 $entree = explode ('-',$entree,2);
     508        foreach ($ordre as $entree) {
     509                $entree = explode('-', $entree, 2);
    465510                if ($entree[0] == 'bloc') {
    466511                        $bloc = $entree[1];
     
    477522                                'type' => $type,
    478523                                'composition' => $composition,
    479                                 'rang' => $rang
     524                                'rang' => $rang,
    480525                        );
    481526                        $rang += 1;
     
    487532                                'type' => $type,
    488533                                'composition' => $composition,
    489                                 'rang' => $rang
     534                                'rang' => $rang,
    490535                        );
    491536                        $rang += 1;
    492537                }
    493538        }
    494        
    495         foreach ($modifs as $id_noisette => $valeurs)
    496                 sql_updateq('spip_noisettes', $valeurs, 'id_noisette=' . intval($id_noisette));
    497        
     539
     540        foreach ($modifs as $id_noisette => $valeurs) {
     541                sql_updateq('spip_noisettes', $valeurs, 'id_noisette='.intval($id_noisette));
     542        }
     543
    498544        return true;
    499545}
    500546
    501547/**
    502  * Déplace une noisette au sein d'un bloc
     548 * Déplace une noisette au sein d'un bloc.
    503549 *
    504550 * @param text $id_noisette
    505551 * @param text $sens
    506  * 
    507  */
    508 function noizetier_deplacer_noisette($id_noisette, $sens) {
     552 */
     553function noizetier_deplacer_noisette($id_noisette, $sens)
     554{
    509555        $id_noisette = intval($id_noisette);
    510         if ($sens!='bas') $sens = 'haut';
    511         if (autoriser('configurer','noizetier') and intval($id_noisette)) {
     556        if ($sens != 'bas') {
     557                $sens = 'haut';
     558        }
     559        if (autoriser('configurer', 'noizetier') and intval($id_noisette)) {
    512560                // On récupère des infos sur le placement actuel
    513561                $noisette = sql_fetsel(
     
    520568                $composition = $noisette['composition'];
    521569                $rang_actuel = intval($noisette['rang']);
    522                
     570
    523571                // On teste si y a une noisette suivante
    524572                $dernier_rang = intval(sql_getfetsel(
     
    530578                        '0,1'
    531579                ));
    532                
     580
    533581                // Tant qu'on ne veut pas faire de tour complet
    534                 if (!($sens == 'bas' and $rang_actuel == $dernier_rang) and !($sens == 'haut' and $rang_actuel == 1)){
     582                if (!($sens == 'bas' and $rang_actuel == $dernier_rang) and !($sens == 'haut' and $rang_actuel == 1)) {
    535583                        // Alors on ne fait qu'échanger deux noisettes
    536584                        $rang_echange = ($sens == 'bas') ? ($rang_actuel + 1) : ($rang_actuel - 1);
     
    538586                                'spip_noisettes',
    539587                                array(
    540                                         'rang' => $rang_actuel
     588                                        'rang' => $rang_actuel,
    541589                                ),
    542590                                'bloc = '.sql_quote($bloc).' and type='.sql_quote($type).'and composition='.sql_quote($composition).' and rang = '.$rang_echange
    543591                        );
    544                         if ($ok)
     592                        if ($ok) {
    545593                                $ok = sql_updateq(
    546594                                        'spip_noisettes',
    547595                                        array(
    548                                                 'rang' => $rang_echange
     596                                                'rang' => $rang_echange,
    549597                                        ),
    550598                                        'id_noisette = '.$id_noisette
    551599                                );
     600                        }
    552601                }
    553602                // Sinon on fait un tour complet en déplaçant tout
    554                 else{
    555                         if ($sens == 'bas'){
     603                else {
     604                        if ($sens == 'bas') {
    556605                                // Tout le monde descend d'un rang
    557606                                $ok = sql_update(
    558607                                        'spip_noisettes',
    559608                                        array(
    560                                                 'rang' => 'rang + 1'
     609                                                'rang' => 'rang + 1',
    561610                                        ),
    562611                                        'bloc = '.sql_quote($bloc).' and type='.sql_quote($type).'and composition='.sql_quote($composition)
    563612                                );
    564613                                // La noisette passe tout en haut
    565                                 if ($ok)
     614                                if ($ok) {
    566615                                        $ok = sql_updateq(
    567616                                                'spip_noisettes',
    568617                                                array(
    569                                                         'rang' => 1
     618                                                        'rang' => 1,
    570619                                                ),
    571620                                                'id_noisette = '.$id_noisette
    572621                                        );
    573                         }
    574                         else{
     622                                }
     623                        } else {
    575624                                // Tout le monde monte d'un rang
    576625                                $ok = sql_update(
    577626                                        'spip_noisettes',
    578627                                        array(
    579                                                 'rang' => 'rang - 1'
     628                                                'rang' => 'rang - 1',
    580629                                        ),
    581630                                        'bloc = '.sql_quote($bloc).' and type='.sql_quote($type).'and composition='.sql_quote($composition)
    582631                                );
    583632                                // La noisette passe tout en bas
    584                                 if ($ok)
     633                                if ($ok) {
    585634                                        $ok = sql_updateq(
    586635                                                'spip_noisettes',
    587636                                                array(
    588                                                         'rang' => $dernier_rang
     637                                                        'rang' => $dernier_rang,
    589638                                                ),
    590639                                                'id_noisette = '.$id_noisette
    591640                                        );
     641                                }
    592642                        }
    593643                }
     
    599649
    600650/**
    601  * Supprime une composition du noizetier
     651 * Supprime une composition du noizetier.
    602652 *
    603653 * @param text $page
     654 *
    604655 * @return text
    605656 */
    606 function noizetier_supprimer_composition($page) {
     657function noizetier_supprimer_composition($page)
     658{
    607659        $type_page = noizetier_page_type($page);
    608660        $composition = noizetier_page_composition($page);
    609661        $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
    610662        unset($noizetier_compositions[$type_page][$composition]);
    611         if (count($noizetier_compositions[$type_page])==0)
     663        if (count($noizetier_compositions[$type_page]) == 0) {
    612664                unset($noizetier_compositions[$type_page]);
    613         ecrire_meta('noizetier_compositions',serialize($noizetier_compositions));
    614 }
    615 
    616 /**
    617  * Renvoie le type d'une page
     665        }
     666        ecrire_meta('noizetier_compositions', serialize($noizetier_compositions));
     667}
     668
     669/**
     670 * Renvoie le type d'une page.
    618671 *
    619672 * @param text $page
     673 *
    620674 * @return text
    621675 */
    622 function noizetier_page_type($page) {
    623         $type_compo = explode ('-',$page,2);
     676function noizetier_page_type($page)
     677{
     678        $type_compo = explode('-', $page, 2);
     679
    624680        return $type_compo[0];
    625681}
    626682
    627683/**
    628  * Renvoie la composition d'une page
     684 * Renvoie la composition d'une page.
    629685 *
    630686 * @param text $page
     687 *
    631688 * @return text
    632689 */
    633 function noizetier_page_composition($page) {
    634         $type_compo = explode ('-',$page,2);
     690function noizetier_page_composition($page)
     691{
     692        $type_compo = explode('-', $page, 2);
     693
    635694        return $type_compo[1];
    636695}
     
    640699 *
    641700 * @staticvar array $liste_blocs
     701 *
    642702 * @return array
    643703 */
    644 function noizetier_lister_blocs_avec_noisettes(){
     704function noizetier_lister_blocs_avec_noisettes()
     705{
    645706        static $liste_blocs = null;
    646        
    647         if (is_null($liste_blocs)){
     707
     708        if (is_null($liste_blocs)) {
    648709                $liste_blocs = array();
    649710                include_spip('base/abstract_sql');
    650                 $resultats = sql_allfetsel (
     711                $resultats = sql_allfetsel(
    651712                        array('bloc', 'type', 'composition'),
    652713                        'spip_noisettes',
     
    655716                );
    656717                foreach ($resultats as $res) {
    657                         if ($res['composition'])
     718                        if ($res['composition']) {
    658719                                $liste_blocs[] = $res['bloc'].'/'.$res['type'].'-'.$res['composition'];
    659                         else
     720                        } else {
    660721                                $liste_blocs[] = $res['bloc'].'/'.$res['type'];
    661                 }
    662         }
     722                        }
     723                }
     724        }
     725
    663726        return $liste_blocs;
    664727}
    665728
    666729/**
    667  * Liste d'icones en 24px obtenues en fouillant le theme
     730 * Liste d'icones en 24px obtenues en fouillant le theme.
    668731 *
    669732 * @staticvar array $liste_icones
     733 *
    670734 * @return array
    671735 */
    672 function noizetier_lister_icones(){
     736function noizetier_lister_icones()
     737{
    673738        static $liste_icones = null;
    674        
    675         if (is_null($liste_icones)){
    676                 $match = ".+-24[.](jpg|jpeg|png|gif)$";
     739
     740        if (is_null($liste_icones)) {
     741                $match = '.+-24[.](jpg|jpeg|png|gif)$';
    677742                $liste_icones = find_all_in_path('prive/themes/spip/images/', $match);
    678743        }
     744
    679745        return $liste_icones;
    680746}
    681747
    682748/**
    683  * Teste si une page fait partie des compositions du noizetier
     749 * Teste si une page fait partie des compositions du noizetier.
    684750 *
    685751 * @param text $page
     752 *
    686753 * @return text
    687754 */
    688 function noizetier_test_compo_noizetier($page) {
     755function noizetier_test_compo_noizetier($page)
     756{
    689757        $compos = unserialize($GLOBALS['meta']['noizetier_compositions']);
    690758        $type = noizetier_page_type($page);
    691759        $composition = noizetier_page_composition($page);
    692        
     760
    693761        return (is_array($compos[$type][$composition])) ? 'on' : '';
    694762}
    695 
    696 
    697 
    698763
    699764/**
     
    701766 * utiles a la noisette demande.
    702767 *
    703  * @param
    704  * @return
    705 **/
    706 function noizetier_choisir_contexte($noisette, $contexte_entrant, $id_noisette) {
     768 * @param
     769 *
     770 * @return
     771 **/
     772function noizetier_choisir_contexte($noisette, $contexte_entrant, $id_noisette)
     773{
    707774        $contexte_noisette = array_flip(noizetier_obtenir_contexte($noisette));
    708775
    709776        // On transmet toujours l'id_noisette et les variables se terminant par _$id_noisette (utilisees par exemple par Aveline pour la pagination)
    710777        $contexte_min = array('id_noisette' => $id_noisette);
    711        
     778
    712779        if (isset($contexte_noisette['env'])) {
    713                 return array_merge($contexte_entrant,$contexte_min);
    714         }
    715        
    716         $l = -1 * (strlen($id_noisette)+1);
    717         foreach ($contexte_entrant as $variable => $valeur)
    718                 if (substr($variable,$l)=='_'.$id_noisette)
     780                return array_merge($contexte_entrant, $contexte_min);
     781        }
     782
     783        $l = -1 * (strlen($id_noisette) + 1);
     784        foreach ($contexte_entrant as $variable => $valeur) {
     785                if (substr($variable, $l) == '_'.$id_noisette) {
    719786                        $contexte_min[$variable] = $valeur;
    720        
     787                }
     788        }
     789
    721790        if (isset($contexte_noisette['aucun'])) {
    722791                return $contexte_min;
    723792        }
    724793        if ($contexte_noisette) {
    725                 return array_merge(array_intersect_key($contexte_entrant, $contexte_noisette),$contexte_min);
    726         }
    727        
     794                return array_merge(array_intersect_key($contexte_entrant, $contexte_noisette), $contexte_min);
     795        }
     796
    728797        return $contexte_entrant;
    729798}
    730799
    731 
    732 
    733 /**
    734  * Retourne la liste des contextes donc peut avoir besoin une noisette.
    735  *
    736  * @param
    737  * @return
    738 **/
    739 function noizetier_obtenir_contexte($noisette) {
     800/**
     801 * Retourne la liste des contextes donc peut avoir besoin une noisette.
     802 *
     803 * @param
     804 *
     805 * @return
     806 **/
     807function noizetier_obtenir_contexte($noisette)
     808{
    740809        static $noisettes = false;
    741        
     810
    742811        // seulement 1 fois par appel, on lit ou calcule tous les contextes
    743812        if ($noisettes === false) {
    744813                // lire le cache des contextes sauves
    745                 lire_fichier_securise(_DIR_CACHE . _CACHE_CONTEXTE_NOISETTES, $noisettes);
     814                lire_fichier_securise(_DIR_CACHE._CACHE_CONTEXTE_NOISETTES, $noisettes);
    746815                $noisettes = @unserialize($noisettes);
    747                
     816
    748817                // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
    749818                if (!$noisettes or (_request('var_mode') == 'recalcul')) {
     
    753822                                $noisettes[$cle_noisette] = ($infos['contexte'] ? $infos['contexte'] : array());
    754823                        }
    755                         ecrire_fichier_securise(_DIR_CACHE . _CACHE_CONTEXTE_NOISETTES, serialize($noisettes));
     824                        ecrire_fichier_securise(_DIR_CACHE._CACHE_CONTEXTE_NOISETTES, serialize($noisettes));
    756825                }
    757826        }
     
    760829                return $noisettes[$noisette];
    761830        }
    762        
     831
    763832        return array();
    764833}
    765834
    766835/**
    767  * Retourne true ou false pour indiquer si la noisette doit être inclue en ajax
    768  *
    769  * @param
    770  * @return
    771 **/
    772 function noizetier_ajaxifier_noisette($noisette) {
     836 * Retourne true ou false pour indiquer si la noisette doit être inclue en ajax.
     837 *
     838 * @param
     839 *
     840 * @return
     841 **/
     842function noizetier_ajaxifier_noisette($noisette)
     843{
    773844        static $noisettes = false;
    774        
     845
    775846        // seulement 1 fois par appel, on lit ou calcule tous les contextes
    776847        if ($noisettes === false) {
    777848                // lire le cache des contextes sauves
    778                 lire_fichier_securise(_DIR_CACHE . _CACHE_AJAX_NOISETTES, $noisettes);
     849                lire_fichier_securise(_DIR_CACHE._CACHE_AJAX_NOISETTES, $noisettes);
    779850                $noisettes = @unserialize($noisettes);
    780                
     851
    781852                // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
    782853                if (!$noisettes or (_request('var_mode') == 'recalcul')) {
     
    784855                        $noisettes = array();
    785856                        foreach ($infos as $cle_noisette => $infos) {
    786                                 $noisettes[$cle_noisette] = ($infos['ajax'] == 'non') ? false : true ;
    787                         }
    788                         ecrire_fichier_securise(_DIR_CACHE . _CACHE_AJAX_NOISETTES, serialize($noisettes));
     857                                $noisettes[$cle_noisette] = ($infos['ajax'] == 'non') ? false : true;
     858                        }
     859                        ecrire_fichier_securise(_DIR_CACHE._CACHE_AJAX_NOISETTES, serialize($noisettes));
    789860                }
    790861        }
     
    793864                return $noisettes[$noisette];
    794865        }
    795        
     866
    796867        return true;
    797868}
    798869
    799870/**
    800  * Retourne true ou false pour indiquer si la noisette doit être inclue dynamiquement
    801  *
    802  * @param
    803  * @return
    804 **/
    805 function noizetier_inclusion_dynamique($noisette) {
     871 * Retourne true ou false pour indiquer si la noisette doit être inclue dynamiquement.
     872 *
     873 * @param
     874 *
     875 * @return
     876 **/
     877function noizetier_inclusion_dynamique($noisette)
     878{
    806879        static $noisettes = false;
    807        
     880
    808881        // seulement 1 fois par appel, on lit ou calcule tous les contextes
    809882        if ($noisettes === false) {
    810883                // lire le cache des contextes sauves
    811                 lire_fichier_securise(_DIR_CACHE . _CACHE_INCLUSIONS_NOISETTES, $noisettes);
     884                lire_fichier_securise(_DIR_CACHE._CACHE_INCLUSIONS_NOISETTES, $noisettes);
    812885                $noisettes = @unserialize($noisettes);
    813                
     886
    814887                // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
    815888                if (!$noisettes or (_request('var_mode') == 'recalcul')) {
     
    817890                        $noisettes = array();
    818891                        foreach ($infos as $cle_noisette => $infos) {
    819                                 $noisettes[$cle_noisette] = ($infos['inclusion'] == 'dynamique') ? true : false ;
    820                         }
    821                         ecrire_fichier_securise(_DIR_CACHE . _CACHE_INCLUSIONS_NOISETTES, serialize($noisettes));
     892                                $noisettes[$cle_noisette] = ($infos['inclusion'] == 'dynamique') ? true : false;
     893                        }
     894                        ecrire_fichier_securise(_DIR_CACHE._CACHE_INCLUSIONS_NOISETTES, serialize($noisettes));
    822895                }
    823896        }
     
    826899                return $noisettes[$noisette];
    827900        }
    828        
     901
    829902        return false;
    830903}
    831904
    832905/**
    833  * Retourne le tableau des noisettes et des compositions du noizetier pour les exports
    834  *
    835  * @return
    836 **/
    837 function noizetier_tableau_export() {
     906 * Retourne le tableau des noisettes et des compositions du noizetier pour les exports.
     907 *
     908 * @return
     909 **/
     910function noizetier_tableau_export()
     911{
    838912        $data = array();
    839        
     913
    840914        // On calcule le tableau des noisettes
    841915        $data['noisettes'] = sql_allfetsel(
     
    846920                'type, composition, bloc, rang'
    847921        );
    848        
     922
    849923        // On remet au propre les parametres
    850         foreach ($data['noisettes'] as $cle => $noisette)
     924        foreach ($data['noisettes'] as $cle => $noisette) {
    851925                $data['noisettes'][$cle]['parametres'] = unserialize($noisette['parametres']);
    852        
     926        }
     927
    853928        // On recupere les compositions du noizetier
    854929        $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
    855         if (is_array($noizetier_compositions) AND count($noizetier_compositions)>0)
     930        if (is_array($noizetier_compositions) and count($noizetier_compositions) > 0) {
    856931                $data['noizetier_compositions'] = $noizetier_compositions;
    857        
    858         $data = pipeline('noizetier_config_export',$data);
    859        
     932        }
     933
     934        $data = pipeline('noizetier_config_export', $data);
     935
    860936        return $data;
    861937}
    862938
    863939/**
    864  * Importe une configuration de noisettes et de compositions
    865  *
    866  * @param text $type_import
    867  * @param text $import_compos
     940 * Importe une configuration de noisettes et de compositions.
     941 *
     942 * @param text  $type_import
     943 * @param text  $import_compos
    868944 * @param array $config
    869  * @return boolean
    870  */
    871 function noizetier_importer_configuration($type_import, $import_compos, $config){
    872         if ($type_import!='remplacer')
     945 *
     946 * @return bool
     947 */
     948function noizetier_importer_configuration($type_import, $import_compos, $config)
     949{
     950        if ($type_import != 'remplacer') {
    873951                $type_import = 'fusion';
    874         if ($import_compos!='oui')
     952        }
     953        if ($import_compos != 'oui') {
    875954                $import_compos = 'non';
    876        
    877         $config = pipeline('noizetier_config_import',$config);
    878        
     955        }
     956
     957        $config = pipeline('noizetier_config_import', $config);
     958
    879959        // On s'occupe deja des noisettes
    880960        $noisettes = $config['noisettes'];
    881961        include_spip('base/abstract_sql');
    882         if (is_array($noisettes) AND count($noisettes)>0) {
     962        if (is_array($noisettes) and count($noisettes) > 0) {
    883963                $noisettes_insert = array();
    884964                $rang = 1;
    885965                $page = '';
    886                 if ($type_import=='remplacer')
    887                         sql_delete('spip_noisettes','1');
    888                 foreach($noisettes as $noisette) {
     966                if ($type_import == 'remplacer') {
     967                        sql_delete('spip_noisettes', '1');
     968                }
     969                foreach ($noisettes as $noisette) {
    889970                        $type = $noisette['type'];
    890971                        $composition = $noisette['composition'];
    891                         if ($type.'-'.$composition!=$page) {
     972                        if ($type.'-'.$composition != $page) {
    892973                                $page = $type.'-'.$composition;
    893974                                $rang = 1;
    894                                 if ($type_import=='fusion')
    895                                         $rang = sql_getfetsel('rang','spip_noisettes','type='.sql_quote($type).' AND composition='.sql_quote($composition),'','rang DESC') + 1;
    896                         }
    897                         else {
     975                                if ($type_import == 'fusion') {
     976                                        $rang = sql_getfetsel('rang', 'spip_noisettes', 'type='.sql_quote($type).' AND composition='.sql_quote($composition), '', 'rang DESC') + 1;
     977                                }
     978                        } else {
    898979                                $rang = $rang + 1;
    899980                        }
    900                         $noisette['rang']=$rang;
     981                        $noisette['rang'] = $rang;
    901982                        $noisette['parametres'] = serialize($noisette['parametres']);
    902983                        $noisettes_insert[] = $noisette;
    903984                }
    904                 $ok = sql_insertq_multi('spip_noisettes',$noisettes_insert);
    905         }
    906        
     985                $ok = sql_insertq_multi('spip_noisettes', $noisettes_insert);
     986        }
     987
    907988        // On s'occupe des compositions du noizetier
    908         if ($import_compos=='oui') {
     989        if ($import_compos == 'oui') {
    909990                include_spip('inc/meta');
    910991                $compos_importees = $config['noizetier_compositions'];
    911                 if (is_array($compos_importees) AND count($compos_importees)>0){
    912                         if ($type_import=='remplacer')
     992                if (is_array($compos_importees) and count($compos_importees) > 0) {
     993                        if ($type_import == 'remplacer') {
    913994                                effacer_meta('noizetier_compositions');
    914                         else
     995                        } else {
    915996                                $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
    916                        
    917                         if (!is_array($noizetier_compositions))
     997                        }
     998
     999                        if (!is_array($noizetier_compositions)) {
    9181000                                $noizetier_compositions = array();
    919                        
    920                         foreach($compos_importees as $type => $compos_type)
    921                                 foreach($compos_type as $composition => $info_compo)
     1001                        }
     1002
     1003                        foreach ($compos_importees as $type => $compos_type) {
     1004                                foreach ($compos_type as $composition => $info_compo) {
    9221005                                        $noizetier_compositions[$type][$composition] = $info_compo;
    923                        
    924                         ecrire_meta('noizetier_compositions',serialize($noizetier_compositions));
     1006                                }
     1007                        }
     1008
     1009                        ecrire_meta('noizetier_compositions', serialize($noizetier_compositions));
    9251010                        ecrire_metas();
    9261011                }
    9271012        }
    928        
     1013
    9291014        // On invalide le cache
    9301015        include_spip('inc/invalideur');
    9311016        suivre_invalideur('noizetier-import-config');
     1017
    9321018        return $ok;
    9331019}
    9341020
    9351021/**
    936  * Retourne le chemin complet d'une icone, vérifie d'abord chemin_image, sinon passe par find_in_path
     1022 * Retourne le chemin complet d'une icone, vérifie d'abord chemin_image, sinon passe par find_in_path.
    9371023 *
    9381024 * @param text $icone
     1025 *
    9391026 * @return text
    9401027 */
    941 function noizetier_chemin_icone($icone){
    942         if ($i = chemin_image($icone))
     1028function noizetier_chemin_icone($icone)
     1029{
     1030        if ($i = chemin_image($icone)) {
    9431031                return $i;
    944         else {
     1032        } else {
    9451033                return find_in_path($icone);
    9461034        }
  • _plugins_/noizetier/trunk/noizetier_ieconfig.php

    r57709 r93111  
    11<?php
    2 if (!defined("_ECRIRE_INC_VERSION")) return;
     2
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
    36
    47/**
    5  * Pipeline ieconfig pour l'import/export de configuration
     8 * Pipeline ieconfig pour l'import/export de configuration.
    69 *
    710 * @param array $flux
     11 *
    812 * @return array
    913 */
    10 function noizetier_ieconfig($flux){
     14function noizetier_ieconfig($flux)
     15{
    1116        $action = $flux['args']['action'];
    12        
     17
    1318        // Formulaire d'export
    14         if ($action=='form_export') {
     19        if ($action == 'form_export') {
    1520                $saisies = array(
    1621                        array(
     
    1924                                        'nom' => 'noizetier_export',
    2025                                        'label' => '<:noizetier:noizetier:>',
    21                                         'icone' => 'noizetier-24.png'
     26                                        'icone' => 'noizetier-24.png',
    2227                                ),
    2328                                'saisies' => array(
     
    2631                                                'options' => array(
    2732                                                        'nom' => 'noizetier_export_explication',
    28                                                         'texte' => '<:noizetier:ieconfig_noizetier_export_explication:>'
    29                                                 )
     33                                                        'texte' => '<:noizetier:ieconfig_noizetier_export_explication:>',
     34                                                ),
    3035                                        ),
    3136                                        array(
     
    3439                                                        'nom' => 'noizetier_export_option',
    3540                                                        'label' => '<:noizetier:ieconfig_noizetier_export_option:>',
    36                                                         'defaut' => ''
    37                                                 )
    38                                         )
    39                                 )
    40                         )
     41                                                        'defaut' => '',
     42                                                ),
     43                                        ),
     44                                ),
     45                        ),
    4146                );
    42                 $flux['data'] = array_merge($flux['data'],$saisies);
     47                $flux['data'] = array_merge($flux['data'], $saisies);
    4348        }
    44        
     49
    4550        // Tableau d'export
    46         if ($action=='export' && _request('noizetier_export_option')=='on') {
     51        if ($action == 'export' && _request('noizetier_export_option') == 'on') {
    4752                include_spip('noizetier_fonctions');
    4853                $flux['data']['noizetier'] = noizetier_tableau_export();
    4954        }
    50        
     55
    5156        // Formulaire d'import
    52         if ($action=='form_import' && isset($flux['args']['config']['noizetier'])) {
     57        if ($action == 'form_import' && isset($flux['args']['config']['noizetier'])) {
    5358                $texte_explication = '';
    5459                if (isset($flux['args']['config']['noizetier']['noisettes'])) {
    5560                        $texte_explication .= _T('noizetier:formulaire_liste_pages_config');
    5661                        $pages = array();
    57                         foreach($flux['args']['config']['noizetier']['noisettes'] as $noisette)
     62                        foreach ($flux['args']['config']['noizetier']['noisettes'] as $noisette) {
    5863                                $pages[] = $noisette['type'].'-'.$noisette['composition'];
     64                        }
    5965                        $pages = array_unique($pages);
    60                         foreach ($pages as $page)
    61                                 $texte_explication .= '<br />&raquo; '.rtrim($page,'-');
     66                        foreach ($pages as $page) {
     67                                $texte_explication .= '<br />&raquo; '.rtrim($page, '-');
     68                        }
    6269                }
    6370                if (isset($flux['args']['config']['noizetier']['noizetier_compositions'])) {
    6471                        $texte_explication .= '<br />'._T('noizetier:formulaire_liste_compos_config');
    65                         foreach($flux['args']['config']['noizetier']['noizetier_compositions'] as $type => $compositions)
    66                                 foreach ($compositions as $composition => $compo)
     72                        foreach ($flux['args']['config']['noizetier']['noizetier_compositions'] as $type => $compositions) {
     73                                foreach ($compositions as $composition => $compo) {
    6774                                        $texte_explication .= '<br />&raquo; '.$type.'-'.$composition;
     75                                }
     76                        }
    6877                }
    6978                if (isset($flux['args']['config']['noizetier']['noizetier_compositions'])) {
     
    7483                                                'nom' => 'noizetier_export',
    7584                                                'label' => '<:noizetier:noizetier:>',
    76                                                 'icone' => 'noizetier-24.png'
     85                                                'icone' => 'noizetier-24.png',
    7786                                        ),
    7887                                        'saisies' => array(
     
    8190                                                        'options' => array(
    8291                                                                'nom' => 'noizetier_export_explication',
    83                                                                 'texte' => $texte_explication
    84                                                         )
     92                                                                'texte' => $texte_explication,
     93                                                        ),
    8594                                                ),
    8695                                                array(
     
    94103                                                                'datas' => array(
    95104                                                                        'fusion' => '<:noizetier:formulaire_import_fusion:>',
    96                                                                         'remplacer' => '<:noizetier:formulaire_import_remplacer:>'
    97                                                                 )
    98                                                         )
     105                                                                        'remplacer' => '<:noizetier:formulaire_import_remplacer:>',
     106                                                                ),
     107                                                        ),
    99108                                                ),
    100109                                                array(
     
    107116                                                                'datas' => array(
    108117                                                                        'oui' => '<:noizetier:oui:>',
    109                                                                         'non' => '<:noizetier:non:>'
    110                                                                 )
    111                                                         )
    112                                                 )
    113                                         )
    114                                 )
     118                                                                        'non' => '<:noizetier:non:>',
     119                                                                ),
     120                                                        ),
     121                                                ),
     122                                        ),
     123                                ),
    115124                        );
    116125                } else {
     
    121130                                                'nom' => 'noizetier_export',
    122131                                                'label' => '<:noizetier:noizetier:>',
    123                                                 'icone' => 'noizetier-24.png'
     132                                                'icone' => 'noizetier-24.png',
    124133                                        ),
    125134                                        'saisies' => array(
     
    128137                                                        'options' => array(
    129138                                                                'nom' => 'noizetier_export_explication',
    130                                                                 'texte' => $texte_explication
    131                                                         )
     139                                                                'texte' => $texte_explication,
     140                                                        ),
    132141                                                ),
    133142                                                array(
     
    141150                                                                'datas' => array(
    142151                                                                        'fusion' => '<:noizetier:formulaire_import_fusion:>',
    143                                                                         'remplacer' => '<:noizetier:formulaire_import_remplacer:>'
    144                                                                 )
    145                                                         )
     152                                                                        'remplacer' => '<:noizetier:formulaire_import_remplacer:>',
     153                                                                ),
     154                                                        ),
    146155                                                ),
    147156                                                array(
     
    150159                                                                'nom' => 'noizetier_import_compos',
    151160                                                                'defaut' => 'non',
    152                                                         )
    153                                                 )
    154                                         )
    155                                 )
     161                                                        ),
     162                                                ),
     163                                        ),
     164                                ),
    156165                        );
    157166                }
    158                 $flux['data'] = array_merge($flux['data'],$saisies);
     167                $flux['data'] = array_merge($flux['data'], $saisies);
    159168        }
    160        
     169
    161170        // Import de la configuration
    162         if ($action=='import' && isset($flux['args']['config']['noizetier']) && _request('noizetier_type_import')!='') {
     171        if ($action == 'import' && isset($flux['args']['config']['noizetier']) && _request('noizetier_type_import') != '') {
    163172                include_spip('noizetier_fonctions');
    164                 if (!noizetier_importer_configuration(_request('noizetier_type_import'),_request('noizetier_import_compos'),$flux['args']['config']['noizetier']))
     173                if (!noizetier_importer_configuration(_request('noizetier_type_import'), _request('noizetier_import_compos'), $flux['args']['config']['noizetier'])) {
    165174                        $flux['data'] .= _T('noizetier:ieconfig_probleme_import_config').'<br />';
     175                }
    166176        }
    167        
     177
    168178        return($flux);
    169179}
    170 
    171 ?>
  • _plugins_/noizetier/trunk/noizetier_pipelines.php

    r91444 r93111  
    22
    33// Sécurité
    4 if (!defined("_ECRIRE_INC_VERSION")) return;
    5 
    6 function noizetier_header_prive($flux){
     4if (!defined('_ECRIRE_INC_VERSION')) {
     5        return;
     6}
     7
     8function noizetier_header_prive($flux)
     9{
    710        $css = direction_css(find_in_path('css/noizetier.css'));
    811        $flux .= "\n<link rel='stylesheet' href='$css' type='text/css' />\n";
    9         return $flux;
    10 }
    11 
    12 
    13 /**
    14  * Pipeline recuperer_fond pour ajouter les noisettes
     12
     13        return $flux;
     14}
     15
     16/**
     17 * Pipeline recuperer_fond pour ajouter les noisettes.
    1518 *
    1619 * @param array $flux
    17  * @return array
    18  */
    19 function noizetier_recuperer_fond($flux){
    20         if (defined('_NOIZETIER_RECUPERER_FOND')?_NOIZETIER_RECUPERER_FOND:true) {
     20 *
     21 * @return array
     22 */
     23function noizetier_recuperer_fond($flux)
     24{
     25        if (defined('_NOIZETIER_RECUPERER_FOND') ? _NOIZETIER_RECUPERER_FOND : true) {
    2126                include_spip('noizetier_fonctions');
    2227                $fond = $flux['args']['fond'];
     
    2429                // Si une composition est définie et si elle n'est pas déjà dans le fond, on l'ajoute au fond
    2530                // sauf s'il s'agit d'une page de type page (les squelettes page.html assurant la redirection)
    26                 if ($composition!='' AND noizetier_page_composition($fond)=='' AND noizetier_page_type($fond)!='page')
     31                if ($composition != '' and noizetier_page_composition($fond) == '' and noizetier_page_type($fond) != 'page') {
    2732                        $fond .= '-'.$composition;
     33                }
    2834
    2935                // Tester l'installation du noizetier pour éviter un message d'erreur à l'installation
    3036                if (isset($GLOBALS['meta']['noizetier_base_version'])) {
    31                         if ($flux['args']['contexte']['voir']=='noisettes' && !function_exists('autoriser'))
    32                                 include_spip('inc/autoriser');   // si on utilise le formulaire dans le public
    33                         if (in_array($fond,noizetier_lister_blocs_avec_noisettes())) {
     37                        if ($flux['args']['contexte']['voir'] == 'noisettes' && !function_exists('autoriser')) {
     38                                include_spip('inc/autoriser');
     39                        }     // si on utilise le formulaire dans le public
     40                        if (in_array($fond, noizetier_lister_blocs_avec_noisettes())) {
    3441                                $contexte = $flux['data']['contexte'];
    35                                 $contexte['bloc'] = substr($fond,0,strpos($fond,'/'));
    36                                 if ($flux['args']['contexte']['voir']=='noisettes' && autoriser('configurer','noizetier'))
    37                                         $complements = recuperer_fond('noizetier-generer-bloc-voir-noisettes',$contexte,array('raw'=>true));
    38                                 else
    39                                         $complements = recuperer_fond('noizetier-generer-bloc',$contexte,array('raw'=>true));
     42                                $contexte['bloc'] = substr($fond, 0, strpos($fond, '/'));
     43                                if ($flux['args']['contexte']['voir'] == 'noisettes' && autoriser('configurer', 'noizetier')) {
     44                                        $complements = recuperer_fond('noizetier-generer-bloc-voir-noisettes', $contexte, array('raw' => true));
     45                                } else {
     46                                        $complements = recuperer_fond('noizetier-generer-bloc', $contexte, array('raw' => true));
     47                                }
    4048                                $flux['data']['texte'] .= $complements['texte'];
    41                         }
    42                         elseif ($flux['args']['contexte']['voir']=='noisettes' && autoriser('configurer','noizetier')) { // Il faut ajouter les blocs vides en mode voir=noisettes
     49                        } elseif ($flux['args']['contexte']['voir'] == 'noisettes' && autoriser('configurer', 'noizetier')) { // Il faut ajouter les blocs vides en mode voir=noisettes
    4350                                $contexte = $flux['data']['contexte'];
    44                                 $bloc = substr($fond,0,strpos($fond,'/'));
     51                                $bloc = substr($fond, 0, strpos($fond, '/'));
    4552                                $contexte['bloc'] = $bloc;
    4653                                $page = isset($contexte['type']) ? $contexte['type'] : '';
     
    4855                                $info_page = noizetier_lister_pages($page);
    4956                                if (isset($info_page['blocs'][$bloc])) {
    50                                         $complements = recuperer_fond('noizetier-generer-bloc-voir-noisettes',$contexte,array('raw'=>true));
     57                                        $complements = recuperer_fond('noizetier-generer-bloc-voir-noisettes', $contexte, array('raw' => true));
    5158                                        $flux['data']['texte'] .= $complements['texte'];
    5259                                }
     
    5461                }
    5562        }
    56         return $flux;
    57 }
    58 
    59 /**
    60  * Personnaliser le fond des formulaires
     63
     64        return $flux;
     65}
     66
     67/**
     68 * Personnaliser le fond des formulaires.
    6169 *
    6270 * Ajout d'un lien vers la page de configuration
    6371 * dans le formulaire de sélection de composition d'un objet
    6472 */
    65 function noizetier_formulaire_fond($flux) {
     73function noizetier_formulaire_fond($flux)
     74{
    6675        // formulaire d'edition de la composition d'un objet
    6776        if ($flux['args']['form'] == 'editer_composition_objet') {
    68 
    69                 $objet                       = $flux['args']['contexte']['objet'];
    70                 $composition                 = $flux['args']['contexte']['composition'];
    71                 $type_page                   = $objet . ($composition ? '-'.$composition : '');
     77                $objet = $flux['args']['contexte']['objet'];
     78                $composition = $flux['args']['contexte']['composition'];
     79                $type_page = $objet.($composition ? '-'.$composition : '');
    7280                $noizetier_compositions_meta = unserialize($GLOBALS['meta']['noizetier_compositions']);
    73                 $noizetier_compositions_xml  = array_keys(noizetier_lister_pages());
     81                $noizetier_compositions_xml = array_keys(noizetier_lister_pages());
    7482
    7583                // On vérifie que cette composition existe
    7684                if (
    7785                        is_array($noizetier_compositions_meta[$objet][$composition])
    78                         OR in_array($type_page,$noizetier_compositions_xml)
    79                 ){
     86                        or in_array($type_page, $noizetier_compositions_xml)
     87                ) {
    8088                        $balise_img = charger_filtre('balise_img');
    81                         $lien       = generer_url_ecrire("noizetier_page","page=$type_page");
    82                         $alt        = _T('noizetier:editer_configurer_page');
    83                         $cherche    = "/(<span[^>]*class=('|\")toggle_box_link[^>]*>)/is";
    84                         $icone      = inserer_attribut($balise_img(find_in_path("prive/themes/spip/images/noisette-16.png")),'style','vertical-align:middle;');
    85                         $remplace   = "$1" . "<a href=\"$lien\" title=\"$alt\">".$icone."</a> ";
     89                        $lien = generer_url_ecrire('noizetier_page', "page=$type_page");
     90                        $alt = _T('noizetier:editer_configurer_page');
     91                        $cherche = "/(<span[^>]*class=('|\")toggle_box_link[^>]*>)/is";
     92                        $icone = inserer_attribut($balise_img(find_in_path('prive/themes/spip/images/noisette-16.png')), 'style', 'vertical-align:middle;');
     93                        $remplace = '$1'."<a href=\"$lien\" title=\"$alt\">".$icone.'</a> ';
    8694                        $flux['data'] = preg_replace($cherche, $remplace, $flux['data']);
    8795                }
    88 
    89         }
    90         return $flux;
    91 }
    92 
    93 /**
    94  * Pipeline compositions_lister_disponibles pour ajouter les compositions du noizetier
     96        }
     97
     98        return $flux;
     99}
     100
     101/**
     102 * Pipeline compositions_lister_disponibles pour ajouter les compositions du noizetier.
    95103 *
    96104 * @param array $flux
    97  * @return array
    98  */
    99 
    100 function noizetier_compositions_lister_disponibles($flux){
     105 *
     106 * @return array
     107 */
     108function noizetier_compositions_lister_disponibles($flux)
     109{
    101110        $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
    102         if (!is_array($noizetier_compositions))
     111        if (!is_array($noizetier_compositions)) {
    103112                $noizetier_compositions = array();
     113        }
    104114        unset($noizetier_compositions['page']);
    105115        $type = $flux['args']['type'];
     
    107117
    108118        include_spip('inc/texte');
    109         foreach($noizetier_compositions as $t => $compos_type)
    110                 foreach($compos_type as $c => $info_compo) {
    111                         if($informer) {
     119        foreach ($noizetier_compositions as $t => $compos_type) {
     120                foreach ($compos_type as $c => $info_compo) {
     121                        if ($informer) {
    112122                                $noizetier_compositions[$t][$c]['nom'] = typo($info_compo['nom']);
    113123                                $noizetier_compositions[$t][$c]['description'] = propre($info_compo['description']);
    114                                 if ($info_compo['icon']!='')
     124                                if ($info_compo['icon'] != '') {
    115125                                        $icone = $info_compo['icon'];
    116                                 else {
     126                                } else {
    117127                                        $info_page = noizetier_lister_pages($t);
    118                                         $icone = (isset($info_page['icon']) && $info_page['icon']!='') ? $info_page['icon'] : 'composition-24.png';
     128                                        $icone = (isset($info_page['icon']) && $info_page['icon'] != '') ? $info_page['icon'] : 'composition-24.png';
    119129                                }
    120130                                $noizetier_compositions[$t][$c]['icon'] = noizetier_chemin_icone($icone);
    121                         }
    122                         else
     131                        } else {
    123132                                $noizetier_compositions[$t][$c] = 1;
    124133                        }
    125 
    126         if ($type=='' AND count($noizetier_compositions)>0) {
    127                 if (!is_array($flux['data']))
     134                }
     135        }
     136
     137        if ($type == '' and count($noizetier_compositions) > 0) {
     138                if (!is_array($flux['data'])) {
    128139                        $flux['data'] = array();
    129                 $flux['data'] = array_merge_recursive ($flux['data'],$noizetier_compositions);
    130         }
    131         elseif (count($noizetier_compositions[$type])>0) {
    132                 if (!is_array($flux['data'][$type]))
     140                }
     141                $flux['data'] = array_merge_recursive($flux['data'], $noizetier_compositions);
     142        } elseif (count($noizetier_compositions[$type]) > 0) {
     143                if (!is_array($flux['data'][$type])) {
    133144                        $flux['data'][$type] = array();
    134                 if (!is_array($noizetier_compositions[$type]))
     145                }
     146                if (!is_array($noizetier_compositions[$type])) {
    135147                        $noizetier_compositions[$type] = array();
    136                 $flux['data'][$type] = array_merge_recursive ($flux['data'][$type],$noizetier_compositions[$type]);
    137         }
    138         return $flux;
    139 }
    140 
    141 /**
    142  * Pipeline styliser pour les compositions du noizetier de type page si celles-ci sont activées
     148                }
     149                $flux['data'][$type] = array_merge_recursive($flux['data'][$type], $noizetier_compositions[$type]);
     150        }
     151
     152        return $flux;
     153}
     154
     155/**
     156 * Pipeline styliser pour les compositions du noizetier de type page si celles-ci sont activées.
    143157 *
    144158 * @param array $flux
    145  * @return array
    146  */
    147 function noizetier_styliser($flux){
    148         if(defined('_NOIZETIER_COMPOSITIONS_TYPE_PAGE') AND _NOIZETIER_COMPOSITIONS_TYPE_PAGE) {
     159 *
     160 * @return array
     161 */
     162function noizetier_styliser($flux)
     163{
     164        if (defined('_NOIZETIER_COMPOSITIONS_TYPE_PAGE') and _NOIZETIER_COMPOSITIONS_TYPE_PAGE) {
    149165                $squelette = $flux['data'];
    150166                $fond = $flux['args']['fond'];
     
    155171                        // On vérifie qu'on n'a pas demandé une composition du noizetier de type page et qu'on appele ?page=type
    156172                        if (isset($noizetier_compositions['page'][$fond])) {
    157                                 $flux['data'] = substr(find_in_path("page.$ext"), 0, - strlen(".$ext"));
     173                                $flux['data'] = substr(find_in_path("page.$ext"), 0, -strlen(".$ext"));
    158174                                $flux['args']['composition'] = $fond;
    159175                        }
    160176                }
    161177        }
    162         return $flux;
    163 }
    164 
    165 /**
    166  * Pipeline jqueryui_forcer pour demander au plugin l'insertion des scripts pour .sortable()
     178
     179        return $flux;
     180}
     181
     182/**
     183 * Pipeline jqueryui_forcer pour demander au plugin l'insertion des scripts pour .sortable().
    167184 *
    168185 * @param array $plugins
    169  * @return array
    170  */
    171 function noizetier_jqueryui_forcer($plugins){
    172         $plugins[] = "jquery.ui.core";
    173         $plugins[] = "jquery.ui.widget";
    174         $plugins[] = "jquery.ui.mouse";
    175         $plugins[] = "jquery.ui.sortable";
    176         $plugins[] = "jquery.ui.droppable";
    177         $plugins[] = "jquery.ui.draggable";
     186 *
     187 * @return array
     188 */
     189function noizetier_jqueryui_forcer($plugins)
     190{
     191        $plugins[] = 'jquery.ui.core';
     192        $plugins[] = 'jquery.ui.widget';
     193        $plugins[] = 'jquery.ui.mouse';
     194        $plugins[] = 'jquery.ui.sortable';
     195        $plugins[] = 'jquery.ui.droppable';
     196        $plugins[] = 'jquery.ui.draggable';
     197
    178198        return $plugins;
    179199}
    180200
    181 
    182 function noizetier_noizetier_lister_pages($flux){return $flux;}
    183 function noizetier_noizetier_blocs_defaut($flux){return $flux;}
    184 function noizetier_noizetier_config_export($flux){return $flux;}
    185 function noizetier_noizetier_config_import($flux){return $flux;}
     201function noizetier_noizetier_lister_pages($flux)
     202{
     203        return $flux;
     204}
     205function noizetier_noizetier_blocs_defaut($flux)
     206{
     207        return $flux;
     208}
     209function noizetier_noizetier_config_export($flux)
     210{
     211        return $flux;
     212}
     213function noizetier_noizetier_config_import($flux)
     214{
     215        return $flux;
     216}
    186217
    187218// les boutons d'administration : ajouter le mode voir=noisettes
    188 function noizetier_formulaire_admin($flux) {
    189         if (autoriser('configurer','noizetier')) {
     219function noizetier_formulaire_admin($flux)
     220{
     221        if (autoriser('configurer', 'noizetier')) {
    190222                $btn = recuperer_fond('prive/bouton/voir_noisettes');
    191223                $flux['data'] = preg_replace('%(<!--extra-->)%is', $btn.'$1', $flux['data']);
    192224        }
     225
    193226        return $flux;
    194227}
     
    198231// Au moins, le cache est supprimé à chaque changement, mise à jour des plugins.
    199232
    200 function noizetier_affiche_milieu($flux) {
    201         $exec = $flux["args"]["exec"];
    202 
    203         if ($exec == "admin_plugin") {
     233function noizetier_affiche_milieu($flux)
     234{
     235        $exec = $flux['args']['exec'];
     236
     237        if ($exec == 'admin_plugin') {
    204238                include_spip('inc/flock');
    205239                include_spip('noizetier_fonctions');
    206                 supprimer_fichier(_DIR_CACHE . _CACHE_AJAX_NOISETTES);
    207                 supprimer_fichier(_DIR_CACHE . _CACHE_CONTEXTE_NOISETTES);
    208                 supprimer_fichier(_DIR_CACHE . _CACHE_INCLUSIONS_NOISETTES);
    209                 supprimer_fichier(_DIR_CACHE . _CACHE_DESCRIPTIONS_NOISETTES);
    210         }
    211 
    212         return $flux;
    213 }
    214 
    215 ?>
     240                supprimer_fichier(_DIR_CACHE._CACHE_AJAX_NOISETTES);
     241                supprimer_fichier(_DIR_CACHE._CACHE_CONTEXTE_NOISETTES);
     242                supprimer_fichier(_DIR_CACHE._CACHE_INCLUSIONS_NOISETTES);
     243                supprimer_fichier(_DIR_CACHE._CACHE_DESCRIPTIONS_NOISETTES);
     244        }
     245
     246        return $flux;
     247}
Note: See TracChangeset for help on using the changeset viewer.