Your IP : 216.73.216.59
<?php
// Code d'inclusion pour le plugin 'Couteau Suisse'
isset($GLOBALS['cs_fonctions']) ? $GLOBALS['cs_fonctions']++ : $GLOBALS['cs_fonctions'] = 1;
// Ce fichier contient des fonctions toujours compilees dans tmp/couteau-suisse/mes_fonctions.php
if (!defined("_ECRIRE_INC_VERSION")) return;
// compatibilite SPIP < 2.00
if(!defined('_SPIP19300')) {
// #VAL{x} renvoie 'x' (permet d'appliquer un filtre a une chaine)
// Attention #VAL{1,2} renvoie '1', indiquer #VAL{'1,2'}
function balise_VAL($p){
$p->code = interprete_argument_balise(1,$p);
if (!strlen($p->code)) $p->code = "''";
$p->interdire_scripts = false;
return $p;
}
if(!function_exists('oui')) { function oui($code) { return $code?' ':''; } }
if(!function_exists('non')) { function non($code) { return $code?'':' '; } }
}
function balise_CHR_dist($p) {
if (($v = interprete_argument_balise(1,$p))!==NULL){
$p->code = "chr(intval($v))";
$p->type = 'php';
}
return $p;
}
function balise_DEFINED_dist($p) {
if (($v = interprete_argument_balise(1,$p))!==NULL){
$p->code = "defined($v)";
$p->type = 'php';
}
return $p;
}
// compatibilite SPIP < 3.20
if(!defined('_SPIP30200')) {
function balise_CONST_dist($p) {
$_const = interprete_argument_balise(1, $p);
if (!strlen($_const)) $p->code = "''";
else $p->code = "(defined($_const)?constant($_const):'')";
$p->interdire_scripts = false;
return $p;
}
}
// fonction appelant une liste de fonctions qui permettent de nettoyer un texte original de ses raccourcis indesirables
function cs_introduire($texte) {
// liste de filtres qui sert a la balise #INTRODUCTION
if(!isset($GLOBALS['cs_introduire']) || !is_array($GLOBALS['cs_introduire'])) return $texte;
$liste = array_unique($GLOBALS['cs_introduire']);
foreach($liste as $f)
if (function_exists($f)) $texte = $f($texte);
return $texte;
}
// filtre pour ajouter un <span> autour d'un texte
function cs_span($texte, $attr='') { return "<span $attr>$texte</span>"; }
// raccourci pour afficher le statut d'un auteur
function cs_auteur_statut($row) {
$puce_statut = charger_fonction('puce_statut', 'inc');
return $puce_statut(0, $row['statut'], 0, 'auteur');
}
// Controle (basique!) des 3 balises usuelles p|div|span eventuellement coupees
// Attention : simple traitement pour des balises non imbriquees
function cs_safebalises($texte) {
$texte = trim($texte);
// ouvre/supprime la premiere balise trouvee fermee (attention aux modeles SPIP)
if(preg_match(',^(.*)</([a-z]+)>,Ums', $texte, $m) && !preg_match(",<$m[2][ >],", $m[1]))
$texte = strlen($m[1])?"<$m[2]>$texte":trim(substr($texte, strlen($m[2])+3));
// referme/supprime la derniere balise laissee ouverte (attention aux modeles SPIP)
if(preg_match(',^(.*)[ >]([a-z]+)<,Ums', $rev = strrev($texte), $m) && !preg_match(",>$m[2]/<,", $m[1]))
$texte = strrev(strlen($m[1])?">$m[2]/<$rev":trim(substr($rev, strlen($m[2])+2)));
// balises <p|span|div> a traiter
foreach(array('span', 'div', 'p') as $b) {
// ouvrante manquante
if(($fin = strpos($texte, "</$b>")) !== false)
if(!preg_match(",<{$b}[ >],", substr($texte, 0, $fin)))
$texte = "<$b>$texte";
// fermante manquante
$texte = strrev($texte);
if(preg_match(',[ >]'.strrev("<{$b}").',', $texte, $reg)) {
$fin = strpos(substr($texte, 0, $deb = strpos($texte, $reg[0])), strrev("</$b>"));
if($fin===false || $fin>$deb) $texte = strrev("</$b>").$texte;
}
$texte = strrev($texte);
}
return $texte;
}
// fonction de suppression de notes. Utile pour #CS_SOMMAIRE ou #CS_DECOUPE
function cs_supprime_notes($texte) {
return preg_replace(', *\[\[(.*?)\]\],msS', '', $texte);
}
// filtre appliquant les traitements SPIP d'un champ (et eventuellement d'un type d'objet) sur un texte
// (voir la fonction champs_traitements($p) dans : public/references.php)
// => permet d'utiliser les balises etoilees : #TEXTE*|mon_filtre|cs_traitements{TEXTE,articles}
// ce mecanisme est a preferer au traditionnel #TEXTE*|mon_filtre|propre
// cs_traitements() consulte simplement la globale $table_des_traitements et applique le traitement adequat
// $exclusions est une chaine ou un tableau de filtres a exclure du traitement
function cs_traitements($texte, $nom_champ='NULL', $type_objet='NULL', $exclusions=NULL) {
global $table_des_traitements;
if(!isset($table_des_traitements[$nom_champ])) return $texte;
$ps = $table_des_traitements[$nom_champ];
if(is_array($ps)) $ps = $ps[isset($ps[$type_objet]) ? $type_objet : 0];
if(!$ps) return $texte;
// retirer les filtres a exclure
if($exclusions!==NULL) $ps = str_replace($exclusions, 'cs_noop', $ps);
// remplacer le placeholder %s par le texte fourni
eval('$texte=' . str_replace('%s', '$texte', $ps) . ';');
return $texte;
}
function cs_noop($t='',$a=NULL,$b=NULL,$c=NULL) { return $t; }
// renvoie un champ d'un objet en base
function cs_champ_sql($id, $champ='texte', $objet='article') {
// Utiliser la bonne requete en fonction de la version de SPIP
if(function_exists('sql_getfetsel')) {
// SPIP >= 2.0
// TODO : fonctions SPIP pour trouver la table et l'id_objet
if($r = sql_getfetsel($champ, 'spip_'.$objet.'s', 'id_'.$objet.'='.intval($id)))
return $r;
} else {
// SPIP 1.92
if($r = spip_query('SELECT '.$champ.' FROM spip_'.$objet.'s WHERE id_'.$objet.'='.intval($id)))
// s'il existe un champ, on le retourne
if($row = spip_fetch_array($r)) return $row[$champ];
}
// sinon rien !
return '';
}
// recaler un contenu de fond. Exemple : #FILTRE{cs_impossible}
function cs_impossible($chaine='') { return _T('avis_operation_impossible'); }
// aide le Couteau Suisse à calculer la balise #INTRODUCTION
$GLOBALS['cs_introduire'][] = 'sommaire_nettoyer_raccourcis';
// renvoie l'url utilisée par le sommaire
function sommaire_self() {
static $self = NULL;
return isset($self) ? $self :
$self = str_replace('&', '&', nettoyer_uri());//self();//$GLOBALS['REQUEST_URI'];
}
// filtre de remplacement de l'url par défaut (si par exemple #CS_SOMMAIRE est placé dans une boucle d'articles)
function sommaire_url($texte, $url) {
return str_replace(sommaire_self(), $url, $texte);
}
// renvoie le sommaire d'une page d'article
// $page=false reinitialise le compteur interne des ancres
function sommaire_d_une_page(&$texte, &$nbh3, $page=0, $num_pages=0) {
static $index = 0;
if($page===false) { $index = 0; return; }
// trouver quel <hx> est utilise
include_spip('outils/sommaire');
$root = $niveau = $match = cs_niveau_intertitres();
defined('_sommaire_NB_CARACTERES') || define('_sommaire_NB_CARACTERES', 30);
defined('_sommaire_PROFONDEUR') || define('_sommaire_PROFONDEUR', 1);
if(_sommaire_PROFONDEUR>1)
$match = $match .'-' . ($match+_sommaire_PROFONDEUR-1);
// traitement des intertitres <hx>
preg_match_all(",(<h([$match])[^>]*)>(.*)</h\\2>,Umsi", $texte, $regs);
$nbh3 += count($regs[0]);
$pos = 0; $sommaire = '';
// calcul de la page
$self = sommaire_self();
$fct_lien_retour = function_exists('sommaire_lien_retour')?'sommaire_lien_retour':'sommaire_lien_retour_dist';
$fct_id_ancre = defined('_sommaire_JOLIES_ANCRES')?'sommaire_id_ancre_ex'
:(function_exists('sommaire_id_ancre')?'sommaire_id_ancre':'sommaire_id_ancre_dist');
$nb = count($regs[0]);
for($i=0;$i<$nb;$i++,$index++){
$w = &$regs[0][$i]; $h = &$regs[1][$i]; $n = &$regs[2][$i];
if (($pos2 = strpos($texte, $w, $pos))!==false) {
$t = $regs[3][$i];
// calcul de l'ancre, $t peut etre modifie
$ancre = $fct_id_ancre($index, $t, $n);
$id = " id=\"$ancre\">";
//$titre = preg_replace(',^<p[^>]*>(.*)</p>$,Umsi', '\\1', trim($t));
// ancre 'retour au sommaire', sauf :
// si on imprime, ou si les blocs depliables utilisent h{$n}...
$titre = (defined('_CS_PRINT') OR (strpos($w, 'blocs_titre')!==false))
?$t//$titre
:$fct_lien_retour($self, $t);//$titre);
$texte = substr($texte, 0, $pos2) . $h . $id . $titre
. substr($texte, $pos2 + strlen($h)+1 + strlen($regs[3][$i]));
$pos = $pos2 + strlen($id) + strlen($w);
$brut = sommaire_nettoyer_titre($t);
// pas trop long quand meme...
$lien = cs_propre(couper($brut, _sommaire_NB_CARACTERES));
// eviter une ponctuation a la fin, surtout si la page est precisee
$lien = preg_replace('/( |\s)*'.($page?'[!?,;.:]+$/':'[,;.:]+$/'), '', $lien);
$titre = attribut_html(couper($brut, 100));
// si la decoupe en page est active...
$artpage = (function_exists('decoupe_url') && (strlen(_request('artpage')) || $page>1) )
?decoupe_url($self, $page, $num_pages):$self;
$artpage = "<a title=\"$titre\" href=\"{$artpage}#$ancre\">$lien</a>";
$artpage = "\n<li>" . ( function_exists('sommaire_id_page')
?sommaire_id_page($artpage, $page):sommaire_id_page_dist($artpage, $page) );
if($niveau==$n) $sommaire .= ($sommaire?'</li>':'') . $artpage;
elseif($niveau<$n) $sommaire .= "\n<ul>".str_repeat('<li><ul>',$n-$niveau-1) . $artpage;
else $sommaire .= '</li>'.str_repeat('</ul></li>',$niveau-$n) . $artpage;
$niveau = $n;
}
}
return $sommaire?$sommaire.'</li>'.($niveau!=$root?'</ul>':''):'';
}
function sommaire_nettoyer_titre($t) {
// pas de notes
$brut = preg_replace(',\[<a href=["\']#nb.*?</a>\],','', echappe_retour($t,'CS'));
// pas de glossaire
if(function_exists('cs_retire_glossaire')) $brut = cs_retire_glossaire($brut);
// texte brut
$brut2 = trim(preg_replace(',[\n\r]+,',' ',textebrut($brut)));
// cas des intertitres en image_typo
if(!strlen($brut2)) $brut2 = trim(extraire_attribut($brut, 'alt'));
return $brut2;
}
/*
Fonction surchargeable qui reconstruit les titres de la page
en ajoutant une ancre de retour au sommaire.
La fonction de surcharge a placer dans config/mes_options.php est :
sommaire_lien_retour($self, $titre)
Exemple sans lien de retour :
function sommaire_lien_retour($self, $titre) { return $titre; }
*/
function sommaire_lien_retour_dist($self, $titre) {
static $haut = NULL;
if(!isset($haut))
$haut = '<a title="'._T('couteau:sommaire_titre').'" href="'.$self.'#outil_sommaire" class="sommaire_ancre"> </a>';
return $haut . $titre;
}
/*
Fonction surchargeable qui ajoute au sommaire l'information d'une page en cas de decoupe
Exemple : "<a ...>Mon titre</a>, page 4"
La fonction de surcharge a placer dans config/mes_options.php est :
sommaire_id_page($element, $page)
$element est le lien cliquable du sommaire
*/
function sommaire_id_page_dist($element, $page) {
return $page ? $element . _T('couteau:sommaire_page', array('page'=>$page)) : $element;
}
/*
Fonction surchargeable qui calcule l'ancre d'un intertitre
La fonction de surcharge a placer dans config/mes_options.php est :
sommaire_id_ancre($index, &$titre, $hn)
$titre peut etre modifie par cette fonction : utile pour traiter le format {{{Mon titre<mon_ancre>}}}
*/
function sommaire_id_ancre_dist($index, &$titre, $hn) {
return 'outil_sommaire_'.$index;
}
// Surcharge compatible avec les intertitres en image : jolies ancres
function sommaire_id_ancre_ex($index, &$titre, $hn) {
// traiter le format {{{Mon titre<mon_ancre>}}} (ou alt='Mon titre<mon_ancre>')
if(preg_match(',<(\w+)>$,', $titre, $r) || preg_match(',<(\w+)>(?=\'),', $titre, $r)) {
$titre = str_replace($r[0], '', $titre);
return $r[1];
}
// calculer les ancres d'apres le titre
$a = strtolower(translitteration(sommaire_nettoyer_titre($titre)));
$a = trim(preg_replace(',[^a-z0-9_]+,', '_', $a), '_');
return strlen($a)>2?$a:"sommaire_$index";
}
function sommaire_echappe_balises_callback($matches) {
return cs_code_echappement($matches[0], 'SOMM');
}
// fonction appellee sur les parties du textes non comprises entre les balises : html|code|cadre|frame|script|cite|acronym|onglets|table
// $sommaire_seul = true ou 1 : retour du sommaire seul, fond complet
// $sommaire_seul = 2 : retour du sommaire seul sous forme de liste <li></li>
// $sommaire_seul = false : insertion du sommaire automatique dans le texte si la balise #CS_SOMMAIRE est inactive
// $sommaire_seul = 0 : insertion du sommaire automatique dans le texte, balise #CS_SOMMAIRE active ou non
function sommaire_d_article_rempl($texte0, $sommaire_seul=false) {
// pour sommaire_nettoyer_raccourcis()
include_spip('outils/sommaire');
// si le sommaire est malvenu ou s'il n'y a pas de balise <hx>, alors on laisse tomber
$inserer_sommaire = defined('_sommaire_AUTOMATIQUE')
? strpos($texte0, _CS_SANS_SOMMAIRE)===false
: strpos($texte0, _CS_AVEC_SOMMAIRE)!==false;
if (!$inserer_sommaire || strpos($texte0, '<h')===false)
return $sommaire_seul?'':sommaire_nettoyer_raccourcis($texte0);
// on retire les raccourcis du texte
$texte = sommaire_nettoyer_raccourcis($texte0);
// on masque les onglets s'il y en a
if(defined('_onglets_FIN'))
$texte = preg_replace_callback(',<div class="onglets_bloc_initial.*'._onglets_FIN.',Ums',
'sommaire_echappe_balises_callback', $texte);
// et la, on y va...
$sommaire = ''; $i = 1; $nbh3 = 0;
// reinitialisation de l'index interne de la fonction
sommaire_d_une_page($texte, $nbh3, false);
// couplage avec l'outil 'decoupe_article'
if(defined('_decoupe_SEPARATEUR') && !defined('_CS_PRINT')) {
$pages = explode(_decoupe_SEPARATEUR, $texte);
if (($num_page=count($pages)) == 1) $sommaire = sommaire_d_une_page($texte, $nbh3);
else {
foreach($pages as $p=>$page) {
$sommaire .= sommaire_d_une_page($page, $nbh3, $i++, $num_page);
$pages[$p] = $page;
}
$texte = implode(_decoupe_SEPARATEUR, $pages);
}
} else $sommaire = sommaire_d_une_page($texte, $nbh3);
defined('_sommaire_NB_TITRES_MINI') || define('_sommaire_NB_TITRES_MINI', 2);
if(!strlen($sommaire) || $nbh3<_sommaire_NB_TITRES_MINI)
return $sommaire_seul ? '' : sommaire_nettoyer_raccourcis($texte0);
// on ne veut que la liste <li></li> du sommaire ?
if($sommaire_seul===2) return $sommaire;
// contexte du sommaire : on passe aussi les id_objet disponibles
$temp = array(
'sommaire' => $sommaire,
'fond_css' => strpos($texte0, _sommaire_SANS_FOND)===false ?'avec':'sans',
);
if(!defined('_SPIP30000') && test_espace_prive() && !empty($_GET)) // SPIP < 3.0 : partie privee non squelettisee
foreach($_GET as $i=>$v) if(strncmp($i,'id_',3)==0) $temp[$i] = $v;
if(isset($GLOBALS['contexte']) && is_array($GLOBALS['contexte']))
foreach($GLOBALS['contexte'] as $i=>$v)
if(strncmp($i,'id_',3)==0) $temp[$i] = $v;
// calcul du sommaire
include_spip('public/assembler');
$sommaire = recuperer_fond('fonds/sommaire', $temp);
// si on ne veut que le sommaire, on renvoie le sommaire
// sinon, on n'insere ce sommaire en tete de texte que si la balise #CS_SOMMAIRE n'est pas activee
if($sommaire_seul) return $sommaire;
if(defined('_onglets_FIN')) $texte = echappe_retour($texte, 'SOMM');
if(defined('_sommaire_BALISE') && $sommaire_seul===false) return $texte;
return _sommaire_REM.$sommaire._sommaire_REM.$texte;
}
// fonction/filtre appelee par le traitement de #TEXTE/articles
function sommaire_d_article($texte, $sommaire_seul=false) {
// s'il n'y a aucun intertitre, on ne fait rien
// si la balise est utilisee, il faut quand meme inserer les ancres de retour
if((strpos($texte, '<h')===false)) return $texte;
return cs_echappe_balises('|cite|acronym|onglets|table', 'sommaire_d_article_rempl', $texte, $sommaire_seul);
}
// fonction appelee par le traitement post_propre de #CS_SOMMAIRE
function sommaire_d_article_balise($texte) {
// si la balise n'est pas utilisee ou s'il n'y a aucun intertitre, on ne fait rien
if(!defined('_sommaire_BALISE') || (strpos($texte, '<h')===false)) return '';
return cs_echappe_balises('|cite|acronym|onglets|table', 'sommaire_d_article_rempl', $texte, true);
}
// si on veut la balise #CS_SOMMAIRE
if (defined('_sommaire_BALISE')) {
// fonction traitant la balise
function balise_CS_SOMMAIRE_dist($p) {
// id de l'article a trouver pour retourner son texte
$texte = ($v = interprete_argument_balise(1,$p))!==NULL ? 'cs_champ_sql('.$v.')' : champ_sql('texte', $p);
if ($p->type_requete == 'articles' || $v!==NULL) {
$p->code = 'cs_supprime_notes('.$texte.')';
} else {
$p->code = "''";
}
$p->interdire_scripts = true;
return $p;
}
}
// Outils GLOSSAIRE - 26 mai 2007
// Serieuse refonte et integration au Couteau Suisse : Patrice Vanneufville
// Doc : https://contrib.spip.net/?article2206
include_spip('inc/charsets');
// liste des accents (sans casse)
define('_GLOSSAIRE_ACCENTS', '#(19[2-9]|2[023][0-9]|21[0-46-9]|24[0-689]|25[0-4]|33[89]|35[23]|376)|a(?:acute|circ|elig|grave|ring|tilde|uml)|ccedil|e(?:acute|circ|grave|th|uml)|i(?:acute|circ|grave|uml)|ntilde|o(?:acute|circ|elig|grave|slash|tilde|uml)|s(?:caron|zlig)|thorn|u(?:acute|circ|grave|uml)|y(?:acute|uml)');
// on calcule ici la constante _GLOSSAIRE_QUERY, surchargeable dans config/mes_options.php
function glossaire_groupes() {
$groupes = trim($GLOBALS['glossaire_groupes']);
if(!strlen($groupes)) return _q('Glossaire');
else {
$groupes = explode(':', $groupes);
foreach($groupes as $i=>$g) $groupes[$i] = _q(trim($g));
return implode(" OR type=", $groupes);
}
}
// Separateur des titres de mots stockes en base
if(!defined('_GLOSSAIRE_TITRE_BASE_SEP')) define('_GLOSSAIRE_TITRE_BASE_SEP', '/');
// Separateur utilise pour fabriquer le titre de la fenetre de glossaire (fichiers fonds/glossaire_xx.html).
if(!defined('_GLOSSAIRE_TITRE_SEP')) define('_GLOSSAIRE_TITRE_SEP', '<br />');
// Balises a echapper avant le traitement du glossaire
if(!defined('_GLOSSAIRE_ECHAPPER')) define('_GLOSSAIRE_ECHAPPER', '|cite|a|acronym|abbr');
// chaine pour interroger la base (SPIP <= 1.92)
if(!defined('_SPIP19300'))
@define('_GLOSSAIRE_QUERY', 'SELECT id_mot, titre, texte, descriptif FROM spip_mots WHERE type=' . glossaire_groupes() . ' ORDER BY id_mot ASC');
// surcharge possible de cette fonction glossaire_generer_url_dist par : glossaire_generer_url($id_mot, $titre_mot)
// si elle existe, elle sera utilisee pour generer l'url cliquable des mots trouves
// exemple pour annuler le clic : function glossaire_generer_url($id_mot, $titre_mot) { return 'javascript:;'; }
function glossaire_generer_url_dist($id_mot, $titre_mot) {
if(strpos($titre_mot, '=')!==false) {
list(, $lien) = glossaire_redirection($titre_mot);
if($lien) return calculer_url($lien);
}
if(defined('_SPIP40100'))
return generer_objet_url($id_mot, 'mot');
if(defined('_SPIP19300'))
return generer_url_entite($id_mot, 'mot');
// avant SPIP 2.0 :
charger_generer_url(); return generer_url_mot($id_mot);
}
// surcharge possible de cette fonction glossaire_generer_mot_dist par : glossaire_generer_mot($id_mot, $mot)
// si elle existe, elle sera utilisee pour remplacer le mot detecte dans la phrase
/* exemple pour utiliser un fond personnalise, mettre une couleur de groupe ou inserer un logo par exemple :
function glossaire_generer_mot($id_mot, $mot) {
return recuperer_fond('/fonds/mon_glossaire', array('id_mot'=>$id_mot, 'mot'=>$mot));
}*/
function glossaire_generer_mot_dist($id_mot, $mot) {
return $mot;
}
/* surcharge possible de cette fonction glossaire_attributs_lien_dist par : glossaire_attributs_lien($lien, $titre, $gloss_id)
si elle existe, elle sera utilisee pour les attributs (sauf class et name) du <a> place autour du mot detecte.
$lien : lien du mot - $titre : titre brut du mot - $les_titres : array() des differents titres possibles du mot
Exemple :
function glossaire_attributs_lien($id_mot, $lien, $titre, $les_titres) {
return "href='$lien' title=\"" . attribut_html($les_titres[0]). '"';
} */
function glossaire_attributs_lien_dist($id_mot, $lien, $titre, $les_titres) {
return "href='$lien'";
}
// traitement pour #TITRE/mots : retrait des expressions regulieres
function cs_glossaire_titres($titre) {
if(strpos($titre, ',')===false && strpos($titre, '=')===false) return $titre;
list(,,$mots) = glossaire_parse($titre);
return $mots;
}
// Cette fonction retire du texte les boites de definition et les liens du glossaire
function cs_retire_glossaire($texte) {
$texte = preg_replace(',<span class="gl_(jst?|d[td])".*?</span>,s', '', $texte);
if(!defined('_GLOSSAIRE_JS')) $texte = preg_replace(',<span class="gl_dl">.*?</span>,s', '', $texte);
return preg_replace(',<a [^>]+class=\'cs_glossaire\'><span class=\'gl_mot\'>(.*?)</span></a>,s', '$1', $texte);
}
$GLOBALS['cs_introduire'][] = 'cs_retire_glossaire';
// remplace les accents unicode par l'equivalent charset/unicode/html
function glossaire_accents($regexpr) {
if (strpos($regexpr, '&')===false) return $regexpr;
return preg_replace_callback(",&#([0-9]+);,", 'glossaire_accents_callback', str_replace('& ','& ',$regexpr));
}
// $matches est un caractere unicode sous forme &#XXX;
// ici on cherche toutes les formes de ce caractere, minuscule ou majuscule : unicode, charset et html
function glossaire_accents_callback($matches) {
$u = unicode2charset($matches[0]); // charset
$u2 = init_mb_string()?mb_strtoupper($u):strtoupper($u); // charset majuscule
$u3 = htmlentities($u2, ENT_QUOTES, $GLOBALS['meta']['charset']); // html majuscule
$u4 = html2unicode($u3); // unicode majuscule
$a = array_unique(array($u, $u2, htmlentities($u, ENT_QUOTES, $GLOBALS['meta']['charset']), $u3, $matches[0], $u4));
// $a = array_unique(array($u, htmlentities($u, ENT_QUOTES, $GLOBALS['meta']['charset']), $matches[0]));
return '(?:'.implode('|', $a).')';
}
function glossaire_echappe_balises_callback($matches) {
global $gloss_ech, $gloss_ech_id;
$gloss_ech[] = $matches[0];
return '@@E'.$gloss_ech_id++.'@@';
}
function glossaire_echappe_mot_callback($matches) {
global $gloss_mots, $gloss_mots_id, $gloss_id;
$gloss_mots[] = $matches[0];
return '@@M'.$gloss_mots_id++.'#'.$gloss_id.'@@';
}
function glossaire_safe($texte) {
// on retire les notes avant propre()
return safehtml(cs_propre(preg_replace(', *\[\[(.*?)\]\],msS', '', nl2br(trim($texte)))));
}
// renvoie le tableau des mots du glossaire
function glossaire_query_tab() {
// interrogation personnalisee de la base
if(defined('_GLOSSAIRE_QUERY')) {
$res = array();
$fetch = function_exists('sql_fetch')?'sql_fetch':'spip_fetch_array'; // Pour SPIP 1.92
$query = function_exists('sql_query')?sql_query(_GLOSSAIRE_QUERY):spip_query(_GLOSSAIRE_QUERY); // Pour SPIP 1.92
while($r = $fetch($query)) $res[] = $r;
return $res;
}
return sql_allfetsel('id_mot,titre,texte,descriptif', 'spip_mots', 'type='.glossaire_groupes(), '', 'id_mot ASC');
}
function glossaire_redirection($titre) {
$titre = preg_split(','.preg_quote(_GLOSSAIRE_TITRE_BASE_SEP,',').'\s*=,', $titre, 2);
return array(trim($titre[0]), isset($titre[1])?trim($titre[1]):'');
}
// parse toutes les formes du titre d'un mot-cle du glossaire
// prendre en compte les formes du mot : architrave/architraves
function glossaire_parse($titre) {
$mots = $regs = $titres = array(); $ok_mots = true;
// cas d'une redirection
if(strpos($titre, '=')!==false) list($titre) = glossaire_redirection($titre);
foreach(explode(_GLOSSAIRE_TITRE_BASE_SEP, str_replace('</','@@tag@@',$titre)) as $m) {
// interpretation des expressions regulieres grace aux virgules : ,un +mot,i
$m = trim(str_replace('@@tag@@','</',$m));
if(strncmp($m,',',1)===0)
$ok_mots = $ok_mots && !preg_match('/^,\w{1,3},$/', $regs[] = $m);
else {
$mots[] = charset2unicode($m);
$titres[] = $m;
$ok_mots = $ok_mots && mb_strlen($m)>3;
}
}
if(count($titres))
$titres = implode(_GLOSSAIRE_TITRE_SEP, $titres);
elseif(count($regs)) {
preg_match('/^,(.*),\w*$/', $regs[0], $rr);
if (strpos($titres = $rr[1], '\\')!==false) {
$titres = preg_replace('@\\\\([\.\\\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|:,-])@', '$1', $titres);
$titres = preg_replace(',\\\\[bswd],i', '', $titres);
}
} else
$titres = '??';
if(count($mots)) {
$mots = array_unique($mots);
array_walk($mots, 'cs_preg_quote');
// expliciter l'apostrophe et les accents
$mots = str_replace("'", "(?:'|’)", glossaire_accents(implode('|', $mots)));
} else $mots = '';
$ok_regexp = count($regs)?preg_replace($regs, 't', 'test', 1) !== null : true;
return array($mots, $ok_regexp?$regs:array(), $titres, $ok_regexp, $ok_mots);
}
function glossaire_gogogo($texte, $mots, $limit, &$unicode) {
// prudence 2 : on protege TOUTES les balises HTML comprenant le mot
if (strpos($texte, '<')!==false)
$texte = preg_replace_callback(",<[a-z][^>]*(?:$mots)[^>]*>,Ui", 'glossaire_echappe_balises_callback', $texte);
// echo "lesmots : $lesmots"; static $iii; echo '<hr>TEXTE #',++$iii,'<hr>',$texte,'<hr>';
// prudence 3 : en iso-8859-1, (\W) comprend les accents, mais pas en utf-8... Donc on passe en unicode
if(($GLOBALS['meta']['charset'] != 'iso-8859-1') && !$unicode)
{ $texte = charset2unicode($texte); $unicode = true; }
// prudence 4 : on neutralise le mot si on trouve un accent (HTML ou unicode) juste avant ou apres
if (strpos($texte, '&')!==false) {
$texte = preg_replace_callback(',&(?:'._GLOSSAIRE_ACCENTS.");(?:$mots),i", 'glossaire_echappe_balises_callback', $texte);
$texte = preg_replace_callback(",(?:$mots)&(?:"._GLOSSAIRE_ACCENTS.');,i', 'glossaire_echappe_balises_callback', $texte);
}
// a chaque mot reconnu, on pose une balise temporaire cryptee
return trim(preg_replace_callback(",(?<=\W)(?:$mots)(?=\W),i", 'glossaire_echappe_mot_callback', " $texte ", $limit));
}
// cette fonction n'est pas appelee dans les balises html echappees : html|code|cadre|frame|script|cite|acronym|abbr|a|etc...
// si $liste=true alors la fonction renvoie la liste des mots trouves
// chaque element du tableau renvoye est array('mot trouve', id_mot, 'lien mot', 'titre mot');
function cs_rempl_glossaire($texte, $liste = false) {
global $gloss_tab1, $gloss_tab2, $gloss_id, $gloss_mots, $gloss_mots_id, $gloss_ech, $gloss_ech_id;
// si [!glossaire] est trouve on sort
if(strpos($texte, _CS_SANS_GLOSSAIRE)!==false)
return $liste ? array() : str_replace(_CS_SANS_GLOSSAIRE, '', $texte);
// mise en static de la table des mots pour eviter d'interrroger la base a chaque fois
// attention aux besoins de memoire...
static $limit, $glossaire_generer_url, $glossaire_generer_mot, $glossaire_array = NULL;
if(!isset($glossaire_array)) {
$glossaire_array = glossaire_query_tab();
$glossaire_generer_url = function_exists('glossaire_generer_url') ? 'glossaire_generer_url' : 'glossaire_generer_url_dist';
$limit = defined('_GLOSSAIRE_LIMITE') ? _GLOSSAIRE_LIMITE : -1;
$glossaire_generer_mot = function($m) {
return '<a ' . $GLOBALS["gloss_tab1"][$m[2]] . "_" . $GLOBALS["gl_i"]++
. "' class='cs_glossaire'><span class='gl_mot'>"
. (function_exists('glossaire_generer_mot')
? glossaire_generer_mot($m[2], $GLOBALS['gloss_mots'][$m[1]])
: $GLOBALS['gloss_mots'][$m[1]]
)
. "</span>" . $GLOBALS["gloss_tab2"][$m[2]] . "</a>";
};
}
$unicode = false;
// initialisation des globales d'echappement
$gloss_ech = $gloss_mots = array();
$gloss_ech_id = $gloss_mots_id = 0;
// prudence 1 : protection des liens SPIP
if(strpos($texte, '[') !== false)
$texte = preg_replace_callback(',\[[^][]*->>?[^]]*\],msS', 'glossaire_echappe_balises_callback', $texte);
// parcours de tous les mots, sauf celui qui peut faire partie du contexte (par ex : /spip.php?mot5)
$mot_contexte = (isset($GLOBALS['contexte']['id_mot']) && $GLOBALS['contexte']['id_mot'])
? $GLOBALS['contexte']['id_mot'] : _request('id_mot');
foreach ($glossaire_array as $mot) if (($gloss_id = $mot['id_mot']) <> $mot_contexte) {
// parser le mot-cle du glossaire
// contexte de langue a prendre en compte ici
list($les_mots, $les_regexp, $les_titres, $ok_regexp, $ok_mots) = glossaire_parse($titre = extraire_multi($mot['titre']));
$mot_present = false;
if(!$ok_regexp)
spip_log(couteauprive_T('glossaire:nom') . '. ' . couteauprive_T('erreur_syntaxe').$titre);
elseif(count($les_regexp)) {
// prudence 2 : on protege QUELQUES balises HTML
if (strpos($texte, '<')!==false)
$texte = preg_replace_callback(",<(?:div|span|input) [^>]*>,Ui", 'glossaire_echappe_balises_callback', $texte);
// a chaque expression reconnue, on pose une balise temporaire cryptee
// ce remplacement est puissant, attention aux balises HTML ; par exemple, eviter : ,div,i
$texte = preg_replace_callback($les_regexp, 'glossaire_echappe_mot_callback', $texte, $limit);
// TODO 1 : sous PHP 5.0, un parametre &$count permet de savoir si un remplacement a eu lieu
// et s'il faut construire la fenetre de glossaire.
// TODO 2 : decrementer le parametre $limit pour $les_mots, si &$count est renseigne.
// en attendant, construisons qd meme la fenetre...
$mot_present = true;
}
if($les_mots && preg_match(",\W(?:$les_mots)\W,i", " $texte ")) {
$texte = glossaire_gogogo($texte, $les_mots, $limit, $unicode);
$mot_present = true;
}
// si un mot est trouve, on construit la fenetre de glossaire
if($mot_present) {
$lien = $glossaire_generer_url($gloss_id, $titre);
// $definition = strlen($mot['descriptif'])?$mot['descriptif']:$mot['texte'];
if($liste)
// on ne renvoie que la liste des mots trouves
$gloss_tab1[$gloss_id] = array($gloss_id, $lien, $les_titres);
else {
// l'attribut 'name' en fin de chaine est complete plus tard pour eviter les doublons :
$gloss_tab1[$gloss_id] = (function_exists('glossaire_attributs_lien')
?glossaire_attributs_lien($gloss_id, $lien, $titre, explode(_GLOSSAIRE_TITRE_SEP, $les_titres))
:"href='$lien'") . " name='mot$gloss_id";
$gloss_tab2[$gloss_id] = defined('_CS_PRINT')?'':recuperer_fond(
defined('_GLOSSAIRE_JS')?'fonds/glossaire_js':'fonds/glossaire_css',
array('id_mot' => $gloss_id, 'titre' => $les_titres,
'texte' => glossaire_safe($mot['texte']),
'descriptif' => glossaire_safe($mot['descriptif'])));
}
}
}
$GLOBALS['gl_i'] = 0;
if($liste)
$texte = (preg_match_all(',@@M(\d+)#(\d+)@@,', $texte, $reg, PREG_SET_ORDER)
&& array_walk($reg,
function (&$v) { $v = array_merge(array($GLOBALS['gloss_mots'][$v[1]]), $GLOBALS['gloss_tab1'][$v[2]]); })
) ? $reg : array();
else {
// remplacement des echappements
$texte = preg_replace_callback(',@@E(\d+)@@,', function($m) { return $GLOBALS['gloss_ech'][$m[1]]; }, $texte);
// remplacement final des balises posees ci-dessus
$texte = preg_replace_callback(',@@M(\d+)#(\d+)@@,', $glossaire_generer_mot, $texte);
}
// nettoyage
unset($gloss_tab1, $gloss_tab2, $gloss_id, $gloss_mots, $gloss_mots_id, $gloss_ech, $gloss_ech_id);
if($liste) return $texte;
// ordre correct des balises en cas d'acronyme ou d'abreviation
if(strpos($texte, '</span></a></a')!==false)
$texte = preg_replace(',(<a(bbr|cronym) [^>]+>)(<a [^>]+class=\'cs_glossaire\'><span class=\'gl_mot\'>)(.*?)</span>(<span class="gl_.*?</span>)</a></a\\2>,smS', '$3$1$4</a$2></span>$5</a>', $texte);
return $texte;
}
// filtre appliquant l'insertion du glossaire
function cs_glossaire($texte) {
return cs_echappe_balises(_GLOSSAIRE_ECHAPPER, 'cs_rempl_glossaire', $texte);
}
// filtre renvoyant la liste des mots trouves dans le texte
function cs_mots_glossaire($texte, $type='', $sep='') {
if(strpos($texte, "<span class='gl_mot'>")!==false && preg_match_all(",'gl_mot'>(.*?)</span>,", $texte, $reg)) {
// glossaire deja present, on simplifie donc le texte
$texte = implode(' ', $reg[1]);
}
// recuperation de la liste des mots
$mots = cs_echappe_balises(_GLOSSAIRE_ECHAPPER, 'cs_rempl_glossaire', $texte, true);
if(!count($mots)) return strlen($sep) ? '' : $mots;
$titre_fct = strpos($type, '_unique')===false
? function(&$v) { return str_replace("<br />", " / ", $v[3]); }
: function(&$v) { return reset($ttt = explode(_GLOSSAIRE_TITRE_SEP, $v[3])); };
switch($type) {
case '': return $mots;
case 'id_mot':
array_walk($mots, function (&$v) { $v = $v[1]; });
break;
case 'mot':
array_walk($mots, function(&$v) { $v = $v[0]; });
break;
case 'titre': case 'titre_unique':
//array_walk($mots, create_function('&$v', "\$v=$titre;"));
array_walk($mots, function(&$v) use($titre_fct) { $v = $titre_fct($v); });
break;
case 'lien_mot':
//array_walk($mots, create_function('&$v', '$v="<a href=\"$v[2]\">$v[0]</a>";'));
array_walk($mots, function(&$v) { $v = "<a href=\"$v[2]\">$v[0]</a>"; });
break;
case 'lien_titre': case 'lien_titre_unique':
//array_walk($mots, create_function('&$v', '$v="<a href=\"$v[2]\">".'.$titre.'."</a>";'));
array_walk($mots, function(&$v) use($titre_fct) { $v = "<a href=\"$v[2]\">" . $titre_fct($v) . "</a>"; });
break;
case 'nuage': case 'nuage_unique':
$stats = array(); $min = 999999; $max = 0;
foreach($mots as $m) $stats[$m[1]]++;
$m = min($stats); $d = max($stats) - $m;
// array_walk($stats, create_function('&$v', $d?"\$v=round((\$v-$m)*9/$d)+1;":'$v=1;')); // valeurs de 1 a 10
array_walk($stats, $d ? function(&$v) use($d,$m) { $v = round(($v-$m)*9/$d)+1; } : function(&$v) { $v = 1; }); // valeurs de 1 a 10
// array_walk($mots, create_function('&$v,$k,&$s', '$v="<a href=\"$v[2]\" class=\"nuage".$s[$v[1]]."\">".'.$titre.'."</a>";'), $stats);
array_walk($mots, function (&$v,$k,&$s) use($titre_fct) { $v = "<a href=\"$v[2]\" class=\"nuage" . $s[$v[1]] . "\">" . $titre_fct($v) . "</a>"; }, $stats);
break;
default: return "#GLOSSAIRE/$type?";
}
$mots = array_unique($mots);
return strlen($sep) ? implode($sep, $mots) : $mots;
}
// fonction pipeline SPIP>=3.0
function glossaire_affiche_milieu($flux) {
if($flux['args']['exec']=='mot') {
$titre = sql_getfetsel('titre', 'spip_mots', '(id_mot='.intval($flux['args']['id_mot']).') AND (type='.glossaire_groupes().')');
if(!$titre) return $flux; // Ce n'est pas un mot du glossaire
include_spip('inc/presentation');
$flux['data'] .= debut_cadre_relief(cs_icone(24), true).'<b>'
. cs_lien(generer_url_ecrire('admin_couteau_suisse', 'cmd=descrip&outil=glossaire#cs_infos'), couteauprive_T('glossaire:nom')).'</b>'
. '<br/> > <b>'._T('info_titre').'</b> '.htmlentities($titre, ENT_QUOTES, $GLOBALS['meta']['charset']);
list(,$lien) = glossaire_redirection($titre);
if($lien && $lien = calculer_url($lien, '', 'tout'))
$flux['data'] .= '<br/> > <b>'._T('info_lien_hypertexte').'</b> '.cs_lien($lien['url'], $lien['titre']);
$flux['data'] .= fin_cadre_relief(true);
}
return $flux;
}
/* Trois ou quatre balises pour creer des blocs depliables :
#BLOC_TITRE / {une_URL} si ajax, {un_numero} si bloc numerote, {visible} si bloc deplie /
Mon titre
#BLOC_RESUME / facultatif /
Mon resume qui disparait si on clique
#BLOC_DEBUT
Mon bloc depliable / qui est aussi l'emplacement pour l'Ajax si le fragment est donne /
#BLOC_FIN
*/
if(!defined('_BLOC_TITRE_H')) define('_BLOC_TITRE_H', 'h4');
if(!function_exists('balise_BLOC_TITRE')) {
// Pour la balise suivante, l'ordre des arguments importe peu
// Un bloc replie, titre simple : #BLOC_TITRE
// Un bloc replie AJAX : #BLOC_TITRE{fragment} (fragment est une URLs)
// Un bloc replie numerote : #BLOC_TITRE{numero} (numero est un nombre entier)
// Un bloc deplie ou replie : ajouter l'argument 'visible' ou 'invisible' : #BLOC_TITRE{visible}
// Par defaut : les blocs sont replies
function balise_BLOC_TITRE($p) {
// Les arguments : 'visible' ou 'invisible', un numero, une URL
$p->code = "blocs_balises('titre', array(".blocs_arguments($p).'))';
$p->interdire_scripts = false;
return $p;
}
function blocs_arguments(&$p) {
$i = 0; $args = array();
while(($a = interprete_argument_balise(++$i,$p)) != NULL) $args[] = $a;
return implode(",", $args);
}
// 3 balises obsoletes
function balise_BLOC_TITRE_NUM(&$p) {return balise_BLOC_TITRE($p);}
function balise_BLOC_VISIBLE_TITRE_NUM(&$p) {return balise_BLOC_VISIBLE_TITRE($p);}
function balise_BLOC_VISIBLE_TITRE(&$p) {
// Produire le premier argument {visible}
$texte = new Texte; $texte->type='texte'; $texte->texte='visible';
array_unshift($p->param, array(0=>NULL, 1=>array(0=>$texte)));
return balise_BLOC_TITRE($p);
}
function balise_BLOC_RESUME($p) {
$p->code = "blocs_balises('resume')";
$p->interdire_scripts = false;
return $p;
}
function balise_BLOC_DEBUT($p) {
$p->code = "blocs_balises('debut', array(".blocs_arguments($p).'))';
$p->interdire_scripts = false;
return $p;
}
function balise_BLOC_FIN($p) {
$p->code = "blocs_balises('fin')";
$p->interdire_scripts = false;
return $p;
}
function balise_BLOC_TITRE_DEBUT($p) {
$p->code = "blocs_balises('titre_debut', array(".blocs_arguments($p).'))';
$p->interdire_scripts = false;
return $p;
}
function balise_BLOC_TITRE_FIN($p) {
$p->code = "blocs_balises('titre_fin')";
$p->interdire_scripts = false;
return $p;
}
// Renvoie un code JQuery pour deplier un bloc au chargement de la page.
// Exemple pour deplier le 5eme bloc : #BLOC_DEPLIER{4} (l'index commence a zero)
function balise_BLOC_DEPLIER($p) {
$eq = interprete_argument_balise(1, $p);
$p->code = "bloc_deplier_script(intval($eq))";
$p->interdire_scripts = false;
return $p;
}
// Renvoie un code JQuery pour deplier un bloc numerote au chargement de la page.
// Exemple pour deplier le bloc .cs_bloc4 : #BLOC_DEPLIER_NUM{4}
function balise_BLOC_DEPLIER_NUM($p) {
$eq = interprete_argument_balise(1, $p);
$p->code = "bloc_num_deplier_script(intval($eq))";
$p->interdire_scripts = false;
return $p;
}
// Renvoie un code JQuery pour courcuiter la variable configurant les blocs uniques
// Argument : oui/non ou 0/1
function balise_BLOC_UNIQUE($p) {
$arg = interprete_argument_balise(1, $p);
$p->code = "bloc_unique_script($arg)";
$p->interdire_scripts = false;
return $p;
}
// fonction (SPIP>=2.0) pour le calcul de la balise #BLOC_DEPLIER
function bloc_deplier_script($num=0) {
return $num<0?'':http_script("jQuery(document).ready(function() { jQuery('"._BLOC_TITRE_H.".blocs_titre').eq($num).click(); });");
}
// fonction (SPIP>=2.0) pour le calcul de la balise #BLOC_DEPLIER_NUM
function bloc_num_deplier_script($num=-1) {
return $num<0?'':http_script("jQuery(document).ready(function() { jQuery('div.cs_bloc$num').children('.blocs_titre').eq(0).click(); });");
}
// fonction (SPIP>=2.0) pour le calcul de la balise #BLOC_UNIQUE
function bloc_unique_script($num=1) {
$num = ($num==='oui' || intval($num)>0)?1:0;
return http_script("var blocs_replier_tout = $num;");
}
// fonction pour le calcul des balises de type #BLOC_XXX
// $args ne sert que pour #BLOC_TITRE et contient les arguments de la balise sous forme de tableau
function blocs_balises($type, $args = array()) {
// statut binaire : bit1=ajax bit2=titre bit3=resume bit4=debut
// 2 = ajax (20 si distant) ; 1 = titre pas d'ajax (10 si distant); idem negatif = bloc visible
static $bloc_stade;
$k = isset($bloc_stade)?count($bloc_stade):0;
$stade = $k?abs($bloc_stade[--$k]):0;
$distant = $replie = 1; $id = $numero = '';
switch($type) {
case 'titre_debut':
// id pour le bloc distant
$id = ' id="cs_bloc_id_' . reset($args) . '"';
$distant = 10;
case 'titre':
foreach($args as $a) {
if(is_numeric($a = trim($a))) $numero = ' cs_bloc'.$a.'" id="deplier_num'.$a;
elseif($a=='visible') $replie = -1;
elseif($a=='invisible') $replie = 1;
elseif(strlen($a)) $fragment = $a;
}
if (isset($fragment)){
$ajax = ' blocs_ajax ';
$bloc_stade[] = 2*$distant*$replie;
} else {
$fragment = "javascript:;";
$ajax = '';
$bloc_stade[] = 1*$distant*$replie;
}
$replie = $replie>0?' blocs_replie':'';
return "<div class=\"cs_blocs$numero\"><"._BLOC_TITRE_H." class=\"blocs_titre$replie$ajax\"$id><a href=\"$fragment\">";
case 'resume':
$class = $bloc_stade[$k]>0?'':' blocs_invisible blocs_slide';
if($stade<1 || $stade>2) // on DOIT arriver de titre
die("Erreur : #BLOC_RESUME sans #BLOC_TITRE ($stade)");
$bloc_stade[$k] = $bloc_stade[$k]>0?3:-3; // 3 = resume
return "</a></"._BLOC_TITRE_H."><div class=\"blocs_resume$class\">";
case 'debut':
if(count($args)) {
// debut d'un bloc depliable a distance
foreach($args as $a) {
if($a=='visible') $replie = -1;
elseif($a=='invisible') $replie = 1;
elseif(strlen($a)) $id = " cs_bloc_id_$a";
}
$bloc_stade[]=11;
$class = $replie>0?' blocs_invisible blocs_slide':'';
return "<div class=\"blocs_destination$class$id\">";
}
$class = $bloc_stade[$k]<0?'':' blocs_invisible blocs_slide';
$bloc_stade[$k]=$bloc_stade[$k]>0?4:-4; // 4=debut
if($stade == 3) // on arrive du resume, fermer la div resume seulement
return "</div><div class=\"blocs_destination$class\">";
else {
if($stade<1 || $stade>2) // on DOIT arriver de titre
die("Erreur : #BLOC_DEBUT sans #BLOC_TITRE ($stade)");
return '</a></'._BLOC_TITRE_H."><div class=\"blocs_destination$class\">";
}
case 'titre_fin':
$k = isset($bloc_stade)?abs(array_pop($bloc_stade)):0;
if($k==10 || $k==20) // on DOIT arriver de #BLOC_TITRE_DEBUT
return '</a></'._BLOC_TITRE_H.'></div>';
die("Erreur : #BLOC_TITRE_FIN sans #BLOC_TITRE_DEBUT ($k)");
case 'fin':
$k = isset($bloc_stade)?abs(array_pop($bloc_stade)):0;
switch($k) {
case 4: return "</div></div>";
case 11: return "</div>";
default: die("Erreur : #BLOC_FIN sans #BLOC_DEBUT ($k)");
}
}
}
} // if(!function_exists('balise_BLOC_TITRE'))
?>