Changeset 110127 in spip-zone


Ignore:
Timestamp:
May 7, 2018, 5:28:17 PM (14 months ago)
Author:
eric@…
Message:

On remplace le filtre propre au noizetier par la balise #CHEMIN_IMAGE.
On continue à améliorer les balises du noizetier afin de se passer de filtres superflus.
On fait un up de z pour identifier cette version qui commence à être bien cohérente.

Location:
_plugins_/noizetier/trunk
Files:
1 deleted
13 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/noizetier/trunk/bloc_preview.html

    r110112 r110127  
    2525                <BOUCLE_type_noisette(TYPES_NOISETTES){type_noisette}>
    2626                        <div style="color:#9DBA00; font-size:1.5em; margin:5px 0;"><strong>
    27                                 <div style="float:right;">[(#ICON|sinon{noisette-24.png}|noizetier_icone_chemin|balise_img{})]</div>
     27                                <div style="float:right;">[(#CHEMIN_IMAGE{#ICON|sinon{noisette-24.png}}|balise_img{})]</div>
    2828                                [(#NOM)]
    2929                        </strong></div>
  • _plugins_/noizetier/trunk/formulaires/editer_page.html

    r110124 r110127  
    5353                                        </div>
    5454                                        <strong><:noizetier:apercu:></strong><br />
    55                                         <span id="apercu_icone">[(#ENV{icon}|noizetier_icone_chemin|balise_img)]</span>
     55                                        <span id="apercu_icone">[(#CHEMIN_IMAGE{#ENV{icon}}|balise_img)]</span>
    5656                                        <B_suggestions_icones>
    5757                                        <div id="suggestions_icones">
     
    6262                                        <BOUCLE_suggestions_icones(DATA){source table, #NOIZETIER_ICONE_LISTE{24}}{par cle}>
    6363                                                        <div class="suggestion_icone" onclick="jQuery('input#icon').val('#CLE');maj_apercu_icone();jQuery('#suggestions_icones').hide(500);jQuery('#afficher_suggestions').show(500);return false;">
    64                                                                 [(#CLE|noizetier_icone_chemin|balise_img)<br />]
     64                                                                [(#CHEMIN_IMAGE{#CLE}|balise_img)<br />]
    6565                                                                #CLE
    6666                                                        </div>
  • _plugins_/noizetier/trunk/formulaires/inclure/inc-input_type_noisette.html

    r110066 r110127  
    77[(#ENV{input_radio}|oui)</label>]
    88<div class="icone">
    9         [(#ENV{icon}|noizetier_icone_chemin|image_reduire{24}|extraire_attribut{src}|balise_img)]
     9        [(#CHEMIN_IMAGE{#ENV{icon}}|image_reduire{24}|extraire_attribut{src}|balise_img)]
    1010</div>
    1111[(#ENV{input_radio}|non)<input type="hidden" name="ordre\[\]" value="#ENV{type_noisette}" />]
  • _plugins_/noizetier/trunk/formulaires/inclure/inc-liste_types_noisette.html

    r110077 r110127  
    1 #SET{compteurs, #ENV{page, #OBJET}|noizetier_type_noisette_compter}
     1#SET{compteurs, #NOIZETIER_PAGE_INFOS{#ENV{page, #OBJET}, compteurs_type_noisette}}
    22<BOUCLE_si_noisette(CONDITION) {si #GET{compteurs/total}}>
    33        <BOUCLE_infos_page(NOIZETIER_PAGES) {page=#ENV{page, #OBJET}}>
  • _plugins_/noizetier/trunk/formulaires/inclure/inc-resume_noisette.html

    r110110 r110127  
    66                [(#REM) Logo de la noisette ]
    77                <div class="icone">
    8                         [(#ICON|noizetier_icone_chemin|image_reduire{24}|extraire_attribut{src}|balise_img)]
     8                        [(#CHEMIN_IMAGE{#ICON}|image_reduire{24}|extraire_attribut{src}|balise_img)]
    99                </div>
    1010        </div>
  • _plugins_/noizetier/trunk/icone_preview.html

    r109907 r110127  
    1 #HTTP_HEADER{Content-Type: text/html}[(#ENV{icone}|oui)[(#ENV{icone}|noizetier_icone_chemin|url_absolue|balise_img|sinon{<span style="color:red;"><strong><:noizetier:icone_introuvable:></strong></span>})]][(#ENV{icone}|non)-----]
     1#HTTP_HEADER{Content-Type: text/html}[(#ENV{icone}|oui)[(#CHEMIN_IMAGE{#ENV{icone}}|url_absolue|balise_img|sinon{<span style="color:red;"><strong><:noizetier:icone_introuvable:></strong></span>})]][(#ENV{icone}|non)-----]
  • _plugins_/noizetier/trunk/inc/noizetier_objet.php

    r110122 r110127  
    4646                }
    4747                if (!$description['logo']) {
    48                         $description['logo'] = noizetier_icone_chemin("${type_objet}.png");
     48                        $description['logo'] = chemin_image("${type_objet}.png");
    4949                }
    5050
     
    195195        return $est_active;
    196196}
     197
     198
     199/**
     200 * Détermine, pour un objet donné, la liste des blocs ayant des noisettes incluses et renvoie leur nombre.
     201 *
     202 * @api
     203 *
     204 * @param string $objet
     205 *            Le type d'objet comme `article`.
     206 * @param int    $id_objet
     207 *            L'id de l'objet.
     208 *
     209 * @return array
     210 *             Tableau des nombre de noisettes incluses par bloc de la forme [bloc] = nombre de noisettes.
     211 */
     212function noizetier_objet_compter_noisettes($objet, $id_objet) {
     213
     214        static $blocs_compteur = array();
     215
     216        if (!isset($blocs_compteur["${objet}-${id_objet}"])) {
     217                // Initialisation des compteurs par bloc
     218                $nb_noisettes = array();
     219
     220                // Le nombre de noisettes par bloc doit être calculé par une lecture de la table spip_noisettes.
     221                $from = array('spip_noisettes');
     222                $select = array('bloc', "count(type_noisette) as 'noisettes'");
     223                // -- Construction du where identifiant précisément le type et la composition de la page
     224                $where = array(
     225                        'plugin=' . sql_quote('noizetier'),
     226                        'objet=' . sql_quote($objet),
     227                        'id_objet=' . intval($id_objet)
     228                );
     229                $group = array('bloc');
     230                $blocs_non_vides = sql_allfetsel($select, $from, $where, $group);
     231                if ($blocs_non_vides) {
     232                        // On formate le tableau [bloc] = nb noisettes
     233                        $nb_noisettes = array_column($blocs_non_vides, 'noisettes', 'bloc');
     234                }
     235
     236                // Sauvegarde des compteurs pour les blocs concernés.
     237                $blocs_compteur["${objet}-${id_objet}"] = $nb_noisettes;
     238        }
     239
     240        return $blocs_compteur["${objet}-${id_objet}"];
     241}
  • _plugins_/noizetier/trunk/inc/noizetier_page.php

    r110122 r110127  
    323323 * l'insertion de noisettes.
    324324 *
    325  * @package SPIP\NOIZETIER\API\PAGE
    326325 * @api
    327326 *
     
    341340
    342341        return $repertoire_pages;
     342}
     343
     344/**
     345 * Détermine, pour une page donnée, la liste des blocs ayant des noisettes incluses et renvoie leur nombre.
     346 *
     347 * @api
     348 *
     349 * @param string $page
     350 *            L'identifiant de la page ou de la composition.
     351 *
     352 * @return array
     353 *             Tableau des nombre de noisettes incluses par bloc de la forme [bloc] = nombre de noisettes.
     354 */
     355function noizetier_page_compter_noisettes($page) {
     356
     357        static $blocs_compteur = array();
     358
     359        if (!isset($blocs_compteur[$page])) {
     360                // Initialisation des compteurs par bloc
     361                $nb_noisettes = array();
     362
     363                // Le nombre de noisettes par bloc doit être calculé par une lecture de la table spip_noisettes.
     364                $from = array('spip_noisettes');
     365                $select = array('bloc', "count(type_noisette) as 'noisettes'");
     366                // -- Construction du where identifiant précisément le type et la composition de la page
     367                $where = array(
     368                        'plugin=' . sql_quote('noizetier'),
     369                        'type=' . sql_quote(noizetier_page_type($page)),
     370                        'composition=' . sql_quote(noizetier_page_composition($page))
     371                );
     372                $group = array('bloc');
     373                $blocs_non_vides = sql_allfetsel($select, $from, $where, $group);
     374                if ($blocs_non_vides) {
     375                        // On formate le tableau [bloc] = nb noisettes
     376                        $nb_noisettes = array_column($blocs_non_vides, 'noisettes', 'bloc');
     377                }
     378
     379                // Sauvegarde des compteurs pour les blocs concernés.
     380                $blocs_compteur[$page] = $nb_noisettes;
     381        }
     382
     383        return $blocs_compteur[$page];
    343384}
    344385
  • _plugins_/noizetier/trunk/noizetier_fonctions.php

    r110124 r110127  
    1212// --------------------- API TYPES DE NOISETTE : COMPLEMENT -----------------------
    1313// --------------------------------------------------------------------------------
    14 include_spip('inc/noizetier_type_noisette');
    1514
    1615
     
    6160
    6261/**
    63  * Retourne le chemin complet d'une icone.
    64  * La fonction vérifie d'abord que l'icone est dans le thème du privé (chemin_image),
    65  * sinon cherche dans le path SPIP (find_in_path).
    66  *
    67  * @package SPIP\NOIZETIER\ICONE\API
    68  * @api
    69  * @filtre
    70  *
    71  * @param string $icone
    72  *
    73  * @return string
    74  */
    75  function noizetier_icone_chemin($icone){
    76         // TODO : faut-il garder cette fonction ou simplifier en utilisant uniquement chemin_image() ?
    77         if (!$chemin = chemin_image($icone)) {
    78                 $chemin = find_in_path($icone);
    79         }
    80 
    81         return $chemin;
    82 }
    83 
    84 /**
    8562 * Compile la balise `#NOIZETIER_ICONE_LISTE` qui fournit la liste des icones d'une taille donnée en pixels
    8663 * disponibles dans les thèmes SPIP de l'espace privé.
     
    11087
    11188/**
     89 * @internal
     90 *
    11291 * @param int $taille
    11392 *
     
    130109// ---------------------------- API BLOCS ----------------------------
    131110// -------------------------------------------------------------------
    132 
    133 /**
    134  * Renvoie le nombre de noisettes de chaque bloc configurables d'une page, d'une composition
    135  * ou d'un objet.
    136  *
    137  * @package SPIP\NOIZETIER\BLOC\API
    138  * @api
    139  * @filtre
    140  *
    141  * @param string $page_ou_objet
    142  *              L'identifiant de la page, de la composition ou de l'objet au format:
    143  *              - pour une page : type
    144  *              - pour une composition : type-composition
    145  *              - pour un objet : type_objet-id_objet
    146  *
    147  * @return array
    148  */
    149 function noizetier_bloc_compter_noisettes($page_ou_objet) {
    150 
    151         static $blocs_compteur = array();
    152 
    153         if (!isset($blocs_compteur[$page_ou_objet])) {
    154                 // Initialisation des compteurs par bloc
    155                 $nb_noisettes = array();
    156 
    157                 // Le nombre de noisettes par bloc doit être calculé par une lecture de la table spip_noisettes.
    158                 $from = array('spip_noisettes');
    159                 $select = array('bloc', "count(type_noisette) as 'noisettes'");
    160                 // -- Construction du where identifiant précisément la page ou l'objet concerné
    161                 $identifiants = explode('-', $page_ou_objet);
    162                 if (isset($identifiants[1]) and ($id = intval($identifiants[1]))) {
    163                         // L'identifiant est celui d'un objet
    164                         $where = array('objet=' . sql_quote($identifiants[0]), 'id_objet=' . $id);
    165                 } else {
    166                         if (!isset($identifiants[1])) {
    167                                 // L'identifiant est celui d'une page
    168                                 $identifiants[1] = '';
    169                         }
    170                         $where = array('type=' . sql_quote($identifiants[0]), 'composition=' . sql_quote($identifiants[1]));
    171                 }
    172                 $group = array('bloc');
    173                 $compteurs = sql_allfetsel($select, $from, $where, $group);
    174                 if ($compteurs) {
    175                         // On formate le tableau [bloc] = nb noisettes
    176                         foreach ($compteurs as $_compteur) {
    177                                 $nb_noisettes[$_compteur['bloc']] = $_compteur['noisettes'];
    178                         }
    179                 }
    180                 $blocs_compteur[$page_ou_objet] = $nb_noisettes;
    181         }
    182 
    183         return (isset($blocs_compteur[$page_ou_objet])
    184                 ? $blocs_compteur[$page_ou_objet]
    185                 : array());
    186 }
    187111
    188112/**
     
    216140
    217141/**
     142 * @internal
     143 *
    218144 * @param string $bloc
    219145 * @param string $information
     
    237163 * La signature de la balise est : `#NOIZETIER_PAGE_INFOS{page, information}`.
    238164 *
    239  * La fonction peut aussi renvoyée une information spéciale `est_modifiee` qui indique si la configuration
    240  * du fichier YAML ou XML de la page a été modifiée ou pas.
     165 * La fonction peut aussi renvoyée d'autres informations calculées, à savoir :
     166 * - `est_modifiee` qui indique si la configuration du fichier YAML ou XML de la page a été modifiée ou pas.
     167 * - `compteurs_type_noisette` qui donne le nombre de types de noisettes disponibles pour la page ou la composition
     168 *    donnée en distinguant les types de noisettes communs à toutes les pages, les types de noisettes spécifiques à
     169 *    un type de page et les types de noisettes spécifiques à une composition.
     170 * - `compteurs_noisette` qui donne le nombre de noisettes incluses dans chaque bloc de la page.
    241171 *
    242172 * @package SPIP\NOIZETIER\PAGE\BALISE
     
    249179 *     #NOIZETIER_PAGE_INFOS{article-forum, nom}, renvoie le titre de la composition forum de la page article
    250180 *     #NOIZETIER_PAGE_INFOS{article, est_modifiee}, indique si la configuration de la page article a été modifiée
     181 *     #NOIZETIER_PAGE_INFOS{article, compteurs_type_noisette}, fournit les compteurs de types de noisette compatibles
     182 *     #NOIZETIER_PAGE_INFOS{article, compteurs_noisette}, fournit les compteurs de noisettes incluses par bloc
    251183 *     ```
    252184 *
     
    273205
    274206/**
     207 * @internal
     208 *
    275209 * @param        $page
    276210 * @param string $information
    277211 *
    278  * @return array
     212 * @return mixed
    279213 */
    280214function calculer_infos_page($page, $information = '') {
     
    303237                        }
    304238                }
     239        } elseif ($information == 'compteurs_type_noisette') {
     240                // Initialisation des compteurs par bloc
     241                $retour = array(
     242                        'composition' => 0,
     243                        'type'        => 0,
     244                        'commun'      => 0
     245                );
     246
     247                // Acquisition du type et de la composition éventuelle.
     248                $type = noizetier_page_type($page);
     249                $composition = noizetier_page_composition($page);
     250
     251                // Les compteurs de types de noisette d'une page sont calculés par une lecture de la table 'spip_types_noisettes'.
     252                $from = array('spip_types_noisettes');
     253                $where = array(
     254                        'plugin=' . sql_quote('noizetier'),
     255                        'type=' . sql_quote($type),
     256                        'composition=' . sql_quote($composition)
     257                );
     258                $compteur = sql_countsel($from, $where);
     259
     260                // On cherche maintenant les 3 compteurs possibles :
     261                if ($composition) {
     262                        // - les types de noisette spécifiques de la composition si la page en est une.
     263                        if ($compteur) {
     264                                $retour['composition'] = $compteur;
     265                        }
     266                        $where[2] = 'composition=' . sql_quote('');
     267                        $compteur = sql_countsel($from, $where);
     268                        if ($compteur) {
     269                                $retour['type'] = $compteur;
     270                        }
     271                } else {
     272                        // - les types de noisette spécifiques de la page ou du type de la composition
     273                        if ($compteur) {
     274                                $retour['type'] = $compteur;
     275                        }
     276                }
     277                // - les types de noisette communs à toutes les pages.
     278                $where[1] = 'type=' . sql_quote('');
     279                $compteur = sql_countsel($from, $where);
     280                if ($compteur) {
     281                        $retour['commun'] = $compteur;
     282                }
     283
     284                $retour['total'] = array_sum($retour);
     285        } elseif ($information == 'compteurs_noisette') {
     286                $retour = noizetier_page_compter_noisettes($page);
    305287        } else {
    306288                $retour = noizetier_page_lire($page, $information);
     
    353335
    354336/**
     337 * @internal
     338 *
    355339 * @param        $objet
    356340 * @param        $id_objet
     
    362346
    363347        include_spip('inc/noizetier_objet');
    364         return noizetier_objet_lire($objet, $id_objet, $information);
     348        if ($information == 'compteurs_noisette') {
     349                $retour = noizetier_objet_compter_noisettes($objet, $id_objet);
     350        } else {
     351                $retour = noizetier_objet_lire($objet, $id_objet, $information);
     352        }
     353        return $retour;
    365354}
    366355
     
    388377
    389378/**
     379 * @internal
     380 *
    390381 * @return array|string
    391382 */
  • _plugins_/noizetier/trunk/noizetier_pipelines.php

    r110112 r110127  
    2121        if ((defined('_NOIZETIER_RECUPERER_FOND') ? _NOIZETIER_RECUPERER_FOND : true) and !test_espace_prive()) {
    2222                include_spip('inc/noizetier_page');
     23                include_spip('inc/noizetier_objet');
    2324                $fond = isset($flux['args']['fond']) ? $flux['args']['fond'] : '';
    2425                if ($fond) {
     
    6263                                                and isset($flux['args']['contexte'][$cle_objet])
    6364                                                and $id_objet = intval($flux['args']['contexte'][$cle_objet])
    64                                                 and $par_objet = array_key_exists($bloc, noizetier_bloc_compter_noisettes("${objet}-${id_objet}"))
     65                                                and $par_objet = array_key_exists($bloc, noizetier_objet_compter_noisettes($objet, $id_objet))
    6566                                        )
    66                                         or array_key_exists($bloc, noizetier_bloc_compter_noisettes($page))
     67                                        or array_key_exists($bloc, noizetier_page_compter_noisettes($page))
    6768                                ) {
    6869                                        $contexte = $flux['data']['contexte'];
     
    207208                                        'nom'                   => _T_ou_typo($_configuration['nom']),
    208209                                        'description'   => isset($_configuration['description']) ? _T_ou_typo($_configuration['description']) : '',
    209                                         'icon'                  => noizetier_icone_chemin($_configuration['icon']),
     210                                        'icon'                  => chemin_image($_configuration['icon']),
    210211                                        'branche'               => unserialize($_configuration['branche']),
    211212                                        'class'                 => '',
  • _plugins_/noizetier/trunk/prive/squelettes/contenu/noizetier_page.html

    r110112 r110127  
    1212                <h1>
    1313                        [(#NOM)]
    14                         [(#ICON|noizetier_icone_chemin|balise_img{page,cadre-icone})]
     14                        [(#CHEMIN_IMAGE{#ICON}|balise_img{page,cadre-icone})]
    1515                </h1>
    1616        ,simple fiche_objet})]
  • _plugins_/noizetier/trunk/prive/squelettes/contenu/noizetier_pages.html

    r109831 r110127  
    2222                                [(#REM) Logo de la page ]
    2323                                <div class="icone">
    24                                         [(#ICON|noizetier_icone_chemin|image_reduire{24}|extraire_attribut{src}|balise_img)]
     24                                        [(#CHEMIN_IMAGE{#ICON}|image_reduire{24}|extraire_attribut{src}|balise_img)]
    2525                                </div>
    2626                        </div>
  • _plugins_/noizetier/trunk/prive/squelettes/inclure/inc-nav_blocs.html

    r110102 r110127  
    11[(#REM) <!-- Navigation dans les blocs configurables de la page --> ]
    2 [(#SET{blocs_decompte, [(#ENV{page}|?{#ENV{page}, #ENV{objet}-#ENV{id_objet}}|noizetier_bloc_compter_noisettes)]})]
     2#SET{blocs_decompte,
     3        #ENV{page}|?{
     4                #NOIZETIER_PAGE_INFOS{#ENV{page}, compteurs_noisette},
     5                #NOIZETIER_OBJET_INFOS{#ENV{objet}, #ENV{id_objet}, compteurs_noisette}
     6        }
     7}
    38<B_blocs>
    49<div class="onglets_simple second clearfix">
Note: See TracChangeset for help on using the changeset viewer.