Mise en route du suivi.
[aidenligne_francais_universite.git] / ecrire / inc / filtres.php
1 <?php
2
3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
5 * *
6 * Copyright (c) 2001-2007 *
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
14 if (!defined("_ECRIRE_INC_VERSION")) return;
15
16 include_spip('inc/charsets');
17 // on definit la matrice pour les filtres images : le compilateur fera passer l'appel par filtrer
18 // on ne definit pas de fichier a inclure : l'inclusion sera faite dans image_filtrer
19 // par un include_spip unique en cas d'appel multiple
20
21 $GLOBALS['spip_matrice']['image_valeurs_trans'] = '';
22 $GLOBALS['spip_matrice']['image_reduire'] = '';
23 $GLOBALS['spip_matrice']['image_reduire_par'] = '';
24 $GLOBALS['spip_matrice']['image_recadre'] = '';
25 $GLOBALS['spip_matrice']['image_alpha'] = '';
26 $GLOBALS['spip_matrice']['image_flip_vertical'] = '';
27 $GLOBALS['spip_matrice']['image_flip_horizontal'] = '';
28 $GLOBALS['spip_matrice']['image_masque'] = '';
29 $GLOBALS['spip_matrice']['image_nb'] = '';
30 $GLOBALS['spip_matrice']['image_flou'] = '';
31 $GLOBALS['spip_matrice']['image_RotateBicubic'] = '';
32 $GLOBALS['spip_matrice']['image_rotation'] = '';
33 $GLOBALS['spip_matrice']['image_distance_pixel'] = '';
34 $GLOBALS['spip_matrice']['image_decal_couleur'] = '';
35 $GLOBALS['spip_matrice']['image_gamma'] = '';
36 $GLOBALS['spip_matrice']['image_decal_couleur_127'] = '';
37 $GLOBALS['spip_matrice']['image_sepia'] = '';
38 $GLOBALS['spip_matrice']['image_aplatir'] = '';
39 $GLOBALS['spip_matrice']['image_couleur_extraire'] = '';
40 $GLOBALS['spip_matrice']['image_select'] = '';
41 $GLOBALS['spip_matrice']['image_renforcement'] = '';
42 $GLOBALS['spip_matrice']['image_imagick'] = '';
43
44 $inc_filtres_images = _DIR_RESTREINT."inc/filtres_images.php"; # find_in_path('inc/filtres_images');
45 $GLOBALS['spip_matrice']['couleur_dec_to_hex'] = $inc_filtres_images;
46 $GLOBALS['spip_matrice']['couleur_hex_to_dec'] = $inc_filtres_images;
47 $GLOBALS['spip_matrice']['couleur_extreme'] = $inc_filtres_images;
48 $GLOBALS['spip_matrice']['couleur_inverser'] = $inc_filtres_images;
49 $GLOBALS['spip_matrice']['couleur_eclaircir'] = $inc_filtres_images;
50 $GLOBALS['spip_matrice']['couleur_foncer'] = $inc_filtres_images;
51 $GLOBALS['spip_matrice']['couleur_foncer_si_claire'] = $inc_filtres_images;
52 $GLOBALS['spip_matrice']['couleur_eclaircir_si_foncee'] = $inc_filtres_images;
53
54 // Appliquer un filtre (eventuellement defini dans la matrice) aux donnees
55 // et arguments
56 // http://doc.spip.org/@filtrer
57 function filtrer($filtre) {
58 if ($f = $GLOBALS['spip_matrice'][$filtre])
59 include_once($f);
60
61 $tous = func_get_args();
62 if (substr($filtre,0,6)=='image_')
63 return image_filtrer($tous);
64 else{
65 array_shift($tous); # enlever $filtre
66 return call_user_func_array($filtre, $tous);
67 }
68 }
69
70
71 // http://doc.spip.org/@spip_version
72 function spip_version() {
73 $version = $GLOBALS['spip_version_affichee'];
74 include_spip('inc/minipres');
75 if ($svn_revision = version_svn_courante(_DIR_RACINE))
76 $version .= ($svn_revision<0 ? ' SVN':'').' ['.abs($svn_revision).']';
77 return $version;
78 }
79
80 //
81 // Fonctions graphiques
82 //
83
84 // fonction generique d'entree des filtres images
85 // accepte en entree un texte complet, un img-log (produit par #LOGO_XX),
86 // un tag <img ...> complet, ou encore un nom de fichier *local* (passer
87 // le filtre |copie_locale si on veut l'appliquer a un document)
88 // applique le filtre demande a chacune des occurences
89
90 // http://doc.spip.org/@image_filtrer
91 function image_filtrer($args){
92 static $inclure = true;
93 $filtre = array_shift($args); # enlever $filtre
94 $texte = array_shift($args);
95 if (!$texte) return;
96 // Cas du nom de fichier local
97 if (preg_match(',^('._DIR_IMG .'|'. _DIR_IMG_PACK .'|'. _DIR_VAR .'),', $texte)) {
98 if ($inclure){
99 include_spip('inc/filtres_images');
100 $inclure = false;
101 }
102 array_unshift($args,"<img src='$texte' />");
103 return call_user_func_array($filtre, $args);
104 }
105
106 // Cas general : trier toutes les images, avec eventuellement leur <span>
107 if (preg_match_all(
108 ',(<([a-z]+) [^<>]*spip_documents[^<>]*>)?\s*(<img\s.*>),UimsS',
109 $texte, $tags, PREG_SET_ORDER)) {
110 if ($inclure){
111 include_spip('inc/filtres_images');
112 $inclure = false;
113 }
114 foreach ($tags as $tag) {
115 $class = extraire_attribut($tag[3],'class');
116 if (!$class || (strpos($class,'no_image_filtrer')===FALSE)){
117 array_unshift($args,$tag[3]);
118 if ($reduit = call_user_func_array($filtre, $args)) {
119 // En cas de span spip_documents, modifier le style=...width:
120 if($tag[1]){
121 $w = extraire_attribut($reduit, 'width');
122 if (!$w AND preg_match(",width:\s*(\d+)px,S",extraire_attribut($reduit,'style'),$regs))
123 $w = $regs[1];
124 if ($w AND ($style = extraire_attribut($tag[1], 'style'))){
125 $style = preg_replace(",width:\s*\d+px,S", "width:${w}px", $style);
126 $replace = inserer_attribut($tag[1], 'style', $style);
127 $texte = str_replace($tag[1], $replace, $texte);
128 }
129 }
130 // traiter aussi un eventuel mouseover
131 if ($mouseover = extraire_attribut($reduit,'onmouseover')){
132 if (preg_match(",this[.]src=['\"]([^'\"]+)['\"],ims", $mouseover, $match)){
133 $srcover = $match[1];
134 array_shift($args);
135 array_unshift($args,"<img src='".$match[1]."' />");
136 $srcover_filter = call_user_func_array($filtre, $args);
137 $srcover_filter = extraire_attribut($srcover_filter,'src');
138 $reduit = str_replace($srcover,$srcover_filter,$reduit);
139 }
140 }
141 $texte = str_replace($tag[3], $reduit, $texte);
142 }
143 array_shift($args);
144 }
145 }
146 }
147
148 return $texte;
149 }
150
151 // Pour assurer la compatibilite avec les anciens nom des filtres image_xxx
152 // commencent par "image_"
153 // http://doc.spip.org/@reduire_image
154 function reduire_image($texte, $taille = -1, $taille_y = -1) {
155 return filtrer('image_reduire',$texte, $taille, $taille_y);
156 }
157 // http://doc.spip.org/@valeurs_image_trans
158 function valeurs_image_trans($img, $effet, $forcer_format = false) {
159 include_spip('inc/filtres_images');
160 return image_valeurs_trans($img, $effet, $forcer_format = false);
161 }
162 // http://doc.spip.org/@couleur_extraire
163 function couleur_extraire($img, $x=10, $y=6) {
164 return filtrer('image_couleur_extraire',$img, $x, $y);
165 }
166 // http://doc.spip.org/@image_typo
167 function image_typo() {
168 include_spip('inc/filtres_images');
169 $tous = func_get_args();
170 return call_user_func_array('produire_image_typo', $tous);
171 }
172
173 //
174 // Retourner taille d'une image
175 // pour les filtres |largeur et |hauteur
176 //
177 // http://doc.spip.org/@taille_image
178 function taille_image($img) {
179 static $largeur_img =array(), $hauteur_img= array();
180 $srcWidth = 0;
181 $srcHeight = 0;
182
183 $logo = extraire_attribut($img,'src');
184 if (!$logo) $logo = $img;
185 else {
186 $srcWidth = extraire_attribut($img,'width');
187 $srcHeight = extraire_attribut($img,'height');
188 }
189
190 // pour essayer de limiter les lectures disque
191 // $meme remplace $logo, pour unifier certains fichiers dont on sait qu'ils ont la meme taille
192 $mem = $logo;
193 if (strrpos($mem,"/") > 0) $mem = substr($mem, strrpos($mem,"/")+1, strlen($mem));
194 $mem = ereg_replace("\-flip\_v|\-flip\_h", "", $mem);
195 $mem = ereg_replace("\-nb\-[0-9]+(\.[0-9]+)?\-[0-9]+(\.[0-9]+)?\-[0-9]+(\.[0-9]+)?", "", $mem);
196
197 $srcsize = false;
198 if (isset($largeur_img[$mem]))
199 $srcWidth = $largeur_img[$mem];
200 if (!$srcWidth AND $srcsize = @getimagesize($logo)) {
201 $srcWidth = $srcsize[0];
202 $largeur_img[$mem] = $srcWidth;
203 }
204 if (isset($hauteur_img[$mem]))
205 $srcHeight = $hauteur_img[$mem];
206 if (!$srcHeight AND ($srcsize OR ($srcsize = @getimagesize($logo)))) {
207 $srcHeight = $srcsize[1];
208 $hauteur_img[$mem] = $srcHeight;
209 }
210 return array($srcHeight, $srcWidth);
211 }
212 // http://doc.spip.org/@largeur
213 function largeur($img) {
214 if (!$img) return;
215 list ($h,$l) = taille_image($img);
216 return $l;
217 }
218 // http://doc.spip.org/@hauteur
219 function hauteur($img) {
220 if (!$img) return;
221 list ($h,$l) = taille_image($img);
222 return $h;
223 }
224
225
226 // Echappement des entites HTML avec correction des entites "brutes"
227 // (generees par les butineurs lorsqu'on rentre des caracteres n'appartenant
228 // pas au charset de la page [iso-8859-1 par defaut])
229 //
230 // Attention on limite cette correction aux caracteres "hauts" (en fait > 99
231 // pour aller plus vite que le > 127 qui serait logique), de maniere a
232 // preserver des echappements de caracteres "bas" (par exemple [ ou ")
233 // et au cas particulier de &amp; qui devient &amp;amp; dans les url
234 // http://doc.spip.org/@corriger_entites_html
235 function corriger_entites_html($texte) {
236 if (strpos($texte,'&amp;') === false) return $texte;
237 return preg_replace(',&amp;(#[0-9][0-9][0-9]+;|amp;),iS', '&\1', $texte);
238 }
239 // idem mais corriger aussi les &amp;eacute; en &eacute;
240 // http://doc.spip.org/@corriger_toutes_entites_html
241 function corriger_toutes_entites_html($texte) {
242 if (strpos($texte,'&amp;') === false) return $texte;
243 return preg_replace(',&amp;(#?[a-z0-9]+;),S', '&\1', $texte);
244 }
245
246 // http://doc.spip.org/@entites_html
247 function entites_html($texte) {
248 return corriger_entites_html(htmlspecialchars($texte));
249 }
250
251 // Transformer les &eacute; dans le charset local
252 // http://doc.spip.org/@filtrer_entites
253 function filtrer_entites($texte) {
254 if (strpos($texte,'&') === false) return $texte;
255 # include_spip('inc/charsets');
256 // filtrer
257 $texte = html2unicode($texte);
258 // remettre le tout dans le charset cible
259 return unicode2charset($texte);
260 }
261
262 // caracteres de controle - http://www.w3.org/TR/REC-xml/#charsets
263 // http://doc.spip.org/@supprimer_caracteres_illegaux
264 function supprimer_caracteres_illegaux($texte) {
265 $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";
266 $to = str_repeat('-', strlen($from));
267 return strtr($texte, $from, $to);
268 }
269
270 // Supprimer caracteres windows et les caracteres de controle ILLEGAUX
271 // http://doc.spip.org/@corriger_caracteres
272 function corriger_caracteres ($texte) {
273 include_spip('inc/charsets');
274 $texte = corriger_caracteres_windows($texte);
275 $texte = supprimer_caracteres_illegaux($texte);
276 return $texte;
277 }
278
279 // Encode du HTML pour transmission XML
280 // http://doc.spip.org/@texte_backend
281 function texte_backend($texte) {
282
283 // si on a des liens ou des images, les passer en absolu
284 $texte = liens_absolus($texte);
285
286 // echapper les tags &gt; &lt;
287 $texte = preg_replace(',&(gt|lt);,S', '&amp;\1;', $texte);
288
289 // importer les &eacute;
290 $texte = filtrer_entites($texte);
291
292 // " -> &quot; et tout ce genre de choses
293 // contourner bug windows ou char(160) fait partie de la regexp \s
294 $u = ($GLOBALS['meta']['charset']=='utf-8') ? 'u':'';
295 $texte = str_replace("&nbsp;", " ", $texte);
296 $texte = preg_replace('/\s{2,}/'.$u.'S', " ", $texte);
297 $texte = entites_html($texte);
298
299 // verifier le charset
300 $texte = charset2unicode($texte);
301
302 // Caracteres problematiques en iso-latin 1
303 if ($GLOBALS['meta']['charset'] == 'iso-8859-1') {
304 $texte = str_replace(chr(156), '&#156;', $texte);
305 $texte = str_replace(chr(140), '&#140;', $texte);
306 $texte = str_replace(chr(159), '&#159;', $texte);
307 }
308
309 // nettoyer l'apostrophe curly qui semble poser probleme a certains rss-readers
310 $texte = str_replace("&#8217;","'",$texte);
311
312 return $texte;
313 }
314
315 // Enleve le numero des titres numerotes ("1. Titre" -> "Titre")
316 // http://doc.spip.org/@supprimer_numero
317 function supprimer_numero($texte) {
318 return preg_replace(
319 ",^[[:space:]]*([0-9]+)([.)]|".chr(194).'?'.chr(176).")[[:space:]]+,S",
320 "", $texte);
321 }
322
323 // et la fonction inverse
324 // http://doc.spip.org/@recuperer_numero
325 function recuperer_numero($texte) {
326 if (preg_match(
327 ",^[[:space:]]*([0-9]+)([.)]|".chr(194).'?'.chr(176).")[[:space:]]+,S",
328 $texte, $regs))
329 return intval($regs[1]);
330 else
331 return '';
332 }
333
334 // Suppression basique et brutale de tous les <...>
335 // http://doc.spip.org/@supprimer_tags
336 function supprimer_tags($texte, $rempl = "") {
337 $texte = preg_replace(",<[^>]*>,US", $rempl, $texte);
338 // ne pas oublier un < final non ferme
339 // mais qui peut aussi etre un simple signe plus petit que
340 $texte = str_replace('<', ' ', $texte);
341 return $texte;
342 }
343
344 // Convertit les <...> en la version lisible en HTML
345 // http://doc.spip.org/@echapper_tags
346 function echapper_tags($texte, $rempl = "") {
347 $texte = ereg_replace("<([^>]*)>", "&lt;\\1&gt;", $texte);
348 return $texte;
349 }
350
351 // Convertit un texte HTML en texte brut
352 // http://doc.spip.org/@textebrut
353 function textebrut($texte) {
354 $u = ($GLOBALS['meta']['charset']=='utf-8') ? 'u':'';
355 $texte = preg_replace('/\s+/'.$u.'S', " ", $texte);
356 $texte = preg_replace("/<(p|br)( [^>]*)?".">/iS", "\n\n", $texte);
357 $texte = preg_replace("/^\n+/", "", $texte);
358 $texte = preg_replace("/\n+$/", "", $texte);
359 $texte = preg_replace("/\n +/", "\n", $texte);
360 $texte = supprimer_tags($texte);
361 $texte = preg_replace("/(&nbsp;| )+/S", " ", $texte);
362 // nettoyer l'apostrophe curly qui pose probleme a certains rss-readers, lecteurs de mail...
363 $texte = str_replace("&#8217;","'",$texte);
364 return $texte;
365 }
366
367 // Remplace les liens SPIP en liens ouvrant dans une nouvelle fenetre (target=blank)
368 // http://doc.spip.org/@liens_ouvrants
369 function liens_ouvrants ($texte) {
370 return preg_replace(",<a ([^>]*https?://[^>]*class=\"spip_(out|url)\b[^>]+)>,",
371 "<a \\1 target=\"_blank\">", $texte);
372 }
373
374 // Transformer les sauts de paragraphe en simples passages a la ligne
375 // http://doc.spip.org/@PtoBR
376 function PtoBR($texte){
377 $texte = eregi_replace("</p>", "\n", $texte);
378 $texte = eregi_replace("<p([[:space:]][^>]*)?".">", "<br />", $texte);
379 $texte = ereg_replace("^[[:space:]]*<br />", "", $texte);
380 return $texte;
381 }
382
383 // Couper les "mots" de plus de $l caracteres (souvent des URLs)
384 // http://doc.spip.org/@lignes_longues
385 function lignes_longues($texte, $l = 70) {
386 // Passer en utf-8 pour ne pas avoir de coupes trop courtes avec les &#xxxx;
387 // qui prennent 7 caracteres
388 #include_spip('inc/charsets');
389 $texte = unicode_to_utf_8(charset2unicode(
390 $texte, $GLOBALS['meta']['charset'], true));
391
392 // echapper les tags (on ne veut pas casser les a href=...)
393 $tags = array();
394 if (preg_match_all('/<.*>/UumsS', $texte, $t, PREG_SET_ORDER)) {
395 foreach ($t as $n => $tag) {
396 $tags[$n] = $tag[0];
397 $texte = str_replace($tag[0], " @@SPIPTAG$n@@ ", $texte);
398 }
399 }
400 // casser les mots longs qui restent
401 // note : on pourrait preferer couper sur les / , etc.
402 if (preg_match_all("/[\w,\/.]{".$l."}/UmsS", $texte, $longs, PREG_SET_ORDER)) {
403 foreach ($longs as $long) {
404 $texte = str_replace($long[0], $long[0].' ', $texte);
405 }
406 }
407
408 // retablir les tags
409 foreach ($tags as $n=>$tag) {
410 $texte = str_replace(" @@SPIPTAG$n@@ ", $tag, $texte);
411 }
412
413 return importer_charset($texte, 'utf-8');
414 }
415
416 // Majuscules y compris accents, en HTML
417 // http://doc.spip.org/@majuscules
418 function majuscules($texte) {
419 if (!strlen($texte)) return '';
420
421 // Cas du turc
422 if ($GLOBALS['spip_lang'] == 'tr') {
423 # remplacer hors des tags et des entites
424 if (preg_match_all(',<[^<>]+>|&[^;]+;,S', $texte, $regs, PREG_SET_ORDER))
425 foreach ($regs as $n => $match)
426 $texte = str_replace($match[0], "@@SPIP_TURC$n@@", $texte);
427
428 $texte = str_replace('i', '&#304;', $texte);
429
430 if ($regs)
431 foreach ($regs as $n => $match)
432 $texte = str_replace("@@SPIP_TURC$n@@", $match[0], $texte);
433 }
434
435 // Cas general
436 return "<span style='text-transform: uppercase;'>$texte</span>";
437 }
438
439 // "127.4 ko" ou "3.1 Mo"
440 // http://doc.spip.org/@taille_en_octets
441 function taille_en_octets ($taille) {
442 if ($taille < 1024) {$taille = _T('taille_octets', array('taille' => $taille));}
443 else if ($taille < 1024*1024) {
444 $taille = _T('taille_ko', array('taille' => ((floor($taille / 102.4))/10)));
445 } else {
446 $taille = _T('taille_mo', array('taille' => ((floor(($taille / 1024) / 102.4))/10)));
447 }
448 return $taille;
449 }
450
451
452 // Rend une chaine utilisable sans dommage comme attribut HTML
453 // http://doc.spip.org/@attribut_html
454 function attribut_html($texte) {
455 $texte = texte_backend(supprimer_tags($texte));
456 $texte = str_replace(array("'",'"'),array('&#39;', '&#34;'), $texte);
457
458 return preg_replace(array("/&(amp;|#38;)/","/&(?![A-Za-z]{0,4}\w{2,3};|#[0-9]{2,5};)/"),array("&","&#38;") , $texte);
459 return $texte;
460 }
461
462 // Vider les url nulles comme 'http://' ou 'mailto:'
463 // et leur appliquer un htmlspecialchars() + gerer les &amp;
464 // http://doc.spip.org/@vider_url
465 function vider_url($url, $entites = true) {
466 # un message pour abs_url
467 $GLOBALS['mode_abs_url'] = 'url';
468
469 $url = trim($url);
470 if (preg_match(",^(http:?/?/?|mailto:?)$,iS", $url))
471 return '';
472
473 if ($entites) $url = entites_html($url);
474
475 return $url;
476 }
477
478 //
479 // Ajouter le &var_recherche=toto dans les boucles de recherche
480 //
481 // http://doc.spip.org/@url_var_recherche
482 function url_var_recherche($url) {
483 if (_request('recherche')
484 AND !ereg("var_recherche", $url)) {
485
486 list ($url,$ancre) = preg_split(',#,', $url, 2);
487 if ($ancre) $ancre='#'.$ancre;
488
489 $x = "var_recherche=".rawurlencode(_request('recherche'));
490
491 if (strpos($url, '?') === false)
492 return "$url?$x$ancre";
493 else
494 return "$url&$x$ancre";
495 }
496 else return $url;
497 }
498
499
500 // Extraire une date de n'importe quel champ (a completer...)
501 // http://doc.spip.org/@extraire_date
502 function extraire_date($texte) {
503 // format = 2001-08
504 if (ereg("([1-2][0-9]{3})[^0-9]*(0?[1-9]|1[0-2])",$texte,$regs))
505 return $regs[1]."-".sprintf("%02d", $regs[2])."-01";
506 }
507
508 // Maquiller une adresse e-mail
509 // http://doc.spip.org/@antispam
510 function antispam($texte) {
511 include_spip('inc/acces');
512 $masque = creer_pass_aleatoire(3);
513 return ereg_replace("@", " $masque ", $texte);
514 }
515
516 // |sinon{rien} : affiche "rien" si la chaine est vide, affiche la chaine si non vide
517 // http://doc.spip.org/@sinon
518 function sinon ($texte, $sinon='') {
519 if (strlen($texte))
520 return $texte;
521 else
522 return $sinon;
523 }
524
525 // |choixsivide{vide,pasvide} affiche pasvide si la chaine n'est pas vide...
526 // http://doc.spip.org/@choixsivide
527 function choixsivide($a, $vide, $pasvide) {
528 return $a ? $pasvide : $vide;
529 }
530
531 // |choixsiegal{aquoi,oui,non} affiche oui si la chaine est egal a aquoi ...
532 // http://doc.spip.org/@choixsiegal
533 function choixsiegal($a1,$a2,$v,$f) {
534 return ($a1 == $a2) ? $v : $f;
535 }
536
537
538 //
539 // Date, heure, saisons
540 //
541
542 // http://doc.spip.org/@normaliser_date
543 function normaliser_date($date) {
544 if ($date) {
545 $date = vider_date($date);
546 if (ereg("^[0-9]{8,10}$", $date))
547 $date = date("Y-m-d H:i:s", $date);
548 if (ereg("^([12][0-9]{3})([-/]00)?( [-0-9:]+)?$", $date, $regs))
549 $date = $regs[1]."-01-01".$regs[3];
550 else if (ereg("^([12][0-9]{3}[-/][01]?[0-9])([-/]00)?( [-0-9:]+)?$", $date, $regs))
551 $date = ereg_replace("/","-",$regs[1])."-01".$regs[3];
552 else
553 $date = date("Y-m-d H:i:s", strtotime($date));
554 }
555 return $date;
556 }
557
558 // http://doc.spip.org/@vider_date
559 function vider_date($letexte) {
560 if (ereg("^0000-00-00", $letexte)) return;
561 if (ereg("^1970-01-01", $letexte)) return; // eviter le bug GMT-1
562 return $letexte;
563 }
564
565 // http://doc.spip.org/@recup_heure
566 function recup_heure($numdate){
567 if (!$numdate) return '';
568
569 if (ereg('([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})', $numdate, $regs)) {
570 $heures = $regs[1];
571 $minutes = $regs[2];
572 $secondes = $regs[3];
573 }
574 return array($heures, $minutes, $secondes);
575 }
576
577 // http://doc.spip.org/@heures
578 function heures($numdate) {
579 $date_array = recup_heure($numdate);
580 if ($date_array)
581 list($heures, $minutes, $secondes) = $date_array;
582 return $heures;
583 }
584
585 // http://doc.spip.org/@minutes
586 function minutes($numdate) {
587 $date_array = recup_heure($numdate);
588 if ($date_array)
589 list($heures, $minutes, $secondes) = $date_array;
590 return $minutes;
591 }
592
593 // http://doc.spip.org/@secondes
594 function secondes($numdate) {
595 $date_array = recup_heure($numdate);
596 if ($date_array)
597 list($heures,$minutes,$secondes) = $date_array;
598 return $secondes;
599 }
600
601 // http://doc.spip.org/@heures_minutes
602 function heures_minutes($numdate) {
603 return _T('date_fmt_heures_minutes', array('h'=> heures($numdate), 'm'=> minutes($numdate)));
604 }
605
606 // http://doc.spip.org/@recup_date
607 function recup_date($numdate){
608 if (!$numdate) return '';
609 if (ereg('([0-9]{1,2})/([0-9]{1,2})/([0-9]{1,2}|[0-9]{4})', $numdate, $regs)) {
610 $jour = $regs[1];
611 $mois = $regs[2];
612 $annee = $regs[3];
613 if ($annee < 90){
614 $annee = 2000 + $annee;
615 } elseif ($annee<100) {
616 $annee = 1900 + $annee ;
617 }
618 }
619 elseif (ereg('([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})',$numdate, $regs)) {
620 $annee = $regs[1];
621 $mois = $regs[2];
622 $jour = $regs[3];
623 }
624 elseif (ereg('([0-9]{4})-([0-9]{2})', $numdate, $regs)){
625 $annee = $regs[1];
626 $mois = $regs[2];
627 }
628 if ($annee > 4000) $annee -= 9000;
629 if (substr($jour, 0, 1) == '0') $jour = substr($jour, 1);
630
631 return array($annee, $mois, $jour);
632 }
633
634 // une date pour l'interface : utilise date_relative si le decalage
635 // avec time() est de moins de douze heures, sinon la date complete
636 // http://doc.spip.org/@date_interface
637 function date_interface($date, $decalage_maxi = 43200/* 12*3600 */) {
638 return sinon(
639 date_relative($date, $decalage_maxi),
640 affdate_heure($date)
641 );
642 }
643
644 // http://doc.spip.org/@date_relative
645 function date_relative($date, $decalage_maxi=0) {
646
647 if (!$date) return;
648 $decal = date("U") - date("U", strtotime($date));
649
650 if ($decalage_maxi AND ($decal > $decalage_maxi OR $decal < 0))
651 return '';
652
653 if ($decal < 0) {
654 $il_y_a = "date_dans";
655 $decal = -1 * $decal;
656 } else {
657 $il_y_a = "date_il_y_a";
658 }
659
660 if ($decal < 3600) {
661 $minutes = ceil($decal / 60);
662 $retour = _T($il_y_a, array("delai"=>"$minutes "._T("date_minutes")));
663 }
664 else if ($decal < (3600 * 24) ) {
665 $heures = ceil ($decal / 3600);
666 $retour = _T($il_y_a, array("delai"=>"$heures "._T("date_heures")));
667 }
668 else if ($decal < (3600 * 24 * 7)) {
669 $jours = ceil ($decal / (3600 * 24));
670 $retour = _T($il_y_a, array("delai"=>"$jours "._T("date_jours")));
671 }
672 else if ($decal < (3600 * 24 * 7 * 4)) {
673 $semaines = ceil ($decal / (3600 * 24 * 7));
674 $retour = _T($il_y_a, array("delai"=>"$semaines "._T("date_semaines")));
675 }
676 else if ($decal < (3600 * 24 * 30 * 6)) {
677 $mois = ceil ($decal / (3600 * 24 * 30));
678 $retour = _T($il_y_a, array("delai"=>"$mois "._T("date_mois")));
679 }
680 else {
681 $retour = affdate_court($date);
682 }
683
684
685
686 return $retour;
687 }
688
689
690 // http://doc.spip.org/@affdate_base
691 function affdate_base($numdate, $vue, $param = '') {
692 global $spip_lang;
693 $date_array = recup_date($numdate);
694 if ($date_array)
695 list($annee, $mois, $jour) = $date_array;
696 else
697 return '';
698
699 // 1er, 21st, etc.
700 $journum = $jour;
701
702 if ($jour == 0)
703 $jour = '';
704 else if ($jourth = _T('date_jnum'.$jour))
705 $jour = $jourth;
706
707 $mois = intval($mois);
708 if ($mois > 0 AND $mois < 13) {
709 $nommois = _T('date_mois_'.$mois);
710 if ($jour)
711 $jourmois = _T('date_de_mois_'.$mois, array('j'=>$jour, 'nommois'=>$nommois));
712 else
713 $jourmois = $nommois;
714 }
715
716 if ($annee < 0) {
717 $annee = -$annee." "._T('date_avant_jc');
718 $avjc = true;
719 }
720 else $avjc = false;
721
722 switch ($vue) {
723 case 'saison':
724 if ($mois > 0){
725 $saison = 1;
726 if (($mois == 3 AND $jour >= 21) OR $mois > 3) $saison = 2;
727 if (($mois == 6 AND $jour >= 21) OR $mois > 6) $saison = 3;
728 if (($mois == 9 AND $jour >= 21) OR $mois > 9) $saison = 4;
729 if (($mois == 12 AND $jour >= 21) OR $mois > 12) $saison = 1;
730 }
731 return _T('date_saison_'.$saison);
732
733 case 'court':
734 if ($avjc) return $annee;
735 $a = date('Y');
736 if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
737 if ($annee != $a) return _T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>ucfirst($nommois), 'annee'=>$annee));
738 return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
739
740 case 'jourcourt':
741 if ($avjc) return $annee;
742 $a = date('Y');
743 if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
744 if ($annee != $a) return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
745 return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
746
747 case 'entier':
748 if ($avjc) return $annee;
749 if ($jour)
750 return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
751 else
752 return trim(_T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
753
754 case 'nom_mois':
755 return $nommois;
756
757 case 'mois':
758 return sprintf("%02s",$mois);
759
760 case 'jour':
761 return $jour;
762
763 case 'journum':
764 return $journum;
765
766 case 'nom_jour':
767 if (!$mois OR !$jour) return '';
768 $nom = mktime(1,1,1,$mois,$jour,$annee);
769 $nom = 1+date('w',$nom);
770 $param = $param ? '_'.$param : '';
771 return _T('date_jour_'.$nom.$param);
772
773 case 'mois_annee':
774 if ($avjc) return $annee;
775 return trim(_T('date_fmt_mois_annee', array('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
776
777 case 'annee':
778 return $annee;
779
780 // Cas d'une vue non definie : retomber sur le format
781 // de date propose par http://www.php.net/date
782 default:
783 return date($vue, strtotime($numdate));
784 }
785 }
786
787 // http://doc.spip.org/@nom_jour
788 function nom_jour($numdate, $forme = '') {
789 if(!($forme == 'abbr' OR $forme == 'initiale')) $forme = '';
790 return affdate_base($numdate, 'nom_jour', $forme);
791 }
792
793 // http://doc.spip.org/@jour
794 function jour($numdate) {
795 return affdate_base($numdate, 'jour');
796 }
797
798 // http://doc.spip.org/@journum
799 function journum($numdate) {
800 return affdate_base($numdate, 'journum');
801 }
802
803 // http://doc.spip.org/@mois
804 function mois($numdate) {
805 return affdate_base($numdate, 'mois');
806 }
807
808 // http://doc.spip.org/@nom_mois
809 function nom_mois($numdate) {
810 return affdate_base($numdate, 'nom_mois');
811 }
812
813 // http://doc.spip.org/@annee
814 function annee($numdate) {
815 return affdate_base($numdate, 'annee');
816 }
817
818 // http://doc.spip.org/@saison
819 function saison($numdate) {
820 return affdate_base($numdate, 'saison');
821 }
822
823 // http://doc.spip.org/@affdate
824 function affdate($numdate, $format='entier') {
825 return affdate_base($numdate, $format);
826 }
827
828 // http://doc.spip.org/@affdate_court
829 function affdate_court($numdate) {
830 return affdate_base($numdate, 'court');
831 }
832
833 // http://doc.spip.org/@affdate_jourcourt
834 function affdate_jourcourt($numdate) {
835 return affdate_base($numdate, 'jourcourt');
836 }
837
838 // http://doc.spip.org/@affdate_mois_annee
839 function affdate_mois_annee($numdate) {
840 return affdate_base($numdate, 'mois_annee');
841 }
842
843 // http://doc.spip.org/@affdate_heure
844 function affdate_heure($numdate) {
845 if (!$numdate) return '';
846 return _T('date_fmt_jour_heure', array('jour' => affdate($numdate), 'heure' => heures_minutes($numdate)));
847 }
848
849
850 //
851 // Alignements en HTML (Old-style, preferer CSS)
852 //
853
854 // Cette fonction cree le paragraphe s'il n'existe pas (texte sur un seul para)
855 // http://doc.spip.org/@aligner
856 function aligner($letexte, $justif='') {
857 $letexte = trim($letexte);
858 if (!strlen($letexte)) return '';
859
860 // Paragrapher proprement
861 $letexte = paragrapher($letexte, true);
862
863 // Inserer les alignements
864 if ($justif)
865 $letexte = str_replace(
866 '<p class="spip">', '<p class="spip" align="'.$justif.'">',
867 $letexte);
868
869 return $letexte;
870 }
871
872 // http://doc.spip.org/@justifier
873 function justifier($letexte) {
874 return aligner($letexte,'justify');
875 }
876
877 // http://doc.spip.org/@aligner_droite
878 function aligner_droite($letexte) {
879 return aligner($letexte,'right');
880 }
881
882 // http://doc.spip.org/@aligner_gauche
883 function aligner_gauche($letexte) {
884 return aligner($letexte,'left');
885 }
886
887 // http://doc.spip.org/@centrer
888 function centrer($letexte) {
889 return aligner($letexte,'center');
890 }
891
892 // http://doc.spip.org/@style_align
893 function style_align($bof) {
894 global $spip_lang_left;
895 return "text-align: $spip_lang_left";
896 }
897
898 //
899 // Export iCal
900 //
901
902 // http://doc.spip.org/@filtrer_ical
903 function filtrer_ical($texte) {
904 #include_spip('inc/charsets');
905 $texte = html2unicode($texte);
906 $texte = unicode2charset(charset2unicode($texte, $GLOBALS['meta']['charset'], 1), 'utf-8');
907 $texte = ereg_replace("\n", " ", $texte);
908 $texte = ereg_replace(",", "\,", $texte);
909
910 return $texte;
911 }
912
913 // http://doc.spip.org/@date_ical
914 function date_ical($date, $addminutes = 0) {
915 list($heures, $minutes, $secondes) = recup_heure($date);
916 list($annee, $mois, $jour) = recup_date($date);
917 return date("Ymd\THis",
918 mktime($heures, $minutes+$addminutes,$secondes,$mois,$jour,$annee));
919 }
920
921 // date_iso retourne la date au format "RFC 3339" / "ISO 8601"
922 // voir http://www.php.net/manual/fr/ref.datetime.php#datetime.constants
923 // http://doc.spip.org/@date_iso
924 function date_iso($date_heure) {
925 list($annee, $mois, $jour) = recup_date($date_heure);
926 list($heures, $minutes, $secondes) = recup_heure($date_heure);
927 $time = mktime($heures, $minutes, $secondes, $mois, $jour, $annee);
928 return gmdate('Y-m-d\TH:i:s\Z', $time);
929 }
930
931 // date_822 retourne la date au format "RFC 822"
932 // utilise pour <pubdate> dans certains feeds RSS
933 // http://doc.spip.org/@date_822
934 function date_822($date_heure) {
935 list($annee, $mois, $jour) = recup_date($date_heure);
936 list($heures, $minutes, $secondes) = recup_heure($date_heure);
937 $time = mktime($heures, $minutes, $secondes, $mois, $jour, $annee);
938 return date('r', $time);
939 }
940
941 // http://doc.spip.org/@date_anneemoisjour
942 function date_anneemoisjour($d) {
943 if (!$d) $d = date("Y-m-d");
944 return substr($d, 0, 4) . substr($d, 5, 2) .substr($d, 8, 2);
945 }
946
947 // http://doc.spip.org/@date_anneemois
948 function date_anneemois($d) {
949 if (!$d) $d = date("Y-m-d");
950 return substr($d, 0, 4) . substr($d, 5, 2);
951 }
952
953 // http://doc.spip.org/@date_debut_semaine
954 function date_debut_semaine($annee, $mois, $jour) {
955 $w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
956 if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
957 $debut = $jour-$w_day+1;
958 return date("Ymd", mktime(0,0,0,$mois,$debut,$annee));
959 }
960
961 // http://doc.spip.org/@date_fin_semaine
962 function date_fin_semaine($annee, $mois, $jour) {
963 $w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
964 if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
965 $debut = $jour-$w_day+1;
966 return date("Ymd", mktime(0,0,0,$mois,$debut+6,$annee));
967 }
968
969 // http://doc.spip.org/@agenda_connu
970 function agenda_connu($type)
971 {
972 return in_array($type, array('jour','mois','semaine','periode')) ? ' ' : '';
973 }
974
975
976 // Cette fonction memorise dans un tableau indexe par son 5e arg
977 // un evenement decrit par les 4 autres (date, descriptif, titre, URL).
978 // Appellee avec une date nulle, elle renvoie le tableau construit.
979 // l'indexation par le 5e arg autorise plusieurs calendriers dans une page
980
981 // http://doc.spip.org/@agenda_memo
982 function agenda_memo($date=0 , $descriptif='', $titre='', $url='', $cal='')
983 {
984 static $agenda = array();
985 if (!$date) return $agenda;
986 $idate = date_ical($date);
987 $cal = trim($cal); // func_get_args (filtre alterner) rajoute \n !!!!
988 $agenda[$cal][(date_anneemoisjour($date))][] = array(
989 'CATEGORIES' => $cal,
990 'DTSTART' => $idate,
991 'DTEND' => $idate,
992 'DESCRIPTION' => texte_script($descriptif),
993 'SUMMARY' => texte_script($titre),
994 'URL' => $url);
995 // toujours retourner vide pour qu'il ne se passe rien
996 return "";
997 }
998
999 // Cette fonction recoit:
1000 // - un nombre d'evenements,
1001 // - une chaine a afficher si ce nombre est nul,
1002 // - un type de calendrier
1003 // -- et une suite de noms N.
1004 // Elle demande a la fonction precedente son tableau
1005 // et affiche selon le type les elements indexes par N dans ce tableau.
1006 // Si le suite de noms est vide, tout le tableau est pris
1007 // Ces noms N sont aussi des classes CSS utilisees par http_calendrier_init
1008
1009 // http://doc.spip.org/@agenda_affiche
1010 function agenda_affiche($i)
1011 {
1012 include_spip('inc/agenda');
1013 include_spip('inc/minipres');
1014 $args = func_get_args();
1015 $nb = array_shift($args); // nombre d'evenements (on pourrait l'afficher)
1016 $sinon = array_shift($args);
1017 $type = array_shift($args);
1018 if (!$nb){
1019 return http_calendrier_init('', $type, '', '', str_replace('&amp;', '&', self()), $sinon);
1020 }
1021 $agenda = agenda_memo(0);
1022 $evt = array();
1023 foreach (($args ? $args : array_keys($agenda)) as $k) {
1024 if (is_array($agenda[$k]))
1025 foreach($agenda[$k] as $d => $v) {
1026 $evt[$d] = $evt[$d] ? (array_merge($evt[$d], $v)) : $v;
1027 }
1028 }
1029 $d = array_keys($evt);
1030
1031 if (count($d)){
1032 $mindate = min($d);
1033 $start = strtotime($mindate);
1034 }
1035 else {
1036 $mindate = ($j=_request('jour')) * ($m=_request('mois')) * ($a=_request('annee'));
1037 if ($mindate)
1038 $start = mktime(0,0,0, $j, $m, $a);
1039 else $start = mktime(0,0,0);
1040 }
1041 if ($type != 'periode')
1042 $evt = array('', $evt);
1043 else {
1044 $min = substr($mindate,6,2);
1045 $max = $min + ((strtotime(max($d)) - $start) / (3600 * 24));
1046 if ($max < 31) $max = 0;
1047 $evt = array('', $evt, $min, $max);
1048 $type = 'mois';
1049 }
1050 return http_calendrier_init($start, $type, '', '', str_replace('&amp;', '&', self()), $evt);
1051 }
1052
1053 //
1054 // Recuperation de donnees dans le champ extra
1055 // Ce filtre n'a de sens qu'avec la balise #EXTRA
1056 //
1057 // http://doc.spip.org/@extra
1058 function extra($letexte, $champ) {
1059 $champs = unserialize($letexte);
1060 return $champs[$champ];
1061 }
1062
1063 // postautobr : transforme les sauts de ligne en _
1064 // http://doc.spip.org/@post_autobr
1065 function post_autobr($texte, $delim="\n_ ") {
1066 $texte = str_replace("\r\n", "\r", $texte);
1067 $texte = str_replace("\r", "\n", $texte);
1068 $texte = echappe_html($texte, '', true);
1069
1070 $debut = '';
1071 $suite = $texte;
1072 while ($t = strpos('-'.$suite, "\n", 1)) {
1073 $debut .= substr($suite, 0, $t-1);
1074 $suite = substr($suite, $t);
1075 $car = substr($suite, 0, 1);
1076 if (($car<>'-') AND ($car<>'_') AND ($car<>"\n") AND ($car<>"|"))
1077 $debut .= $delim;
1078 else
1079 $debut .= "\n";
1080 if (ereg("^\n+", $suite, $regs)) {
1081 $debut.=$regs[0];
1082 $suite = substr($suite, strlen($regs[0]));
1083 }
1084 }
1085 $texte = $debut.$suite;
1086
1087 $texte = echappe_retour($texte);
1088 return $texte;
1089 }
1090
1091
1092 //
1093 // Gestion des blocs multilingues
1094 //
1095
1096 //
1097 // Selection dans un tableau dont les index sont des noms de langues
1098 // de la valeur associee a la langue en cours
1099 //
1100
1101 // http://doc.spip.org/@multi_trad
1102 function multi_trad ($trads) {
1103 global $spip_lang;
1104
1105 if (isset($trads[$spip_lang])) {
1106 return $trads[$spip_lang];
1107
1108 } // cas des langues xx_yy
1109 else if (ereg('^([a-z]+)_', $spip_lang, $regs) AND isset($trads[$regs[1]])) {
1110 return $trads[$regs[1]];
1111 }
1112 // sinon, renvoyer la premiere du tableau
1113 // remarque : on pourrait aussi appeler un service de traduction externe
1114 // ou permettre de choisir une langue "plus proche",
1115 // par exemple le francais pour l'espagnol, l'anglais pour l'allemand, etc.
1116 else return array_shift($trads);
1117 }
1118
1119 // analyse un bloc multi
1120 // http://doc.spip.org/@extraire_trad
1121 function extraire_trad ($bloc) {
1122 $lang = '';
1123 // ce reg fait planter l'analyse multi s'il y a de l'{italique} dans le champ
1124 // while (preg_match("/^(.*?)[{\[]([a-z_]+)[}\]]/siS", $bloc, $regs)) {
1125 while (preg_match("/^(.*?)[\[]([a-z_]+)[\]]/siS", $bloc, $regs)) {
1126 $texte = trim($regs[1]);
1127 if ($texte OR $lang)
1128 $trads[$lang] = $texte;
1129 $bloc = substr($bloc, strlen($regs[0]));
1130 $lang = $regs[2];
1131 }
1132 $trads[$lang] = $bloc;
1133
1134 // faire la traduction avec ces donnees
1135 return multi_trad($trads);
1136 }
1137
1138 // repere les blocs multi dans un texte et extrait le bon
1139 // http://doc.spip.org/@extraire_multi
1140 function extraire_multi ($letexte) {
1141 if (strpos($letexte, '<multi>') === false) return $letexte; // perf
1142 if (preg_match_all("@<multi>(.*?)</multi>@sS", $letexte, $regs, PREG_SET_ORDER))
1143 foreach ($regs as $reg)
1144 $letexte = str_replace($reg[0], extraire_trad($reg[1]), $letexte);
1145 return $letexte;
1146 }
1147
1148
1149 //
1150 // Ce filtre retourne la donnee si c'est la premiere fois qu'il la voit ;
1151 // possibilite de gerer differentes "familles" de donnees |unique{famille}
1152 # |unique{famille,1} affiche le nombre d'elements affiches (preferer toutefois #TOTAL_UNIQUE)
1153 # ameliorations possibles :
1154 # 1) si la donnee est grosse, mettre son md5 comme cle
1155 # 2) purger $mem quand on change de squelette (sinon bug inclusions)
1156 //
1157 // http://www.spip.net/@unique
1158 // http://doc.spip.org/@unique
1159 function unique($donnee, $famille='', $cpt = false) {
1160 static $mem;
1161 if ($cpt)
1162 return count($mem[$famille]);
1163 if (!($mem[$famille][$donnee]++))
1164 return $donnee;
1165 }
1166
1167 //
1168 // Filtre |alterner
1169 //
1170 // Exemple [(#COMPTEUR_BOUCLE|alterner{'bleu','vert','rouge'})]
1171 //
1172 // http://doc.spip.org/@alterner
1173 function alterner($i) {
1174 // recuperer les arguments (attention fonctions un peu space)
1175 $num = func_num_args();
1176 $args = func_get_args();
1177
1178 // renvoyer le i-ieme argument, modulo le nombre d'arguments
1179 return $args[(intval($i)-1)%($num-1)+1];
1180 }
1181
1182 // recuperer une balise HTML de type "xxx"
1183 // exemple : [(#DESCRIPTIF|extraire_tag{img})] (pour flux RSS-photo)
1184 // http://doc.spip.org/@extraire_tag
1185 function extraire_tag($texte, $tag) {
1186 if (preg_match(",<$tag(\\s.*)?".">,UimsS", $texte, $regs))
1187 return $regs[0];
1188 }
1189
1190
1191 // recuperer un attribut d'une balise html
1192 // ($complet demande de retourner $r)
1193 // http://doc.spip.org/@extraire_attribut
1194 function extraire_attribut($balise, $attribut, $complet = false) {
1195 if (preg_match(
1196 // ',(.*?<[^>]*)(\s'.$attribut.'=\s*([\'"]?)([^\\3]*?)\\3)([^>]*>.*),isS',
1197 ',(^.*?<(?:(?>\s*)(?>\w+)(?>(?:=(?:"[^"]*"|\'[^\']*\'|[^\'"]\S*))?))*?)(\s+'.$attribut.'(?:=\s*("[^"]*"|\'[^\']*\'|[^\'"]\S*))?)()([^>]*>.*),isS',
1198 $balise, $r)) {
1199 if ($r[3][0] == '"' || $r[3][0] == "'") {
1200 $r[4] = substr($r[3], 1, -1);
1201 $r[3] = $r[3][0];
1202 } elseif ($r[3]!=='') {
1203 $r[4] = $r[3];
1204 $r[3] = '';
1205 } else {
1206 $r[4] = trim($r[2]);
1207 }
1208 $att = filtrer_entites(str_replace("&#39;", "'", $r[4]));
1209 }
1210 else
1211 $att = NULL;
1212
1213 if ($complet)
1214 return array($att, $r);
1215 else
1216 return $att;
1217 }
1218
1219 // modifier (ou inserer) un attribut html dans une balise
1220 // http://doc.spip.org/@inserer_attribut
1221 function inserer_attribut($balise, $attribut, $val, $texte_backend=true, $vider=false) {
1222 // preparer l'attribut
1223 if ($texte_backend) $val = texte_backend($val); # supprimer les &nbsp; etc
1224
1225 // echapper les ' pour eviter tout bug
1226 $val = str_replace("'", "&#39;", $val);
1227 if ($vider AND strlen($val)==0)
1228 $insert = '';
1229 else
1230 $insert = " $attribut='$val' ";
1231
1232 list($old, $r) = extraire_attribut($balise, $attribut, true);
1233
1234 if ($old !== NULL) {
1235 // Remplacer l'ancien attribut du meme nom
1236 $balise = $r[1].$insert.$r[5];
1237 }
1238 else {
1239 // preferer une balise " />" (comme <img />)
1240 if (preg_match(',[[:space:]]/>,S', $balise))
1241 $balise = preg_replace(",[[:space:]]/>,S", $insert."/>", $balise, 1);
1242 // sinon une balise <a ...> ... </a>
1243 else
1244 $balise = preg_replace(",>,", $insert.">", $balise, 1);
1245 }
1246
1247 return $balise;
1248 }
1249
1250 // http://doc.spip.org/@vider_attribut
1251 function vider_attribut ($balise, $attribut) {
1252 return inserer_attribut($balise, $attribut, '', false, true);
1253 }
1254
1255
1256 // Un filtre ad hoc, qui retourne ce qu'il faut pour les tests de config
1257 // dans les squelettes : [(#URL_SITE_SPIP|tester_config{quoi})]
1258 // http://doc.spip.org/@tester_config
1259 function tester_config($ignore, $quoi) {
1260 switch ($quoi) {
1261 case 'mode_inscription':
1262 if ($GLOBALS['meta']["accepter_inscriptions"] == "oui")
1263 return 'redac';
1264 else if ($GLOBALS['meta']["accepter_visiteurs"] == "oui"
1265 OR $GLOBALS['meta']['forums_publics'] == 'abo')
1266 return 'forum';
1267 else
1268 return '';
1269
1270 default:
1271 return '';
1272 }
1273 }
1274
1275 //
1276 // Un filtre qui, etant donne un #PARAMETRES_FORUM, retourne un URL de suivi rss
1277 // dudit forum
1278 // Attention applique a un #PARAMETRES_FORUM complexe (id_article=x&id_forum=y)
1279 // ca retourne un url de suivi du thread y (que le thread existe ou non)
1280 // http://doc.spip.org/@url_rss_forum
1281 function url_rss_forum($param) {
1282 if (preg_match(',.*(id_.*?)=([0-9]+),S', $param, $regs)) {
1283 include_spip('inc/acces');
1284 $regs[1] = str_replace('id_forum', 'id_thread', $regs[1]);
1285 $arg = $regs[1].'-'.$regs[2];
1286 $cle = afficher_low_sec(0, "rss forum $arg");
1287 return generer_url_action('rss', "op=forum&args=$arg&cle=$cle");
1288 }
1289 }
1290
1291 //
1292 // Un filtre applique a #PARAMETRES_FORUM, qui donne l'adresse de la page
1293 // de reponse
1294 //
1295 // http://doc.spip.org/@url_reponse_forum
1296 function url_reponse_forum($parametres) {
1297 if (!$parametres) return '';
1298 return generer_url_public('forum', $parametres);
1299 }
1300
1301 //
1302 // Filtres d'URLs
1303 //
1304
1305 // Nettoyer une URL contenant des ../
1306 //
1307 // resolve_url('/.././/truc/chose/machin/./.././.././hopla/..');
1308 // inspire (de loin) par PEAR:NetURL:resolvePath
1309 //
1310 // http://doc.spip.org/@resolve_path
1311 function resolve_path($url) {
1312 while (preg_match(',/\.?/,', $url, $regs) # supprime // et /./
1313 OR preg_match(',/[^/]*/\.\./,S', $url, $regs) # supprime /toto/../
1314 OR preg_match(',^/\.\./,S', $url, $regs)) # supprime les /../ du haut
1315 $url = str_replace($regs[0], '/', $url);
1316
1317 return '/'.preg_replace(',^/,S', '', $url);
1318 }
1319
1320 //
1321 // Suivre un lien depuis une adresse donnee -> nouvelle adresse
1322 //
1323 // suivre_lien('http://rezo.net/sous/dir/../ect/ory/fi.html..s#toto',
1324 // 'a/../../titi.coco.html/tata#titi');
1325 // http://doc.spip.org/@suivre_lien
1326 function suivre_lien($url, $lien) {
1327 # lien absolu ? ok
1328 if (preg_match(',^([a-z0-9]+://|mailto:),iS', $lien))
1329 return $lien;
1330
1331 # lien relatif, il faut verifier l'url de base
1332 if (preg_match(',^(.*?://[^/]+)(/.*?/?)?[^/]*$,S', $url, $regs)) {
1333 $debut = $regs[1];
1334 $dir = $regs[2];
1335 }
1336 if (substr($lien,0,1) == '/')
1337 return $debut . resolve_path($lien);
1338 else
1339 return $debut . resolve_path($dir.$lien);
1340 }
1341
1342 // un filtre pour transformer les URLs relatives en URLs absolues ;
1343 // ne s'applique qu'aux #URL_XXXX
1344 // http://doc.spip.org/@url_absolue
1345 function url_absolue($url, $base='') {
1346 if (strlen($url = trim($url)) == 0)
1347 return '';
1348 if (!$base)
1349 $base = url_de_base() . (_DIR_RACINE ? _DIR_RESTREINT_ABS : '');
1350 return suivre_lien($base, $url);
1351 }
1352
1353 // un filtre pour transformer les URLs relatives en URLs absolues ;
1354 // ne s'applique qu'aux textes contenant des liens
1355 // http://doc.spip.org/@liens_absolus
1356 function liens_absolus($texte, $base='') {
1357 if (preg_match_all(',(<(a|link)[[:space:]]+[^<>]*href=["\']?)([^"\' ><[:space:]]+)([^<>]*>),imsS',
1358 $texte, $liens, PREG_SET_ORDER)) {
1359 foreach ($liens as $lien) {
1360 $abs = url_absolue($lien[3], $base);
1361 if ($abs <> $lien[3])
1362 $texte = str_replace($lien[0], $lien[1].$abs.$lien[4], $texte);
1363 }
1364 }
1365 if (preg_match_all(',(<(img|script)[[:space:]]+[^<>]*src=["\']?)([^"\' ><[:space:]]+)([^<>]*>),imsS',
1366 $texte, $liens, PREG_SET_ORDER)) {
1367 foreach ($liens as $lien) {
1368 $abs = url_absolue($lien[3], $base);
1369 if ($abs <> $lien[3])
1370 $texte = str_replace($lien[0], $lien[1].$abs.$lien[4], $texte);
1371 }
1372 }
1373 return $texte;
1374 }
1375
1376 //
1377 // Ce filtre public va traiter les URL ou les <a href>
1378 //
1379 // http://doc.spip.org/@abs_url
1380 function abs_url($texte, $base='') {
1381 if ($GLOBALS['mode_abs_url'] == 'url')
1382 return url_absolue($texte, $base);
1383 else
1384 return liens_absolus($texte, $base);
1385 }
1386
1387 //
1388 // Quelques fonctions de calcul arithmetique
1389 //
1390 // http://doc.spip.org/@plus
1391 function plus($a,$b) {
1392 return $a+$b;
1393 }
1394 // http://doc.spip.org/@moins
1395 function moins($a,$b) {
1396 return $a-$b;
1397 }
1398 // http://doc.spip.org/@mult
1399 function mult($a,$b) {
1400 return $a*$b;
1401 }
1402 // http://doc.spip.org/@div
1403 function div($a,$b) {
1404 return $b?$a/$b:0;
1405 }
1406 // http://doc.spip.org/@modulo
1407 function modulo($nb, $mod, $add=0) {
1408 return ($nb%$mod)+$add;
1409 }
1410
1411
1412 // Verifier la conformite d'une ou plusieurs adresses email
1413 // retourne false ou la normalisation de la derniere adresse donnee
1414 // http://doc.spip.org/@email_valide
1415 function email_valide($adresses) {
1416 // Si c'est un spammeur autant arreter tout de suite
1417 if (preg_match(",[\n\r].*(MIME|multipart|Content-),i", $adresses)) {
1418 spip_log("Tentative d'injection de mail : $adresses");
1419 return false;
1420 }
1421
1422 foreach (explode(',', $adresses) as $v) {
1423 // nettoyer certains formats
1424 // "Marie Toto <Marie@toto.com>"
1425 $adresse = trim(eregi_replace("^[^<>\"]*<([^<>\"]+)>$", "\\1", $v));
1426 // RFC 822
1427 if (!eregi('^[^()<>@,;:\\"/[:space:]]+(@([-_0-9a-z]+\.)*[-_0-9a-z]+)$', $adresse))
1428 return false;
1429 }
1430 return $adresse;
1431 }
1432
1433 // Pour un champ de microformats :
1434 // afficher les tags
1435 // ou afficher les enclosures
1436 // http://doc.spip.org/@extraire_tags
1437 function extraire_tags($tags) {
1438 if (preg_match_all(',<a([[:space:]][^>]*)?[[:space:]][^>]*>.*</a>,UimsS',
1439 $tags, $regs, PREG_PATTERN_ORDER))
1440 return $regs[0];
1441 else
1442 return array();
1443 }
1444 // http://doc.spip.org/@afficher_enclosures
1445 function afficher_enclosures($tags) {
1446 $s = array();
1447 foreach (extraire_tags($tags) as $tag) {
1448 if (extraire_attribut($tag, 'rel') == 'enclosure'
1449 AND $t = extraire_attribut($tag, 'href')) {
1450 include_spip('inc/minipres'); #pour http_img_pack (quel bazar)
1451 $s[] = preg_replace(',>[^<]+</a>,S',
1452 '>'
1453 .http_img_pack('attachment.gif', $t,
1454 'height="15" width="15" title="'.attribut_html($t).'"')
1455 .'</a>', $tag);
1456 }
1457 }
1458 return join('&nbsp;', $s);
1459 }
1460 // http://doc.spip.org/@afficher_tags
1461 function afficher_tags($tags, $rels='tag,directory') {
1462 $s = array();
1463 foreach (extraire_tags($tags) as $tag) {
1464 $rel = extraire_attribut($tag, 'rel');
1465 if (strstr(",$rels,", ",$rel,"))
1466 $s[] = $tag;
1467 }
1468 return join(', ', $s);
1469 }
1470
1471 // Passe un <enclosure url="fichier" length="5588242" type="audio/mpeg"/>
1472 // au format microformat <a rel="enclosure" href="fichier" ...>fichier</a>
1473 // attention length="zz" devient title="zz", pour rester conforme
1474 // http://doc.spip.org/@enclosure2microformat
1475 function enclosure2microformat($e) {
1476 $url = filtrer_entites(extraire_attribut($e, 'url'));
1477 $type = extraire_attribut($e, 'type');
1478 $length = extraire_attribut($e, 'length');
1479 $fichier = basename($url);
1480 return '<a rel="enclosure"'
1481 . ($url? ' href="'.htmlspecialchars($url).'"' : '')
1482 . ($type? ' type="'.htmlspecialchars($type).'"' : '')
1483 . ($length? ' title="'.htmlspecialchars($length).'"' : '')
1484 . '>'.$fichier.'</a>';
1485 }
1486 // La fonction inverse
1487 // http://doc.spip.org/@microformat2enclosure
1488 function microformat2enclosure($tags) {
1489 $enclosures = array();
1490 foreach (extraire_tags($tags) as $e)
1491 if (extraire_attribut($e, 'rel') == 'enclosure') {
1492 $url = filtrer_entites(extraire_attribut($e, 'href'));
1493 $type = extraire_attribut($e, 'type');
1494 if (!$length = intval(extraire_attribut($e, 'title')))
1495 $length = intval(extraire_attribut($e, 'length')); # vieux data
1496 $fichier = basename($url);
1497 $enclosures[] = '<enclosure'
1498 . ($url? ' url="'.htmlspecialchars($url).'"' : '')
1499 . ($type? ' type="'.htmlspecialchars($type).'"' : '')
1500 . ($length? ' length="'.$length.'"' : '')
1501 . ' />';
1502 }
1503 return join("\n", $enclosures);
1504 }
1505 // Creer les elements ATOM <dc:subject> a partir des tags
1506 // http://doc.spip.org/@tags2dcsubject
1507 function tags2dcsubject($tags) {
1508 $subjects = '';
1509 foreach (extraire_tags($tags) as $e) {
1510 if (extraire_attribut($e, rel) == 'tag') {
1511 $subjects .= '<dc:subject>'
1512 . texte_backend(textebrut($e))
1513 . '</dc:subject>'."\n";
1514 }
1515 }
1516 return $subjects;
1517 }
1518 // fabrique un bouton de type $t de Name $n, de Value $v et autres attributs $a
1519 // http://doc.spip.org/@boutonne
1520 function boutonne($t, $n, $v, $a='') {
1521 return "\n<input type='$t'"
1522 . (!$n ? '' : " name='$n'")
1523 . " value=\"$v\" $a />";
1524 }
1525
1526 // retourne la premiere balise du type demande
1527 // ex: [(#DESCRIPTIF|extraire_balise{img})]
1528 // http://doc.spip.org/@extraire_balise
1529 function extraire_balise($texte, $tag) {
1530 if (preg_match(",<$tag\\s.*>,UimsS", $texte, $regs))
1531 return $regs[0];
1532 }
1533
1534 // construit une balise textarea avec la barre de raccourcis std de Spip.
1535 // ATTENTION: cette barre injecte un script JS que le squelette doit accepter
1536 // donc ce filtre doit IMPERATIVEMENT assurer la securite a sa place
1537
1538 // http://doc.spip.org/@barre_textarea
1539 function barre_textarea($texte, $rows, $cols, $lang='') {
1540 static $num_textarea = 0;
1541 include_spip('inc/layer'); // definit browser_barre
1542
1543 $texte = entites_html($texte);
1544 if (!$GLOBALS['browser_barre'])
1545 return "<textarea name='texte' rows='$rows' class='forml' cols='$cols'>$texte</textarea>";
1546
1547 $num_textarea++;
1548 include_spip ('inc/barre');
1549 return afficher_barre("document.getElementById('textarea_$num_textarea')", true, $lang) .
1550 "
1551 <textarea name='texte' rows='$rows' class='forml' cols='$cols'
1552 id='textarea_$num_textarea'
1553 onselect='storeCaret(this);'
1554 onclick='storeCaret(this);'
1555 onkeyup='storeCaret(this);'
1556 ondblclick='storeCaret(this);'>$texte</textarea>";
1557 }
1558
1559 // comme in_array mais renvoie son 3e arg si le 2er arg n'est pas un tableau
1560 // prend ' ' comme representant de vrai et '' de faux
1561
1562 // http://doc.spip.org/@in_any
1563 function in_any($val, $vals, $def) {
1564 return (!is_array($vals) ? $def : (in_array($val, $vals) ? ' ' : ''));
1565 }
1566
1567 // valeur_numerique("3*2") => 6
1568 // n'accepte que les *, + et - (a ameliorer si on l'utilise vraiment)
1569 // http://doc.spip.org/@valeur_numerique
1570 function valeur_numerique($expr) {
1571 if (preg_match(',^[0-9]+(\s*[+*-]\s*[0-9]+)*$,S', trim($expr)))
1572 eval("\$a = $expr;");
1573 return intval($a);
1574 }
1575
1576 // Si on fait un formulaire qui GET ou POST des donnees sur un lien
1577 // comprenant des arguments, il faut remettre ces valeurs dans des champs
1578 // hidden ; cette fonction calcule les hidden en question
1579 // http://doc.spip.org/@form_hidden
1580 function form_hidden($action) {
1581 $hidden = '';
1582 if (false !== ($p = strpos($action, '?')))
1583 foreach(preg_split('/&(amp;)?/S',substr($action,$p+1)) as $c) {
1584 $hidden .= "\n<input name='" .
1585 entites_html(rawurldecode(str_replace('=', "' value='", $c))) .
1586 "' type='hidden' />";
1587 }
1588 return $hidden;
1589 }
1590
1591 // http://doc.spip.org/@calcul_bornes_pagination
1592 function calcul_bornes_pagination($courante, $nombre, $max = 10) {
1593 if (function_exists("bornes_pagination"))
1594 return bornes_pagination($max, $nombre, $courante);
1595
1596 if($max<=0 OR $max>=$nombre)
1597 return array(1, $nombre);
1598
1599 $premiere = max(1, $courante-floor(($max-1)/2));
1600 $derniere = min($nombre, $premiere+$max-2);
1601 $premiere = $derniere == $nombre ? $derniere-$max+1 : $premiere;
1602 return array($premiere, $derniere);
1603 }
1604
1605 //
1606 // fonction standard de calcul de la balise #PAGINATION
1607 // on peut la surcharger en definissant dans mes_fonctions :
1608 // function pagination($total, $nom, $pas, $liste) {...}
1609 //
1610
1611 // http://doc.spip.org/@calcul_pagination
1612 function calcul_pagination($total, $nom, $pas, $liste = true, $modele='') {
1613 static $ancres = array();
1614 $bloc_ancre = "";
1615
1616 if ($pas<1) return;
1617
1618 if (function_exists("pagination"))
1619 return pagination($total, $nom, $pas, $liste);
1620
1621 $debut = 'debut'.$nom;
1622 $ancre='pagination'.$nom;
1623
1624 // n'afficher l'ancre qu'une fois
1625 if (!isset($ancres[$ancre]))
1626 $bloc_ancre = $ancres[$ancre] = "<a name='$ancre' id='$ancre'></a>";
1627
1628 $pagination = array(
1629 'debut' => 'debut'.$nom,
1630 'url' => parametre_url(self(),'fragment',''), // nettoyer l'id ahah eventuel
1631 'total' => $total,
1632 'position' => intval(_request($debut)),
1633 'pas' => $pas,
1634 'nombre_pages' => floor(($total-1)/$pas)+1,
1635 'page_courante' => floor(intval(_request($debut))/$pas)+1,
1636 'ancre' => $ancre,
1637 'bloc_ancre' => $bloc_ancre
1638 );
1639
1640 // Pas de pagination
1641 if ($pagination['nombre_pages']<=1)
1642 return '';
1643
1644 // liste = false : on ne veut que l'ancre
1645 if (!$liste)
1646 return $bloc_ancre;
1647
1648 if ($modele) $modele = '_'.$modele;
1649 return recuperer_fond("modeles/pagination$modele",$pagination);
1650 }
1651
1652 // recuperere le chemin d'une css existante et :
1653 // 1. regarde si une css inversee droite-gauche existe dans le meme repertoire
1654 // 2. sinon la cree (ou la recree) dans _DIR_VAR/cache_css/
1655 // SI on lui donne a manger une feuille nommee _rtl.css il va faire l'inverse
1656 // http://doc.spip.org/@direction_css
1657 function direction_css ($css, $voulue='') {
1658 if (!preg_match(',(_rtl)?\.css$,i', $css, $r)) return $css;
1659
1660 // si on a precise le sens voulu en argument, le prendre en compte
1661 if ($voulue = strtolower($voulue)) {
1662 if ($voulue != 'rtl' AND $voulue != 'ltr')
1663 $voulue = lang_dir($voulue);
1664 }
1665 else
1666 $voulue = $GLOBALS['spip_lang_dir'];
1667
1668 $right = $r[1] ? 'left' : 'right'; // 'right' de la css lue en entree
1669 $dir = $r[1] ? 'rtl' : 'ltr';
1670 $ndir = $r[1] ? 'ltr' : 'rtl';
1671
1672 if ($voulue == $dir)
1673 return $css;
1674
1675 $path = dirname(url_absolue($css))."/"; // pour mettre sur les images
1676
1677 // 1.
1678 $f = preg_replace(',(_rtl)?\.css$,i', '_'.$ndir.'.css', $css);
1679 if (@file_exists($f))
1680 return $f;
1681
1682 // 2.
1683 $dir_var = sous_repertoire (_DIR_VAR, 'cache-css');
1684 $f = $dir_var
1685 . preg_replace(',.*/(.*?)(_rtl)?\.css,', '\1', $css)
1686 . '.' . substr(md5($css), 0,4) . '_' . $ndir . '.css';
1687
1688 // la css peut etre distante (url absolue !)
1689 if (preg_match(",^http:,i",$css)){
1690 include_spip('inc/distant');
1691 $contenu = recuperer_page($css);
1692 if (!$contenu) return $css;
1693 }
1694 else {
1695 if ((@filemtime($f) > @filemtime($css))
1696 AND ($GLOBALS['var_mode'] != 'recalcul'))
1697 return $f;
1698 if (!lire_fichier($css, $contenu))
1699 return $css;
1700 }
1701
1702 $contenu = str_replace(
1703 array('right', 'left', '@@@@L E F T@@@@'),
1704 array('@@@@L E F T@@@@', 'right', 'left'),
1705 $contenu);
1706
1707 // reperer les @import auxquels il faut propager le direction_css
1708 preg_match_all(",\@import\s*url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims",$contenu,$regs);
1709 $src = array();$src_direction_css = array();$src_faux_abs=array();
1710 $d = dirname($css);
1711 foreach($regs[1] as $k=>$import_css){
1712 $css_direction = direction_css("$d/$import_css",$voulue);
1713 // si la css_direction est dans le meme path que la css d'origine, on tronque le path, elle sera passee en absolue
1714 if (substr($css_direction,0,strlen($d)+1)=="$d/") $css_direction = substr($css_direction,strlen($d)+1);
1715 // si la css_direction commence par $dir_var on la fait passer pour une absolue
1716 elseif (substr($css_direction,0,strlen($dir_var))==$dir_var) {
1717 $css_direction = substr($css_direction,strlen($dir_var));
1718 $src_faux_abs["/@@@@@@/".$css_direction] = $css_direction;
1719 $css_direction = "/@@@@@@/".$css_direction;
1720 }
1721 $src[] = $regs[0][$k];
1722 $src_direction_css[] = str_replace($import_css,$css_direction,$regs[0][$k]);
1723 }
1724 $contenu = str_replace($src,$src_direction_css,$contenu);
1725
1726 // passer les url relatives a la css d'origine en url absolues
1727 $contenu = preg_replace(",url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims","url($path\\1)",$contenu);
1728 // virer les fausses url absolues que l'on a mis dans les import
1729 if (count($src_faux_abs))
1730 $contenu = str_replace(array_keys($src_faux_abs),$src_faux_abs,$contenu);
1731
1732 if (!ecrire_fichier($f, $contenu))
1733 return $css;
1734
1735 return $f;
1736 }
1737
1738 // recuperere le chemin d'une css existante et :
1739 // cree (ou recree) dans _DIR_VAR/cache_css/ une css dont les url relatives sont passees en url absolues
1740 // http://doc.spip.org/@url_absolue_css
1741 function url_absolue_css ($css) {
1742 if (!preg_match(',\.css$,i', $css, $r)) return $css;
1743
1744 $path = dirname(url_absolue($css))."/"; // pour mettre sur les images
1745
1746 $f = basename($css,'.css');
1747 $f = sous_repertoire (_DIR_VAR, 'cache-css')
1748 . preg_replace(",^(.*?)(_rtl|_ltr)?$,","\\1-urlabs-" . substr(md5("$css-urlabs"), 0,4) . "\\2",$f)
1749 . '.css';
1750
1751 if ((@filemtime($f) > @filemtime($css))
1752 AND ($GLOBALS['var_mode'] != 'recalcul'))
1753 return $f;
1754
1755 if (!lire_fichier($css, $contenu))
1756 return $css;
1757
1758 // passer les url relatives a la css d'origine en url absolues
1759 $contenu = preg_replace(",url\s*\(\s*['\"]?([^'\"/][^:]*)['\"]?\s*\),Uims","url($path\\1)",$contenu);
1760
1761 // ecrire la css
1762 if (!ecrire_fichier($f, $contenu))
1763 return $css;
1764
1765 return $f;
1766 }
1767
1768 // http://doc.spip.org/@compacte_css
1769 function compacte_css ($contenu) {
1770 // nettoyer la css de tout ce qui sert pas
1771 $contenu = preg_replace(",/\*.*\*/,Ums","",$contenu); // pas de commentaires
1772 $contenu = preg_replace(",\s(?=\s),Ums","",$contenu); // pas d'espaces consecutifs
1773 $contenu = preg_replace("/\s?({|;|,|:)\s?/ms","$1",$contenu); // pas d'espaces dans les declarations css
1774 $contenu = preg_replace("/\s}/ms","}",$contenu); // pas d'espaces dans les declarations css
1775 $contenu = preg_replace(",#([0-9a-f])(\\1)([0-9a-f])(\\3)([0-9a-f])(\\5),i","#$1$3$5",$contenu); // passser les codes couleurs en 3 car si possible
1776 $contenu = preg_replace(",([^{}]*){},Ums"," ",$contenu); // supprimer les declarations vides
1777 $contenu = trim($contenu);
1778
1779 return $contenu;
1780 }
1781
1782 // filtre table_valeur
1783 // permet de recuperer la valeur d'un tableau pour une cle donnee
1784 // prend en entree un tableau serialise ou non (ce qui permet d'enchainer le filtre)
1785 // http://doc.spip.org/@table_valeur
1786 function table_valeur($table,$cle,$defaut=''){
1787 $table= is_string($table)?unserialize($table):$table;
1788 $table= is_array($table)?$table:array();
1789 return isset($table[$cle])?$table[$cle]:$defaut;
1790 }
1791
1792 // filtre match pour faire des tests avec expression reguliere
1793 // [(#TEXTE|match{^ceci$,Uims})]
1794 // retourne le fragment de chaine qui "matche"
1795 // http://doc.spip.org/@match
1796 function match($texte, $expression, $modif="UimsS") {
1797 $expression=str_replace("\/","/",$expression);
1798 $expression=str_replace("/","\/",$expression);
1799 return preg_match('/' . $expression . '/' . $modif,$texte, $r)
1800 ? ($r[0]?$r[0]:true) : false;
1801 }
1802
1803 // filtre replace pour faire des operations avec expression reguliere
1804 // [(#TEXTE|replace{^ceci$,cela,Uims})]
1805 // http://doc.spip.org/@replace
1806 function replace($texte, $expression, $replace='', $modif="UimsS") {
1807 $expression=str_replace("\/","/", $expression);
1808 $expression=str_replace("/","\/",$expression);
1809 return preg_replace('/' . $expression . '/' . $modif, $replace, $texte);
1810 }
1811
1812
1813 // cherche les documents numerotes dans un texte traite par propre()
1814 // et affecte les doublons['documents']
1815 // http://doc.spip.org/@traiter_doublons_documents
1816 // http://doc.spip.org/@traiter_doublons_documents
1817 function traiter_doublons_documents(&$doublons, $letexte) {
1818
1819 // Verifier dans le texte & les notes (pas beau, helas)
1820 $t = $letexte.$GLOBALS['les_notes'];
1821
1822 if (strstr($t, 'spip_document_') // evite le preg_match_all si inutile
1823 AND preg_match_all(
1824 ',<[^>]+\sclass=["\']spip_document_([0-9]+)[\s"\'],imsS',
1825 $t, $matches, PREG_PATTERN_ORDER))
1826 $doublons['documents'] .= "," . join(',', $matches[1]);
1827
1828 return $letexte;
1829 }
1830
1831 // filtre vide qui ne renvoie rien
1832 // http://doc.spip.org/@vide
1833 function vide($texte){
1834 return "";
1835 }
1836
1837 //
1838 // Filtres pour le modele/emb (embed document)
1839 //
1840
1841 // A partir d'un #ENV, retourne des <param ...>
1842 // http://doc.spip.org/@env_to_params
1843 function env_to_params ($texte){
1844 $ignore_params = array('id_document','date','date_redac','align','fond','','recurs','emb');
1845 $tableau = unserialize($texte);
1846 $texte = "";
1847 foreach ($tableau as $i => $j)
1848 if (!in_array($i,$ignore_params))
1849 $texte .= "<param name='".$i."' value='".$j."' />";
1850 return $texte;
1851 }
1852 // A partir d'un #ENV, retourne des attributs
1853 // http://doc.spip.org/@env_to_attributs
1854 function env_to_attributs ($texte){
1855 $ignore_params = array('id_document','date','date_redac','align','fond','','recurs','emb');
1856 $tableau = unserialize($texte);
1857 $texte = "";
1858 foreach ($tableau as $i => $j)
1859 if (!in_array($i,$ignore_params))
1860 $texte .= $i."='".$j."' ";
1861 return $texte;
1862 }
1863
1864 // Inserer jQuery
1865 // et au passage verifier qu'on ne doublonne pas #INSERT_HEAD
1866 // http://doc.spip.org/@f_jQuery
1867 function f_jQuery ($texte) {
1868 static $doublon=0;
1869 if ($doublon++) {
1870 include_spip('public/debug');
1871 $texte = affiche_erreurs_page(array(
1872 array("#INSERT_HEAD",_T('double_occurrence')))
1873 ) . $texte;
1874 } else {
1875 $texte = "\n<script src=\"".generer_url_public('jquery.js')
1876 . "\" type=\"text/javascript\"></script>\n"
1877 . $texte;
1878 }
1879 return $texte;
1880 }
1881
1882 // Concatener des chaines
1883 // #TEXTE|concat{texte1,texte2,...}
1884 // http://doc.spip.org/@concat
1885 function concat(){
1886 $args = func_get_args();
1887 return join('', $args);
1888 }
1889
1890
1891 // Compacte du javascript grace a javascriptcompressor
1892 // utile pour dist/jquery.js par exemple
1893 // http://doc.spip.org/@compacte_js
1894 function compacte_js($flux) {
1895 include_spip('inc/compacte_js');
1896 $k = new JavaScriptCompressor();
1897 // en cas d'echec (?) renvoyer l'original
1898 if (strlen($t = $k->getClean($flux)))
1899 return $t;
1900
1901 // erreur
1902 spip_log('erreur de compacte_js');
1903 return $flux;
1904 }
1905
1906 // Si la source est un chemin, on retourne un chemin avec le contenu compacte
1907 // dans _DIR_VAR/cache_$format/
1908 // Si c'est un flux on le renvoit compacte
1909 // Si on ne sait pas compacter, on renvoie ce qu'on a recu
1910 // http://doc.spip.org/@compacte
1911 function compacte($source, $format = null) {
1912 if (!$format AND preg_match(',\.(js|css)$,', $source, $r))
1913 $format = $r[1];
1914 if (!function_exists($compacte = 'compacte_'.$format))
1915 return $source;
1916
1917 // Si on n'importe pas, est-ce un fichier ?
1918 if (!preg_match(',[\s{}],', $source)
1919 AND preg_match(',\.'.$format.'$,i', $source, $r)
1920 AND file_exists($source)) {
1921 $f = basename($source,'.'.$format);
1922 $f = sous_repertoire (_DIR_VAR, 'cache-'.$format)
1923 . preg_replace(",(.*?)(_rtl|_ltr)?$,","\\1-compacte-"
1924 . substr(md5("$source-compacte"), 0,4) . "\\2", $f, 1)
1925 . '.' . $format;
1926
1927 if ((@filemtime($f) > @filemtime($source))
1928 AND ($GLOBALS['var_mode'] != 'recalcul'))
1929 return $f;
1930
1931 if (!lire_fichier($source, $contenu))
1932 return $source;
1933
1934 // traiter le contenu
1935 $contenu = $compacte($contenu);
1936
1937 // ecrire le fichier destination, en cas d'echec renvoyer la source
1938 if (ecrire_fichier($f, $contenu))
1939 return $f;
1940 else
1941 return $source;
1942 }
1943
1944 // Sinon simple compactage de contenu
1945 return $compacte($source);
1946 }
1947
1948 ?>