dépôts / ptitvelo / web / www.git / blob
? search:


8c42d44ffdac4d1c30e1b600a1a75e213a62a8b5
[ptitvelo/web/www.git] / www / ecrire / inc / filtres.php
1 <?php
2
3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
5 * *
6 * Copyright (c) 2001-2012 *
7 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
8 * *
9 * Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
10 * Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
11 \***************************************************************************/
12
13 if (!defined('_ECRIRE_INC_VERSION')) return;
14
15 include_spip('inc/charsets');
16 include_spip('inc/filtres_mini');
17 include_spip('base/objets');
18 include_spip('public/parametrer'); // charger les fichiers fonctions
19
20 /**
21 * Charger un filtre depuis le php :
22 * - on inclue tous les fichiers fonctions des plugins et du skel
23 * - on appelle chercher_filtre
24 *
25 * @param string $fonc
26 * @param string $default
27 * @return string
28 */
29 function charger_filtre($fonc, $default='filtre_identite_dist') {
30 include_spip('public/parametrer'); // inclure les fichiers fonctions
31 return chercher_filtre($fonc, $default);
32 }
33
34 function filtre_identite_dist($texte){return $texte;}
35
36 /**
37 * http://doc.spip.org/@chercher_filtre
38 *
39 * @param string $fonc
40 * @param null $default
41 * @return string
42 */
43 function chercher_filtre($fonc, $default=NULL) {
44 if (!$fonc) return $default;
45 // Cas des types mime, sans confondre avec les appels de fonction de classe
46 // Foo::Bar
47 // qui peuvent etre avec un namespace : space\Foo::Bar
48 if (preg_match(',^[\w]+/,',$fonc)){
49 $nom = preg_replace(',\W,','_', $fonc);
50 $f = chercher_filtre($nom);
51 // cas du sous-type MIME sans filtre associe, passer au type:
52 // si filtre_text_plain pas defini, passe a filtre_text
53 if (!$f AND $nom!==$fonc)
54 $f = chercher_filtre(preg_replace(',\W.*$,','', $fonc));
55 return $f;
56 }
57 foreach (
58 array('filtre_'.$fonc, 'filtre_'.$fonc.'_dist', $fonc) as $f){
59 if (isset( $GLOBALS['spip_matrice'][$f]) AND is_string($g = $GLOBALS['spip_matrice'][$f]))
60 find_in_path($g,'', true);
61 if (function_exists($f)
62 OR (preg_match("/^(\w*)::(\w*)$/", $f, $regs)
63 AND is_callable(array($regs[1], $regs[2]))
64 )) {
65 return $f;
66 }
67 }
68 return $default;
69 }
70
71 /**
72 * Applique un filtre
73 *
74 * Fonction générique qui prend en argument l’objet (texte, etc) à modifier
75 * et le nom du filtre. Retrouve les arguments du filtre demandé dans les arguments
76 * transmis à cette fonction, via func_get_args().
77 *
78 * @see filtrer() Assez proche
79 *
80 * @param string $arg
81 * Texte sur lequel appliquer le filtre
82 * @param string $filtre
83 * Nom du filtre a appliquer
84 * @param string $force
85 * La fonction doit-elle retourner le texte ou rien ?
86 * @return string
87 * Texte avec le filtre appliqué s'il a été trouvé,
88 * Texte sans le filtre appliqué s'il n'a pas été trouvé et que $force n'a
89 * pas été fourni,
90 * Chaîne vide si le filtre n'a pas été trouvé et que $force a été fourni.
91 **/
92 function appliquer_filtre($arg, $filtre, $force=NULL) {
93 $f = chercher_filtre($filtre);
94 if (!$f) {
95 if (!$force) return '';
96 else return $arg;
97 }
98
99 $args = func_get_args();
100 array_shift($args); // enlever $arg
101 array_shift($args); // enlever $filtre
102 array_unshift($args, $arg); // remettre $arg
103 return call_user_func_array($f,$args);
104 }
105
106 // http://doc.spip.org/@spip_version
107 function spip_version() {
108 $version = $GLOBALS['spip_version_affichee'];
109 if ($svn_revision = version_svn_courante(_DIR_RACINE))
110 $version .= ($svn_revision<0 ? ' SVN':'').' ['.abs($svn_revision).']';
111 return $version;
112 }
113
114
115 //
116 // Mention de la revision SVN courante de l'espace restreint standard
117 // (numero non garanti pour l'espace public et en cas de mutualisation)
118 // on est negatif si on est sur .svn, et positif si on utilise svn.revision
119 // http://doc.spip.org/@version_svn_courante
120 function version_svn_courante($dir) {
121 if (!$dir) $dir = '.';
122
123 // version installee par paquet ZIP
124 if (lire_fichier($dir.'/svn.revision', $c)
125 AND preg_match(',Revision: (\d+),', $c, $d))
126 return intval($d[1]);
127
128 // version installee par SVN
129 if (lire_fichier($dir . '/.svn/entries', $c)
130 AND (
131 (preg_match_all(
132 ',committed-rev="([0-9]+)",', $c, $r1, PREG_PATTERN_ORDER)
133 AND $v = max($r1[1])
134 )
135 OR
136 (preg_match(',^\d.*dir[\r\n]+(\d+),ms', $c, $r1) # svn >= 1.4
137 AND $v = $r1[1]
138 )))
139 return -$v;
140
141 // Bug ou paquet fait main
142 return 0;
143 }
144
145 // La matrice est necessaire pour ne filtrer _que_ des fonctions definies dans filtres_images
146 // et laisser passer les fonctions personnelles baptisees image_...
147 $GLOBALS['spip_matrice']['image_graver'] = true;//'inc/filtres_images_mini.php';
148 $GLOBALS['spip_matrice']['image_select'] = true;//'inc/filtres_images_mini.php';
149 $GLOBALS['spip_matrice']['image_reduire'] = true;//'inc/filtres_images_mini.php';
150 $GLOBALS['spip_matrice']['image_reduire_par'] = true;//'inc/filtres_images_mini.php';
151 $GLOBALS['spip_matrice']['image_passe_partout'] = true;//'inc/filtres_images_mini.php';
152
153 $GLOBALS['spip_matrice']['couleur_html_to_hex'] = 'inc/filtres_images_mini.php';
154 $GLOBALS['spip_matrice']['couleur_foncer'] = 'inc/filtres_images_mini.php';
155 $GLOBALS['spip_matrice']['couleur_eclaircir'] = 'inc/filtres_images_mini.php';
156
157 // ou pour inclure un script au moment ou l'on cherche le filtre
158 $GLOBALS['spip_matrice']['filtre_image_dist'] = 'inc/filtres_mime.php';
159 $GLOBALS['spip_matrice']['filtre_audio_dist'] = 'inc/filtres_mime.php';
160 $GLOBALS['spip_matrice']['filtre_video_dist'] = 'inc/filtres_mime.php';
161 $GLOBALS['spip_matrice']['filtre_application_dist'] = 'inc/filtres_mime.php';
162 $GLOBALS['spip_matrice']['filtre_message_dist'] = 'inc/filtres_mime.php';
163 $GLOBALS['spip_matrice']['filtre_multipart_dist'] = 'inc/filtres_mime.php';
164 $GLOBALS['spip_matrice']['filtre_text_dist'] = 'inc/filtres_mime.php';
165 $GLOBALS['spip_matrice']['filtre_text_csv_dist'] = 'inc/filtres_mime.php';
166 $GLOBALS['spip_matrice']['filtre_text_html_dist'] = 'inc/filtres_mime.php';
167 $GLOBALS['spip_matrice']['filtre_audio_x_pn_realaudio'] = 'inc/filtres_mime.php';
168
169
170 // charge les fonctions graphiques et applique celle demandee
171 // http://doc.spip.org/@filtrer
172 function filtrer($filtre) {
173 if (isset($GLOBALS['spip_matrice'][$filtre]) and is_string($f = $GLOBALS['spip_matrice'][$filtre])){
174 find_in_path($f,'', true);
175 $GLOBALS['spip_matrice'][$filtre] = true;
176 }
177 $tous = func_get_args();
178 if (substr($filtre,0,6)=='image_' && $GLOBALS['spip_matrice'][$filtre])
179 return image_filtrer($tous);
180 elseif($f = chercher_filtre($filtre)) {
181 array_shift($tous);
182 return call_user_func_array($f, $tous);
183 }
184 else {
185 // le filtre n'existe pas, on provoque une erreur
186 $msg = array('zbug_erreur_filtre', array('filtre'=>texte_script($filtre)));
187 erreur_squelette($msg);
188 return '';
189 }
190 }
191
192 // fonction generique d'entree des filtres images
193 // accepte en entree un texte complet, un img-log (produit par #LOGO_XX),
194 // un tag <img ...> complet, ou encore un nom de fichier *local* (passer
195 // le filtre |copie_locale si on veut l'appliquer a un document)
196 // applique le filtre demande a chacune des occurrences
197
198 // http://doc.spip.org/@image_filtrer
199 function image_filtrer($args){
200 $filtre = array_shift($args); # enlever $filtre
201 $texte = array_shift($args);
202 if (!strlen($texte)) return;
203 find_in_path('filtres_images_mini.php','inc/', true);
204 statut_effacer_images_temporaires(true); // activer la suppression des images temporaires car le compilo finit la chaine par un image_graver
205 // Cas du nom de fichier local
206 if ( strpos(substr($texte,strlen(_DIR_RACINE)),'..')===FALSE
207 AND !preg_match(',^/|[<>]|\s,S', $texte)
208 AND (
209 file_exists(preg_replace(',[?].*$,','',$texte))
210 OR preg_match(';^(\w{3,7}://);', $texte)
211 )) {
212 array_unshift($args,"<img src='$texte' />");
213 $res = call_user_func_array($filtre, $args);
214 statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
215 return $res;
216 }
217
218 // Cas general : trier toutes les images, avec eventuellement leur <span>
219 if (preg_match_all(
220 ',(<([a-z]+) [^<>]*spip_documents[^<>]*>)?\s*(<img\s.*>),UimsS',
221 $texte, $tags, PREG_SET_ORDER)) {
222 foreach ($tags as $tag) {
223 $class = extraire_attribut($tag[3],'class');
224 if (!$class || (strpos($class,'no_image_filtrer')===FALSE)){
225 array_unshift($args,$tag[3]);
226 if ($reduit = call_user_func_array($filtre, $args)) {
227 // En cas de span spip_documents, modifier le style=...width:
228 if($tag[1]){
229 $w = extraire_attribut($reduit, 'width');
230 if (!$w AND preg_match(",width:\s*(\d+)px,S",extraire_attribut($reduit,'style'),$regs))
231 $w = $regs[1];
232 if ($w AND ($style = extraire_attribut($tag[1], 'style'))){
233 $style = preg_replace(",width:\s*\d+px,S", "width:${w}px", $style);
234 $replace = inserer_attribut($tag[1], 'style', $style);
235 $texte = str_replace($tag[1], $replace, $texte);
236 }
237 }
238 // traiter aussi un eventuel mouseover
239 if ($mouseover = extraire_attribut($reduit,'onmouseover')){
240 if (preg_match(",this[.]src=['\"]([^'\"]+)['\"],ims", $mouseover, $match)){
241 $srcover = $match[1];
242 array_shift($args);
243 array_unshift($args,"<img src='".$match[1]."' />");
244 $srcover_filter = call_user_func_array($filtre, $args);
245 $srcover_filter = extraire_attribut($srcover_filter,'src');
246 $reduit = str_replace($srcover,$srcover_filter,$reduit);
247 }
248 }
249 $texte = str_replace($tag[3], $reduit, $texte);
250 }
251 array_shift($args);
252 }
253 }
254 }
255 statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
256 return $texte;
257 }
258
259 //
260 // Retourner taille d'une image
261 // pour les filtres |largeur et |hauteur
262 //
263 // http://doc.spip.org/@taille_image
264 function taille_image($img) {
265
266 static $largeur_img =array(), $hauteur_img= array();
267 $srcWidth = 0;
268 $srcHeight = 0;
269
270 $logo = extraire_attribut($img,'src');
271
272 if (!$logo) $logo = $img;
273 else {
274 $srcWidth = extraire_attribut($img,'width');
275 $srcHeight = extraire_attribut($img,'height');
276 }
277
278 // ne jamais operer directement sur une image distante pour des raisons de perfo
279 // la copie locale a toutes les chances d'etre la ou de resservir
280 if (preg_match(';^(\w{3,7}://);', $logo)){
281 include_spip('inc/distant');
282 $fichier = copie_locale($logo);
283 $logo = $fichier ? _DIR_RACINE . $fichier : $logo;
284 }
285 if (($p=strpos($logo,'?'))!==FALSE)
286 $logo=substr($logo,0,$p);
287
288 $srcsize = false;
289 if (isset($largeur_img[$logo]))
290 $srcWidth = $largeur_img[$logo];
291 if (isset($hauteur_img[$logo]))
292 $srcHeight = $hauteur_img[$logo];
293 if (!$srcWidth OR !$srcHeight){
294 if (file_exists($logo)
295 AND $srcsize = @getimagesize($logo)){
296 if (!$srcWidth) $largeur_img[$logo] = $srcWidth = $srcsize[0];
297 if (!$srcHeight) $hauteur_img[$logo] = $srcHeight = $srcsize[1];
298 }
299 // $logo peut etre une reference a une image temporaire dont a n'a que le log .src
300 // on s'y refere, l'image sera reconstruite en temps utile si necessaire
301 elseif(@file_exists($f = "$logo.src")
302 AND lire_fichier($f,$valeurs)
303 AND $valeurs=unserialize($valeurs)) {
304 if (!$srcWidth) $largeur_img[$logo] = $srcWidth = $valeurs["largeur_dest"];
305 if (!$srcHeight) $hauteur_img[$logo] = $srcHeight = $valeurs["hauteur_dest"];
306 }
307 }
308 return array($srcHeight, $srcWidth);
309 }
310 // http://doc.spip.org/@largeur
311 function largeur($img) {
312 if (!$img) return;
313 list ($h,$l) = taille_image($img);
314 return $l;
315 }
316 // http://doc.spip.org/@hauteur
317 function hauteur($img) {
318 if (!$img) return;
319 list ($h,$l) = taille_image($img);
320 return $h;
321 }
322
323
324 // Echappement des entites HTML avec correction des entites "brutes"
325 // (generees par les butineurs lorsqu'on rentre des caracteres n'appartenant
326 // pas au charset de la page [iso-8859-1 par defaut])
327 //
328 // Attention on limite cette correction aux caracteres "hauts" (en fait > 99
329 // pour aller plus vite que le > 127 qui serait logique), de maniere a
330 // preserver des echappements de caracteres "bas" (par exemple [ ou ")
331 // et au cas particulier de &amp; qui devient &amp;amp; dans les url
332 // http://doc.spip.org/@corriger_entites_html
333 function corriger_entites_html($texte) {
334 if (strpos($texte,'&amp;') === false) return $texte;
335 return preg_replace(',&amp;(#[0-9][0-9][0-9]+;|amp;),iS', '&\1', $texte);
336 }
337 // idem mais corriger aussi les &amp;eacute; en &eacute;
338 // http://doc.spip.org/@corriger_toutes_entites_html
339 function corriger_toutes_entites_html($texte) {
340 if (strpos($texte,'&amp;') === false) return $texte;
341 return preg_replace(',&amp;(#?[a-z0-9]+;),iS', '&\1', $texte);
342 }
343
344 // http://doc.spip.org/@proteger_amp
345 function proteger_amp($texte){
346 return str_replace('&','&amp;',$texte);
347 }
348
349 //
350 /**
351 * http://doc.spip.org/@entites_html
352 *
353 * @param string $texte
354 * chaine a echapper
355 * @param bool $tout
356 * corriger toutes les &amp;xx; en &xx;
357 * @param bool $quote
358 * echapper aussi les simples quotes en &#039;
359 * @return mixed|string
360 */
361 function entites_html($texte, $tout=false, $quote=true) {
362 if (!is_string($texte) OR !$texte
363 OR strpbrk($texte, "&\"'<>")==false
364 ) return $texte;
365 include_spip('inc/texte');
366 $texte = htmlspecialchars(echappe_retour(echappe_html($texte,'',true),'','proteger_amp'),$quote?ENT_QUOTES:(ENT_COMPAT|ENT_HTML401));
367 if ($tout)
368 return corriger_toutes_entites_html($texte);
369 else
370 return corriger_entites_html($texte);
371 }
372
373 // Transformer les &eacute; dans le charset local
374 // http://doc.spip.org/@filtrer_entites
375 function filtrer_entites($texte) {
376 if (strpos($texte,'&') === false) return $texte;
377 // filtrer
378 $texte = html2unicode($texte);
379 // remettre le tout dans le charset cible
380 return unicode2charset($texte);
381 }
382
383 // caracteres de controle - http://www.w3.org/TR/REC-xml/#charsets
384 // http://doc.spip.org/@supprimer_caracteres_illegaux
385 function supprimer_caracteres_illegaux($texte) {
386 static $from = "\x0\x1\x2\x3\x4\x5\x6\x7\x8\xB\xC\xE\xF\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F";
387 static $to = null;
388
389 if (is_array($texte)) {
390 return array_map('corriger_caracteres_windows', $texte);
391 }
392
393 if (!$to) $to = str_repeat('-', strlen($from));
394 return strtr($texte, $from, $to);
395 }
396
397 // Supprimer caracteres windows et les caracteres de controle ILLEGAUX
398 // http://doc.spip.org/@corriger_caracteres
399 function corriger_caracteres ($texte) {
400 $texte = corriger_caracteres_windows($texte);
401 $texte = supprimer_caracteres_illegaux($texte);
402 return $texte;
403 }
404
405 /**
406 * Encode du HTML pour transmission XML
407 * notamment dans les flux RSS
408 *
409 * http://doc.spip.org/@texte_backend
410 *
411 * @param $texte
412 * @return mixed
413 */
414 function texte_backend($texte) {
415
416 static $apostrophe = array("&#8217;", "'"); # n'allouer qu'une fois
417
418 // si on a des liens ou des images, les passer en absolu
419 $texte = liens_absolus($texte);
420
421 // echapper les tags &gt; &lt;
422 $texte = preg_replace(',&(gt|lt);,S', '&amp;\1;', $texte);
423
424 // importer les &eacute;
425 $texte = filtrer_entites($texte);
426
427 // " -> &quot; et tout ce genre de choses
428 $u = $GLOBALS['meta']['pcre_u'];
429 $texte = str_replace("&nbsp;", " ", $texte);
430 $texte = preg_replace('/\s{2,}/S'.$u, " ", $texte);
431 // ne pas echapper les sinqle quotes car certains outils de syndication gerent mal
432 $texte = entites_html($texte, false, false);
433
434 // verifier le charset
435 $texte = charset2unicode($texte);
436
437 // Caracteres problematiques en iso-latin 1
438 if ($GLOBALS['meta']['charset'] == 'iso-8859-1') {
439 $texte = str_replace(chr(156), '&#156;', $texte);
440 $texte = str_replace(chr(140), '&#140;', $texte);
441 $texte = str_replace(chr(159), '&#159;', $texte);
442 }
443
444 // l'apostrophe curly pose probleme a certains lecteure de RSS
445 // et le caractere apostrophe alourdit les squelettes avec PHP
446 // ==> on les remplace par l'entite HTML
447 return str_replace($apostrophe, "'", $texte);
448 }
449
450 // Comme ci-dessus, mais avec addslashes final pour squelettes avec PHP (rss)
451
452 function texte_backendq($texte) {
453 return addslashes(texte_backend($texte));
454 }
455
456 // Enleve le numero des titres numerotes ("1. Titre" -> "Titre")
457 // http://doc.spip.org/@supprimer_numero
458 function supprimer_numero($texte) {
459 return preg_replace(
460 ",^[[:space:]]*([0-9]+)([.)]|".chr(194).'?'.chr(176).")[[:space:]]+,S",
461 "", $texte);
462 }
463
464 // et la fonction inverse
465 // http://doc.spip.org/@recuperer_numero
466 function recuperer_numero($texte) {
467 if (preg_match(
468 ",^[[:space:]]*([0-9]+)([.)]|".chr(194).'?'.chr(176).")[[:space:]]+,S",
469 $texte, $regs))
470 return intval($regs[1]);
471 else
472 return '';
473 }
474
475 // Suppression basique et brutale de tous les <...>
476 // http://doc.spip.org/@supprimer_tags
477 function supprimer_tags($texte, $rempl = "") {
478 $texte = preg_replace(",<[^>]*>,US", $rempl, $texte);
479 // ne pas oublier un < final non ferme
480 // mais qui peut aussi etre un simple signe plus petit que
481 $texte = str_replace('<', ' ', $texte);
482 return $texte;
483 }
484
485 // Convertit les <...> en la version lisible en HTML
486 // http://doc.spip.org/@echapper_tags
487 function echapper_tags($texte, $rempl = "") {
488 $texte = preg_replace("/<([^>]*)>/", "&lt;\\1&gt;", $texte);
489 return $texte;
490 }
491
492 // Convertit un texte HTML en texte brut
493 // http://doc.spip.org/@textebrut
494 function textebrut($texte) {
495 $u = $GLOBALS['meta']['pcre_u'];
496 $texte = preg_replace('/\s+/S'.$u, " ", $texte);
497 $texte = preg_replace("/<(p|br)( [^>]*)?".">/iS", "\n\n", $texte);
498 $texte = preg_replace("/^\n+/", "", $texte);
499 $texte = preg_replace("/\n+$/", "", $texte);
500 $texte = preg_replace("/\n +/", "\n", $texte);
501 $texte = supprimer_tags($texte);
502 $texte = preg_replace("/(&nbsp;| )+/S", " ", $texte);
503 // nettoyer l'apostrophe curly qui pose probleme a certains rss-readers, lecteurs de mail...
504 $texte = str_replace("&#8217;","'",$texte);
505 return $texte;
506 }
507
508 // Remplace les liens SPIP en liens ouvrant dans une nouvelle fenetre (target=blank)
509 // http://doc.spip.org/@liens_ouvrants
510 function liens_ouvrants ($texte) {
511 return preg_replace(",<a\s+([^>]*https?://[^>]*class=[\"']spip_(out|url)\b[^>]+)>,",
512 "<a \\1 target=\"_blank\">", $texte);
513 }
514
515 /**
516 * Ajouter un attribut rel="nofollow" sur tous les liens d'un texte
517 * @param string $texte
518 * @return string
519 */
520 function liens_nofollow($texte) {
521 if (stripos($texte,"<a")===false)
522 return $texte;
523
524 if (preg_match_all(",<a\b[^>]*>,UimsS",$texte, $regs, PREG_PATTERN_ORDER)){
525 foreach($regs[0] as $a){
526 $rel = extraire_attribut($a,"rel");
527 if (strpos($rel,"nofollow")===false){
528 $rel = "nofollow" . ($rel?" $rel":"");
529 $anofollow = inserer_attribut($a,"rel",$rel);
530 $texte = str_replace($a,$anofollow,$texte);
531 }
532 }
533 }
534
535 return $texte;
536 }
537
538 // Transformer les sauts de paragraphe en simples passages a la ligne
539 // http://doc.spip.org/@PtoBR
540 function PtoBR($texte){
541 $u = $GLOBALS['meta']['pcre_u'];
542 $texte = preg_replace("@</p>@iS", "\n", $texte);
543 $texte = preg_replace("@<p\b.*>@UiS", "<br />", $texte);
544 $texte = preg_replace("@^\s*<br />@S".$u, "", $texte);
545 return $texte;
546 }
547
548
549 /**
550 * lignes_longues assure qu'un texte ne vas pas deborder d'un bloc
551 * par la faute d'un mot trop long (souvent des URLs)
552 * Ne devrait plus etre utilise et fait directement en CSS par un style
553 * word-wrap:break-word;
554 * cf http://www.alsacreations.com/tuto/lire/1038-gerer-debordement-contenu-css.html
555 *
556 * Pour assurer la compatibilite du filtre, on encapsule le contenu par
557 * un div ou span portant ce style inline.
558 *
559 * http://doc.spip.org/@lignes_longues
560 *
561 * @param string $texte
562 * @return string
563 */
564 function lignes_longues($texte) {
565 if (!strlen(trim($texte))) return $texte;
566 include_spip('inc/texte');
567 $tag = preg_match(',</?('._BALISES_BLOCS.')[>[:space:]],iS', $texte) ?
568 'div' : 'span';
569
570 return "<$tag style='word-wrap:break-word;'>$texte</$tag>";
571 }
572
573 // Majuscules y compris accents, en HTML
574 // http://doc.spip.org/@majuscules
575 function majuscules($texte) {
576 if (!strlen($texte)) return '';
577
578 // Cas du turc
579 if ($GLOBALS['spip_lang'] == 'tr') {
580 # remplacer hors des tags et des entites
581 if (preg_match_all(',<[^<>]+>|&[^;]+;,S', $texte, $regs, PREG_SET_ORDER))
582 foreach ($regs as $n => $match)
583 $texte = str_replace($match[0], "@@SPIP_TURC$n@@", $texte);
584
585 $texte = str_replace('i', '&#304;', $texte);
586
587 if ($regs)
588 foreach ($regs as $n => $match)
589 $texte = str_replace("@@SPIP_TURC$n@@", $match[0], $texte);
590 }
591
592 // Cas general
593 return "<span style='text-transform: uppercase;'>$texte</span>";
594 }
595
596 // "127.4 ko" ou "3.1 Mo"
597 // http://doc.spip.org/@taille_en_octets
598 function taille_en_octets ($taille) {
599 if ($taille < 1) return '';
600 if ($taille < 1024) {$taille = _T('taille_octets', array('taille' => $taille));}
601 else if ($taille < 1024*1024) {
602 $taille = _T('taille_ko', array('taille' => round($taille/1024, 1)));
603 } else if ($taille < 1024*1024*1024) {
604 $taille = _T('taille_mo', array('taille' => round($taille/1024/1024, 1)));
605 } else {
606 $taille = _T('taille_go', array('taille' => round($taille/1024/1024/1024, 2)));
607 }
608 return $taille;
609 }
610
611
612 // Rend une chaine utilisable sans dommage comme attribut HTML
613 // http://doc.spip.org/@attribut_html
614 function attribut_html($texte,$textebrut = true) {
615 $u = $GLOBALS['meta']['pcre_u'];
616 if ($textebrut)
617 $texte = preg_replace(array(",\n,",",\s(?=\s),msS".$u),array(" ",""),textebrut($texte));
618 $texte = texte_backend($texte);
619 $texte = str_replace(array("'",'"'),array('&#039;', '&#034;'), $texte);
620
621 return preg_replace(array("/&(amp;|#38;)/","/&(?![A-Za-z]{0,4}\w{2,3};|#[0-9]{2,5};)/"),array("&","&#38;") , $texte);
622 }
623
624 // Vider les url nulles comme 'http://' ou 'mailto:'
625 // et leur appliquer un htmlspecialchars() + gerer les &amp;
626 // http://doc.spip.org/@vider_url
627 function vider_url($url, $entites = true) {
628 # un message pour abs_url
629 $GLOBALS['mode_abs_url'] = 'url';
630 $url = trim($url);
631 $r = ",^(?:" . _PROTOCOLES_STD . '):?/?/?$,iS';
632 return preg_match($r, $url) ? '': ($entites ? entites_html($url) : $url);
633 }
634
635 // Extraire une date de n'importe quel champ (a completer...)
636 // http://doc.spip.org/@extraire_date
637 function extraire_date($texte) {
638 // format = 2001-08
639 if (preg_match(",([1-2][0-9]{3})[^0-9]*(1[0-2]|0?[1-9]),",$texte,$regs))
640 return $regs[1]."-".sprintf("%02d", $regs[2])."-01";
641 }
642
643 // Maquiller une adresse e-mail
644 // http://doc.spip.org/@antispam
645 function antispam($texte) {
646 include_spip('inc/acces');
647 $masque = creer_pass_aleatoire(3);
648 return preg_replace("/@/", " $masque ", $texte);
649 }
650
651 // http://doc.spip.org/@securiser_acces
652 function securiser_acces($id_auteur, $cle, $dir, $op='', $args='')
653 {
654 include_spip('inc/acces');
655 if ($op) $dir .= " $op $args";
656 return verifier_low_sec($id_auteur, $cle, $dir);
657 }
658
659 /**
660 * La fonction sinon retourne le second parametre lorsque
661 * le premier est considere vide, sinon retourne le premier parametre.
662 *
663 * En php sinon($a, 'rien') retourne $a ou 'rien' si $a est vide.
664 * En filtre spip |sinon{#TEXTE, rien} : affiche #TEXTE ou "rien" si #TEXTE est vide,
665 *
666 * Note : l'utilisation de |sinon en tant que filtre de squelette
667 * est directement compile dans public/references par la fonction filtre_logique()
668 *
669 * @param mixed $texte
670 * Contenu de reference a tester
671 * @param mixed $sinon
672 * Contenu a retourner si le contenu de reference est vide
673 * @return mixed
674 * Retourne $texte, sinon $sinon.
675 **/
676 function sinon ($texte, $sinon='') {
677 if ($texte OR (!is_array($texte) AND strlen($texte)))
678 return $texte;
679 else
680 return $sinon;
681 }
682
683 // |choixsivide{vide,pasvide} affiche pasvide si la chaine n'est pas vide...
684 // http://doc.spip.org/@choixsivide
685 function choixsivide($a, $vide, $pasvide) {
686 return $a ? $pasvide : $vide;
687 }
688
689 // |choixsiegal{aquoi,oui,non} affiche oui si la chaine est egal a aquoi ...
690 // http://doc.spip.org/@choixsiegal
691 function choixsiegal($a1,$a2,$v,$f) {
692 return ($a1 == $a2) ? $v : $f;
693 }
694
695
696 //
697 // Date, heure, saisons
698 //
699
700 // on normalise la date, si elle vient du contexte (public/parametrer.php), on force le jour
701 // http://doc.spip.org/@normaliser_date
702 function normaliser_date($date, $forcer_jour = false) {
703 $date = vider_date($date);
704 if ($date) {
705 if (preg_match("/^[0-9]{8,10}$/", $date))
706 $date = date("Y-m-d H:i:s", $date);
707 if (preg_match("#^([12][0-9]{3})([-/]00)?( [-0-9:]+)?$#", $date, $regs))
708 $date = $regs[1]."-00-00".$regs[3];
709 else if (preg_match("#^([12][0-9]{3}[-/][01]?[0-9])([-/]00)?( [-0-9:]+)?$#", $date, $regs))
710 $date = preg_replace("@/@","-",$regs[1])."-00".$regs[3];
711 else
712 $date = date("Y-m-d H:i:s", strtotime($date));
713
714 if ($forcer_jour)
715 $date = str_replace('-00', '-01', $date);
716 }
717 return $date;
718 }
719
720 // http://doc.spip.org/@vider_date
721 function vider_date($letexte) {
722 if (strncmp("0000-00-00", $letexte,10)==0) return '';
723 if (strncmp("0001-01-01", $letexte,10)==0) return '';
724 if (strncmp("1970-01-01", $letexte,10)==0) return ''; // eviter le bug GMT-1
725 return $letexte;
726 }
727
728 // http://doc.spip.org/@recup_heure
729 function recup_heure($date){
730
731 static $d = array(0,0,0);
732 if (!preg_match('#([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})#', $date, $r))
733 return $d;
734
735 array_shift($r);
736 return $r;
737 }
738
739 // http://doc.spip.org/@heures
740 function heures($numdate) {
741 $date_array = recup_heure($numdate);
742 if ($date_array)
743 list($heures, $minutes, $secondes) = $date_array;
744 return $heures;
745 }
746
747 // http://doc.spip.org/@minutes
748 function minutes($numdate) {
749 $date_array = recup_heure($numdate);
750 if ($date_array)
751 list($heures, $minutes, $secondes) = $date_array;
752 return $minutes;
753 }
754
755 // http://doc.spip.org/@secondes
756 function secondes($numdate) {
757 $date_array = recup_heure($numdate);
758 if ($date_array)
759 list($heures,$minutes,$secondes) = $date_array;
760 return $secondes;
761 }
762
763 // http://doc.spip.org/@heures_minutes
764 function heures_minutes($numdate) {
765 return _T('date_fmt_heures_minutes', array('h'=> heures($numdate), 'm'=> minutes($numdate)));
766 }
767
768 // http://doc.spip.org/@recup_date
769 function recup_date($numdate, $forcer_jour = true){
770 if (!$numdate) return '';
771 $heures = $minutes = $secondes = 0;
772 if (preg_match('#([0-9]{1,2})/([0-9]{1,2})/([0-9]{4}|[0-9]{1,2})#', $numdate, $regs)) {
773 $jour = $regs[1];
774 $mois = $regs[2];
775 $annee = $regs[3];
776 if ($annee < 90){
777 $annee = 2000 + $annee;
778 } elseif ($annee<100) {
779 $annee = 1900 + $annee ;
780 }
781 list($heures, $minutes, $secondes) = recup_heure($numdate);
782
783 }
784 elseif (preg_match('#([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})#',$numdate, $regs)) {
785 $annee = $regs[1];
786 $mois = $regs[2];
787 $jour = $regs[3];
788 list($heures, $minutes, $secondes) = recup_heure($numdate);
789 }
790 elseif (preg_match('#([0-9]{4})-([0-9]{2})#', $numdate, $regs)){
791 $annee = $regs[1];
792 $mois = $regs[2];
793 $jour ='';
794 list($heures, $minutes, $secondes) = recup_heure($numdate);
795 }
796 elseif (preg_match('#^([0-9]{4})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})$#', $numdate, $regs)){
797 $annee = $regs[1];
798 $mois = $regs[2];
799 $jour = $regs[3];
800 $heures = $regs[4];
801 $minutes = $regs[5];
802 $secondes = $regs[6];
803 } else $annee = $mois = $jour ='';
804 if ($annee > 4000) $annee -= 9000;
805 if (substr($jour, 0, 1) == '0') $jour = substr($jour, 1);
806
807 if ($forcer_jour AND $jour == '0') $jour = '1';
808 if ($forcer_jour AND $mois == '0') $mois = '1';
809 if ($annee OR $mois OR $jour OR $heures OR $minutes OR $secondes)
810 return array($annee, $mois, $jour, $heures, $minutes, $secondes);
811 }
812
813 // une date pour l'interface : utilise date_relative si le decalage
814 // avec time() est de moins de douze heures, sinon la date complete
815 // http://doc.spip.org/@date_interface
816 function date_interface($date, $decalage_maxi = 43200/* 12*3600 */) {
817 return sinon(
818 date_relative($date, $decalage_maxi),
819 affdate_heure($date)
820 );
821 }
822
823 // http://doc.spip.org/@date_relative
824 function date_relative($date, $decalage_maxi=0,$ref_date=null) {
825
826 if (is_null($ref_date))
827 $ref_time = time();
828 else
829 $ref_time = strtotime($ref_date);
830
831 if (!$date) return;
832 $decal = date("U",$ref_time) - date("U", strtotime($date));
833
834 if ($decalage_maxi AND ($decal > $decalage_maxi OR $decal < 0))
835 return '';
836
837 if ($decal < 0) {
838 $il_y_a = "date_dans";
839 $decal = -1 * $decal;
840 } else {
841 $il_y_a = "date_il_y_a";
842 }
843
844 if ($decal > 3600 * 24 * 30 * 6)
845 return affdate_court($date);
846
847 if ($decal > 3600 * 24 * 30) {
848 $mois = floor ($decal / (3600 * 24 * 30));
849 if ($mois < 2)
850 $delai = "$mois "._T("date_un_mois");
851 else
852 $delai = "$mois "._T("date_mois");
853 }
854 else if ($decal > 3600 * 24 * 7) {
855 $semaines = floor ($decal / (3600 * 24 * 7));
856 if ($semaines < 2)
857 $delai = "$semaines "._T("date_une_semaine");
858 else
859 $delai = "$semaines "._T("date_semaines");
860 }
861 else if ($decal > 3600 * 24) {
862 $jours = floor ($decal / (3600 * 24));
863 if ($jours < 2)
864 return $il_y_a=="date_dans"?_T("date_demain"):_T("date_hier");
865 else
866 $delai = "$jours "._T("date_jours");
867 }
868 else if ($decal >= 3600) {
869 $heures = floor ($decal / 3600);
870 if ($heures < 2)
871 $delai = "$heures "._T("date_une_heure");
872 else
873 $delai = "$heures "._T("date_heures");
874 }
875 else if ($decal >= 60) {
876 $minutes = floor($decal / 60);
877 if ($minutes < 2)
878 $delai = "$minutes "._T("date_une_minute");
879 else
880 $delai = "$minutes "._T("date_minutes");
881 } else {
882 $secondes = ceil($decal);
883 if ($secondes < 2)
884 $delai = "$secondes "._T("date_une_seconde");
885 else
886 $delai = "$secondes "._T("date_secondes");
887 }
888
889 return _T($il_y_a, array("delai"=> $delai));
890 }
891
892
893 // http://doc.spip.org/@date_relativecourt
894 function date_relativecourt($date, $decalage_maxi=0) {
895
896 if (!$date) return;
897 $decal = date("U",strtotime(date('Y-m-d'))-strtotime(date('Y-m-d',strtotime($date))));
898
899 if ($decalage_maxi AND ($decal > $decalage_maxi OR $decal < 0))
900 return '';
901
902 if ($decal < -24*3600) {
903 $retour = date_relative($date, $decalage_maxi);
904 }
905 elseif ($decal < 0) {
906 $retour = _T("date_demain");
907 }
908 else if ($decal < (3600 * 24) ) {
909 $retour = _T("date_aujourdhui");
910 }
911 else if ($decal < (3600 * 24 *2) ) {
912 $retour = _T("date_hier");
913 }
914 else {
915 $retour = date_relative($date, $decalage_maxi);
916 }
917
918
919
920 return $retour;
921 }
922
923 /**
924 * Formatage humain de la date $numdate selon le format $vue
925 * http://doc.spip.org/@affdate_base
926 *
927 * @param $numdate
928 * @param $vue
929 * @param array $options
930 * param : 'abbr' ou 'initiale' permet d'afficher les jours au format court ou initiale
931 * annee_courante : permet de definir l'annee de reference pour l'affichage des dates courtes
932 * @return mixed|string
933 */
934 function affdate_base($numdate, $vue, $options = array()) {
935 if (is_string($options))
936 $options = array('param'=>$options);
937 $date_array = recup_date($numdate, false);
938 if (!$date_array) return;
939 list($annee, $mois, $jour, $heures, $minutes, $secondes)= $date_array;
940
941 // 1er, 21st, etc.
942 $journum = $jour;
943
944 if ($jour == 0) {
945 $jour = '';
946 } else {
947 $njour = intval($jour);
948 if ($jourth = _T('date_jnum'.$jour))
949 $jour = $jourth;
950 }
951
952 $mois = intval($mois);
953 if ($mois > 0 AND $mois < 13) {
954 $nommois = _T('date_mois_'.$mois);
955 if ($jour)
956 $jourmois = _T('date_de_mois_'.$mois, array('j'=>$jour, 'nommois'=>$nommois));
957 else
958 $jourmois = $nommois;
959 } else $nommois = '';
960
961 if ($annee < 0) {
962 $annee = -$annee." "._T('date_avant_jc');
963 $avjc = true;
964 }
965 else $avjc = false;
966
967 switch ($vue) {
968 case 'saison':
969 $saison = '';
970 if ($mois > 0){
971 $saison = 1;
972 if (($mois == 3 AND $jour >= 21) OR $mois > 3) $saison = 2;
973 if (($mois == 6 AND $jour >= 21) OR $mois > 6) $saison = 3;
974 if (($mois == 9 AND $jour >= 21) OR $mois > 9) $saison = 4;
975 if (($mois == 12 AND $jour >= 21) OR $mois > 12) $saison = 1;
976 }
977 return $saison?_T('date_saison_'.$saison):'';
978
979 case 'court':
980 if ($avjc) return $annee;
981 $a = ((isset($options['annee_courante']) AND $options['annee_courante'])?$options['annee_courante']:date('Y'));
982 if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
983 if ($annee != $a) return _T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>spip_ucfirst($nommois), 'annee'=>$annee));
984 return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
985
986 case 'jourcourt':
987 if ($avjc) return $annee;
988 $a = ((isset($options['annee_courante']) AND $options['annee_courante'])?$options['annee_courante']:date('Y'));
989 if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
990 if ($annee != $a) return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
991 return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
992
993 case 'entier':
994 if ($avjc) return $annee;
995 if ($jour)
996 return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
997 elseif ($mois)
998 return trim(_T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
999 else
1000 return $annee;
1001
1002 case 'nom_mois':
1003 $param = ((isset($options['param']) AND $options['param']) ? '_'.$options['param'] : '');
1004 if ($param and $mois) {
1005 return _T('date_mois_'.$mois.$param);
1006 }
1007 return $nommois;
1008
1009 case 'mois':
1010 return sprintf("%02s",$mois);
1011
1012 case 'jour':
1013 return $jour;
1014
1015 case 'journum':
1016 return $journum;
1017
1018 case 'nom_jour':
1019 if (!$mois OR !$njour)
1020 return '';
1021 $nom = mktime(1,1,1,$mois,$njour,$annee);
1022 $nom = 1+date('w',$nom);
1023 $param = ((isset($options['param']) AND $options['param']) ? '_'.$options['param'] : '');
1024 return _T('date_jour_'.$nom.$param);
1025
1026 case 'mois_annee':
1027 if ($avjc) return $annee;
1028 return trim(_T('date_fmt_mois_annee', array('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
1029
1030 case 'annee':
1031 return $annee;
1032
1033 // Cas d'une vue non definie : retomber sur le format
1034 // de date propose par http://www.php.net/date
1035 default:
1036 return date($vue, strtotime($numdate));
1037 }
1038 }
1039
1040 // http://doc.spip.org/@nom_jour
1041 function nom_jour($numdate, $forme = '') {
1042 if(!($forme == 'abbr' OR $forme == 'initiale')) $forme = '';
1043 return affdate_base($numdate, 'nom_jour', $forme);
1044 }
1045
1046 // http://doc.spip.org/@jour
1047 function jour($numdate) {
1048 return affdate_base($numdate, 'jour');
1049 }
1050
1051 // http://doc.spip.org/@journum
1052 function journum($numdate) {
1053 return affdate_base($numdate, 'journum');
1054 }
1055
1056 // http://doc.spip.org/@mois
1057 function mois($numdate) {
1058 return affdate_base($numdate, 'mois');
1059 }
1060
1061 // http://doc.spip.org/@nom_mois
1062 function nom_mois($numdate, $forme='') {
1063 if(!($forme == 'abbr')) $forme = '';
1064 return affdate_base($numdate, 'nom_mois', $forme);
1065 }
1066
1067 // http://doc.spip.org/@annee
1068 function annee($numdate) {
1069 return affdate_base($numdate, 'annee');
1070 }
1071
1072 // http://doc.spip.org/@saison
1073 function saison($numdate) {
1074 return affdate_base($numdate, 'saison');
1075 }
1076
1077 // http://doc.spip.org/@affdate
1078 function affdate($numdate, $format='entier') {
1079 return affdate_base($numdate, $format);
1080 }
1081
1082 // http://doc.spip.org/@affdate_court
1083 function affdate_court($numdate, $annee_courante=null) {
1084 return affdate_base($numdate, 'court', array('annee_courante'=>$annee_courante));
1085 }
1086
1087 // http://doc.spip.org/@affdate_jourcourt
1088 function affdate_jourcourt($numdate, $annee_courante=null) {
1089 return affdate_base($numdate, 'jourcourt', array('annee_courante'=>$annee_courante));
1090 }
1091
1092 // http://doc.spip.org/@affdate_mois_annee
1093 function affdate_mois_annee($numdate) {
1094 return affdate_base($numdate, 'mois_annee');
1095 }
1096
1097 // http://doc.spip.org/@affdate_heure
1098 function affdate_heure($numdate) {
1099 $date_array = recup_date($numdate);
1100 if (!$date_array) return;
1101 list($annee, $mois, $jour, $heures, $minutes, $sec)= $date_array;
1102 return _T('date_fmt_jour_heure', array('jour' => affdate($numdate), 'heure' => _T('date_fmt_heures_minutes', array('h'=> $heures, 'm'=> $minutes))));
1103 }
1104
1105 /**
1106 * Afficher de facon textuelle les dates de debut et fin en fonction des cas
1107 * - Lundi 20 fevrier a 18h
1108 * - Le 20 fevrier de 18h a 20h
1109 * - Du 20 au 23 fevrier
1110 * - Du 20 fevrier au 30 mars
1111 * - Du 20 fevrier 2007 au 30 mars 2008
1112 * $horaire='oui' ou true permet d'afficher l'horaire, toute autre valeur n'indique que le jour
1113 * $forme peut contenir une ou plusieurs valeurs parmi
1114 * - abbr (afficher le nom des jours en abbrege)
1115 * - hcal (generer une date au format hcal)
1116 * - jour (forcer l'affichage des jours)
1117 * - annee (forcer l'affichage de l'annee)
1118 *
1119 * @param string $date_debut
1120 * @param string $date_fin
1121 * @param string $horaire
1122 * @param string $forme
1123 * @return string
1124 */
1125 function affdate_debut_fin($date_debut, $date_fin, $horaire = 'oui', $forme=''){
1126 $abbr = $jour = '';
1127 $affdate = "affdate_jourcourt";
1128 if (strpos($forme,'abbr') !==false) $abbr = 'abbr';
1129 if (strpos($forme,'annee')!==false) $affdate = 'affdate';
1130 if (strpos($forme,'jour') !==false) $jour = 'jour';
1131
1132 $dtstart = $dtend = $dtabbr = "";
1133 if (strpos($forme,'hcal')!==false) {
1134 $dtstart = "<abbr class='dtstart' title='".date_iso($date_debut)."'>";
1135 $dtend = "<abbr class='dtend' title='".date_iso($date_fin)."'>";
1136 $dtabbr = "</abbr>";
1137 }
1138
1139 $date_debut = strtotime($date_debut);
1140 $date_fin = strtotime($date_fin);
1141 $d = date("Y-m-d", $date_debut);
1142 $f = date("Y-m-d", $date_fin);
1143 $h = ($horaire==='oui' OR $horaire===true);
1144 $hd = _T('date_fmt_heures_minutes_court', array('h'=> date("H",$date_debut), 'm'=> date("i",$date_debut)));
1145 $hf = _T('date_fmt_heures_minutes_court', array('h'=> date("H",$date_fin), 'm'=> date("i",$date_fin)));
1146
1147 if ($d==$f)
1148 { // meme jour
1149 $nomjour = nom_jour($d,$abbr);
1150 $s = $affdate($d);
1151 $s = _T('date_fmt_jour',array('nomjour'=>$nomjour,'jour' => $s));
1152 if ($h){
1153 if ($hd==$hf){
1154 // Lundi 20 fevrier a 18h25
1155 $s = spip_ucfirst(_T('date_fmt_jour_heure',array('jour'=>$s,'heure'=>$hd)));
1156 $s = "$dtstart$s$dtabbr";
1157 }else{
1158 // Le <abbr...>lundi 20 fevrier de 18h00</abbr> a <abbr...>20h00</abbr>
1159 if($dtabbr && $dtstart && $dtend)
1160 $s = spip_ucfirst(_T('date_fmt_jour_heure_debut_fin_abbr',array('jour'=>$s,'heure_debut'=>$hd,'heure_fin'=>$hf,'dtstart'=>$dtstart,'dtend'=>$dtend,'dtabbr'=>$dtabbr)));
1161 // Le lundi 20 fevrier de 18h00 a 20h00
1162 else
1163 $s = spip_ucfirst(_T('date_fmt_jour_heure_debut_fin',array('jour'=>$s,'heure_debut'=>$hd,'heure_fin'=>$hf)));
1164 }
1165 }else{
1166 if($dtabbr && $dtstart)
1167 $s = $dtstart.spip_ucfirst($s).$dabbr;
1168 else
1169 $s = spip_ucfirst($s);
1170 }
1171 }
1172 else if ((date("Y-m",$date_debut))==date("Y-m",$date_fin))
1173 { // meme annee et mois, jours differents
1174 if(!$h)
1175 $date_debut = jour($d);
1176 else
1177 $date_debut = $affdate($d);
1178 $date_fin = $affdate($f);
1179 if($jour){
1180 $nomjour_debut = nom_jour($d,$abbr);
1181 $date_debut = _T('date_fmt_jour',array('nomjour'=>$nomjour_debut,'jour' => $date_debut));
1182 $nomjour_fin = nom_jour($f,$abbr);
1183 $date_fin = _T('date_fmt_jour',array('nomjour'=>$nomjour_fin,'jour' => $date_fin));
1184 }
1185 if ($h){
1186 $date_debut = _T('date_fmt_jour_heure',array('jour'=>$date_debut,'heure'=>$hd));
1187 $date_fin = _T('date_fmt_jour_heure',array('jour'=>$date_fin,'heure'=>$hf));
1188 }
1189 $date_debut = $dtstart.$date_debut.$dtabbr;
1190 $date_fin = $dtend.$date_fin.$dtabbr;
1191
1192 $s = _T('date_fmt_periode',array('date_debut' => $date_debut,'date_fin'=>$date_fin));
1193 }
1194 else {
1195 $date_debut = affdate($d);
1196 $date_fin = affdate($f);
1197 if($jour){
1198 $nomjour_debut = nom_jour($d,$abbr);
1199 $date_debut = _T('date_fmt_jour_periode',array('nomjour'=>$nomjour_debut,'jour' => $date_debut));
1200 $nomjour_fin = nom_jour($f,$abbr);
1201 $date_fin = _T('date_fmt_jour_periode',array('nomjour'=>$nomjour_fin,'jour' => $date_fin));
1202 }
1203 if ($h){
1204 $date_debut = _T('date_fmt_jour_heure',array('jour'=>$date_debut,'heure'=>$hd));
1205 $date_fin = _T('date_fmt_jour_heure',array('jour'=>$date_fin,'heure'=>$hf));
1206 }
1207
1208 $date_debut = $dtstart.$date_debut.$dtabbr;
1209 $date_fin=$dtend.$date_fin.$dtabbr;
1210 $s = _T('date_fmt_periode',array('date_debut' => $date_debut,'date_fin'=>$date_fin));
1211
1212 }
1213 return $s;
1214 }
1215
1216 /**
1217 * Alignements en HTML (Old-style, preferer CSS)
1218 * Cette fonction ne cree pas de paragraphe
1219 *
1220 * http://doc.spip.org/@aligner
1221 *
1222 * @param $letexte
1223 * @param string $justif
1224 * @return string
1225 */
1226 function aligner($letexte, $justif='') {
1227 $letexte = trim($letexte);
1228 if (!strlen($letexte)) return '';
1229
1230 // Paragrapher rapidement
1231 $letexte = "<div style='text-align:$justif'>"
1232 . $letexte
1233 ."</div>";
1234
1235 return $letexte;
1236 }
1237 // http://doc.spip.org/@justifier
1238 function justifier($letexte) { return aligner($letexte,'justify');}
1239 // http://doc.spip.org/@aligner_droite
1240 function aligner_droite($letexte) { return aligner($letexte,'right');}
1241 // http://doc.spip.org/@aligner_gauche
1242 function aligner_gauche($letexte) {return aligner($letexte,'left');}
1243 // http://doc.spip.org/@centrer
1244 function centrer($letexte) {return aligner($letexte,'center');}
1245
1246 // http://doc.spip.org/@style_align
1247 function style_align($bof) {
1248 global $spip_lang_left;
1249 return "text-align: $spip_lang_left";
1250 }
1251
1252 //
1253 // Export iCal
1254 //
1255
1256 // http://doc.spip.org/@filtrer_ical
1257 function filtrer_ical($texte) {
1258 #include_spip('inc/charsets');
1259 $texte = html2unicode($texte);
1260 $texte = unicode2charset(charset2unicode($texte, $GLOBALS['meta']['charset'], 1), 'utf-8');
1261 $texte = preg_replace("/\n/", " ", $texte);
1262 $texte = preg_replace("/,/", "\,", $texte);
1263
1264 return $texte;
1265 }
1266
1267 // http://doc.spip.org/@date_ical
1268 function date_ical($date, $addminutes = 0) {
1269 list($heures, $minutes, $secondes) = recup_heure($date);
1270 list($annee, $mois, $jour) = recup_date($date);
1271 return date("Ymd\THis",
1272 mktime($heures, $minutes+$addminutes,$secondes,$mois,$jour,$annee));
1273 }
1274
1275 // date_iso retourne la date au format "RFC 3339" / "ISO 8601"
1276 // voir http://www.php.net/manual/fr/ref.datetime.php#datetime.constants
1277 // http://doc.spip.org/@date_iso
1278 function date_iso($date_heure) {
1279 list($annee, $mois, $jour) = recup_date($date_heure);
1280 list($heures, $minutes, $secondes) = recup_heure($date_heure);
1281 $time = @mktime($heures, $minutes, $secondes, $mois, $jour, $annee);
1282 return gmdate('Y-m-d\TH:i:s\Z', $time);
1283 }
1284
1285 // date_822 retourne la date au format "RFC 822"
1286 // utilise pour <pubdate> dans certains feeds RSS
1287 // http://doc.spip.org/@date_822
1288 function date_822($date_heure) {
1289 list($annee, $mois, $jour) = recup_date($date_heure);
1290 list($heures, $minutes, $secondes) = recup_heure($date_heure);
1291 $time = mktime($heures, $minutes, $secondes, $mois, $jour, $annee);
1292 return date('r', $time);
1293 }
1294
1295 // http://doc.spip.org/@date_anneemoisjour
1296 function date_anneemoisjour($d) {
1297 if (!$d) $d = date("Y-m-d");
1298 return substr($d, 0, 4) . substr($d, 5, 2) .substr($d, 8, 2);
1299 }
1300
1301 // http://doc.spip.org/@date_anneemois
1302 function date_anneemois($d) {
1303 if (!$d) $d = date("Y-m-d");
1304 return substr($d, 0, 4) . substr($d, 5, 2);
1305 }
1306
1307 // http://doc.spip.org/@date_debut_semaine
1308 function date_debut_semaine($annee, $mois, $jour) {
1309 $w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
1310 if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
1311 $debut = $jour-$w_day+1;
1312 return date("Ymd", mktime(0,0,0,$mois,$debut,$annee));
1313 }
1314
1315 // http://doc.spip.org/@date_fin_semaine
1316 function date_fin_semaine($annee, $mois, $jour) {
1317 $w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
1318 if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
1319 $debut = $jour-$w_day+1;
1320 return date("Ymd", mktime(0,0,0,$mois,$debut+6,$annee));
1321 }
1322
1323
1324 //
1325 // Recuperation de donnees dans le champ extra
1326 // Ce filtre n'a de sens qu'avec la balise #EXTRA
1327 //
1328 // http://doc.spip.org/@extra
1329 function extra($letexte, $champ) {
1330 $champs = unserialize($letexte);
1331 return $champs[$champ];
1332 }
1333
1334 // postautobr : transforme les sauts de ligne en _
1335 // http://doc.spip.org/@post_autobr
1336 function post_autobr($texte, $delim="\n_ ") {
1337 if (!function_exists('echappe_html'))
1338 include_spip('inc/texte_mini');
1339 $texte = str_replace("\r\n", "\r", $texte);
1340 $texte = str_replace("\r", "\n", $texte);
1341
1342 if (preg_match(",\n+$,", $texte, $fin))
1343 $texte = substr($texte, 0, -strlen($fin = $fin[0]));
1344 else
1345 $fin = '';
1346
1347 $texte = echappe_html($texte, '', true);
1348
1349 // echapper les modeles
1350 if (strpos($texte,"<")!==false){
1351 include_spip('inc/lien');
1352 if (defined('_PREG_MODELE')){
1353 $preg_modeles = "@"._PREG_MODELE."@imsS";
1354 $texte = echappe_html($texte, '', true, $preg_modeles);
1355 }
1356 }
1357
1358 $debut = '';
1359 $suite = $texte;
1360 while ($t = strpos('-'.$suite, "\n", 1)) {
1361 $debut .= substr($suite, 0, $t-1);
1362 $suite = substr($suite, $t);
1363 $car = substr($suite, 0, 1);
1364 if (($car<>'-') AND ($car<>'_') AND ($car<>"\n") AND ($car<>"|") AND ($car<>"}")
1365 AND !preg_match(',^\s*(\n|</?(quote|div|dl|dt|dd)|$),S',($suite))
1366 AND !preg_match(',</?(quote|div|dl|dt|dd)> *$,iS', $debut)) {
1367 $debut .= $delim;
1368 } else
1369 $debut .= "\n";
1370 if (preg_match(",^\n+,", $suite, $regs)) {
1371 $debut.=$regs[0];
1372 $suite = substr($suite, strlen($regs[0]));
1373 }
1374 }
1375 $texte = $debut.$suite;
1376
1377 $texte = echappe_retour($texte);
1378 return $texte.$fin;
1379 }
1380
1381
1382 define('_EXTRAIRE_MULTI', "@<multi>(.*?)</multi>@sS");
1383
1384 // Extraire et transformer les blocs multi ; on indique la langue courante
1385 // pour ne pas mettre de span@lang=fr si on est deja en fr
1386 // http://doc.spip.org/@extraire_multi
1387 function extraire_multi($letexte, $lang=null, $echappe_span=false) {
1388 if (preg_match_all(_EXTRAIRE_MULTI, $letexte, $regs, PREG_SET_ORDER)) {
1389 if (!$lang) $lang = $GLOBALS['spip_lang'];
1390
1391 foreach ($regs as $reg) {
1392 // chercher la version de la langue courante
1393 $trads = extraire_trads($reg[1]);
1394 if ($l = approcher_langue($trads, $lang)) {
1395 $trad = $trads[$l];
1396 } else {
1397 include_spip('inc/texte');
1398 // langue absente, prendre la premiere dispo
1399 // mais typographier le texte selon les regles de celle-ci
1400 // Attention aux blocs multi sur plusieurs lignes
1401 $l = key($trads);
1402 $trad = $trads[$l];
1403 $typographie = charger_fonction(lang_typo($l), 'typographie');
1404 $trad = $typographie($trad);
1405 include_spip('inc/texte');
1406 // Tester si on echappe en span ou en div
1407 // il ne faut pas echapper en div si propre produit un seul paragraphe
1408 $trad_propre = preg_replace(",(^<p[^>]*>|</p>$),Uims","",propre($trad));
1409 $mode = preg_match(',</?('._BALISES_BLOCS.')[>[:space:]],iS', $trad_propre) ? 'div' : 'span';
1410 $trad = code_echappement($trad, 'multi', false, $mode);
1411 $trad = str_replace("'", '"', inserer_attribut($trad, 'lang', $l));
1412 if (lang_dir($l) !== lang_dir($lang))
1413 $trad = str_replace("'", '"', inserer_attribut($trad, 'dir', lang_dir($l)));
1414 if (!$echappe_span)
1415 $trad = echappe_retour($trad, 'multi');
1416 }
1417 $letexte = str_replace($reg[0], $trad, $letexte);
1418 }
1419 }
1420
1421 return $letexte;
1422 }
1423
1424 // convertit le contenu d'une balise multi en un tableau
1425 // http://doc.spip.org/@extraire_trad
1426 function extraire_trads($bloc) {
1427 $lang = '';
1428 // ce reg fait planter l'analyse multi s'il y a de l'{italique} dans le champ
1429 // while (preg_match("/^(.*?)[{\[]([a-z_]+)[}\]]/siS", $bloc, $regs)) {
1430 while (preg_match("/^(.*?)[\[]([a-z_]+)[\]]/siS", $bloc, $regs)) {
1431 $texte = trim($regs[1]);
1432 if ($texte OR $lang)
1433 $trads[$lang] = $texte;
1434 $bloc = substr($bloc, strlen($regs[0]));
1435 $lang = $regs[2];
1436 }
1437 $trads[$lang] = $bloc;
1438
1439 return $trads;
1440 }
1441
1442 // Calculer l'initiale d'un nom
1443 function initiale($nom){
1444 return spip_substr(trim(strtoupper(extraire_multi($nom))),0,1);
1445 }
1446
1447 //
1448 // Ce filtre retourne la donnee si c'est la premiere fois qu'il la voit ;
1449 // possibilite de gerer differentes "familles" de donnees |unique{famille}
1450 # |unique{famille,1} affiche le nombre d'elements affiches (preferer toutefois #TOTAL_UNIQUE)
1451 # ameliorations possibles :
1452 # 1) si la donnee est grosse, mettre son md5 comme cle
1453 # 2) purger $mem quand on change de squelette (sinon bug inclusions)
1454 //
1455 // http://www.spip.net/@unique
1456 // http://doc.spip.org/@unique
1457 function unique($donnee, $famille='', $cpt = false) {
1458 static $mem = array();
1459 // permettre de vider la pile et de la restaurer
1460 // pour le calcul de introduction...
1461 if ($famille=='_spip_raz_'){
1462 $tmp = $mem;
1463 $mem = array();
1464 return $tmp;
1465 } elseif ($famille=='_spip_set_'){
1466 $mem = $donnee;
1467 return;
1468 }
1469 // eviter une notice
1470 if (!isset($mem[$famille])) {
1471 $mem[$famille] = array();
1472 }
1473 if ($cpt) {
1474 return count($mem[$famille]);
1475 }
1476 // eviter une notice
1477 if (!isset($mem[$famille][$donnee])) {
1478 $mem[$famille][$donnee] = 0;
1479 }
1480 if (!($mem[$famille][$donnee]++)) {
1481 return $donnee;
1482 }
1483 }
1484
1485 //
1486 // Filtre |alterner
1487 //
1488 // Exemple [(#COMPTEUR_BOUCLE|alterner{'bleu','vert','rouge'})]
1489 //
1490 // http://doc.spip.org/@alterner
1491 function alterner($i) {
1492 // recuperer les arguments (attention fonctions un peu space)
1493 $num = func_num_args();
1494 $args = func_get_args();
1495
1496 if($num == 2 && is_array($args[1])) {
1497 $args = $args[1];
1498 array_unshift($args,'');
1499 $num = count($args);
1500 }
1501
1502 // renvoyer le i-ieme argument, modulo le nombre d'arguments
1503 return $args[(intval($i)-1)%($num-1)+1];
1504 }
1505
1506 // recuperer un attribut d'une balise html
1507 // ($complet demande de retourner $r)
1508 // la regexp est mortelle : cf. tests/filtres/extraire_attribut.php
1509 // Si on a passe un tableau de balises, renvoyer un tableau de resultats
1510 // (dans ce cas l'option $complet n'est pas disponible)
1511 // http://doc.spip.org/@extraire_attribut
1512 function extraire_attribut($balise, $attribut, $complet = false) {
1513 if (is_array($balise)) {
1514 array_walk($balise,
1515 create_function('&$a,$key,$t',
1516 '$a = extraire_attribut($a,$t);'
1517 ),
1518 $attribut);
1519 return $balise;
1520 }
1521 if (preg_match(
1522 ',(^.*?<(?:(?>\s*)(?>[\w:.-]+)(?>(?:=(?:"[^"]*"|\'[^\']*\'|[^\'"]\S*))?))*?)(\s+'
1523 .$attribut
1524 .'(?:=\s*("[^"]*"|\'[^\']*\'|[^\'"]\S*))?)()([^>]*>.*),isS',
1525
1526 $balise, $r)) {
1527 if ($r[3][0] == '"' || $r[3][0] == "'") {
1528 $r[4] = substr($r[3], 1, -1);
1529 $r[3] = $r[3][0];
1530 } elseif ($r[3]!=='') {
1531 $r[4] = $r[3];
1532 $r[3] = '';
1533 } else {
1534 $r[4] = trim($r[2]);
1535 }
1536 $att = filtrer_entites(str_replace("&#39;", "'", $r[4]));
1537 }
1538 else
1539 $att = NULL;
1540
1541 if ($complet)
1542 return array($att, $r);
1543 else
1544 return $att;
1545 }
1546
1547 /**
1548 * modifier (ou inserer) un attribut html dans une balise
1549 *
1550 * http://doc.spip.org/@inserer_attribut
1551 *
1552 * @param string $balise
1553 * @param string $attribut
1554 * @param string $val
1555 * @param bool $proteger
1556 * @param bool $vider
1557 * @return string
1558 */
1559 function inserer_attribut($balise, $attribut, $val, $proteger=true, $vider=false) {
1560 // preparer l'attribut
1561 // supprimer les &nbsp; etc mais pas les balises html
1562 // qui ont un sens dans un attribut value d'un input
1563 if ($proteger) $val = attribut_html($val,false);
1564
1565 // echapper les ' pour eviter tout bug
1566 $val = str_replace("'", "&#039;", $val);
1567 if ($vider AND strlen($val)==0)
1568 $insert = '';
1569 else
1570 $insert = " $attribut='$val'";
1571
1572 list($old, $r) = extraire_attribut($balise, $attribut, true);
1573
1574 if ($old !== NULL) {
1575 // Remplacer l'ancien attribut du meme nom
1576 $balise = $r[1].$insert.$r[5];
1577 }
1578 else {
1579 // preferer une balise " />" (comme <img />)
1580 if (preg_match(',/>,', $balise))
1581 $balise = preg_replace(",\s?/>,S", $insert." />", $balise, 1);
1582 // sinon une balise <a ...> ... </a>
1583 else
1584 $balise = preg_replace(",\s?>,S", $insert.">", $balise, 1);
1585 }
1586
1587 return $balise;
1588 }
1589
1590 // http://doc.spip.org/@vider_attribut
1591 function vider_attribut ($balise, $attribut) {
1592 return inserer_attribut($balise, $attribut, '', false, true);
1593 }
1594
1595
1596 /**
1597 * Un filtre pour determiner le nom du satut des inscrits
1598 *
1599 * @param void|int $id
1600 * @param string $mode
1601 * @return string
1602 */
1603 function tester_config($id, $mode='') {
1604 include_spip('action/inscrire_auteur');
1605 return tester_statut_inscription($mode, $id);
1606 }
1607
1608 //
1609 // Quelques fonctions de calcul arithmetique
1610 //
1611 // http://doc.spip.org/@plus
1612 function plus($a,$b) {
1613 return $a+$b;
1614 }
1615 // http://doc.spip.org/@moins
1616 function moins($a,$b) {
1617 return $a-$b;
1618 }
1619 // http://doc.spip.org/@mult
1620 function mult($a,$b) {
1621 return $a*$b;
1622 }
1623 // http://doc.spip.org/@div
1624 function div($a,$b) {
1625 return $b?$a/$b:0;
1626 }
1627 // http://doc.spip.org/@modulo
1628 function modulo($nb, $mod, $add=0) {
1629 return ($mod?$nb%$mod:0)+$add;
1630 }
1631
1632
1633 /**
1634 * Vérifie qu'un nom (d'auteur) ne comporte pas d'autres tags que <multi>
1635 *
1636 * @param string $nom
1637 * Nom (signature) proposé
1638 * @return bool
1639 * - false si pas conforme,
1640 * - true sinon
1641 **/
1642 function nom_acceptable($nom) {
1643 if (!is_string($nom)) {
1644 return false;
1645 }
1646 $v_nom = str_replace(array('@multi@','@/multi@'), array('<multi>','</multi>'), supprimer_tags(str_replace(array('<multi>','</multi>'), array('@multi@','@/multi@'), $nom)));
1647 return str_replace('&lt;', '<', $v_nom) == $nom;
1648 }
1649
1650 // Verifier la conformite d'une ou plusieurs adresses email
1651 // retourne false ou la normalisation de la derniere adresse donnee
1652 // http://doc.spip.org/@email_valide
1653 function email_valide($adresses) {
1654 // eviter d'injecter n'importe quoi dans preg_match
1655 if (!is_string($adresses))
1656 return false;
1657
1658 // Si c'est un spammeur autant arreter tout de suite
1659 if (preg_match(",[\n\r].*(MIME|multipart|Content-),i", $adresses)) {
1660 spip_log("Tentative d'injection de mail : $adresses");
1661 return false;
1662 }
1663
1664 foreach (explode(',', $adresses) as $v) {
1665 // nettoyer certains formats
1666 // "Marie Toto <Marie@toto.com>"
1667 $adresse = trim(preg_replace(",^[^<>\"]*<([^<>\"]+)>$,i", "\\1", $v));
1668 // RFC 822
1669 if (!preg_match('#^[^()<>@,;:\\"/[:space:]]+(@([-_0-9a-z]+\.)*[-_0-9a-z]+)$#i', $adresse))
1670 return false;
1671 }
1672 return $adresse;
1673 }
1674
1675 // http://doc.spip.org/@afficher_enclosures
1676 function afficher_enclosures($tags) {
1677 $s = array();
1678 foreach (extraire_balises($tags, 'a') as $tag) {
1679 if (extraire_attribut($tag, 'rel') == 'enclosure'
1680 AND $t = extraire_attribut($tag, 'href')) {
1681 $s[] = preg_replace(',>[^<]+</a>,S',
1682 '>'
1683 .http_img_pack('attachment-16.png', $t,
1684 'title="'.attribut_html($t).'"')
1685 .'</a>', $tag);
1686 }
1687 }
1688 return join('&nbsp;', $s);
1689 }
1690 // http://doc.spip.org/@afficher_tags
1691 function afficher_tags($tags, $rels='tag,directory') {
1692 $s = array();
1693 foreach (extraire_balises($tags, 'a') as $tag) {
1694 $rel = extraire_attribut($tag, 'rel');
1695 if (strstr(",$rels,", ",$rel,"))
1696 $s[] = $tag;
1697 }
1698 return join(', ', $s);
1699 }
1700
1701 // Passe un <enclosure url="fichier" length="5588242" type="audio/mpeg"/>
1702 // au format microformat <a rel="enclosure" href="fichier" ...>fichier</a>
1703 // attention length="zz" devient title="zz", pour rester conforme
1704 // http://doc.spip.org/@enclosure2microformat
1705 function enclosure2microformat($e) {
1706 if (!$url = filtrer_entites(extraire_attribut($e, 'url')))
1707 $url = filtrer_entites(extraire_attribut($e, 'href'));
1708 $type = extraire_attribut($e, 'type');
1709 if (!$length = extraire_attribut($e, 'length')) {
1710 # <media:content : longeur dans fileSize. On tente.
1711 $length = extraire_attribut($e, 'fileSize');
1712 }
1713 $fichier = basename($url);
1714 return '<a rel="enclosure"'
1715 . ($url? ' href="'.htmlspecialchars($url).'"' : '')
1716 . ($type? ' type="'.htmlspecialchars($type).'"' : '')
1717 . ($length? ' title="'.htmlspecialchars($length).'"' : '')
1718 . '>'.$fichier.'</a>';
1719 }
1720 // La fonction inverse
1721 // http://doc.spip.org/@microformat2enclosure
1722 function microformat2enclosure($tags) {
1723 $enclosures = array();
1724 foreach (extraire_balises($tags, 'a') as $e)
1725 if (extraire_attribut($e, 'rel') == 'enclosure') {
1726 $url = filtrer_entites(extraire_attribut($e, 'href'));
1727 $type = extraire_attribut($e, 'type');
1728 if (!$length = intval(extraire_attribut($e, 'title')))
1729 $length = intval(extraire_attribut($e, 'length')); # vieux data
1730 $fichier = basename($url);
1731 $enclosures[] = '<enclosure'
1732 . ($url? ' url="'.htmlspecialchars($url).'"' : '')
1733 . ($type? ' type="'.htmlspecialchars($type).'"' : '')
1734 . ($length? ' length="'.$length.'"' : '')
1735 . ' />';
1736 }
1737 return join("\n", $enclosures);
1738 }
1739 // Creer les elements ATOM <dc:subject> a partir des tags
1740 // http://doc.spip.org/@tags2dcsubject
1741 function tags2dcsubject($tags) {
1742 $subjects = '';
1743 foreach (extraire_balises($tags, 'a') as $e) {
1744 if (extraire_attribut($e, rel) == 'tag') {
1745 $subjects .= '<dc:subject>'
1746 . texte_backend(textebrut($e))
1747 . '</dc:subject>'."\n";
1748 }
1749 }
1750 return $subjects;
1751 }
1752
1753 // retourne la premiere balise du type demande
1754 // ex: [(#DESCRIPTIF|extraire_balise{img})]
1755 // Si on a passe un tableau de textes, renvoyer un tableau de resultats
1756 // http://doc.spip.org/@extraire_balise
1757 function extraire_balise($texte, $tag='a') {
1758 if (is_array($texte)) {
1759 array_walk($texte,
1760 create_function('&$a,$key,$t', '$a = extraire_balise($a,$t);'),
1761 $tag);
1762 return $texte;
1763 }
1764
1765 if (preg_match(
1766 ",<$tag\b[^>]*(/>|>.*</$tag\b[^>]*>|>),UimsS",
1767 $texte, $regs))
1768 return $regs[0];
1769 }
1770
1771 // extraire toutes les balises du type demande, sous forme de tableau
1772 // Si on a passe un tableau de textes, renvoyer un tableau de resultats
1773 // http://doc.spip.org/@extraire_balises
1774 function extraire_balises($texte, $tag='a') {
1775 if (is_array($texte)) {
1776 array_walk($texte,
1777 create_function('&$a,$key,$t', '$a = extraire_balises($a,$t);'),
1778 $tag);
1779 return $texte;
1780 }
1781
1782 if (preg_match_all(
1783 ",<${tag}\b[^>]*(/>|>.*</${tag}\b[^>]*>|>),UimsS",
1784 $texte, $regs, PREG_PATTERN_ORDER))
1785 return $regs[0];
1786 else
1787 return array();
1788 }
1789
1790 // comme in_array mais renvoie son 3e arg si le 2er arg n'est pas un tableau
1791 // prend ' ' comme representant de vrai et '' de faux
1792
1793 // http://doc.spip.org/@in_any
1794 function in_any($val, $vals, $def='') {
1795 if (!is_array($vals) AND $v=unserialize($vals)) $vals = $v;
1796 return (!is_array($vals) ? $def : (in_array($val, $vals) ? ' ' : ''));
1797 }
1798
1799 // valeur_numerique("3*2") => 6
1800 // n'accepte que les *, + et - (a ameliorer si on l'utilise vraiment)
1801 // http://doc.spip.org/@valeur_numerique
1802 function valeur_numerique($expr) {
1803 $a = 0;
1804 if (preg_match(',^[0-9]+(\s*[+*-]\s*[0-9]+)*$,S', trim($expr)))
1805 eval("\$a = $expr;");
1806 return intval($a);
1807 }
1808
1809 // http://doc.spip.org/@regledetrois
1810 function regledetrois($a,$b,$c)
1811 {
1812 return round($a*$b/$c);
1813 }
1814
1815 // Fournit la suite de Input-Hidden correspondant aux parametres de
1816 // l'URL donnee en argument, compatible avec les types_urls depuis [14447].
1817 // cf. tests/filtres/form_hidden.html
1818 // http://doc.spip.org/@form_hidden
1819 function form_hidden($action) {
1820
1821 $contexte = array();
1822 include_spip('inc/urls');
1823 if ($p = urls_decoder_url($action, '')
1824 AND reset($p)) {
1825 $fond = array_shift($p);
1826 if ($fond!='404'){
1827 $contexte = array_shift($p);
1828 $contexte['page'] = $fond;
1829 $action = preg_replace('/([?]'.preg_quote($fond).'[^&=]*[0-9]+)(&|$)/', '?&', $action);
1830 }
1831 }
1832 // defaire ce qu'a injecte urls_decoder_url : a revoir en modifiant la signature de urls_decoder_url
1833 if (defined('_DEFINIR_CONTEXTE_TYPE') AND _DEFINIR_CONTEXTE_TYPE)
1834 unset($contexte['type']);
1835 if (defined('_DEFINIR_CONTEXTE_TYPE_PAGE') AND _DEFINIR_CONTEXTE_TYPE_PAGE)
1836 unset($contexte['type-page']);
1837
1838 // on va remplir un tableau de valeurs en prenant bien soin de ne pas
1839 // ecraser les elements de la forme mots[]=1&mots[]=2
1840 $values = array();
1841
1842 // d'abord avec celles de l'url
1843 if (false !== ($p = strpos($action, '?'))) {
1844 foreach(preg_split('/&(amp;)?/S',substr($action,$p+1)) as $c){
1845 list($var,$val) = explode('=', $c, 2);
1846 if ($var) {
1847 $val = rawurldecode($val);
1848 $var = rawurldecode($var); // decoder les [] eventuels
1849 if (preg_match(',\[\]$,S', $var))
1850 $values[] = array($var, $val);
1851 else if (!isset($values[$var]))
1852 $values[$var] = array($var, $val);
1853 }
1854 }
1855 }
1856
1857 // ensuite avec celles du contexte, sans doublonner !
1858 foreach($contexte as $var=>$val)
1859 if (preg_match(',\[\]$,S', $var))
1860 $values[] = array($var, $val);
1861 else if (!isset($values[$var]))
1862 $values[$var] = array($var, $val);
1863
1864 // puis on rassemble le tout
1865 $hidden = array();
1866 foreach($values as $value) {
1867 list($var,$val) = $value;
1868 $hidden[] = '<input name="'
1869 . entites_html($var)
1870 .'"'
1871 . (is_null($val)
1872 ? ''
1873 : ' value="'.entites_html($val).'"'
1874 )
1875 . ' type="hidden"'."\n/>";
1876 }
1877 return join("", $hidden);
1878 }
1879
1880 // http://doc.spip.org/@filtre_bornes_pagination_dist
1881 function filtre_bornes_pagination_dist($courante, $nombre, $max = 10) {
1882 if($max<=0 OR $max>=$nombre)
1883 return array(1, $nombre);
1884
1885 $premiere = max(1, $courante-floor(($max-1)/2));
1886 $derniere = min($nombre, $premiere+$max-2);
1887 $premiere = $derniere == $nombre ? $derniere-$max+1 : $premiere;
1888 return array($premiere, $derniere);
1889 }
1890
1891
1892 // Ces trois fonctions permettent de simuler les filtres |reset et |end
1893 // pour extraire la premiere ou la derniere valeur d'un tableau ; utile
1894 // pour la pagination (mais peut-etre a refaire plus simplement)
1895 // http://doc.spip.org/@filtre_valeur_tableau
1896 function filtre_valeur_tableau($array, $index) {
1897 if (!is_array($array)
1898 OR !isset($array[$index]))
1899 return null;
1900 return $array[$index];
1901 }
1902 // http://doc.spip.org/@filtre_reset
1903 function filtre_reset($array) {
1904 return !is_array($array) ? null : reset($array);
1905 }
1906 // http://doc.spip.org/@filtre_end
1907 function filtre_end($array) {
1908 return !is_array($array) ? null : end($array);
1909 }
1910
1911 // http://doc.spip.org/@filtre_push
1912 function filtre_push($array, $val) {
1913 if($array == '' OR !array_push($array, $val)) return '';
1914 return $array;
1915 }
1916
1917 // http://doc.spip.org/@filtre_find
1918 function filtre_find($array, $val) {
1919 return (is_array($array) AND in_array($val, $array));
1920 }
1921
1922
1923 //
1924 // fonction standard de calcul de la balise #PAGINATION
1925 // on peut la surcharger en definissant filtre_pagination dans mes_fonctions
1926 //
1927
1928 // http://doc.spip.org/@filtre_pagination_dist
1929 function filtre_pagination_dist($total, $nom, $position, $pas, $liste = true, $modele='', $connect='', $env=array()) {
1930 static $ancres = array();
1931 if ($pas<1) return '';
1932 $ancre = 'pagination'.$nom; // #pagination_articles
1933 $debut = 'debut'.$nom; // 'debut_articles'
1934
1935 // n'afficher l'ancre qu'une fois
1936 if (!isset($ancres[$ancre]))
1937 $bloc_ancre = $ancres[$ancre] = "<a name='".$ancre."' id='".$ancre."'></a>";
1938 else $bloc_ancre = '';
1939 // liste = false : on ne veut que l'ancre
1940 if (!$liste)
1941 return $ancres[$ancre];
1942
1943 $pagination = array(
1944 'debut' => $debut,
1945 'url' => parametre_url(self(),'fragment',''), // nettoyer l'id ahah eventuel
1946 'total' => $total,
1947 'position' => intval($position),
1948 'pas' => $pas,
1949 'nombre_pages' => floor(($total-1)/$pas)+1,
1950 'page_courante' => floor(intval($position)/$pas)+1,
1951 'ancre' => $ancre,
1952 'bloc_ancre' => $bloc_ancre
1953 );
1954 if (is_array($env))
1955 $pagination = array_merge($env,$pagination);
1956
1957 // Pas de pagination
1958 if ($pagination['nombre_pages']<=1)
1959 return '';
1960
1961 if ($modele) $modele = '_'.$modele;
1962
1963 return recuperer_fond("modeles/pagination$modele", $pagination, array('trim'=>true), $connect);
1964 }
1965
1966 // passer les url relatives a la css d'origine en url absolues
1967 // http://doc.spip.org/@urls_absolues_css
1968 function urls_absolues_css($contenu, $source) {
1969 $path = suivre_lien(url_absolue($source),'./');
1970
1971 return preg_replace_callback(
1972 ",url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims",
1973 create_function('$x',
1974 'return "url(\"".suivre_lien("'.$path.'",$x[1])."\")";'
1975 ), $contenu);
1976 }
1977
1978 // recuperere le chemin d'une css existante et :
1979 // 1. regarde si une css inversee droite-gauche existe dans le meme repertoire
1980 // 2. sinon la cree (ou la recree) dans _DIR_VAR/cache_css/
1981 // SI on lui donne a manger une feuille nommee _rtl.css il va faire l'inverse
1982 // http://doc.spip.org/@direction_css
1983 function direction_css ($css, $voulue='') {
1984 if (!preg_match(',(_rtl)?\.css$,i', $css, $r)) return $css;
1985
1986 // si on a precise le sens voulu en argument, le prendre en compte
1987 if ($voulue = strtolower($voulue)) {
1988 if ($voulue != 'rtl' AND $voulue != 'ltr')
1989 $voulue = lang_dir($voulue);
1990 }
1991 else
1992 $voulue = lang_dir();
1993
1994 $r = count($r) > 1;
1995 $right = $r ? 'left' : 'right'; // 'right' de la css lue en entree
1996 $dir = $r ? 'rtl' : 'ltr';
1997 $ndir = $r ? 'ltr' : 'rtl';
1998
1999 if ($voulue == $dir)
2000 return $css;
2001
2002 if (
2003 // url absolue
2004 preg_match(",^http:,i",$css)
2005 // ou qui contient un ?
2006 OR (($p=strpos($css,'?'))!==FALSE)) {
2007 $distant = true;
2008 $cssf = parse_url($css);
2009 $cssf = $cssf['path'].($cssf['query']?"?".$cssf['query']:"");
2010 $cssf = preg_replace(',[?:&=],', "_", $cssf);
2011 }
2012 else {
2013 $distant = false;
2014 $cssf = $css;
2015 // 1. regarder d'abord si un fichier avec la bonne direction n'est pas aussi
2016 //propose (rien a faire dans ce cas)
2017 $f = preg_replace(',(_rtl)?\.css$,i', '_'.$ndir.'.css', $css);
2018 if (@file_exists($f))
2019 return $f;
2020 }
2021
2022 // 2.
2023 $dir_var = sous_repertoire (_DIR_VAR, 'cache-css');
2024 $f = $dir_var
2025 . preg_replace(',.*/(.*?)(_rtl)?\.css,', '\1', $cssf)
2026 . '.' . substr(md5($cssf), 0,4) . '_' . $ndir . '.css';
2027
2028 // la css peut etre distante (url absolue !)
2029 if ($distant){
2030 include_spip('inc/distant');
2031 $contenu = recuperer_page($css);
2032 if (!$contenu) return $css;
2033 }
2034 else {
2035 if ((@filemtime($f) > @filemtime($css))
2036 AND (_VAR_MODE != 'recalcul'))
2037 return $f;
2038 if (!lire_fichier($css, $contenu))
2039 return $css;
2040 }
2041
2042 $contenu = str_replace(
2043 array('right', 'left', '@@@@L E F T@@@@'),
2044 array('@@@@L E F T@@@@', 'right', 'left'),
2045 $contenu);
2046
2047 // reperer les @import auxquels il faut propager le direction_css
2048 preg_match_all(",\@import\s*url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims",$contenu,$regs);
2049 $src = array();$src_direction_css = array();$src_faux_abs=array();
2050 $d = dirname($css);
2051 foreach($regs[1] as $k=>$import_css){
2052 $css_direction = direction_css("$d/$import_css",$voulue);
2053 // si la css_direction est dans le meme path que la css d'origine, on tronque le path, elle sera passee en absolue
2054 if (substr($css_direction,0,strlen($d)+1)=="$d/") $css_direction = substr($css_direction,strlen($d)+1);
2055 // si la css_direction commence par $dir_var on la fait passer pour une absolue
2056 elseif (substr($css_direction,0,strlen($dir_var))==$dir_var) {
2057 $css_direction = substr($css_direction,strlen($dir_var));
2058 $src_faux_abs["/@@@@@@/".$css_direction] = $css_direction;
2059 $css_direction = "/@@@@@@/".$css_direction;
2060 }
2061 $src[] = $regs[0][$k];
2062 $src_direction_css[] = str_replace($import_css,$css_direction,$regs[0][$k]);
2063 }
2064 $contenu = str_replace($src,$src_direction_css,$contenu);
2065
2066 $contenu = urls_absolues_css($contenu, $css);
2067
2068 // virer les fausses url absolues que l'on a mis dans les import
2069 if (count($src_faux_abs))
2070 $contenu = str_replace(array_keys($src_faux_abs),$src_faux_abs,$contenu);
2071
2072 if (!ecrire_fichier($f, $contenu))
2073 return $css;
2074
2075 return $f;
2076 }
2077
2078 // recuperere le chemin d'une css existante et :
2079 // cree (ou recree) dans _DIR_VAR/cache_css/ une css dont les url relatives sont passees en url absolues
2080 // http://doc.spip.org/@url_absolue_css
2081 function url_absolue_css ($css) {
2082 if (!preg_match(',\.css$,i', $css, $r)) return $css;
2083
2084 $url_absolue_css = url_absolue($css);
2085
2086 $f = basename($css,'.css');
2087 $f = sous_repertoire (_DIR_VAR, 'cache-css')
2088 . preg_replace(",(.*?)(_rtl|_ltr)?$,","\\1-urlabs-" . substr(md5("$css-urlabs"), 0,4) . "\\2",$f)
2089 . '.css';
2090
2091 if ((@filemtime($f) > @filemtime($css))
2092 AND (_VAR_MODE != 'recalcul'))
2093 return $f;
2094
2095 if ($url_absolue_css==$css){
2096 if (strncmp($GLOBALS['meta']['adresse_site'],$css,$l=strlen($GLOBALS['meta']['adresse_site']))!=0
2097 OR !lire_fichier(_DIR_RACINE . substr($css,$l), $contenu)){
2098 include_spip('inc/distant');
2099 if (!$contenu = recuperer_page($css))
2100 return $css;
2101 }
2102 }
2103 elseif (!lire_fichier($css, $contenu))
2104 return $css;
2105
2106 // passer les url relatives a la css d'origine en url absolues
2107 $contenu = urls_absolues_css($contenu, $css);
2108
2109 // ecrire la css
2110 if (!ecrire_fichier($f, $contenu))
2111 return $css;
2112
2113 return $f;
2114 }
2115
2116
2117
2118 /**
2119 * Le filtre table_valeur
2120 * permet de recuperer la valeur d'une cle donnee
2121 * dans un tableau (ou un objet).
2122 *
2123 * @param mixed $table
2124 * Tableau ou objet
2125 * (ou chaine serialisee de tableau, ce qui permet d'enchainer le filtre)
2126 *
2127 * @param string $cle
2128 * Cle du tableau (ou parametre public de l'objet)
2129 * Cette cle peut contenir des caracteres / pour selectionner
2130 * des sous elements dans le tableau, tel que "sous/element/ici"
2131 * pour obtenir la valeur de $tableau['sous']['element']['ici']
2132 *
2133 * @param mixed $defaut
2134 * Valeur par defaut retournee si la cle demandee n'existe pas
2135 *
2136 * @return mixed Valeur trouvee ou valeur par defaut.
2137 **/
2138 function table_valeur($table, $cle, $defaut='') {
2139 foreach (explode('/', $cle) as $k) {
2140
2141 $table = is_string($table) ? @unserialize($table) : $table;
2142
2143 if (is_object($table)) {
2144 $table = (($k !== "") and isset($table->$k)) ? $table->$k : $defaut;
2145 } elseif (is_array($table)) {
2146 $table = isset($table[$k]) ? $table[$k] : $defaut;
2147 } else {
2148 $table = $defaut;
2149 }
2150 }
2151 return $table;
2152 }
2153
2154 // filtre match pour faire des tests avec expression reguliere
2155 // [(#TEXTE|match{^ceci$,Uims})]
2156 // retourne le fragment de chaine qui "matche"
2157 // il est possible de passer en 3eme argument optionnel le numero de parenthese capturante
2158 // accepte egalement la syntaxe #TRUC|match{truc(...)$,1} ou le modificateur n'est pas passe en second argument
2159 // http://doc.spip.org/@match
2160 function match($texte, $expression, $modif="UimsS",$capte=0) {
2161 if (intval($modif) AND $capte==0){
2162 $capte = $modif;
2163 $modif = "UimsS";
2164 }
2165 $expression=str_replace("\/","/",$expression);
2166 $expression=str_replace("/","\/",$expression);
2167
2168 if (preg_match('/' . $expression . '/' . $modif,$texte, $r)) {
2169 if (isset($r[$capte]))
2170 return $r[$capte];
2171 else
2172 return true;
2173 }
2174 return false;
2175 }
2176
2177 // filtre replace pour faire des operations avec expression reguliere
2178 // [(#TEXTE|replace{^ceci$,cela,UimsS})]
2179 // http://doc.spip.org/@replace
2180 function replace($texte, $expression, $replace='', $modif="UimsS") {
2181 $expression=str_replace("\/","/", $expression);
2182 $expression=str_replace("/","\/",$expression);
2183 return preg_replace('/' . $expression . '/' . $modif, $replace, $texte);
2184 }
2185
2186
2187 // cherche les documents numerotes dans un texte traite par propre()
2188 // et affecte les doublons['documents']
2189 // http://doc.spip.org/@traiter_doublons_documents
2190 // http://doc.spip.org/@traiter_doublons_documents
2191 function traiter_doublons_documents(&$doublons, $letexte) {
2192
2193 // Verifier dans le texte & les notes (pas beau, helas)
2194 $t = $letexte.$GLOBALS['les_notes'];
2195
2196 if (strstr($t, 'spip_document_') // evite le preg_match_all si inutile
2197 AND preg_match_all(
2198 ',<[^>]+\sclass=["\']spip_document_([0-9]+)[\s"\'],imsS',
2199 $t, $matches, PREG_PATTERN_ORDER))
2200 $doublons['documents'] .= "," . join(',', $matches[1]);
2201
2202 return $letexte;
2203 }
2204
2205 // filtre vide qui ne renvoie rien
2206 // http://doc.spip.org/@vide
2207 function vide($texte){
2208 return "";
2209 }
2210
2211 //
2212 // Filtres pour le modele/emb (embed document)
2213 //
2214
2215 // A partir d'un #ENV, retourne des <param ...>
2216 // http://doc.spip.org/@env_to_params
2217 function env_to_params ($texte, $ignore_params=array()) {
2218 $ignore_params = array_merge (
2219 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
2220 $ignore_params);
2221 $tableau = unserialize($texte);
2222 $texte = "";
2223 foreach ($tableau as $i => $j)
2224 if (is_string($j) AND !in_array($i,$ignore_params))
2225 $texte .= "<param name='".$i."'\n\tvalue='".$j."' />";
2226 return $texte;
2227 }
2228 // A partir d'un #ENV, retourne des attributs
2229 // http://doc.spip.org/@env_to_attributs
2230 function env_to_attributs ($texte, $ignore_params=array()) {
2231 $ignore_params = array_merge (
2232 array('id', 'lang', 'id_document', 'date', 'date_redac', 'align', 'fond', '', 'recurs', 'emb', 'dir_racine'),
2233 $ignore_params);
2234 $tableau = unserialize($texte);
2235 $texte = "";
2236 foreach ($tableau as $i => $j)
2237 if (is_string($j) AND !in_array($i,$ignore_params))
2238 $texte .= $i."='".$j."' ";
2239 return $texte;
2240 }
2241
2242 // Concatener des chaines
2243 // #TEXTE|concat{texte1,texte2,...}
2244 // http://doc.spip.org/@concat
2245 function concat(){
2246 $args = func_get_args();
2247 return join('', $args);
2248 }
2249
2250
2251 // http://doc.spip.org/@charge_scripts
2252 function charge_scripts($scripts) {
2253 $flux = "";
2254 $args = is_array($scripts)?$scripts:explode("|",$scripts);
2255 foreach($args as $script) {
2256 if(preg_match(",^\w+$,",$script)) {
2257 $path = find_in_path("javascript/$script.js");
2258 if($path) $flux .= spip_file_get_contents($path);
2259 }
2260 }
2261 return $flux;
2262 }
2263
2264
2265
2266 /**
2267 * produit une balise img avec un champ alt d'office si vide
2268 * attention le htmlentities et la traduction doivent etre appliques avant.
2269 *
2270 * http://doc.spip.org/@http_img_pack
2271 *
2272 * @param $img
2273 * @param $alt
2274 * @param string $atts
2275 * @param string $title
2276 * @param array $options
2277 * chemin_image : utiliser chemin_image sur $img fourni, ou non (oui par dafaut)
2278 * utiliser_suffixe_size : utiliser ou non le suffixe de taille dans le nom de fichier de l'image
2279 * sous forme -xx.png (pour les icones essentiellement) (oui par defaut)
2280 * @return string
2281 */
2282 function http_img_pack($img, $alt, $atts='', $title='', $options = array()) {
2283 if (!isset($options['chemin_image']) OR $options['chemin_image']==true)
2284 $img = chemin_image($img);
2285 if (stripos($atts, 'width')===false){
2286 // utiliser directement l'info de taille presente dans le nom
2287 if ((!isset($options['utiliser_suffixe_size']) OR $options['utiliser_suffixe_size']==true)
2288 AND preg_match(',-([0-9]+)[.](png|gif)$,',$img,$regs)){
2289 $largeur = $hauteur = intval($regs[1]);
2290 }
2291 else{
2292 $taille = taille_image($img);
2293 list($hauteur,$largeur) = $taille;
2294 if (!$hauteur OR !$largeur)
2295 return "";
2296 }
2297 $atts.=" width='".$largeur."' height='".$hauteur."'";
2298 }
2299 return "<img src='$img' alt='" . attribut_html($alt ? $alt : $title) . "'"
2300 . ($title ? ' title="'.attribut_html($title).'"' : '')
2301 . " ".ltrim($atts)
2302 . " />";
2303 }
2304
2305 /**
2306 * generer une directive style='background:url()' a partir d'un fichier image
2307 *
2308 * http://doc.spip.org/@http_style_background
2309 *
2310 * @param string $img
2311 * @param string $att
2312 * @return string
2313 */
2314 function http_style_background($img, $att=''){
2315 return " style='background".($att?"":"-image").": url(\"".chemin_image($img)."\")" . ($att ? (' ' . $att) : '') . ";'";
2316 }
2317
2318 /**
2319 * une fonction pour generer une balise img a partir d'un nom de fichier
2320 *
2321 * @param string $img
2322 * @param string $alt
2323 * @param string $class
2324 * @return string
2325 */
2326 function filtre_balise_img_dist($img,$alt="",$class=""){
2327 return http_img_pack($img, $alt, $class?" class='".attribut_html($class)."'":'', '', array('chemin_image'=>false,'utiliser_suffixe_size'=>false));
2328 }
2329
2330
2331 //[(#ENV*|unserialize|foreach)]
2332 // http://doc.spip.org/@filtre_foreach_dist
2333 function filtre_foreach_dist($balise_deserializee, $modele = 'foreach') {
2334 $texte = '';
2335 if(is_array($balise_deserializee))
2336 foreach($balise_deserializee as $k => $v) {
2337 $res = recuperer_fond('modeles/'.$modele,
2338 array_merge(array('cle' => $k), (is_array($v) ? $v : array('valeur' => $v)))
2339 );
2340 $texte .= $res;
2341 }
2342 return $texte;
2343 }
2344
2345 // renvoie la liste des plugins actifs du site
2346 // si le premier parametre est un prefix de cette liste, renvoie vrai, faux sinon
2347 // la valeur du second parametre si celui-ci renvoie a une information connue
2348 // cf liste_plugin_actifs() pour connaitre les informations affichables
2349 // appelee par la balise #PLUGIN
2350 // http://doc.spip.org/@filtre_info_plugin_dist
2351 function filtre_info_plugin_dist($plugin, $type_info) {
2352 include_spip('inc/plugin');
2353 $plugin = strtoupper($plugin);
2354 $plugins_actifs = liste_plugin_actifs();
2355
2356 if (!$plugin)
2357 return serialize(array_keys($plugins_actifs));
2358 elseif (empty($plugins_actifs[$plugin]))
2359 return '';
2360 elseif ($type_info == 'est_actif')
2361 return $plugins_actifs[$plugin] ? 1 : 0;
2362 elseif (isset($plugins_actifs[$plugin][$type_info]))
2363 return $plugins_actifs[$plugin][$type_info];
2364 else {
2365 $get_infos = charger_fonction('get_infos','plugins');
2366 // On prend en compte les extensions
2367 if (!is_dir($plugins_actifs[$plugin]['dir_type']))
2368 $dir_plugins = constant($plugins_actifs[$plugin]['dir_type']);
2369 else
2370 $dir_plugins = $plugins_actifs[$plugin]['dir_type'];
2371 if (!$infos = $get_infos($plugins_actifs[$plugin]['dir'], false, $dir_plugins))
2372 return '';
2373 if ($type_info == 'tout')
2374 return $infos;
2375 else
2376 return strval($infos[$type_info]);
2377 }
2378 }
2379
2380
2381 // http://doc.spip.org/@puce_changement_statut
2382 function puce_changement_statut($id_objet, $statut, $id_rubrique, $type, $ajax=false){
2383 $puce_statut = charger_fonction('puce_statut','inc');
2384 return $puce_statut($id_objet, $statut, $id_rubrique, $type, $ajax);
2385 }
2386
2387 /**
2388 * [(#STATUT|puce_statut{article})] affiche une puce passive
2389 * [(#STATUT|puce_statut{article,#ID_ARTICLE,#ID_RUBRIQUE})] affiche une puce avec changement rapide
2390 *
2391 * utilisable sur tout objet qui a declare
2392 * @param string $statut
2393 * @param string $objet
2394 * @param int $id_objet
2395 * @param int $id_parent
2396 * @return string
2397 */
2398 function filtre_puce_statut_dist($statut,$objet,$id_objet=0,$id_parent=0){
2399 static $puce_statut = null;
2400 if (!$puce_statut)
2401 $puce_statut = charger_fonction('puce_statut','inc');
2402 return $puce_statut($id_objet, $statut, $id_parent, $objet, false, objet_info($objet,'editable')?_ACTIVER_PUCE_RAPIDE:false);
2403 }
2404
2405
2406 /**
2407 * Encoder un contexte pour l'ajax, le signer avec une cle, le crypter
2408 * avec le secret du site, le gziper si possible...
2409 * l'entree peut etre serialisee (le #ENV** des fonds ajax et ajax_stat)
2410 *
2411 * http://doc.spip.org/@encoder_contexte_ajax
2412 *
2413 * @param string|array $c
2414 * contexte, peut etre un tableau serialize
2415 * @param string $form
2416 * nom du formulaire eventuel
2417 * @param string $emboite
2418 * contenu a emboiter dans le conteneur ajax
2419 * @param string $ajaxid
2420 * ajaxid pour cibler le bloc et forcer sa mise a jour
2421 * @return string
2422 */
2423 function encoder_contexte_ajax($c,$form='', $emboite=NULL, $ajaxid='') {
2424 if (is_string($c)
2425 AND !is_null(@unserialize($c))) {
2426 $c = unserialize($c);
2427 }
2428
2429 // supprimer les parametres debut_x
2430 // pour que la pagination ajax ne soit pas plantee
2431 // si on charge la page &debut_x=1 : car alors en cliquant sur l'item 0,
2432 // le debut_x=0 n'existe pas, et on resterait sur 1
2433 foreach ($c as $k => $v) {
2434 if (strpos($k,'debut_') === 0) {
2435 unset($c[$k]);
2436 }
2437 }
2438
2439 if (!function_exists('calculer_cle_action'))
2440 include_spip("inc/securiser_action");
2441 $cle = calculer_cle_action($form.(is_array($c)?serialize($c):$c));
2442 $c = serialize(array($c,$cle));
2443
2444 // on ne stocke pas les contextes dans des fichiers caches
2445 // par defaut, sauf si cette configuration a ete forcee
2446 // OU que la longueur de l''argument generee est plus long
2447 // que ce que telere Suhosin.
2448 $cache_contextes_ajax = (defined('_CACHE_CONTEXTES_AJAX') AND _CACHE_CONTEXTES_AJAX);
2449 if (!$cache_contextes_ajax) {
2450 $env = $c;
2451 if (function_exists('gzdeflate') && function_exists('gzinflate')) {
2452 $env = gzdeflate($env);
2453 // http://core.spip.org/issues/2667 | https://bugs.php.net/bug.php?id=61287
2454 if (substr(phpversion(),0,5) == '5.4.0' AND !@gzinflate($env)) {
2455 $cache_contextes_ajax = true;
2456 spip_log("Contextes AJAX forces en fichiers ! Erreur PHP 5.4.0", _LOG_AVERTISSEMENT);
2457 }
2458 }
2459 $env = _xor($env);
2460 $env = base64_encode($env);
2461 // tester Suhosin et la valeur maximale des variables en GET...
2462 if ($max_len = @ini_get('suhosin.get.max_value_length')
2463 and $max_len < ($len = strlen($env))) {
2464 $cache_contextes_ajax = true;
2465 spip_log("Contextes AJAX forces en fichiers !"
2466 . " Cela arrive lorsque la valeur du contexte"
2467 . " depasse la longueur maximale autorisee par Suhosin"
2468 . " ($max_len) dans 'suhosin.get.max_value_length'. Ici : $len."
2469 . " Vous devriez modifier les parametres de Suhosin"
2470 . " pour accepter au moins 1024 caracteres.", _LOG_AVERTISSEMENT);
2471 }
2472 }
2473
2474 if ($cache_contextes_ajax) {
2475 $dir = sous_repertoire(_DIR_CACHE, 'contextes');
2476 // stocker les contextes sur disque et ne passer qu'un hash dans l'url
2477 $md5 = md5($c);
2478 ecrire_fichier("$dir/c$md5",$c);
2479 $env = $md5;
2480 }
2481
2482 if ($emboite === NULL) return $env;
2483 if (!trim($emboite)) return "";
2484 // toujours encoder l'url source dans le bloc ajax
2485 $r = self();
2486 $r = ' data-origin="'.$r.'"';
2487 $class = 'ajaxbloc';
2488 if ($ajaxid AND is_string($ajaxid)){
2489 $class .= ' ajax-id-'.$ajaxid;
2490 }
2491 $compl = "aria-live='polite' aria-atomic='true' ";
2492 return "<div class='$class' ".$compl."data-ajax-env='$env'$r>\n$emboite</div><!--ajaxbloc-->\n";
2493 }
2494
2495 // la procedure inverse de encoder_contexte_ajax()
2496 // http://doc.spip.org/@decoder_contexte_ajax
2497 function decoder_contexte_ajax($c,$form='') {
2498 if (!function_exists('calculer_cle_action'))
2499 include_spip("inc/securiser_action");
2500 if (( (defined('_CACHE_CONTEXTES_AJAX') AND _CACHE_CONTEXTES_AJAX) OR strlen($c)==32)
2501 AND $dir = sous_repertoire(_DIR_CACHE, 'contextes')
2502 AND lire_fichier("$dir/c$c",$contexte)) {
2503 $c = $contexte;
2504 } else {
2505 $c = @base64_decode($c);
2506 $c = _xor($c);
2507 if (function_exists('gzdeflate') && function_exists('gzinflate'))
2508 $c = @gzinflate($c);
2509 }
2510 list($env, $cle) = @unserialize($c);
2511
2512 if ($cle == calculer_cle_action($form.(is_array($env)?serialize($env):$env)))
2513 return $env;
2514 return false;
2515 }
2516
2517 // encrypter/decrypter un message
2518 // http://www.php.net/manual/fr/language.operators.bitwise.php#81358
2519 // http://doc.spip.org/@_xor
2520 function _xor($message, $key=null){
2521 if (is_null($key)) {
2522 if (!function_exists('calculer_cle_action'))
2523 include_spip("inc/securiser_action");
2524 $key = pack("H*", calculer_cle_action('_xor'));
2525 }
2526
2527 $keylen = strlen($key);
2528 $messagelen = strlen($message);
2529 for($i=0; $i<$messagelen; $i++)
2530 $message[$i] = ~($message[$i]^$key[$i%$keylen]);
2531
2532 return $message;
2533 }
2534
2535 // Les vrai fonctions sont dans le plugin forum, mais on evite ici une erreur du compilateur
2536 // en absence du plugin
2537 function url_reponse_forum($texte){return $texte;}
2538 function url_rss_forum($texte){return $texte;}
2539
2540
2541 /**
2542 * une fonction pour generer des menus avec liens
2543 * ou un <strong class='on'> non clicable lorsque l'item est selectionne
2544 *
2545 * @param string $url
2546 * @param string $libelle
2547 * le texte du lien
2548 * @param bool $on
2549 * etat expose (genere un strong) ou non (genere un lien)
2550 * @param string $class
2551 * @param string $title
2552 * @param string $rel
2553 * @param string $evt
2554 * complement a la balise a pour gerer un evenement javascript, de la forme " onclick='...'"
2555 * @return string
2556 */
2557 function lien_ou_expose($url,$libelle=NULL,$on=false,$class="",$title="",$rel="", $evt=''){
2558 if ($on) {
2559 $bal = "strong";
2560 $att = "class='on'";
2561 } else {
2562 $bal = 'a';
2563 $att = "href='$url'"
2564 .($title?" title='".attribut_html($title)."'":'')
2565 .($class?" class='".attribut_html($class)."'":'')
2566 .($rel?" rel='".attribut_html($rel)."'":'')
2567 .$evt;
2568 }
2569 if ($libelle === NULL)
2570 $libelle = $url;
2571 return "<$bal $att>$libelle</$bal>";
2572 }
2573
2574
2575 /**
2576 * Afficher un message "un truc"/"N trucs"
2577 * Les items sont à indiquer comme pour la fonction _T() sous la forme :
2578 * "module:chaine"
2579 *
2580 * @param int $nb : le nombre
2581 * @param string $chaine_un : l'item de langue si $nb vaut un
2582 * @param string $chaine_plusieurs : l'item de lanque si $nb > 1
2583 * @param string $var : La variable à remplacer par $nb dans l'item de langue (facultatif, défaut "nb")
2584 * @param array $vars : Les autres variables nécessaires aux chaines de langues (facultatif)
2585 * @return string : la chaine de langue finale en utilisant la fonction _T()
2586 */
2587 function singulier_ou_pluriel($nb,$chaine_un,$chaine_plusieurs,$var='nb',$vars=array()){
2588 if (!$nb=intval($nb)) return "";
2589 if (!is_array($vars)) return "";
2590 $vars[$var] = $nb;
2591 if ($nb>1) return _T($chaine_plusieurs, $vars);
2592 else return _T($chaine_un,$vars);
2593 }
2594
2595
2596 /**
2597 * Fonction de base pour une icone dans un squelette
2598 * structure html : <span><a><img><b>texte</b></span>
2599 *
2600 * @param string $type
2601 * 'lien' ou 'bouton'
2602 * @param string $lien
2603 * url
2604 * @param string $texte
2605 * texte du lien / alt de l'image
2606 * @param string $fond
2607 * objet avec ou sans son extension et sa taille (article, article-24, article-24.png)
2608 * @param string $fonction
2609 * new/del/edit
2610 * @param string $class
2611 * classe supplementaire (horizontale, verticale, ajax ...)
2612 * @param string $javascript
2613 * "onclick='...'" par exemple
2614 * @return string
2615 */
2616 function prepare_icone_base($type, $lien, $texte, $fond, $fonction="", $class="",$javascript=""){
2617 if (in_array($fonction,array("del","supprimer.gif")))
2618 $class .= ' danger';
2619 elseif ($fonction == "rien.gif")
2620 $fonction = "";
2621 elseif ($fonction == "delsafe")
2622 $fonction = "del";
2623
2624 // remappage des icone : article-24.png+new => article-new-24.png
2625 if ($icone_renommer = charger_fonction('icone_renommer','inc',true))
2626 list($fond,$fonction) = $icone_renommer($fond,$fonction);
2627
2628 // ajouter le type d'objet dans la class de l'icone
2629 $class .= " " . substr(basename($fond),0,-4);
2630
2631 $alt = attribut_html($texte);
2632 $title = " title=\"$alt\""; // est-ce pertinent de doubler le alt par un title ?
2633
2634 $ajax = "";
2635 if (strpos($class,"ajax")!==false) {
2636 $ajax="ajax";
2637 if (strpos($class,"preload")!==false)
2638 $ajax.=" preload";
2639 if (strpos($class,"nocache")!==false)
2640 $ajax.=" nocache";
2641 $ajax=" class='$ajax'";
2642 }
2643
2644 $size = 24;
2645 if (preg_match("/-([0-9]{1,3})[.](gif|png)$/i",$fond,$match))
2646 $size = $match[1];
2647
2648 if ($fonction){
2649 // 2 images pour composer l'icone : le fond (article) en background,
2650 // la fonction (new) en image
2651 $icone = http_img_pack($fonction, $alt, "width='$size' height='$size'\n" .
2652 http_style_background($fond));
2653 }
2654 else {
2655 $icone = http_img_pack($fond, $alt, "width='$size' height='$size'");
2656 }
2657
2658 if ($type=='lien')
2659 return "<span class='icone s$size $class'>"
2660 . "<a href='$lien'$title$ajax$javascript>"
2661 . $icone
2662 . "<b>$texte</b>"
2663 . "</a></span>\n";
2664
2665 else
2666 return bouton_action("$icone<b>$texte</b>",$lien,"icone s$size $class",$javascript,$alt);
2667 }
2668
2669 function icone_base($lien, $texte, $fond, $fonction="", $class="",$javascript=""){
2670 return prepare_icone_base('lien', $lien, $texte, $fond, $fonction, $class, $javascript);
2671 }
2672 function filtre_icone_verticale_dist($lien, $texte, $fond, $fonction="", $class="",$javascript=""){
2673 return icone_base($lien,$texte,$fond,$fonction,"verticale $class",$javascript);
2674 }
2675 function filtre_icone_horizontale_dist($lien, $texte, $fond, $fonction="", $class="",$javascript=""){
2676 return icone_base($lien,$texte,$fond,$fonction,"horizontale $class",$javascript);
2677 }
2678
2679 function filtre_bouton_action_horizontal_dist($lien, $texte, $fond, $fonction="", $class="",$confirm=""){
2680 return prepare_icone_base('bouton', $lien, $texte, $fond, $fonction, "horizontale $class", $confirm);
2681 }
2682 /*
2683 * Filtre icone pour compatibilite
2684 * mappe sur icone_base
2685 */
2686 function filtre_icone_dist($lien, $texte, $fond, $align="", $fonction="", $class="",$javascript=""){
2687 return icone_base($lien,$texte,$fond,$fonction,"verticale $align $class",$javascript);
2688 }
2689
2690
2691 /**
2692 * filtre explode pour les squelettes permettant d'ecrire
2693 * #GET{truc}|explode{-}
2694 *
2695 * @param strong $a
2696 * @param string $b
2697 * @return array
2698 */
2699 function filtre_explode_dist($a,$b){return explode($b,$a);}
2700
2701 /**
2702 * filtre implode pour les squelettes permettant d'ecrire
2703 * #GET{truc}|implode{-}
2704 *
2705 * @param array $a
2706 * @param string $b
2707 * @return string
2708 */
2709 function filtre_implode_dist($a,$b){return is_array($a)?implode($b,$a):$a;}
2710
2711 /**
2712 * Produire les styles prives qui associent item de menu avec icone en background
2713 * @return string
2714 */
2715 function bando_images_background(){
2716 include_spip('inc/bandeau');
2717 // recuperer tous les boutons et leurs images
2718 $boutons = definir_barre_boutons(definir_barre_contexte(),true,false);
2719
2720 $res = "";
2721 foreach($boutons as $page => $detail){
2722 if ($detail->icone AND strlen(trim($detail->icone)))
2723 $res .="\n.navigation_avec_icones #bando1_$page {background-image:url(".$detail->icone.");}";
2724 $selecteur = (in_array($page,array('outils_rapides','outils_collaboratifs'))?"":".navigation_avec_icones ");
2725 if (is_array($detail->sousmenu))
2726 foreach($detail->sousmenu as $souspage=>$sousdetail)
2727 if ($sousdetail->icone AND strlen(trim($sousdetail->icone)))
2728 $res .="\n$selecteur.bando2_$souspage {background-image:url(".$sousdetail->icone.");}";
2729 }
2730 return $res;
2731 }
2732
2733 /**
2734 * Generer un bouton_action
2735 * utilise par #BOUTON_ACTION
2736 *
2737 * @param string $libelle
2738 * @param string $url
2739 * @param string $class
2740 * @param string $confirm
2741 * message de confirmation oui/non avant l'action
2742 * @param string $title
2743 * @param string $callback
2744 * callback js a appeler lors de l'evenement action (apres confirmation eventuelle si $confirm est non vide)
2745 * et avant execution de l'action. Si la callback renvoie false, elle annule le declenchement de l'action
2746 * @return string
2747 */
2748 function bouton_action($libelle, $url, $class="", $confirm="", $title="", $callback=""){
2749 if ($confirm) {
2750 $confirm = "confirm(\"" . attribut_html($confirm) . "\")";
2751 if ($callback)
2752 $callback = "$confirm?($callback):false";
2753 else
2754 $callback = $confirm;
2755 }
2756 $onclick = $callback?" onclick='return ".addcslashes($callback,"'")."'":"";
2757 $title = $title ? " title='$title'" : "";
2758 return "<form class='bouton_action_post $class' method='post' action='$url'><div>".form_hidden($url)
2759 ."<button type='submit' class='submit'$title$onclick>$libelle</button></div></form>";
2760 }
2761
2762
2763 /**
2764 * Proteger les champs passes dans l'url et utiliser dans {tri ...}
2765 * preserver l'espace pour interpreter ensuite num xxx et multi xxx
2766 * @param string $t
2767 * @return string
2768 */
2769 function tri_protege_champ($t){
2770 return preg_replace(',[^\s\w.+],','',$t);
2771 }
2772
2773 /**
2774 * Interpreter les multi xxx et num xxx utilise comme tri
2775 * pour la clause order
2776 * 'multi xxx' devient simplement 'multi' qui est calcule dans le select
2777 * @param string $t
2778 * @param array $from
2779 * @return string
2780 */
2781 function tri_champ_order($t, $from=null){
2782 if(strncmp($t,'multi ',6)==0){
2783 return "multi";
2784 }
2785
2786 $champ = $t;
2787
2788 if (strncmp($t,'num ',4)==0)
2789 $champ = substr($t,4);
2790 // enlever les autres espaces non evacues par tri_protege_champ
2791 $champ = preg_replace(',\s,','',$champ);
2792
2793 if (is_array($from)){
2794 $trouver_table = charger_fonction('trouver_table','base');
2795 foreach($from as $idt=>$table_sql){
2796 if ($desc = $trouver_table($table_sql)
2797 AND isset($desc['field'][$champ])){
2798 $champ = "$idt.$champ";
2799 break;
2800 }
2801 }
2802 }
2803 if (strncmp($t,'num ',4)==0)
2804 return "0+$champ";
2805 else
2806 return $champ;
2807 }
2808
2809 /**
2810 * Interpreter les multi xxx et num xxx utilise comme tri
2811 * pour la clause select
2812 * 'multi xxx' devient select "...." as multi
2813 * les autres cas ne produisent qu'une chaine vide '' en select
2814 * 'hasard' devient 'rand() AS hasard' dans le select
2815 *
2816 * @param string $t
2817 * @return string
2818 */
2819 function tri_champ_select($t){
2820 if(strncmp($t,'multi ',6)==0){
2821 $t = substr($t,6);
2822 $t = preg_replace(',\s,','',$t);
2823 $t = sql_multi($t,$GLOBALS['spip_lang']);
2824 return $t;
2825 }
2826 if(trim($t)=='hasard'){
2827 return 'rand() AS hasard';
2828 }
2829 return "''";
2830 }
2831
2832
2833 /**
2834 * Donner n'importe quelle information sur un objet de maniere generique.
2835 *
2836 * La fonction va gerer en interne deux cas particuliers les plus utilises :
2837 * l'URL et le titre (qui n'est pas forcemment le champ SQL "titre").
2838 *
2839 * On peut ensuite personnaliser les autres infos en creant une fonction
2840 * generer_<nom_info>_entite($id_objet, $type_objet, $ligne).
2841 * $ligne correspond a la ligne SQL de tous les champs de l'objet, les fonctions
2842 * de personnalisation n'ont donc pas a refaire de requete.
2843 *
2844 * @param int $id_objet
2845 * @param string $type_objet
2846 * @param string $info
2847 * @param string $etoile
2848 * @return string
2849 */
2850 function generer_info_entite($id_objet, $type_objet, $info, $etoile=""){
2851 global $table_des_traitements;
2852 static $trouver_table=null;
2853 static $objets;
2854
2855 // On verifie qu'on a tout ce qu'il faut
2856 $id_objet = intval($id_objet);
2857 if (!($id_objet and $type_objet and $info))
2858 return '';
2859
2860 // si on a deja note que l'objet n'existe pas, ne pas aller plus loin
2861 if (isset($objets[$type_objet]) AND $objets[$type_objet]===false)
2862 return '';
2863
2864 // Si on demande l'url, on retourne direct la fonction
2865 if ($info == 'url')
2866 return generer_url_entite($id_objet, $type_objet);
2867
2868 // Sinon on va tout chercher dans la table et on garde en memoire
2869 $demande_titre = ($info == 'titre');
2870
2871 // On ne fait la requete que si on a pas deja l'objet ou si on demande le titre mais qu'on ne l'a pas encore
2872 if (!isset($objets[$type_objet][$id_objet])
2873 OR
2874 ($demande_titre AND !isset($objets[$type_objet][$id_objet]['titre']))
2875 ){
2876 if (!$trouver_table)
2877 $trouver_table = charger_fonction('trouver_table','base');
2878 $desc = $trouver_table(table_objet_sql($type_objet));
2879 if (!$desc)
2880 return $objets[$type_objet] = false;
2881
2882 // Si on demande le titre, on le gere en interne
2883 $champ_titre = "";
2884 if ($demande_titre){
2885 // si pas de titre declare mais champ titre, il sera peuple par le select *
2886 $champ_titre = (!empty($desc['titre'])) ? ', ' . $desc['titre']:'';
2887 }
2888 include_spip('base/abstract_sql');
2889 include_spip('base/connect_sql');
2890 $objets[$type_objet][$id_objet] = sql_fetsel(
2891 '*'.$champ_titre,
2892 $desc['table_sql'],
2893 id_table_objet($type_objet).' = '.intval($id_objet)
2894 );
2895 }
2896
2897 // Si la fonction generer_TRUC_TYPE existe, on l'utilise pour formater $info_generee
2898 if ($generer = charger_fonction("generer_${info}_${type_objet}", '', true))
2899 $info_generee = $generer($id_objet, $objets[$type_objet][$id_objet]);
2900 // Si la fonction generer_TRUC_entite existe, on l'utilise pour formater $info_generee
2901 else if ($generer = charger_fonction("generer_${info}_entite", '', true))
2902 $info_generee = $generer($id_objet, $type_objet, $objets[$type_objet][$id_objet]);
2903 // Sinon on prend directement le champ SQL tel quel
2904 else
2905 $info_generee = (isset($objets[$type_objet][$id_objet][$info])?$objets[$type_objet][$id_objet][$info]:'');
2906
2907 // On va ensuite chercher les traitements automatiques a faire
2908 $champ = strtoupper($info);
2909 $traitement = isset($table_des_traitements[$champ]) ? $table_des_traitements[$champ] : false;
2910 $table_sql = table_objet_sql($type_objet);
2911
2912 if (!$etoile
2913 AND is_array($traitement)
2914 AND (isset($traitement[$table_sql]) OR isset($traitement[0]))){
2915 $traitement = $traitement[isset($traitement[$table_sql]) ? $table_sql : 0];
2916 $traitement = str_replace('%s', "'".texte_script($info_generee)."'", $traitement);
2917 // FIXME: $connect et $Pile[0] font souvent partie des traitements.
2918 // on les definit pour eviter des notices, mais ce fonctionnement est a ameliorer !
2919 $connect = ""; $Pile = array(0 => array('id_objet'=>$id_objet,'objet'=>$type_objet));
2920 eval("\$info_generee = $traitement;");
2921 }
2922
2923 return $info_generee;
2924 }
2925
2926 /**
2927 * Wrap un texte avec des balises
2928 * wrap('mot','<b>') => '<b>mot</b>'
2929 * @param string $texte
2930 * @param string $wrap
2931 * @return string
2932 */
2933 function wrap($texte,$wrap) {
2934 $balises = extraire_balises($wrap);
2935 if (preg_match_all(",<([a-z]\w*)\b[^>]*>,UimsS",$wrap, $regs, PREG_PATTERN_ORDER)) {
2936 $texte = $wrap . $texte;
2937 $regs = array_reverse($regs[1]);
2938 $wrap = "</".implode("></",$regs).">";
2939 $texte = $texte . $wrap;
2940 }
2941 return $texte;
2942 }
2943
2944
2945 /**
2946 * afficher proprement n'importe quoi
2947 * On affiche in fine un pseudo-yaml qui premet de lire humainement les tableaux et de s'y reperer
2948 *
2949 * Les textes sont retournes avec simplement mise en forme typo
2950 *
2951 * le $join sert a separer les items d'un tableau, c'est en general un \n ou <br /> selon si on fait du html ou du texte
2952 * les tableaux-listes (qui n'ont que des cles numeriques), sont affiches sous forme de liste separee par des virgules :
2953 * c'est VOULU !
2954 *
2955 * @param $u
2956 * @param string $join
2957 * @param int $indent
2958 * @return array|mixed|string
2959 */
2960 function filtre_print_dist($u, $join="<br />", $indent=0) {
2961 if (is_string($u)){
2962 $u = typo($u);
2963 return $u;
2964 }
2965
2966 // caster $u en array si besoin
2967 if (is_object($u))
2968 $u = (array) $u;
2969
2970 if (is_array($u)){
2971 $out = "";
2972 // toutes les cles sont numeriques ?
2973 // et aucun enfant n'est un tableau
2974 // liste simple separee par des virgules
2975 $numeric_keys = array_map('is_numeric',array_keys($u));
2976 $array_values = array_map('is_array',$u);
2977 $object_values = array_map('is_object',$u);
2978 if (array_sum($numeric_keys)==count($numeric_keys)
2979 AND !array_sum($array_values)
2980 AND !array_sum($object_values)){
2981 return join(", ", array_map('filtre_print_dist', $u));
2982 }
2983
2984 // sinon on passe a la ligne et on indente
2985 $i_str = str_pad("",$indent," ");
2986 foreach($u as $k => $v){
2987 $out .= $join . $i_str . "$k: " . filtre_print_dist($v,$join,$indent+2);
2988 }
2989 return $out;
2990 }
2991
2992 // on sait pas quoi faire...
2993 return $u;
2994 }
2995
2996
2997 /**
2998 * Renvoyer l'info d'un objet
2999 * telles que definies dans declarer_tables_objets_sql
3000 *
3001 * @param string $objet
3002 * @param string $info
3003 * @return string
3004 */
3005 function objet_info($objet,$info){
3006 $table = table_objet_sql($objet);
3007 $infos = lister_tables_objets_sql($table);
3008 return (isset($infos[$info])?$infos[$info]:'');
3009 }
3010
3011 /**
3012 * Filtre pour afficher 'Aucun truc' ou '1 truc' ou 'N trucs'
3013 * avec la bonne chaine de langue en fonction de l'objet utilise
3014 * @param $nb
3015 * @param $objet
3016 * @return mixed|string
3017 */
3018 function objet_afficher_nb($nb, $objet){
3019 if (!$nb)
3020 return _T(objet_info($objet,'info_aucun_objet'));
3021 else
3022 return _T(objet_info($objet,$nb==1?'info_1_objet':'info_nb_objets'),array('nb'=>$nb));
3023 }
3024
3025 /**
3026 * Filtre pour afficher l'img icone d'un objet
3027 *
3028 * @param string $objet
3029 * @param int $taille
3030 * @return string
3031 */
3032 function objet_icone($objet,$taille=24){
3033 $icone = objet_info($objet,'icone_objet')."-".$taille.".png";
3034 $icone = chemin_image($icone);
3035 $balise_img = charger_filtre('balise_img');
3036 return $icone?$balise_img($icone,_T(objet_info($objet,'texte_objet'))):'';
3037 }
3038
3039 /**
3040 * Fonction de secours pour inserer le head_css de facon conditionnelle
3041 *
3042 * Appelée en filtre sur le squelette qui contient #INSERT_HEAD,
3043 * elle vérifie l'absence éventuelle de #INSERT_HEAD_CSS et y suplée si besoin
3044 * pour assurer la compat avec les squelettes qui n'utilisent pas.
3045 *
3046 * @param string $flux Code HTML
3047 * @return string Code HTML
3048 */
3049 function insert_head_css_conditionnel($flux){
3050 if (strpos($flux,'<!-- insert_head_css -->')===false
3051 AND $p=strpos($flux,'<!-- insert_head -->')){
3052 // plutot avant le premier js externe (jquery) pour etre non bloquant
3053 if ($p1 = stripos($flux,'<script src=') AND $p1<$p)
3054 $p = $p1;
3055 $flux = substr_replace($flux,pipeline('insert_head_css','<!-- insert_head_css -->'),$p,0);
3056 }
3057 return $flux;
3058 }
3059
3060 /**
3061 * Produire un fichier statique a partir d'un squelette dynamique
3062 * Permet ensuite a apache de le servir en statique sans repasser
3063 * par spip.php a chaque hit sur le fichier
3064 * si le format (css ou js) est passe dans contexte['format'], on l'utilise
3065 * sinon on regarde si le fond finit par .css ou .js
3066 * sinon on utilie "html"
3067 *
3068 * @param string $fond
3069 * @param array $contexte
3070 * @param array $options
3071 * @param string $connect
3072 * @return string
3073 */
3074 function produire_fond_statique($fond, $contexte=array(), $options = array(), $connect=''){
3075 if (isset($contexte['format'])){
3076 $extension = $contexte['format'];
3077 unset($contexte['format']);
3078 }
3079 else {
3080 $extension = "html";
3081 if (preg_match(',[.](css|js|json)$,',$fond,$m))
3082 $extension = $m[1];
3083 }
3084 // recuperer le contenu produit par le squelette
3085 $options['raw'] = true;
3086 $cache = recuperer_fond($fond,$contexte,$options,$connect);
3087
3088 // calculer le nom de la css
3089 $dir_var = sous_repertoire (_DIR_VAR, 'cache-'.$extension);
3090 $nom_safe = preg_replace(",\W,",'_',str_replace('.','_',$fond));
3091 $filename = $dir_var . $extension."dyn-$nom_safe-".substr(md5($fond.serialize($contexte).$connect),0,8) .".$extension";
3092
3093 // mettre a jour le fichier si il n'existe pas
3094 // ou trop ancien
3095 // le dernier fichier produit est toujours suffixe par .last
3096 // et recopie sur le fichier cible uniquement si il change
3097 if (!file_exists($filename)
3098 OR !file_exists($filename.".last")
3099 OR (isset($cache['lastmodified']) AND $cache['lastmodified'] AND filemtime($filename.".last")<$cache['lastmodified'])
3100 OR (defined('_VAR_MODE') AND _VAR_MODE=='recalcul')) {
3101 $contenu = $cache['texte'];
3102 // passer les urls en absolu si c'est une css
3103 if ($extension=="css")
3104 $contenu = urls_absolues_css($contenu, test_espace_prive()?generer_url_ecrire('accueil'):generer_url_public($fond));
3105
3106 // ne pas insérer de commentaire si c'est du json
3107 if ($extension!="json") {
3108 $comment = "/* #PRODUIRE{fond=$fond";
3109 foreach($contexte as $k=>$v)
3110 $comment .= ",$k=$v";
3111 // pas de date dans le commentaire car sinon ca invalide le md5 et force la maj
3112 // mais on peut mettre un md5 du contenu, ce qui donne un aperu rapide si la feuille a change ou non
3113 $comment .="}\n md5:".md5($contenu)." */\n";
3114 }
3115 // et ecrire le fichier
3116 ecrire_fichier($filename.".last",$comment.$contenu);
3117 // regarder si on recopie
3118 if (!file_exists($filename)
3119 OR md5_file($filename)!==md5_file($filename.".last")){
3120 @copy($filename.".last",$filename);
3121 spip_clearstatcache(true,$filename); // eviter que PHP ne reserve le vieux timestamp
3122 }
3123 }
3124
3125 return $filename;
3126 }
3127
3128 /**
3129 * Ajouter un timestamp a une url de fichier
3130 * [(#CHEMIN{monfichier}|timestamp)]
3131 *
3132 * @param string $fichier
3133 * @return string
3134 */
3135 function timestamp($fichier){
3136 if (!$fichier OR !file_exists($fichier)) return $fichier;
3137 $m = filemtime($fichier);
3138 return "$fichier?$m";
3139 }
3140
3141 /**
3142 * Nettoyer le titre d'un email
3143 * eviter une erreur lorsqu'on utilise |nettoyer_titre_email dans un squelette de mail
3144 * @param $titre
3145 * @return mixed
3146 */
3147 function filtre_nettoyer_titre_email_dist($titre){
3148 include_spip('inc/envoyer_mail');
3149 return nettoyer_titre_email($titre);
3150 }
3151
3152 /**
3153 * Afficher le sélecteur de rubrique
3154 *
3155 * Il permet de placer un objet dans la hiérarchie des rubriques de SPIP
3156 *
3157 * @param string $titre
3158 * @param int $id_objet
3159 * @param int $id_parent
3160 * @param string $objet
3161 * @param int $id_secteur
3162 * @param bool $restreint
3163 * @param bool $actionable
3164 * true : fournit le selecteur dans un form directement postable
3165 * @param bool $retour_sans_cadre
3166 * @return string
3167 */
3168 function filtre_chercher_rubrique_dist($titre,$id_objet, $id_parent, $objet, $id_secteur, $restreint,$actionable = false, $retour_sans_cadre=false){
3169 include_spip('inc/filtres_ecrire');
3170 return chercher_rubrique($titre,$id_objet, $id_parent, $objet, $id_secteur, $restreint,$actionable, $retour_sans_cadre);
3171 }
3172
3173 /**
3174 * Rediriger une page suivant une autorisation,
3175 * et ce, n'importe où dans un squelette, même dans les inclusions.
3176 * Exemple :
3177 * [(#AUTORISER{non}|sinon_interdire_acces)]
3178 * [(#AUTORISER{non}|sinon_interdire_acces{#URL_PAGE{login}, 401})]
3179 *
3180 * @param bool $ok Indique si l'on doit rediriger ou pas
3181 * @param string $url Adresse vers laquelle rediriger
3182 * @param int $statut Statut HTML avec lequel on redirigera
3183 * @return string
3184 */
3185 function sinon_interdire_acces($ok=false, $url='', $statut=0){
3186 if ($ok) return '';
3187
3188 // Vider tous les tampons
3189 $level = @ob_get_level();
3190 while ($level--)
3191 @ob_end_clean();
3192
3193 include_spip('inc/headers');
3194 $statut = intval($statut);
3195
3196 // Si aucun argument on essaye de deviner quoi faire par défaut
3197 if (!$url and !$statut){
3198 // Si on est dans l'espace privé, on génère du 403 Forbidden
3199 if (test_espace_prive()){
3200 http_status(403);
3201 $echec = charger_fonction('403','exec');
3202 $echec();
3203 }
3204 // Sinon dans l'espace public on redirige vers une 404 par défaut, car elle toujours présente normalement
3205 else{
3206 $statut = 404;
3207 }
3208 }
3209
3210 // On suit les directives indiquées dans les deux arguments
3211
3212 // S'il y a un statut
3213 if ($statut){
3214 // Dans tous les cas on modifie l'entité avec ce qui est demandé
3215 http_status($statut);
3216 // Si le statut est une erreur et qu'il n'y a pas de redirection on va chercher le squelette du même nom
3217 if ($statut >= 400 and !$url)
3218 echo recuperer_fond("$statut");
3219 }
3220
3221 // S'il y a une URL, on redirige (si pas de statut, la fonction mettra 302 par défaut)
3222 if ($url) redirige_par_entete($url, '', $statut);
3223
3224 exit;
3225 }
3226
3227 /**
3228 * Assurer le fonctionnement de |compacte meme sans l'extension compresseur
3229 * @param string $source
3230 * @param null|string $format
3231 * @return string
3232 */
3233 function filtre_compacte_dist($source, $format = null){
3234 if (function_exists('compacte'))
3235 return compacte($source, $format);
3236 return $source;
3237 }
3238
3239 ?>
Site oueb du p’Tit véLo dAnS La Tête