source: spip-zone/_core_/plugins/porte_plume/porte_plume_fonctions.php @ 93621

Last change on this file since 93621 was 93621, checked in by cedric@…, 5 years ago

Indentation et regles de codage selon http://www.spip.net/fr_article3497.html#regles_codage

File size: 24.9 KB
Line 
1<?php
2/**
3 * Fonctions utiles pour le Porte Plume
4 *
5 * @plugin Porte Plume pour SPIP
6 * @license GPL
7 * @package SPIP\PortePlume\BarreOutils
8 */
9
10if (!defined("_ECRIRE_INC_VERSION")) {
11        return;
12}
13
14/**
15 * Objet contenant les différents paramètres definissant une barre d'outils
16 * Markitup et permettant d'agir dessus
17 *
18 * @example
19 *     $barre = new Barre_Outil($description);
20 *
21 * @package SPIP\PortePlume\BarreOutils
22 */
23class Barre_outils {
24        /**
25         * Identifiant HTML de la barre
26         *
27         * @todo À supprimer car non utilisé !
28         * @var string
29         */
30        public $id = "";
31
32        /**
33         * Nom de la barre d'outil
34         *
35         * @var string
36         */
37        public $nameSpace = "";
38
39        /**
40         * Langue
41         *
42         * @todo À supprimer car non utilisé !
43         * @var string
44         */
45        public $lang = "";
46
47        /**
48         * Option de markitup : rafraîchir la prévisu ?
49         *
50         * @todo À supprimer car non utilisé !
51         * @var bool
52         */
53        public $previewAutoRefresh = false;
54
55        /**
56         * Option de markitup : nom de la fonction de prévisu
57         *
58         * @todo À supprimer car on le redéfini dans l'appel javascript !
59         * @var bool
60         */
61        public $previewParserPath = "";
62
63        /**
64         * Option de markitup : que faire sur l'appuie de Entrée ?
65         *
66         * @var array
67         */
68        public $onEnter = array();
69
70        /**
71         * Option de markitup : que faire sur l'appuie de Shift+Entrée ?
72         *
73         * @example array('keepDefault'=>false, 'replaceWith'=>"\n_ ")
74         * @var array
75         */
76        public $onShiftEnter = array();
77
78        /**
79         * Option de markitup : que faire sur l'appuie de Control+Entrée ?
80         *
81         * @var array
82         */
83        public $onCtrlEnter = array();
84
85        /**
86         * Option de markitup : que faire sur l'appuie d'une tabulation ?
87         *
88         * @var array
89         */
90        public $onTab = array();
91
92        /**
93         * Option de markitup : Code JS à exécuter avant une insertion
94         *
95         * @var string
96         */
97        public $beforeInsert = "";
98
99        /**
100         * Option de markitup : Code JS à exécuter après une insertion
101         *
102         * @var string
103         */
104        public $afterInsert = "";
105
106        /**
107         * Description des outils/boutons et leurs sous boutons éventuels
108         *
109         * @var array
110         */
111        public $markupSet = array();
112
113        /**
114         * Fonctions JS supplémentaires à écrire après la déclaration JSON
115         * des outils. Ces fonctions peuvent servir aux boutons.
116         *
117         * @var string
118         */
119        public $functions = "";
120
121        /**
122         * Liste des paramètres valides pour une description d'outils (markupSet)
123         *
124         * @var array
125         */
126        private $_liste_params_autorises = array(
127
128                'replaceWith',
129                'openWith',
130                'closeWith',
131                'openBlockWith',
132                // sur multiline, avant les lignes selectionnees
133                'closeBlockWith',
134                // sur multiline, apres les lignes selectionnees
135                'placeHolder',
136                // remplace par ce texte lorsqu'il n'y a pas de selection
137
138                'beforeInsert',
139                // avant l'insertion
140                'afterInsert',
141                // apres l'insertion
142                'beforeMultiInsert',
143                'afterMultiInsert',
144
145                'dropMenu',
146                // appelle un sous menu
147
148                'name',
149                // nom affiche au survol
150                'key',
151                // raccourcis clavier
152                'className',
153                // classe css utilisee
154                'lang',
155                // langues dont le bouton doit apparaitre - array
156                'lang_not',
157                // langues dont le bouton ne doit pas apparaitre - array
158                'selectionType',
159                // '','word','line' : type de selection (normale, aux mots les plus proches, a la ligne la plus proche)
160                'multiline',
161                // open/close sur chaque ligne (mais replace est applique sur l'ensemble de la selection)
162                'forceMultiline',
163                // pour faire comme si on faisait systematiquement un control+shift (et replace est applique sur chaque ligne de la selection)
164
165                'separator',
166
167                'call',
168                'keepDefault',
169
170                // cacher ou afficher facilement des boutons
171                'display',
172                // donner un identifiant unique au bouton (pour le php)
173                'id',
174        );
175
176        /**
177         * Constructeur
178         *
179         * Initialise la barre avec les paramètres transmis
180         * en n'adressant que les paramètres effectivement valides
181         *
182         * @api
183         * @param array $params Paramètres de la barre d'outil
184         * @return void
185         */
186        function __construct($params = array()) {
187                foreach ($params as $p => $v) {
188                        if (isset($this->$p)) {
189                                // si tableau, on verifie les entrees
190                                if (is_array($v)) {
191                                        $v = $this->verif_params($p, $v);
192                                }
193                                $this->$p = $v;
194                        }
195                }
196        }
197
198
199        /**
200         * Vérifie que les paramètres d'une clé existent
201         * et retourne un tableau des paramètres valides
202         *
203         * @param string $nom
204         *     Clé à vérifier (ex: 'markupSet')
205         * @param array $params
206         *     Paramètres de cette clé (description des boutons ou sous boutons)
207         * @return array
208         *     Paramètres, soustrait de ceux qui ne sont pas valides
209         */
210        function verif_params($nom, $params = array()) {
211                // si markupset, on boucle sur les items
212                if (stripos($nom, 'markupSet') !== false) {
213                        foreach ($params as $i => $v) {
214                                $params[$i] = $this->verif_params($i, $v);
215                        }
216                } // sinon on teste la validite
217                else {
218                        foreach ($params as $p => $v) {
219                                if (!in_array($p, $this->_liste_params_autorises)) {
220                                        unset($params[$p]);
221                                }
222                        }
223                }
224
225                return $params;
226        }
227
228        /**
229         * Permet d'affecter des paramètres à un élément de la barre
230         *
231         * La fonction retourne les paramètres, de sorte qu'on peut s'en servir
232         * pour simplement récupérer ceux-ci.
233         *
234         * Il est possible d'affecter des paramètres avant/après l'élément trouvé
235         * en definisant une valeur différente pour le $lieu : 'dedans','avant','apres'
236         * par defaut 'dedans' (modifie l'élément trouvé).
237         *
238         * Lorsqu'on demande d'insérer avant ou après, la fonction retourne
239         * les paramètres inserés
240         *
241         * @param array $tableau
242         *     Tableau ou chercher les elements (sert pour la recursion)
243         * @param string $identifiant
244         *     Identifiant du bouton a afficher
245         * @param array $params
246         *     Paramètres à affecter à la trouvaille (ou avant ou après).
247         *     Peut être un tableau clé/valeur ou un tableau de tableaux
248         *     clé/valeur (sauf pour $lieu = dedans)
249         * @param string $lieu
250         *     Lieu d'affectation des paramètres (dedans, avant, apres)
251         * @param bool $plusieurs
252         *     Définit si $params est une forme simple (tableau cle/valeur)
253         *     ou comporte plusieurs boutons (tableau de tableaux cle/valeur).
254         * @return array|bool
255         *     Paramètres de l'élément modifié ou paramètres ajoutés
256         *     False si l'identifiant cherché n'est pas trouvé
257         */
258        function affecter(&$tableau, $identifiant, $params = array(), $lieu = 'dedans', $plusieurs = false) {
259                static $cle_de_recherche = 'id'; // ou className ?
260
261                if ($tableau === null) // utile ?
262                {
263                        $tableau = &$this->markupSet;
264                }
265
266                if (!in_array($lieu, array('dedans', 'avant', 'apres'))) {
267                        $lieu = 'dedans';
268                }
269
270                // present en premiere ligne ?
271                $trouve = false;
272                foreach ($tableau as $i => $v) {
273                        if (isset($v[$cle_de_recherche]) and ($v[$cle_de_recherche] == $identifiant)) {
274                                $trouve = $i;
275                                break;
276                        }
277                }
278                // si trouve, affectations
279                if (($trouve !== false)) {
280                        if ($params) {
281                                // verifier que les insertions sont correctes
282                                $les_params = ($plusieurs ? $params : array($params));
283                                foreach ($les_params as $i => $un_params) {
284                                        $les_params[$i] = $this->verif_params($identifiant, $un_params);
285                                }
286
287                                // dedans on merge ($params uniquement tableau cle/valeur)
288                                if ($lieu == 'dedans' && !$plusieurs) {
289                                        return $tableau[$trouve] = array_merge($tableau[$trouve], $les_params[0]);
290                                } // avant ou apres, on insere ($params peut etre tableau cle/valeur ou tableau de tableaux cle/valeur)
291                                elseif ($lieu == 'avant') {
292                                        array_splice($tableau, $trouve, 0, $les_params);
293
294                                        return $params;
295                                } elseif ($lieu == 'apres') {
296                                        array_splice($tableau, $trouve+1, 0, $les_params);
297
298                                        return $params;
299                                }
300                        }
301
302                        return $tableau[$trouve];
303                }
304
305                // recursivons sinon !
306                foreach ($tableau as $i => $v) {
307                        if (is_array($v)) {
308                                foreach ($v as $m => $n) {
309                                        if (is_array($n) AND ($r = $this->affecter($tableau[$i][$m], $identifiant, $params, $lieu, $plusieurs))) {
310                                                return $r;
311                                        }
312                                }
313                        }
314                }
315
316                return false;
317        }
318
319
320        /**
321         * Permet d'affecter des paramètres à tous les éléments de la barre
322         * ou à une liste d'identifiants d'éléments indiqués.
323         *
324         * @param array $tableau
325         *     Tableau où chercher les éléments
326         * @param array $params
327         *     Paramètres à affecter aux éléments
328         * @param array $ids
329         *     Tableau d'identifiants particuliers à qui on affecte les paramètres.
330         *     Si vide, tous les identifiants seront modifiés
331         * @return bool
332         *     false si aucun paramètre à affecter, true sinon.
333         */
334        function affecter_a_tous(&$tableau, $params = array(), $ids = array()) {
335                if (!$params) {
336                        return false;
337                }
338
339                if ($tableau === null) {
340                        $tableau = &$this->markupSet;
341                }
342
343                $params = $this->verif_params('divers', $params);
344
345                // merge de premiere ligne
346                foreach ($tableau as $i => &$v) {
347                        if (!$ids OR in_array($v['id'], $ids)) {
348                                $tableau[$i] = array_merge($tableau[$i], $params);
349                        }
350                        // recursion si sous-menu
351                        if (isset($tableau[$i]['dropMenu'])) {
352                                $this->affecter_a_tous($tableau[$i]['dropMenu'], $params, $ids);
353                        }
354                }
355
356                return true;
357        }
358
359
360        /**
361         * Affecte les valeurs des paramètres indiqués au bouton demandé
362         * et retourne l'ensemble des paramètres du bouton (sinon false)
363         *
364         * @api
365         * @param string|array $identifiant
366         *     Identifiant du ou des boutons.
367         * @param array $params
368         *     Paramètres de l'ajout (tableau paramètre=>valeur)
369         * @return bool|array
370         *     false si l'identifiant n'a pas été trouvé
371         *     true si plusieurs identifiants,
372         *     array sinon : description de l'identifiant cherché.
373         */
374        function set($identifiant, $params = array()) {
375                // prudence tout de meme a pas tout modifier involontairement (si array)
376                if (!$identifiant) {
377                        return false;
378                }
379
380                if (is_string($identifiant)) {
381                        return $this->affecter($this->markupSet, $identifiant, $params);
382                } elseif (is_array($identifiant)) {
383                        return $this->affecter_a_tous($this->markupSet, $params, $identifiant);
384                }
385
386                return false;
387        }
388
389        /**
390         * Retourne les parametres du bouton demande
391         *
392         * @api
393         * @param string|array $identifiant
394         *     Identifiant du ou des boutons.
395         * @return bool|array
396         *     false si l'identifiant n'est pas trouvé
397         *     array sinon : Description de l'identifiant cherché.
398         */
399        function get($identifiant) {
400                if ($a = $this->affecter($this->markupSet, $identifiant)) {
401                        return $a;
402                }
403
404                return false;
405        }
406
407
408        /**
409         * Affiche le ou les boutons demandés
410         *
411         * @api
412         * @param string|array $identifiant
413         *     Identifiant du ou des boutons
414         * @return bool|array
415         *     false si l'identifiant n'a pas été trouvé
416         *     true si plusieurs identifiants,
417         *     array sinon : description de l'identifiant cherché.
418         */
419        function afficher($identifiant) {
420                return $this->set($identifiant, array('display' => true));
421        }
422
423
424        /**
425         * Cache le ou les boutons demandés
426         *
427         * @api
428         * @param string|array $identifiant
429         *     Identifiant du ou des boutons
430         * @return bool|array
431         *     false si l'identifiant n'a pas été trouvé
432         *     true si plusieurs identifiants,
433         *     array sinon : description de l'identifiant cherché.
434         */
435        function cacher($identifiant) {
436                return $this->set($identifiant, array('display' => false));
437        }
438
439
440        /**
441         * Affiche tous les boutons
442         *
443         * @api
444         * @return bool
445         *     false si aucun paramètre à affecter, true sinon.
446         */
447        function afficherTout() {
448                return $this->affecter_a_tous($this->markupSet, array('display' => true));
449        }
450
451        /**
452         * Cache tous les boutons
453         *
454         * @api
455         * @return bool
456         *     false si aucun paramètre à affecter, true sinon.
457         */
458        function cacherTout() {
459                return $this->affecter_a_tous($this->markupSet, array('display' => false));
460        }
461
462
463        /**
464         * Ajoute un bouton ou quelque chose, avant un autre déjà présent
465         *
466         * @api
467         * @param string $identifiant
468         *     Identifiant du bouton où l'on doit se situer
469         * @param array $params
470         *     Paramètres de l'ajout.
471         *     Description d'un bouton (tableau clé/valeurs).
472         * @return array|bool
473         *     Paramètres ajoutés avant
474         *     False si l'identifiant cherché n'est pas trouvé
475         */
476        function ajouterAvant($identifiant, $params) {
477                return $this->affecter($this->markupSet, $identifiant, $params, 'avant');
478        }
479
480        /**
481         * Ajoute plusieurs boutons, avant un autre déjà présent
482         *
483         * @api
484         * @param string $identifiant
485         *     Identifiant du bouton où l'on doit se situer
486         * @param array $tableau_params
487         *     Paramètres de l'ajout.
488         *     Description de plusieurs boutons (tableau de tableaux clé/valeurs).
489         * @return array|bool
490         *     Paramètres ajoutés avant
491         *     False si l'identifiant cherché n'est pas trouvé
492         */
493        function ajouterPlusieursAvant($identifiant, $tableau_params) {
494                return $this->affecter($this->markupSet, $identifiant, $tableau_params, 'avant', true);
495        }
496
497        /**
498         * Ajoute un bouton ou quelque chose, après un autre déjà présent
499         *
500         * @api
501         * @param string $identifiant
502         *     Identifiant du bouton où l'on doit se situer
503         * @param array $params
504         *     Paramètres de l'ajout.
505         *     Description d'un bouton (tableau clé/valeurs).
506         * @return array|bool
507         *     Paramètres ajoutés après
508         *     False si l'identifiant cherché n'est pas trouvé
509         */
510        function ajouterApres($identifiant, $params) {
511                return $this->affecter($this->markupSet, $identifiant, $params, 'apres');
512        }
513
514        /**
515         * Ajoute plusieurs boutons, après un autre déjà présent
516         *
517         * @api
518         * @param string $identifiant
519         *     Identifiant du bouton où l'on doit se situer
520         * @param array $tableau_params
521         *     Paramètres de l'ajout.
522         *     Description de plusieurs boutons (tableau de tableaux clé/valeurs).
523         * @return array|bool
524         *     Paramètres ajoutés après
525         *     False si l'identifiant cherché n'est pas trouvé
526         */
527        function ajouterPlusieursApres($identifiant, $tableau_params) {
528                return $this->affecter($this->markupSet, $identifiant, $tableau_params, 'apres', true);
529        }
530
531        /**
532         * Ajoute une fonction JS qui pourra être utilisée par les boutons
533         *
534         * @api
535         * @param string $fonction Code de la fonction JS
536         * @return void
537         */
538        function ajouterFonction($fonction) {
539                if (false === strpos($this->functions, $fonction)) {
540                        $this->functions .= "\n" . $fonction . "\n";
541                }
542        }
543
544        /**
545         * Supprimer les éléments non affichés (display:false)
546         * Et les séparateurs (li vides) selon la configuration
547         *
548         * @param array $tableau Tableau de description des outils
549         * @return void
550         */
551        function enlever_elements_non_affiches(&$tableau) {
552                if ($tableau === null) { // utile ?
553                        $tableau = &$this->markupSet;
554                }
555
556                foreach ($tableau as $p => &$v) {
557                        if (isset($v['display']) AND !$v['display']) {
558                                unset($tableau[$p]);
559                                $tableau = array_values($tableau); // remettre les cles automatiques sinon json les affiche et ça plante.
560                        } // sinon, on lance une recursion sur les sous-menus
561                        else {
562                                if (isset($v['dropMenu']) and is_array($v['dropMenu'])) {
563                                        $this->enlever_elements_non_affiches($tableau[$p]['dropMenu']);
564                                        // si le sous-menu est vide
565                                        // on enleve le sous menu.
566                                        // mais pas le parent ($tableau[$p]), qui peut effectuer une action.
567                                        if (empty($tableau[$p]['dropMenu'])) {
568                                                unset($tableau[$p]['dropMenu']);
569                                        }
570                                }
571                        }
572                }
573        }
574
575        /**
576         * Enlève les séparateurs pour améliorer l'accessibilité
577         * au détriment du stylage possible de ces séparateurs.
578         *
579         * Le bouton précédent le séparateur reçoit une classe CSS 'separateur_avant'
580         * Celui apres 'separateur_apres'
581         *
582         * @param array $tableau
583         *     Tableau de description des outils
584         * @return void
585         **/
586        function enlever_separateurs(&$tableau) {
587                if ($tableau === null) { // utile ?
588                        $tableau = &$this->markupSet;
589                }
590
591
592                foreach ($tableau as $p => &$v) {
593                        if (isset($v['separator']) and $v['separator']) {
594                                if (isset($tableau[$p-1])) {
595                                        if (!isset($tableau[$p-1]['className'])) {
596                                                $tableau[$p-1]['className'] = "";
597                                        }
598                                        $tableau[$p-1]['className'] .= " separateur_avant";
599                                }
600                                if (isset($tableau[$p+1])) {
601                                        if (!isset($tableau[$p+1]['className'])) {
602                                                $tableau[$p+1]['className'] = "";
603                                        }
604                                        $tableau[$p+1]['className'] .= " separateur separateur_apres $v[id]";
605                                }
606                                unset($tableau[$p]);
607                                $tableau = array_values($tableau); // remettre les cles automatiques sinon json les affiche et ça plante.
608                        } // sinon, on lance une recursion sur les sous-menus
609                        else {
610                                if (isset($v['dropMenu']) and is_array($v['dropMenu'])) {
611                                        #$this->enlever_separateurs($tableau[$p]['dropMenu']);
612                                }
613                        }
614                }
615        }
616
617        /**
618         * Supprime les éléments vides (uniquement à la racine de l'objet)
619         * et uniquement si chaîne ou tableau.
620         *
621         * Supprime les paramètres privés
622         * Supprime les paramètres inutiles a markitup/json dans les paramètres markupSet
623         * (id, display, icone)
624         */
625        function enlever_parametres_inutiles() {
626                foreach ($this as $p => $v) {
627                        if (!$v) {
628                                if (is_array($v) or is_string($v)) {
629                                        unset($this->$p);
630                                }
631                        } elseif ($p == 'functions') {
632                                unset($this->$p);
633                        }
634                }
635                foreach ($this->markupSet as $p => $v) {
636                        foreach ($v as $n => $m) {
637                                if (in_array($n, array('id', 'display'))) {
638                                        unset($this->markupSet[$p][$n]);
639                                }
640                        }
641                }
642                unset ($this->_liste_params_autorises);
643        }
644
645
646        /**
647         * Crée la sortie json pour le javascript des paramètres de la barre
648         *
649         * @return string Déclaration json de la barre
650         */
651        function creer_json() {
652                $barre = $this;
653                $type = $barre->nameSpace;
654                $fonctions = $barre->functions;
655
656                $barre->enlever_elements_non_affiches($this->markupSet);
657                $barre->enlever_separateurs($this->markupSet);
658                $barre->enlever_parametres_inutiles();
659
660                $json = Barre_outils::json_export($barre);
661
662                // on lance la transformation des &chose; en veritables caracteres
663                // sinon markitup restitue &laquo; au lieu de « directement
664                // lorsqu'on clique sur l'icone
665                include_spip('inc/charsets');
666                $json = unicode2charset(html2unicode($json));
667
668                return "\n\nbarre_outils_$type = " . $json . "\n\n $fonctions";
669        }
670
671        /**
672         * Transforme une variable PHP dans un équivalent javascript (json)
673         *
674         * Copié depuis ecrire/inc/json, mais modifié pour que les fonctions
675         * JavaScript ne soient pas encapsulées dans une chaîne (string)
676         *
677         * @access private
678         * @param mixed $var the variable
679         * @return string|boolean
680         *     - string : js script
681         *     - boolean false if error
682         */
683        function json_export($var) {
684                $asso = false;
685                switch (true) {
686                        case is_null($var) :
687                                return 'null';
688                        case is_string($var) :
689                                if (strtolower(substr(ltrim($var), 0, 8)) == 'function') {
690                                        return $var;
691                                }
692
693                                return '"' . addcslashes($var, "\"\\\n\r") . '"';
694                        case is_bool($var) :
695                                return $var ? 'true' : 'false';
696                        case is_scalar($var) :
697                                return $var;
698                        case is_object($var) :
699                                $var = get_object_vars($var);
700                                $asso = true;
701                        case is_array($var) :
702                                $keys = array_keys($var);
703                                $ikey = count($keys);
704                                while (!$asso && $ikey--) {
705                                        $asso = $ikey !== $keys[$ikey];
706                                }
707                                $sep = '';
708                                if ($asso) {
709                                        $ret = '{';
710                                        foreach ($var as $key => $elt) {
711                                                $ret .= $sep . '"' . $key . '":' . Barre_outils::json_export($elt);
712                                                $sep = ',';
713                                        }
714
715                                        return $ret . "}\n";
716                                } else {
717                                        $ret = '[';
718                                        foreach ($var as $elt) {
719                                                $ret .= $sep . Barre_outils::json_export($elt);
720                                                $sep = ',';
721                                        }
722
723                                        return $ret . "]\n";
724                                }
725                }
726
727                return false;
728        }
729
730}
731
732
733/**
734 * Crée le code CSS pour les images des icones des barres d'outils
735 *
736 * S'appuie sur la description des jeux de barres disponibles et cherche
737 * une fonction barre_outils_($barre)_icones pour chaque barre et
738 * l'exécute si existe, attendant alors en retour un tableau de couples :
739 * nom de l'outil => nom de l'image
740 *
741 * @pipeline_appel porte_plume_lien_classe_vers_icone
742 *
743 * @return string Déclaration CSS des icones
744 */
745function barre_outils_css_icones() {
746        // recuperer la liste, extraire les icones
747        $css = "";
748
749        // liste des barres
750        if (!$barres = barre_outils_liste()) {
751                return null;
752        }
753
754        // liste des classes css et leur correspondance avec une icone
755        $classe2icone = array();
756        foreach ($barres as $barre) {
757                include_spip('barre_outils/' . $barre);
758                if ($f = charger_fonction($barre . '_icones', 'barre_outils', true)) {
759                        if (is_array($icones = $f())) {
760                                $classe2icone = array_merge($classe2icone, $icones);
761                        }
762                }
763        }
764
765        /**
766         * Permettre aux plugins d'étendre les icones connues du porte plume
767         *
768         * On passe la liste des icones connues au pipeline pour ceux qui
769         * ajoutent de simples icones à des barres existantes
770         *
771         * @pipeline_appel porte_plume_lien_classe_vers_icone
772         * @var array $classe2icone
773         *     Couples identifiant de bouton => nom de l'image (ou tableau)
774         *     Dans le cas d'un tableau, cela indique une sprite : (nom de l'image , position haut, position bas)
775         *     Exemple : 'outil_header1' => array('spt-v1.png','-10px -226px')
776         */
777        $classe2icone = pipeline('porte_plume_lien_classe_vers_icone', $classe2icone);
778
779        // passage en css
780        foreach ($classe2icone as $n => $i) {
781                $pos = "";
782                if (is_array($i)) {
783                        $pos = "background-position:" . end($i);
784                        $i = reset($i);
785                }
786                if (file_exists($i)) {
787                        $file = $i;
788                } else {
789                        $file = find_in_path("icones_barre/$i");
790                }
791                if ($file) {
792                        $css .= "\n.markItUp .$n>a>em {background-image:url(" . protocole_implicite(url_absolue($file)) . ");$pos}";
793                }
794        }
795
796        return $css;
797}
798
799
800/**
801 * Retourne une instance de Barre_outils
802 * crée à partir du type de barre demandé
803 *
804 * Une fonction barre_outils_{type}_dist() retournant la barre doit
805 * donc exister.
806 *
807 * @param string $set
808 *     Type de barre (ex: 'edition')
809 * @return Barre_Outils|bool
810 *     La barre d'outil si la fonction a été trouvée, false sinon
811 */
812function barre_outils_initialiser($set) {
813        if ($f = charger_fonction($set, 'barre_outils')) {
814                // retourne une instance de l'objet Barre_outils
815                return $f();
816        }
817
818        return false;
819}
820
821/**
822 * Retourne la liste des barres d'outils connues
823 *
824 * @return array|bool
825 *     Tableau des noms de barres d'outils trouvées
826 *     False si on ne trouve aucune barre.
827 */
828function barre_outils_liste() {
829        static $sets = -1;
830        if ($sets !== -1) {
831                return $sets;
832        }
833
834        // on recupere l'ensemble des barres d'outils connues
835        if (!$sets = find_all_in_path('barre_outils/', '.*[.]php')
836                or !is_array($sets)
837        ) {
838                spip_log("[Scandale] Porte Plume ne trouve pas de barre d'outils !");
839                $sets = false;
840
841                return $sets;
842        }
843
844        foreach ($sets as $fichier => $adresse) {
845                $sets[$fichier] = substr($fichier, 0, -4); // juste le nom
846        }
847
848        return $sets;
849}
850
851/**
852 * Filtre appliquant les traitements SPIP d'un champ
853 *
854 * Applique les filtres prévus sur un champ (et eventuellement un type d'objet)
855 * sur un texte donné. Sécurise aussi le texte en appliquant safehtml().
856 *
857 * Ce mécanisme est à préférer au traditionnel #TEXTE*|propre
858 *
859 * traitements_previsu() consulte la globale $table_des_traitements et
860 * applique le traitement adequat. Si aucun traitement n'est trouvé,
861 * alors propre() est appliqué.
862 *
863 * @package SPIP\PortePlume\Fonctions
864 * @see champs_traitements() dans public/references.php
865 * @global table_des_traitements
866 *
867 * @param string $texte
868 *     Texte source
869 * @param string $nom_champ
870 *     Nom du champ (nom de la balise, en majuscules)
871 * @param string $type_objet
872 *     L'objet a qui appartient le champ (en minuscules)
873 * @param string $connect
874 *     Nom du connecteur de base de données
875 * @return string
876 *     Texte traité avec les filtres déclarés pour le champ.
877 */
878function traitements_previsu($texte, $nom_champ = '', $type_objet = '', $connect = null) {
879        include_spip('public/interfaces'); // charger les traitements
880
881        global $table_des_traitements;
882        if (!strlen($nom_champ) || !isset($table_des_traitements[$nom_champ])) {
883                $texte = propre($texte, $connect);
884        } else {
885                include_spip('base/abstract_sql');
886                $table = table_objet($type_objet);
887                $ps = $table_des_traitements[$nom_champ];
888                if (is_array($ps)) {
889                        $ps = $ps[(strlen($table) && isset($ps[$table])) ? $table : 0];
890                }
891                if (!$ps) {
892                        $texte = propre($texte, $connect);
893                } else {
894                        // [FIXME] Éviter une notice sur le eval suivant qui ne connait
895                        // pas la Pile ici. C'est pas tres joli...
896                        $Pile = array(0 => array());
897                        // remplacer le placeholder %s par le texte fourni
898                        eval('$texte=' . str_replace('%s', '$texte', $ps) . ';');
899                }
900        }
901        // il faut toujours securiser le texte prévisualisé car il peut contenir n'importe quoi
902        // et servir de support a une attaque xss ou vol de cookie admin
903        // on ne peut donc se fier au statut de l'auteur connecté car le contenu ne vient pas
904        // forcément de lui
905        return safehtml($texte);
906}
Note: See TracBrowser for help on using the repository browser.