source: spip-zone/_squelettes_/galaxie_melusine/melusine/trunk/melusine_fonctions.php @ 82969

Last change on this file since 82969 was 82969, checked in by jml9340@…, 7 years ago

gestion des colonnes

  • Property svn:executable set to *
File size: 21.2 KB
Line 
1<?php
2
3/**
4 * Plugin Mélusine
5 * (c) 2012 Jean-Marc Labat
6 * Licence GNU/GPL
7 */
8
9if (!defined('_ECRIRE_INC_VERSION')) return;
10
11// Les mêmes caches que pour le noizetier:
12
13include_spip('inc/filtres');
14$f = chercher_filtre('info_plugin');
15$noiz_actif = $f("noizetier","est_actif");
16
17// Si pas noizetier, on crée ls constantes
18if (!$noiz_actif) {
19        define('_CACHE_AJAX_NOISETTES', 'noisettes_ajax.php');
20        define('_CACHE_CONTEXTE_NOISETTES', 'noisettes_contextes.php');
21        define('_CACHE_DESCRIPTIONS_NOISETTES', 'noisettes_descriptions.php');
22        define('_CACHE_INCLUSIONS_NOISETTES', 'noisettes_inclusions.php');
23}
24
25
26/*
27 * Un fichier de fonctions permet de definir des elements
28 * systematiquement charges lors du calcul des squelettes.
29 *
30 * Il peut par exemple définir des filtres, critères, balises, ?
31 *
32 */
33
34
35
36
37
38
39// ===================================================
40// Filtre : hauteur_majoree
41// ===================================================
42// Auteur: S. Bellégo
43// Fonction : Retourne la hauteur d'une image + 20. Sert pour
44//                   afficher correctemnt le logo d'une rubrique
45// ===================================================
46//
47
48
49
50function hauteur_majoree($img) {
51    if (!$img) return;
52    include_spip('logos.php');
53    list ($h,$l) = taille_image($img);
54    $h+=20;
55    return $h;
56}
57// FIN du Filtre : hauteur_majoree
58
59// ===================================================
60// Filtre : typo_couleur
61// ===================================================
62// Auteur : Smellup, inspiré du filtre original de A. Piérard
63// Fonction : permettant de modifier la couleur du texte ou
64//                   de l'introduction d'un article
65// Utilisation :                 
66//  - pour le rédacteur : [rouge]xxxxxx[/rouge]
67//  - pour le webmaster : [(#TEXTE|couleur)]
68// ===================================================
69//
70function typo_couleur($texte) {
71
72    // Variables personnalisables par l'utilisateur
73    $typo_couleur_active = 'oui';
74    // --> Activation ou désactivation de la fonction
75    // --> Nuances personnalisables par l'utilisateur
76    $couleur = array(
77        'noir' => "#000000",
78        'blanc' => "#FFFFFF",
79        'rouge' => "#FF0000",
80        'vert' => "#00FF00",
81        'bleu' => "#0000FF",
82        'jaune' => "#FFFF00",
83        'gris' => "#808080",
84        'marron' => "#800000",
85        'violet' => "#800080",
86        'rose' => "#FFC0CB",
87        'orange' => "#FFA500"
88    );
89
90    $recherche = array(
91        'noir' => "/(\[noir\])(.*?)(\[\/noir\])/",
92        'blanc' => "/(\[blanc\])(.*?)(\[\/blanc\])/",
93        'rouge' => "/(\[rouge\])(.*?)(\[\/rouge\])/",
94        'vert' => "/(\[vert\])(.*?)(\[\/vert\])/",
95        'bleu' => "/(\[bleu\])(.*?)(\[\/bleu\])/",
96        'jaune' => "/(\[jaune\])(.*?)(\[\/jaune\])/",
97        'gris' => "/(\[gris\])(.*?)(\[\/gris\])/",
98        'marron' => "/(\[marron\])(.*?)(\[\/marron\])/",
99        'violet' => "/(\[violet\])(.*?)(\[\/violet\])/",
100        'rose' => "/(\[rose\])(.*?)(\[\/rose\])/",
101        'orange' => "/(\[orange\])(.*?)(\[\/orange\])/"
102    );
103
104    $remplace = array(
105        'noir' => "<span style=\"color:".$couleur['noir'].";\">\\2</span>",
106        'blanc' => "<span style=\"color:".$couleur['blanc'].";\">\\2</span>",
107        'rouge' => "<span style=\"color:".$couleur['rouge'].";\">\\2</span>",
108        'vert' => "<span style=\"color:".$couleur['vert'].";\">\\2</span>",
109        'bleu' => "<span style=\"color:".$couleur['bleu'].";\">\\2</span>",
110        'jaune' => "<span style=\"color:".$couleur['jaune'].";\">\\2</span>",
111        'gris' => "<span style=\"color:".$couleur['gris'].";\">\\2</span>",
112        'marron' => "<span style=\"color:".$couleur['marron'].";\">\\2</span>",
113        'violet' => "<span style=\"color:".$couleur['violet'].";\">\\2</span>",
114        'rose' => "<span style=\"color:".$couleur['rose'].";\">\\2</span>",
115        'orange' => "<span style=\"color:".$couleur['orange'].";\">\\2</span>"
116    );
117
118    $supprime = "\\2";
119
120
121    if ($typo_couleur_active == 'non') {
122        $texte = preg_replace($recherche, $supprime, $texte);
123    }
124    else {
125        $texte = preg_replace($recherche, $remplace, $texte);
126    }
127    return $texte;
128}
129
130// ===================================================
131// Balise : #INTRODUCTION (surcharge)
132// ===================================================
133// Auteur: Smellup
134// Fonction : Surcharge de la fonction standard de calcul de la
135//                   balise #INTRODUCTION. Permet d'en definir la
136//                   taille en nombre de caractère
137// ===================================================
138//
139function introduction ($type, $texte, $chapo='', $descriptif='') {
140
141    // Personnalisable par l'utilisateur
142    $taille_intro_article = 600;
143    $taille_intro_breve = 300;
144    $taille_intro_message = 600;
145    $taille_intro_rubrique = 600;
146   
147    switch ($type) {
148        case 'articles':
149            if ($descriptif)
150                return propre($descriptif);
151            else if (substr($chapo, 0, 1) == '=')   // article virtuel
152                return '';
153            else
154                return PtoBR(propre(supprimer_tags(couper_intro($chapo."\n\n\n".$texte, $taille_intro_article))));
155            break;
156        case 'breves':
157            return PtoBR(propre(supprimer_tags(couper_intro($texte, $taille_intro_breve))));
158            break;
159        case 'forums':
160            return PtoBR(propre(supprimer_tags(couper_intro($texte, $taille_intro_message))));
161            break;
162        case 'rubriques':
163            if ($descriptif)
164                return propre($descriptif);
165            else
166                return PtoBR(propre(supprimer_tags(couper_intro($texte, $taille_intro_rubrique))));
167            break;
168    }
169}
170
171
172/**
173 * Obtenir la liste des noisettes disponibles correspondant au type
174 * passé en paramètre
175 *
176 * @param text $type est le type de noisette (articles, rurbiques, mobil, etc.)
177 * le type correspond aussi au sous répertoire de module dans
178 * lequel sont rangées les noisettes
179 * @return
180 *
181 * TODO changer le nom du répertoire en noisettes (et réperctuer les changements)
182**/
183function melusine_liste_noisettes_dispo($type=""){
184        $type_casier = $type ? $type : "squelettes";
185        effacer_config("melusine_".$type_casier."/skel");
186        $sous_rep = $type ? $type."/" : "";
187        $chemin="modules/".$sous_rep;
188
189        // Ce qui suit est très inspiré des fonctions du noizetier
190        // par Joseph, Marcimat et Kent1 (GPL3)
191        $match = "[^-]*[.]html$";
192        $liste = find_all_in_path($chemin, $match);
193        $i=1;
194        foreach($liste as $squelette=>$chemin) {
195                $noisette = preg_replace(',[.]html$,i', '', $squelette);
196                $cheminskels="melusine_".$type_casier."/skel/skels".$i;
197                ecrire_config($cheminskels,$noisette);
198                $i++;
199               
200        }
201}
202
203
204/**
205 * Vérifier qu'une colonne du squelette n'est pas vide
206 *
207 * @param text $colonne issu du caser de config
208 *
209 * @return bool true si c'est vide
210 *
211**/
212
213function melusine_colonne_pasvide($colonne){
214        foreach($colonne as $value){
215                if($value!=''and $value!='aucun'){return true;};
216        }
217        return false;
218}
219
220/**
221 * Sert à rassembler (ou à ordonner) les noisettes dans le casier
222 * Est utilisé dans les formulaires de config du squelette melusine
223 *
224 * @param num $i ???
225 * @param text $objet est le type d'objet concerné
226 * @param text $zone est le casier concerné
227 * (et donc le suffixe de la table meta où seront stockées les données)
228 * @param text $casier le chemin complet du casier dans le meta s'il est fourni
229 *      (supplante $objet et $zone)
230 *
231 *
232**/
233
234function melusine_rassembler($i,$objet="squelettes",$zone="effectifs",$casier=""){
235        $var=$i;
236        if ($casier) {
237                $base_chemin = $casier;
238        } else {
239                // TODO à retirer quand les zones ne seront plus
240                // du tout utilisées (penser aussi à modifier l'arité)
241                $base_chemin = 'melusine_'.$objet.'/'.$zone.'/';
242        }
243        $chemin=$base_chemin.$var;
244        $j=$i+1;
245        $varplus=$j;
246        $chemin_bas=$base_chemin.$varplus;
247        $pos_bas=lire_config($chemin_bas);
248        ecrire_config($chemin,$pos_bas);
249        ecrire_config($chemin_bas,'aucun');
250        $i++;
251        if($i<12){melusine_rassembler($i,$objet,$zone,$casier);};
252}
253/**
254 * Retourne la liste des fichiers qui doivent être déplacés
255 * à partir de la valeur des metas
256 *
257 * @param text $casier casier dans les meta qui contient les arrays
258 *
259 * @return text la liste HTML des fichiers à déplacer.
260 *
261**/
262
263function melusine_message_noisettes_a_deplacer($casier="melusine_perso_a_deplacer"){
264        $return = "";
265
266        // TODO à déplacer dans le fichier lang quand il y en aura un
267        $message_info = "<p>Lors de son installation, M&eacute;lusine a r&eacute;cup&eacute;r&eacute; des fichiers de l'ancien plugin DATICE que vous aviez personnalis&eacute;s.</p>
268
269<p>Pour que ces fichiers ne soient pas &eacute;cras&eacute;s lors de la prochaine mise &agrave; jour de M&eacute;lusine, il est n&eacute;cessaire que vous effectuiez par FTP les op&eacute;rations de copie ci-dessous&nbsp:</p>";
270
271        // On détemine le dossier squelette
272        $dossier_squelettes = $GLOBALS['dossier_squelettes'];
273        if (!$dossier_squelettes) $dossier_squelettes = "squelettes";
274        // On récupère les meta
275        include_spip('inc/config');
276        $tableaux = lire_config($casier);
277        // Pour chaque URL
278        if ($tableaux) {
279                foreach($tableaux as $key1 => $sous_tableau) {
280                        foreach($sous_tableau as $value) {
281
282                                // Chemins pour le privé
283                                $chemin_fichier = substr($value,3);
284                                $chemin_copie = str_replace(_DIR_PLUGIN_MELUSINE,$dossier_squelettes."/",$value);
285                                $chemin_socialtags = str_replace(_DIR_PLUGIN_MELUSINE,_DIR_PLUGIN_MELUSINE_SOCIALTAGS,$value);
286
287                                $chemin_test_fichier = $value;
288                                $chemin_test_socialtags = $chemin_socialtags;
289                                $chemin_test_copie = "../".$chemin_copie;
290
291
292                                // Chemins pour le public
293                                if (!test_espace_prive()) {
294                                        $chemin_test_fichier = $chemin_fichier;
295                                        $chemin_copie = substr($chemin_copie,3);
296                                        $chemin_test_copie = $chemin_copie;
297                                        $chemin_test_socialtags = substr($chemin_socialtags,3);
298
299                                }
300
301                                // On vérifie que le fichier existe encore dans Mélusine
302                                // qu'il n'est pas vide
303                                // et qu'il n'existe pas encore dans le répertoire squelettes
304                                // et qu'il n'est pas non plus dans les socialtags...
305
306                                if (file_exists($chemin_test_fichier) AND filesize($chemin_test_fichier)>0 AND !file_exists($chemin_test_copie) AND !file_exists($chemin_test_socialtags)) {
307                                        $return .= wrap("<strong>Copier</strong> ".wrap($chemin_fichier,"<code>")." dans ".wrap($chemin_copie,"<code>"),"<li class='liste-item'>");
308                                }
309                        }
310                }
311               
312        }
313        if ($return) $return = $message_info.wrap($return,"<ul class='liste'>");
314        return $return;
315
316}
317
318// Reprises de plusieurs fonctions du noizetier
319// TODO il faudra voir à converger vraiment
320// éventuellement en modificant le noizetier
321// pour que ses fonctions soient dist et
322// surchageables
323
324/**
325 * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
326 * C'est un GROS calcul lorsqu'il est a faire.
327 *
328 * Issu du Plugin noizetier et modifié pour Mélusine:
329 * + Prise en compte du répertoire modules
330 *      et des éventuels sous répertoires
331 *      Bilan: le calcul est encore plus lourd !
332 * + Prise en compte des noisettes sans yaml associé
333 *
334 * @return array
335 */
336function melusine_obtenir_infos_noisettes_direct(){
337
338        $liste_noisettes = array();
339       
340        // répertoires possibles pour Mélusine
341        // et necessité d'un examen récursif'
342        $liste_rep = array(
343                        "noisettes/" => false,  // Compat noizetier
344                        "modules/" => true      // Compat Mélusine
345                );
346               
347        $match = "[^-]*[.]html$";
348
349        // diff avec noizetier: dans plusieurs répertoires
350        // et récusrvivement
351        $liste= array();
352        foreach($liste_rep as $rep => $recurs) {
353                $liste = array_merge(
354                                $liste,
355                                find_all_in_path(
356                                        $rep,   // dans plusieurs rép
357                                        $match,
358                                        $recurs // récusrvivement ou pas
359                                )
360                        );
361        }
362
363        if (count($liste)){
364                foreach($liste as $squelette=>$chemin) {
365
366                        $noisette = preg_replace(',[.]html$,i', '', $squelette);
367                        $dossier = str_replace($squelette, '', $chemin);
368                       
369                        // Position du module dans les osu-rép de Mélusine
370                        $sous_rep_pos = strrpos($dossier,"modules/");
371                        if ($sous_rep_pos === false)
372                                $sous_rep_pos = 0; // compat noizetier: pas de chemin dans le nom de la noisette
373                        // On ne garde que les squelettes ayant un fichier YAML de config
374                        if (file_exists("$dossier$noisette.yaml")
375                                AND ($infos_noisette = melusine_charger_infos_noisette_yaml($dossier.$noisette))
376                        ){
377                                // diff avec noizetier:
378                                // le sous-répertoire va être noté pour
379                                // les inclusions...
380                                $liste_noisettes[substr($dossier,$sous_rep_pos).$noisette] = $infos_noisette;
381                        } else {
382                                // diff avec noizetier:
383                                // Sans YAML, on garde la noisette
384                                // avec des infos sommaires
385                                $bloc = substr($dossier,$sous_rep_pos+8,-1);
386                                if ($bloc == "articles" OR $bloc == "rubriques")
387                                        $bloc = substr($bloc,0,-1);
388                                if ($bloc) $bloc = array($bloc);
389                                $liste_noisettes[substr($dossier,$sous_rep_pos).$noisette] = array(
390                                                "nom" => spip_ucfirst(str_replace("_"," ",$noisette)),
391                                                "parametres" => array(),
392                                                "contexte" => array(),
393                                                "ajax" => "non",
394                                                "inclusion" => "statique",
395                                                "blocs_autorises" => $bloc,     // spécifique de Mélusine
396                                        );
397                        }
398                }
399        }
400       
401        // supprimer de la liste les noisettes necissant un plugin qui n'est pas actif
402        foreach ($liste_noisettes as $noisette => $infos_noisette)
403                if (isset($infos_noisette['necessite']))
404                        foreach ($infos_noisette['necessite'] as $plugin)
405                                if (!defined('_DIR_PLUGIN_'.strtoupper($plugin)))
406                                        unset($liste_noisettes[$noisette]);
407       
408        return $liste_noisettes;
409}
410/**
411 * Charger les informations contenues dans le YAML d'une noisette
412 * Issu du Plugin noizetier
413 *
414 * @param string $noisette
415 * @param string $info
416 * @return array
417 */
418function melusine_charger_infos_noisette_yaml($noisette, $info=""){
419                // on peut appeler avec le nom du squelette
420                $fichier = preg_replace(',[.]html$,i','',$noisette).".yaml";
421                include_spip('inc/yaml');
422                include_spip('inc/texte');
423                $infos_noisette = array();
424                if ($infos_noisette = yaml_charger_inclusions(yaml_decode_file($fichier))) {
425                        if (isset($infos_noisette['nom']))
426                                $infos_noisette['nom'] = _T_ou_typo($infos_noisette['nom']);
427                        if (isset($infos_noisette['description']))
428                                $infos_noisette['description'] = _T_ou_typo($infos_noisette['description']);
429                        if (isset($infos_noisette['icon']))
430                                $infos_noisette['icon'] = $infos_noisette['icon'];
431                               
432                        if (!isset($infos_noisette['parametres']))
433                                $infos_noisette['parametres'] = array();
434                               
435                        // contexte
436                        if (!isset($infos_noisette['contexte'])) {
437                                $infos_noisette['contexte'] = array();
438                        }
439                        if (is_string($infos_noisette['contexte'])) {
440                                $infos_noisette['contexte'] = array($infos_noisette['contexte']);
441                        }
442                       
443                        // ajax
444                        if (!isset($infos_noisette['ajax'])) {
445                                $infos_noisette['ajax'] = 'oui';
446                        }
447                        // inclusion
448                        if (!isset($infos_noisette['inclusion'])) {
449                                $infos_noisette['inclusion'] = 'statique';
450                        }
451                }
452
453                if (!$info)
454                        return $infos_noisette;
455                else 
456                        return isset($infos_noisette[$info]) ? $infos_noisette[$info] : "";
457}
458/**
459 * Lister les noisettes disponibles dans les dossiers noisettes/
460 * Issu du Plugin noizetier
461 *
462 * @staticvar array $liste_noisettes
463 * @param text $type renvoyer seulement un type de noisettes
464 * @param text $noisette renvoyer spécifiquement une noisette données
465 * @return array
466 */
467function melusine_lister_noisettes($type='tout'){
468        static $liste_noisettes = array();
469        if ($type == 'tout') {
470                return melusine_obtenir_infos_noisettes();
471        }
472        if (isset($liste_noisettes[$type])) {
473                return $liste_noisettes[$type];
474        }
475       
476        $noisettes = melusine_obtenir_infos_noisettes();
477        if ($type == '') {
478                $match = "^[^-]*$";
479        } else {
480                $match = $type."-[^-]*$";
481        }
482       
483        foreach($noisettes as $noisette => $description) {
484                if (preg_match("/$match/", $noisette)) {
485                        $liste_noisettes[$type][$noisette] = $description;
486                }
487        }
488       
489        return $liste_noisettes[$type];
490}
491
492
493/**
494 * Renvoie les info d'une seule noisette
495 * Issu du Plugin noizetier
496 *
497 * @param text $noisette renvoyer spécifiquement une noisette données
498 * @return array
499 */
500function melusine_info_noisette($noisette) {
501        $noisettes = melusine_obtenir_infos_noisettes();
502        return $noisettes[$noisette];
503}
504
505/**
506 * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
507 * On utilise un cache php pour alleger le calcul.
508 * Issu du Plugin noizetier
509 *
510 * @param
511 * @return
512**/
513function melusine_obtenir_infos_noisettes() {
514        static $noisettes = false;
515       
516        // seulement 1 fois par appel, on lit ou calcule tous les contextes
517        if ($noisettes === false) {
518                // lire le cache des descriptions sauvees
519                lire_fichier_securise(_DIR_CACHE . _CACHE_DESCRIPTIONS_NOISETTES, $noisettes);
520                $noisettes = @unserialize($noisettes);
521                // s'il en mode recalcul, on recalcule toutes les descriptions des noisettes trouvees.
522                // ou si le cache est desactive
523                if (!$noisettes or (_request('var_mode') == 'recalcul') or (defined('_NO_CACHE') and _NO_CACHE!=0)) {
524                        $noisettes = melusine_obtenir_infos_noisettes_direct();
525                        ecrire_fichier_securise(_DIR_CACHE . _CACHE_DESCRIPTIONS_NOISETTES, serialize($noisettes));
526                }
527        }
528       
529        return $noisettes;
530}
531
532/**
533 * Fork du filtre table_valeur: pour pouvoir utiliser des clé avec des "/"
534 * permet de recuperer la valeur d'une cle donnee
535 * dans un tableau (ou un objet).
536 *
537 * @param mixed $table
538 *              Tableau ou objet
539 *              (ou chaine serialisee de tableau, ce qui permet d'enchainer le filtre)
540 *             
541 * @param string $cle
542 *              Cle du tableau (ou parametre public de l'objet)
543 *              Cette cle peut contenir des caracteres ! (et non /) pour selectionner
544 *              des sous elements dans le tableau, tel que "sous.element.ici"
545 *              pour obtenir la valeur de $tableau['sous']['element']['ici']
546 *
547 * @param mixed $defaut
548 *              Valeur par defaut retournee si la cle demandee n'existe pas
549 *
550 * @return mixed Valeur trouvee ou valeur par defaut.
551**/
552function table_valeur_cleslash($table, $cle, $defaut='') {
553        foreach (explode('!', $cle) as $k) {
554
555                $table = is_string($table) ? @unserialize($table) : $table;
556
557                if (is_object($table)) {
558                        $table =  (($k !== "") and isset($table->$k)) ? $table->$k : $defaut;
559                } elseif (is_array($table)) {
560                        $table = isset($table[$k]) ? $table[$k] : $defaut;
561                } else {
562                        $table = $defaut;
563                }
564        }
565        return $table;
566}
567
568/**
569 * Retourne le joli nom d'un bloc passé en argument
570 *
571 * @param text $bloc nom abrégé du bloc
572 *
573 * @return text joli nom du bloc
574 *
575**/
576
577function melusine_nombloc($bloc){
578        $fin_nom_col = strrpos($bloc,"-col");
579        if ($fin_nom_col === false)
580                return $GLOBALS['noms_z_blocs'][$bloc];
581        if (strripos($bloc,"3",$fin_nom_col))
582                return $GLOBALS['noms_z_blocs'][substr($bloc,0,$fin_nom_col)]." colonne 3";
583        if (strripos($bloc,"2",$fin_nom_col))
584                return $GLOBALS['noms_z_blocs'][substr($bloc,0,$fin_nom_col)]." colonne 2";
585        return "Pas de nom";
586}
587/**
588 * Retourne la liste des modules qui sont autorisés pour un bloc donné
589 *
590 * @param text $bloc nom du bloc
591 * @param text $type type de page (par défaut: rubrique)
592 *
593 * @return array liste des modules avec les infos attenantes
594 *
595**/
596
597function melusine_liste_modules_autorises($bloc,$type="rubrique"){
598        $colonne=strpos($bloc,"-col");
599        if($colonne>0)
600                $bloc=substr($bloc,0,$colonne);
601        $liste_finale = array();
602        $liste_complete = melusine_lister_noisettes();
603
604        // On nettoie bloc pour que ça marche quelle que
605        // soit la colonne
606        $colonne = strrpos($bloc,"-col");
607        if ($colonne > 0)
608                $bloc = substr($bloc,0,$colonne);
609
610        // Pour chaque module...
611        foreach($liste_complete as $module => $infos_module) {
612                if (!is_array($infos_module)){
613                        print_r($infos_module)."-";
614                        $infos_module = (array)$infos_module;
615                }
616                if (!is_array($infos_module["blocs_autorises"])){
617                        $infos_module["blocs_autorises"]=array();
618                        }
619                       
620                // Si pas de bloc blocs_autorises
621                // alors, c'est autorisé partout
622                // (compat noizetier et Mélusine 1/DATICE)
623                if (!$infos_module["blocs_autorises"]) {
624                        $liste_finale[$module] = $infos_module;
625                } elseif (in_array($bloc,$infos_module["blocs_autorises"])){
626                        // Sinon on vérifie que le module est autorisé
627                        $liste_finale[$module] = $infos_module;
628                } elseif (
629                        $bloc=="content"
630                        AND in_array($type,$infos_module["blocs_autorises"])
631                        ) {
632                        // Cas des blocs "content" désignés directement par le type page
633                        $liste_finale[$module] = $infos_module;
634                }
635               
636        }
637       
638        return $liste_finale;
639}
640/**
641 * Retourne la liste des modules passé en param triée en séprant
642 *  les modules "uniques" des autres
643 *
644 * @param text $liste_modules
645 *      (liste de modules issue de melusine_lister_noisettes ou
646 *      melusine_liste_modules_autorises)
647 *
648 * @return array deux listes des modules (avec détails)
649 *      uniques => une liste, multiples => l'autre
650 *
651**/
652
653function melusine_trier_uniques($liste_modules){
654        $liste_finale = array("uniques" => array(),"multiples" => array());
655
656        // Pour chaque module...
657        foreach($liste_modules as $module => $infos_module) {
658                        $unique_ou_non = "multiples";
659                if ($infos_module["unique"] == "oui")
660                        $unique_ou_non = "uniques";
661                $liste_finale[$unique_ou_non][$module] = $infos_module;
662        }
663       
664        return $liste_finale;
665}
666
667?>
Note: See TracBrowser for help on using the repository browser.