www/plugins-dist/porte_plume/porte_plume_fonctions.php

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