| 4 |
david |
1 |
<?php
|
|
|
2 |
|
|
|
3 |
/***************************************************************************\
|
|
|
4 |
* SPIP, Systeme de publication pour l'internet *
|
|
|
5 |
* *
|
|
|
6 |
* Copyright (c) 2001-2005 *
|
|
|
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 |
//
|
|
|
15 |
// Ce fichier ne sera execute qu'une fois
|
|
|
16 |
if (defined("_ECRIRE_INC_FILTRES")) return;
|
|
|
17 |
define("_ECRIRE_INC_FILTRES", "1");
|
|
|
18 |
|
|
|
19 |
|
|
|
20 |
// Echappement des entites HTML avec correction des entites "brutes"
|
|
|
21 |
// (generees par les butineurs lorsqu'on rentre des caracteres n'appartenant
|
|
|
22 |
// pas au charset de la page [iso-8859-1 par defaut])
|
|
|
23 |
function corriger_entites_html($texte) {
|
|
|
24 |
return preg_replace(',&(#[0-9]+;),i', '&\1', $texte);
|
|
|
25 |
}
|
|
|
26 |
// idem mais corriger aussi les &eacute; en é
|
|
|
27 |
function corriger_toutes_entites_html($texte) {
|
|
|
28 |
return preg_replace(',&(#?[a-z0-9]+;),', '&\1', $texte);
|
|
|
29 |
}
|
|
|
30 |
|
|
|
31 |
function entites_html($texte) {
|
|
|
32 |
return corriger_entites_html(htmlspecialchars($texte));
|
|
|
33 |
}
|
|
|
34 |
|
|
|
35 |
// Transformer les é dans le charset local
|
|
|
36 |
function filtrer_entites($texte) {
|
|
|
37 |
include_ecrire('inc_charsets.php3');
|
|
|
38 |
// filtrer
|
|
|
39 |
$texte = html2unicode($texte);
|
|
|
40 |
// remettre le tout dans le charset cible
|
|
|
41 |
return unicode2charset($texte);
|
|
|
42 |
}
|
|
|
43 |
|
|
|
44 |
// Tout mettre en entites pour l'export backend (sauf iso-8859-1)
|
|
|
45 |
function entites_unicode($texte) {
|
|
|
46 |
include_ecrire('inc_charsets.php3');
|
|
|
47 |
return charset2unicode($texte);
|
|
|
48 |
}
|
|
|
49 |
|
|
|
50 |
// caracteres de controle - http://www.w3.org/TR/REC-xml/#charsets
|
|
|
51 |
function supprimer_caracteres_illegaux($texte) {
|
|
|
52 |
$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";
|
|
|
53 |
$to = str_repeat('-', strlen($from));
|
|
|
54 |
return strtr($texte, $from, $to);
|
|
|
55 |
}
|
|
|
56 |
|
|
|
57 |
// Corrige les caracteres degoutants utilises par les Windozeries
|
|
|
58 |
function corriger_caracteres_windows($texte) {
|
|
|
59 |
static $trans;
|
|
|
60 |
if (!$trans) {
|
|
|
61 |
// 145,146,180 = simple quote ; 147,148 = double quote ; 150,151 = tiret long
|
|
|
62 |
$trans['iso-8859-1'] = array(
|
|
|
63 |
chr(146) => "'",
|
|
|
64 |
chr(180) => "'",
|
|
|
65 |
chr(147) => '“',
|
|
|
66 |
chr(148) => '”',
|
|
|
67 |
chr(150) => '-',
|
|
|
68 |
chr(151) => '-',
|
|
|
69 |
chr(133) => '...'
|
|
|
70 |
);
|
|
|
71 |
$trans['utf-8'] = array(
|
|
|
72 |
chr(194).chr(146) => "'",
|
|
|
73 |
chr(194).chr(180) => "'",
|
|
|
74 |
chr(194).chr(147) => '“',
|
|
|
75 |
chr(194).chr(148) => '”',
|
|
|
76 |
chr(194).chr(150) => '-',
|
|
|
77 |
chr(194).chr(151) => '-',
|
|
|
78 |
chr(194).chr(133) => '...'
|
|
|
79 |
);
|
|
|
80 |
}
|
|
|
81 |
$charset = lire_meta('charset');
|
|
|
82 |
if (!$trans[$charset]) return $texte;
|
|
|
83 |
return strtr($texte, $trans[$charset]);
|
|
|
84 |
}
|
|
|
85 |
|
|
|
86 |
// Supprimer caracteres windows et les caracteres de controle ILLEGAUX
|
|
|
87 |
function corriger_caracteres ($texte) {
|
|
|
88 |
$texte = corriger_caracteres_windows($texte);
|
|
|
89 |
$texte = supprimer_caracteres_illegaux($texte);
|
|
|
90 |
return $texte;
|
|
|
91 |
}
|
|
|
92 |
|
|
|
93 |
|
|
|
94 |
// Nettoyer les backend
|
|
|
95 |
function texte_backend($texte) {
|
|
|
96 |
|
|
|
97 |
// importer les é
|
|
|
98 |
$texte = filtrer_entites($texte);
|
|
|
99 |
|
|
|
100 |
// " -> " et tout ce genre de choses
|
|
|
101 |
// contourner bug windows ou char(160) fait partie de la regexp \s
|
|
|
102 |
$u = (lire_meta('charset')=='utf-8') ? 'u':'';
|
|
|
103 |
$texte = str_replace(" ", " ", $texte);
|
|
|
104 |
$texte = preg_replace("/\s\s+/$u", " ", $texte);
|
|
|
105 |
$texte = entites_html($texte);
|
|
|
106 |
|
|
|
107 |
// verifier le charset
|
|
|
108 |
$texte = entites_unicode($texte);
|
|
|
109 |
|
|
|
110 |
// Caracteres problematiques en iso-latin 1
|
|
|
111 |
if (lire_meta('charset') == 'iso-8859-1') {
|
|
|
112 |
$texte = str_replace(chr(156), 'œ', $texte);
|
|
|
113 |
$texte = str_replace(chr(140), 'Œ', $texte);
|
|
|
114 |
$texte = str_replace(chr(159), 'Ÿ', $texte);
|
|
|
115 |
}
|
|
|
116 |
|
|
|
117 |
// nettoyer l'apostrophe curly qui semble poser probleme a certains rss-readers
|
|
|
118 |
$texte = str_replace("’","'",$texte);
|
|
|
119 |
|
|
|
120 |
return $texte;
|
|
|
121 |
}
|
|
|
122 |
|
|
|
123 |
// Enleve le numero des titres numerotes ("1. Titre" -> "Titre")
|
|
|
124 |
function supprimer_numero($texte) {
|
|
|
125 |
$texte = preg_replace(",^[[:space:]]*[0-9]+[.)".chr(176)."][[:space:]]+,", "", $texte);
|
|
|
126 |
return $texte;
|
|
|
127 |
}
|
|
|
128 |
|
|
|
129 |
// Suppression basique et brutale de tous les <...>
|
|
|
130 |
function supprimer_tags($texte, $rempl = "") {
|
|
|
131 |
$texte = preg_replace(",<[^>]*>,U", $rempl, $texte);
|
|
|
132 |
// ne pas oublier un < final non ferme
|
|
|
133 |
$texte = str_replace('<', ' ', $texte);
|
|
|
134 |
return $texte;
|
|
|
135 |
}
|
|
|
136 |
|
|
|
137 |
// Convertit les <...> en la version lisible en HTML
|
|
|
138 |
function echapper_tags($texte, $rempl = "") {
|
|
|
139 |
$texte = ereg_replace("<([^>]*)>", "<\\1>", $texte);
|
|
|
140 |
return $texte;
|
|
|
141 |
}
|
|
|
142 |
|
|
|
143 |
// Convertit un texte HTML en texte brut
|
|
|
144 |
function textebrut($texte) {
|
|
|
145 |
$u = (lire_meta('charset')=='utf-8') ? 'u':'';
|
|
|
146 |
$texte = preg_replace("/\s+/$u", " ", $texte);
|
|
|
147 |
$texte = preg_replace("/<(p|br)( [^>]*)?".">/i", "\n\n", $texte);
|
|
|
148 |
$texte = preg_replace("/^\n+/", "", $texte);
|
|
|
149 |
$texte = preg_replace("/\n+$/", "", $texte);
|
|
|
150 |
$texte = preg_replace("/\n +/", "\n", $texte);
|
|
|
151 |
$texte = supprimer_tags($texte);
|
|
|
152 |
$texte = preg_replace("/( | )+/", " ", $texte);
|
|
|
153 |
// nettoyer l'apostrophe curly qui pose probleme a certains rss-readers, lecteurs de mail...
|
|
|
154 |
$texte = str_replace("’","'",$texte);
|
|
|
155 |
return $texte;
|
|
|
156 |
}
|
|
|
157 |
|
|
|
158 |
// Remplace les liens SPIP en liens ouvrant dans une nouvelle fenetre (target=blank)
|
|
|
159 |
function liens_ouvrants ($texte) {
|
|
|
160 |
return ereg_replace("<a ([^>]*https?://[^>]*class=\"spip_(out|url)\")>",
|
|
|
161 |
"<a \\1 target=\"_blank\">", $texte);
|
|
|
162 |
}
|
|
|
163 |
|
|
|
164 |
// Fabrique une balise A, avec un href conforme au validateur W3C
|
|
|
165 |
// attention au cas ou la href est du Javascript avec des "'"
|
|
|
166 |
|
|
|
167 |
function http_href($href, $clic, $title='', $style='', $class='', $evt='') {
|
|
|
168 |
return '<a href="' .
|
|
|
169 |
str_replace('&', '&', $href) .
|
|
|
170 |
'"' .
|
|
|
171 |
(!$title ? '' : ("\ntitle=\"" . supprimer_tags($title)."\"")) .
|
|
|
172 |
(!$style ? '' : ("\nstyle=\"" . $style . "\"")) .
|
|
|
173 |
(!$class ? '' : ("\nclass=\"" . $class . "\"")) .
|
|
|
174 |
($evt ? "\n$evt" : '') .
|
|
|
175 |
'>' .
|
|
|
176 |
$clic .
|
|
|
177 |
'</a>';
|
|
|
178 |
}
|
|
|
179 |
|
|
|
180 |
// produit une balise img avec un champ alt d'office si vide
|
|
|
181 |
// attention le htmlentities et la traduction doivent etre appliques avant.
|
|
|
182 |
|
|
|
183 |
function http_img_pack($img, $alt, $att, $title='') {
|
|
|
184 |
return "<img src='" . _DIR_IMG_PACK . $img
|
|
|
185 |
. ("'\nalt=\"" .
|
|
|
186 |
($alt ? $alt : ($title ? $title : ereg_replace('\..*$','',$img)))
|
|
|
187 |
. '" ')
|
|
|
188 |
. ($title ? " title=\"$title\"" : '')
|
|
|
189 |
. $att . " />";
|
|
|
190 |
}
|
|
|
191 |
|
|
|
192 |
// variante avec un label et un checkbox
|
|
|
193 |
|
|
|
194 |
function http_label_img($statut, $etat, $var, $img, $texte) {
|
|
|
195 |
return "<label for='$statut'>".
|
|
|
196 |
"<input type='checkbox' " .
|
|
|
197 |
(($etat !== false) ? ' checked="checked"' : '') .
|
|
|
198 |
" name='$var" .
|
|
|
199 |
"[]' value='$statut' id='$statut'> " .
|
|
|
200 |
http_img_pack($img, $texte, "width='8' height='9' border='0'", $texte) .
|
|
|
201 |
" " .
|
|
|
202 |
$texte .
|
|
|
203 |
"</label><br />";
|
|
|
204 |
}
|
|
|
205 |
|
|
|
206 |
function http_href_img($href, $img, $att, $title='', $style='', $class='', $evt='') {
|
|
|
207 |
return http_href($href, http_img_pack($img, $title, $att), $title, $style, $class, $evt);
|
|
|
208 |
}
|
|
|
209 |
|
|
|
210 |
|
|
|
211 |
// Transformer les sauts de paragraphe en simples passages a la ligne
|
|
|
212 |
function PtoBR($texte){
|
|
|
213 |
$texte = eregi_replace("</p>", "\n", $texte);
|
|
|
214 |
$texte = eregi_replace("<p([[:space:]][^>]*)?".">", "<br />", $texte);
|
|
|
215 |
$texte = ereg_replace("^[[:space:]]*<br />", "", $texte);
|
|
|
216 |
return $texte;
|
|
|
217 |
}
|
|
|
218 |
|
|
|
219 |
// Couper les "mots" de plus de $l caracteres (souvent des URLs)
|
|
|
220 |
function lignes_longues($texte, $l = 70) {
|
|
|
221 |
// Passer en utf-8 pour ne pas avoir de coupes trop courtes avec les &#xxxx;
|
|
|
222 |
// qui prennent 7 caracteres
|
|
|
223 |
include_ecrire('inc_charsets.php3');
|
|
|
224 |
$texte = unicode_to_utf_8(charset2unicode(
|
|
|
225 |
$texte, lire_meta('charset'), true));
|
|
|
226 |
|
|
|
227 |
// echapper les tags (on ne veut pas casser les a href=...)
|
|
|
228 |
$tags = array();
|
|
|
229 |
if (preg_match_all('/<.*>/Uums', $texte, $t, PREG_SET_ORDER)) {
|
|
|
230 |
foreach ($t as $n => $tag) {
|
|
|
231 |
$tags[$n] = $tag[0];
|
|
|
232 |
$texte = str_replace($tag[0], " @@SPIPTAG$n@@ ", $texte);
|
|
|
233 |
}
|
|
|
234 |
}
|
|
|
235 |
// casser les mots longs qui restent
|
|
|
236 |
if (preg_match_all("/\S{".$l."}/Ums", $texte, $longs, PREG_SET_ORDER)) {
|
|
|
237 |
foreach ($longs as $long) {
|
|
|
238 |
$texte = str_replace($long[0], $long[0].' ', $texte);
|
|
|
239 |
}
|
|
|
240 |
}
|
|
|
241 |
|
|
|
242 |
// retablir les tags
|
|
|
243 |
foreach ($tags as $n=>$tag) {
|
|
|
244 |
$texte = str_replace(" @@SPIPTAG$n@@ ", $tag, $texte);
|
|
|
245 |
}
|
|
|
246 |
|
|
|
247 |
return importer_charset($texte, 'utf-8');
|
|
|
248 |
}
|
|
|
249 |
|
|
|
250 |
// Majuscules y compris accents, en HTML
|
|
|
251 |
function majuscules($texte) {
|
|
|
252 |
// Cas du turc
|
|
|
253 |
if ($GLOBALS['spip_lang'] == 'tr') {
|
|
|
254 |
# remplacer hors des tags et des entites
|
|
|
255 |
if (preg_match_all(',<[^<>]+>|&[^;]+;,', $texte, $regs, PREG_SET_ORDER))
|
|
|
256 |
foreach ($regs as $n => $match)
|
|
|
257 |
$texte = str_replace($match[0], "@@SPIP_TURC$n@@", $texte);
|
|
|
258 |
|
|
|
259 |
$texte = str_replace('i', 'İ', $texte);
|
|
|
260 |
|
|
|
261 |
if ($regs)
|
|
|
262 |
foreach ($regs as $n => $match)
|
|
|
263 |
$texte = str_replace("@@SPIP_TURC$n@@", $match[0], $texte);
|
|
|
264 |
}
|
|
|
265 |
|
|
|
266 |
// Cas general
|
|
|
267 |
return "<span style='text-transform: uppercase'>$texte</span>";
|
|
|
268 |
}
|
|
|
269 |
|
|
|
270 |
// "127.4 ko" ou "3.1 Mo"
|
|
|
271 |
function taille_en_octets ($taille) {
|
|
|
272 |
if ($taille < 1024) {$taille = _T('taille_octets', array('taille' => $taille));}
|
|
|
273 |
else if ($taille < 1024*1024) {
|
|
|
274 |
$taille = _T('taille_ko', array('taille' => ((floor($taille / 102.4))/10)));
|
|
|
275 |
} else {
|
|
|
276 |
$taille = _T('taille_mo', array('taille' => ((floor(($taille / 1024) / 102.4))/10)));
|
|
|
277 |
}
|
|
|
278 |
return $taille;
|
|
|
279 |
}
|
|
|
280 |
|
|
|
281 |
|
|
|
282 |
// Rend une chaine utilisable sans dommage comme attribut HTML
|
|
|
283 |
function attribut_html($texte) {
|
|
|
284 |
$texte = ereg_replace('"', '"', supprimer_tags($texte));
|
|
|
285 |
return $texte;
|
|
|
286 |
}
|
|
|
287 |
|
|
|
288 |
// Vider les url nulles comme 'http://' ou 'mailto:'
|
|
|
289 |
function vider_url($url) {
|
|
|
290 |
# un message pour abs_url
|
|
|
291 |
$GLOBALS['mode_abs_url'] = 'url';
|
|
|
292 |
|
|
|
293 |
$url = trim($url);
|
|
|
294 |
if (eregi("^(http:?/?/?|mailto:?)$", $url))
|
|
|
295 |
return '';
|
|
|
296 |
|
|
|
297 |
return $url;
|
|
|
298 |
}
|
|
|
299 |
|
|
|
300 |
//
|
|
|
301 |
// Ajouter le &var_recherche=toto dans les boucles de recherche
|
|
|
302 |
//
|
|
|
303 |
function url_var_recherche($url) {
|
|
|
304 |
if (_request('recherche')
|
|
|
305 |
AND !ereg("var_recherche", $url)) {
|
|
|
306 |
|
|
|
307 |
list ($url,$ancre) = preg_split(',#,', $url, 2);
|
|
|
308 |
if ($ancre) $ancre='#'.$ancre;
|
|
|
309 |
|
|
|
310 |
$x = "var_recherche=".urlencode(_request('recherche'));
|
|
|
311 |
|
|
|
312 |
if (!strpos($url, '?'))
|
|
|
313 |
return "$url?$x$ancre";
|
|
|
314 |
else
|
|
|
315 |
return "$url&$x$ancre";
|
|
|
316 |
}
|
|
|
317 |
else return $url;
|
|
|
318 |
}
|
|
|
319 |
|
|
|
320 |
|
|
|
321 |
// Extraire une date de n'importe quel champ (a completer...)
|
|
|
322 |
function extraire_date($texte) {
|
|
|
323 |
// format = 2001-08
|
|
|
324 |
if (ereg("([1-2][0-9]{3})[^0-9]*(0?[1-9]|1[0-2])",$texte,$regs))
|
|
|
325 |
return $regs[1]."-".$regs[2]."01";
|
|
|
326 |
}
|
|
|
327 |
|
|
|
328 |
// Maquiller une adresse e-mail
|
|
|
329 |
function antispam($texte) {
|
|
|
330 |
include_ecrire ("inc_acces.php3");
|
|
|
331 |
$masque = creer_pass_aleatoire(3);
|
|
|
332 |
return ereg_replace("@", " $masque ", $texte);
|
|
|
333 |
}
|
|
|
334 |
|
|
|
335 |
// |sinon{rien} : affiche "rien" si la chaine est vide, affiche la chaine si non vide
|
|
|
336 |
function sinon ($texte, $sinon='') {
|
|
|
337 |
if ($texte)
|
|
|
338 |
return $texte;
|
|
|
339 |
else
|
|
|
340 |
return $sinon;
|
|
|
341 |
}
|
|
|
342 |
|
|
|
343 |
// |choixsivide{vide,pasvide} affiche pasvide si la chaine n'est pas vide...
|
|
|
344 |
function choixsivide($a, $vide, $pasvide) {
|
|
|
345 |
return $a ? $pasvide : $vide;
|
|
|
346 |
}
|
|
|
347 |
|
|
|
348 |
// |choixsiegal{aquoi,oui,non} affiche oui si la chaine est egal a aquoi ...
|
|
|
349 |
function choixsiegal($a1,$a2,$v,$f) {
|
|
|
350 |
return ($a1 == $a2) ? $v : $f;
|
|
|
351 |
}
|
|
|
352 |
|
|
|
353 |
|
|
|
354 |
//
|
|
|
355 |
// Date, heure, saisons
|
|
|
356 |
//
|
|
|
357 |
|
|
|
358 |
function normaliser_date($date) {
|
|
|
359 |
if ($date) {
|
|
|
360 |
$date = vider_date($date);
|
|
|
361 |
if (ereg("^[0-9]{8,10}$", $date))
|
|
|
362 |
$date = date("Y-m-d H:i:s", $date);
|
|
|
363 |
if (ereg("^([12][0-9]{3})([-/]00)?( [-0-9:]+)?$", $date, $regs))
|
|
|
364 |
$date = $regs[1]."-01-01".$regs[3];
|
|
|
365 |
else if (ereg("^([12][0-9]{3}[-/][01]?[0-9])([-/]00)?( [-0-9:]+)?$", $date, $regs))
|
|
|
366 |
$date = ereg_replace("/","-",$regs[1])."-01".$regs[3];
|
|
|
367 |
else
|
|
|
368 |
$date = date("Y-m-d H:i:s", strtotime($date));
|
|
|
369 |
}
|
|
|
370 |
return $date;
|
|
|
371 |
}
|
|
|
372 |
|
|
|
373 |
function vider_date($letexte) {
|
|
|
374 |
if (ereg("^0000-00-00", $letexte)) return;
|
|
|
375 |
if (ereg("^1970-01-01", $date)) return; // eviter le bug GMT-1
|
|
|
376 |
return $letexte;
|
|
|
377 |
}
|
|
|
378 |
|
|
|
379 |
function recup_heure($numdate){
|
|
|
380 |
if (!$numdate) return '';
|
|
|
381 |
|
|
|
382 |
if (ereg('([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})', $numdate, $regs)) {
|
|
|
383 |
$heures = $regs[1];
|
|
|
384 |
$minutes = $regs[2];
|
|
|
385 |
$secondes = $regs[3];
|
|
|
386 |
}
|
|
|
387 |
return array($heures, $minutes, $secondes);
|
|
|
388 |
}
|
|
|
389 |
|
|
|
390 |
function heures($numdate) {
|
|
|
391 |
$date_array = recup_heure($numdate);
|
|
|
392 |
if ($date_array)
|
|
|
393 |
list($heures, $minutes, $secondes) = $date_array;
|
|
|
394 |
return $heures;
|
|
|
395 |
}
|
|
|
396 |
|
|
|
397 |
function minutes($numdate) {
|
|
|
398 |
$date_array = recup_heure($numdate);
|
|
|
399 |
if ($date_array)
|
|
|
400 |
list($heures, $minutes, $secondes) = $date_array;
|
|
|
401 |
return $minutes;
|
|
|
402 |
}
|
|
|
403 |
|
|
|
404 |
function secondes($numdate) {
|
|
|
405 |
$date_array = recup_heure($numdate);
|
|
|
406 |
if ($date_array)
|
|
|
407 |
list($heures,$minutes,$secondes) = $date_array;
|
|
|
408 |
return $secondes;
|
|
|
409 |
}
|
|
|
410 |
|
|
|
411 |
function heures_minutes($numdate) {
|
|
|
412 |
return _T('date_fmt_heures_minutes', array('h'=> heures($numdate), 'm'=> minutes($numdate)));
|
|
|
413 |
}
|
|
|
414 |
|
|
|
415 |
function recup_date($numdate){
|
|
|
416 |
if (!$numdate) return '';
|
|
|
417 |
if (ereg('([0-9]{1,2})/([0-9]{1,2})/([0-9]{1,2})', $numdate, $regs)) {
|
|
|
418 |
$jour = $regs[1];
|
|
|
419 |
$mois = $regs[2];
|
|
|
420 |
$annee = $regs[3];
|
|
|
421 |
if ($annee < 90){
|
|
|
422 |
$annee = 2000 + $annee;
|
|
|
423 |
} else {
|
|
|
424 |
$annee = 1900 + $annee ;
|
|
|
425 |
}
|
|
|
426 |
}
|
|
|
427 |
elseif (ereg('([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})',$numdate, $regs)) {
|
|
|
428 |
$annee = $regs[1];
|
|
|
429 |
$mois = $regs[2];
|
|
|
430 |
$jour = $regs[3];
|
|
|
431 |
}
|
|
|
432 |
elseif (ereg('([0-9]{4})-([0-9]{2})', $numdate, $regs)){
|
|
|
433 |
$annee = $regs[1];
|
|
|
434 |
$mois = $regs[2];
|
|
|
435 |
}
|
|
|
436 |
if ($annee > 4000) $annee -= 9000;
|
|
|
437 |
if (substr($jour, 0, 1) == '0') $jour = substr($jour, 1);
|
|
|
438 |
|
|
|
439 |
return array($annee, $mois, $jour);
|
|
|
440 |
}
|
|
|
441 |
|
|
|
442 |
|
|
|
443 |
function date_relative($date) {
|
|
|
444 |
|
|
|
445 |
if (!$date) return;
|
|
|
446 |
$decal = date("U") - date("U", strtotime($date));
|
|
|
447 |
|
|
|
448 |
if ($decal < 0) {
|
|
|
449 |
$il_y_a = "date_dans";
|
|
|
450 |
$decal = -1 * $decal;
|
|
|
451 |
} else {
|
|
|
452 |
$il_y_a = "date_il_y_a";
|
|
|
453 |
}
|
|
|
454 |
|
|
|
455 |
if ($decal < 3600) {
|
|
|
456 |
$minutes = ceil($decal / 60);
|
|
|
457 |
$retour = _T($il_y_a, array("delai"=>"$minutes "._T("date_minutes")));
|
|
|
458 |
}
|
|
|
459 |
else if ($decal < (3600 * 24) ) {
|
|
|
460 |
$heures = ceil ($decal / 3600);
|
|
|
461 |
$retour = _T($il_y_a, array("delai"=>"$heures "._T("date_heures")));
|
|
|
462 |
}
|
|
|
463 |
else if ($decal < (3600 * 24 * 7)) {
|
|
|
464 |
$jours = ceil ($decal / (3600 * 24));
|
|
|
465 |
$retour = _T($il_y_a, array("delai"=>"$jours "._T("date_jours")));
|
|
|
466 |
}
|
|
|
467 |
else if ($decal < (3600 * 24 * 7 * 4)) {
|
|
|
468 |
$semaines = ceil ($decal / (3600 * 24 * 7));
|
|
|
469 |
$retour = _T($il_y_a, array("delai"=>"$semaines "._T("date_semaines")));
|
|
|
470 |
}
|
|
|
471 |
else if ($decal < (3600 * 24 * 30 * 6)) {
|
|
|
472 |
$mois = ceil ($decal / (3600 * 24 * 30));
|
|
|
473 |
$retour = _T($il_y_a, array("delai"=>"$mois "._T("date_mois")));
|
|
|
474 |
}
|
|
|
475 |
else {
|
|
|
476 |
$retour = affdate_court($date);
|
|
|
477 |
}
|
|
|
478 |
|
|
|
479 |
|
|
|
480 |
|
|
|
481 |
return $retour;
|
|
|
482 |
}
|
|
|
483 |
|
|
|
484 |
|
|
|
485 |
function affdate_base($numdate, $vue) {
|
|
|
486 |
global $spip_lang;
|
|
|
487 |
$date_array = recup_date($numdate);
|
|
|
488 |
if ($date_array)
|
|
|
489 |
list($annee, $mois, $jour) = $date_array;
|
|
|
490 |
else
|
|
|
491 |
return '';
|
|
|
492 |
|
|
|
493 |
// 1er, 21st, etc.
|
|
|
494 |
$journum = $jour;
|
|
|
495 |
|
|
|
496 |
if ($jour == 0)
|
|
|
497 |
$jour = '';
|
|
|
498 |
else if ($jourth = _T('date_jnum'.$jour))
|
|
|
499 |
$jour = $jourth;
|
|
|
500 |
|
|
|
501 |
$mois = intval($mois);
|
|
|
502 |
if ($mois > 0 AND $mois < 13) {
|
|
|
503 |
$nommois = _T('date_mois_'.$mois);
|
|
|
504 |
if ($jour)
|
|
|
505 |
$jourmois = _T('date_de_mois_'.$mois, array('j'=>$jour, 'nommois'=>$nommois));
|
|
|
506 |
}
|
|
|
507 |
|
|
|
508 |
if ($annee < 0) {
|
|
|
509 |
$annee = -$annee." "._T('date_avant_jc');
|
|
|
510 |
$avjc = true;
|
|
|
511 |
}
|
|
|
512 |
else $avjc = false;
|
|
|
513 |
|
|
|
514 |
switch ($vue) {
|
|
|
515 |
case 'saison':
|
|
|
516 |
if ($mois > 0){
|
|
|
517 |
$saison = 1;
|
|
|
518 |
if (($mois == 3 AND $jour >= 21) OR $mois > 3) $saison = 2;
|
|
|
519 |
if (($mois == 6 AND $jour >= 21) OR $mois > 6) $saison = 3;
|
|
|
520 |
if (($mois == 9 AND $jour >= 21) OR $mois > 9) $saison = 4;
|
|
|
521 |
if (($mois == 12 AND $jour >= 21) OR $mois > 12) $saison = 1;
|
|
|
522 |
}
|
|
|
523 |
return _T('date_saison_'.$saison);
|
|
|
524 |
|
|
|
525 |
case 'court':
|
|
|
526 |
if ($avjc) return $annee;
|
|
|
527 |
$a = date('Y');
|
|
|
528 |
if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
|
|
|
529 |
if ($annee != $a) return _T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>ucfirst($nommois), 'annee'=>$annee));
|
|
|
530 |
return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
|
|
|
531 |
|
|
|
532 |
case 'jourcourt':
|
|
|
533 |
if ($avjc) return $annee;
|
|
|
534 |
$a = date('Y');
|
|
|
535 |
if ($annee < ($a - 100) OR $annee > ($a + 100)) return $annee;
|
|
|
536 |
if ($annee != $a) return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
|
|
|
537 |
return _T('date_fmt_jour_mois', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
|
|
|
538 |
|
|
|
539 |
case 'entier':
|
|
|
540 |
if ($avjc) return $annee;
|
|
|
541 |
if ($jour)
|
|
|
542 |
return _T('date_fmt_jour_mois_annee', array ('jourmois'=>$jourmois, 'jour'=>$jour, 'mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee));
|
|
|
543 |
else
|
|
|
544 |
return trim(_T('date_fmt_mois_annee', array ('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
|
|
|
545 |
|
|
|
546 |
case 'nom_mois':
|
|
|
547 |
return $nommois;
|
|
|
548 |
|
|
|
549 |
case 'mois':
|
|
|
550 |
return sprintf("%02s",$mois);
|
|
|
551 |
|
|
|
552 |
case 'jour':
|
|
|
553 |
return $jour;
|
|
|
554 |
|
|
|
555 |
case 'journum':
|
|
|
556 |
return $journum;
|
|
|
557 |
|
|
|
558 |
case 'nom_jour':
|
|
|
559 |
if (!$mois OR !$jour) return '';
|
|
|
560 |
$nom = mktime(1,1,1,$mois,$jour,$annee);
|
|
|
561 |
$nom = 1+date('w',$nom);
|
|
|
562 |
return _T('date_jour_'.$nom);
|
|
|
563 |
|
|
|
564 |
case 'mois_annee':
|
|
|
565 |
if ($avjc) return $annee;
|
|
|
566 |
return trim(_T('date_fmt_mois_annee', array('mois'=>$mois, 'nommois'=>$nommois, 'annee'=>$annee)));
|
|
|
567 |
|
|
|
568 |
case 'annee':
|
|
|
569 |
return $annee;
|
|
|
570 |
|
|
|
571 |
// Cas d'une vue non definie : retomber sur le format
|
|
|
572 |
// de date propose par http://www.php.net/date
|
|
|
573 |
default:
|
|
|
574 |
return date($vue, strtotime($numdate));
|
|
|
575 |
}
|
|
|
576 |
}
|
|
|
577 |
|
|
|
578 |
function nom_jour($numdate) {
|
|
|
579 |
return affdate_base($numdate, 'nom_jour');
|
|
|
580 |
}
|
|
|
581 |
|
|
|
582 |
function jour($numdate) {
|
|
|
583 |
return affdate_base($numdate, 'jour');
|
|
|
584 |
}
|
|
|
585 |
|
|
|
586 |
function journum($numdate) {
|
|
|
587 |
return affdate_base($numdate, 'journum');
|
|
|
588 |
}
|
|
|
589 |
|
|
|
590 |
function mois($numdate) {
|
|
|
591 |
return affdate_base($numdate, 'mois');
|
|
|
592 |
}
|
|
|
593 |
|
|
|
594 |
function nom_mois($numdate) {
|
|
|
595 |
return affdate_base($numdate, 'nom_mois');
|
|
|
596 |
}
|
|
|
597 |
|
|
|
598 |
function annee($numdate) {
|
|
|
599 |
return affdate_base($numdate, 'annee');
|
|
|
600 |
}
|
|
|
601 |
|
|
|
602 |
function saison($numdate) {
|
|
|
603 |
return affdate_base($numdate, 'saison');
|
|
|
604 |
}
|
|
|
605 |
|
|
|
606 |
function affdate($numdate, $format='entier') {
|
|
|
607 |
return affdate_base($numdate, $format);
|
|
|
608 |
}
|
|
|
609 |
|
|
|
610 |
function affdate_court($numdate) {
|
|
|
611 |
return affdate_base($numdate, 'court');
|
|
|
612 |
}
|
|
|
613 |
|
|
|
614 |
function affdate_jourcourt($numdate) {
|
|
|
615 |
return affdate_base($numdate, 'jourcourt');
|
|
|
616 |
}
|
|
|
617 |
|
|
|
618 |
function affdate_mois_annee($numdate) {
|
|
|
619 |
return affdate_base($numdate, 'mois_annee');
|
|
|
620 |
}
|
|
|
621 |
|
|
|
622 |
function affdate_heure($numdate) {
|
|
|
623 |
return _T('date_fmt_jour_heure', array('jour' => affdate($numdate), 'heure' => heures_minutes($numdate)));
|
|
|
624 |
}
|
|
|
625 |
|
|
|
626 |
|
|
|
627 |
//
|
|
|
628 |
// Alignements en HTML
|
|
|
629 |
//
|
|
|
630 |
|
|
|
631 |
function aligner($letexte,$justif) {
|
|
|
632 |
$letexte = eregi_replace("<p([^>]*)", "<p\\1 align='$justif'", trim($letexte));
|
|
|
633 |
if ($letexte AND !ereg("^[[:space:]]*<p", $letexte)) {
|
|
|
634 |
$letexte = "<p class='spip' align='$justif'>" . $letexte . "</p>";
|
|
|
635 |
}
|
|
|
636 |
return $letexte;
|
|
|
637 |
}
|
|
|
638 |
|
|
|
639 |
function justifier($letexte) {
|
|
|
640 |
return aligner($letexte,'justify');
|
|
|
641 |
}
|
|
|
642 |
|
|
|
643 |
function aligner_droite($letexte) {
|
|
|
644 |
return aligner($letexte,'right');
|
|
|
645 |
}
|
|
|
646 |
|
|
|
647 |
function aligner_gauche($letexte) {
|
|
|
648 |
return aligner($letexte,'left');
|
|
|
649 |
}
|
|
|
650 |
|
|
|
651 |
function centrer($letexte) {
|
|
|
652 |
return aligner($letexte,'center');
|
|
|
653 |
}
|
|
|
654 |
|
|
|
655 |
function style_align($bof) {
|
|
|
656 |
global $spip_lang_left;
|
|
|
657 |
return "text-align: $spip_lang_left";
|
|
|
658 |
}
|
|
|
659 |
|
|
|
660 |
//
|
|
|
661 |
// Export iCal
|
|
|
662 |
//
|
|
|
663 |
|
|
|
664 |
function filtrer_ical($texte) {
|
|
|
665 |
include_ecrire('inc_charsets.php3');
|
|
|
666 |
$texte = html2unicode($texte);
|
|
|
667 |
$texte = unicode2charset(charset2unicode($texte, lire_meta('charset'), 1), 'utf-8');
|
|
|
668 |
$texte = ereg_replace("\n", " ", $texte);
|
|
|
669 |
$texte = ereg_replace(",", "\,", $texte);
|
|
|
670 |
|
|
|
671 |
return $texte;
|
|
|
672 |
}
|
|
|
673 |
|
|
|
674 |
function date_ical($date, $addminutes = 0) {
|
|
|
675 |
list($heures, $minutes, $secondes) = recup_heure($date);
|
|
|
676 |
list($annee, $mois, $jour) = recup_date($date);
|
|
|
677 |
return date("Ymd\THis",
|
|
|
678 |
mktime($heures, $minutes+$addminutes,$secondes,$mois,$jour,$annee));
|
|
|
679 |
}
|
|
|
680 |
|
|
|
681 |
function date_iso($date_heure) {
|
|
|
682 |
list($annee, $mois, $jour) = recup_date($date_heure);
|
|
|
683 |
list($heures, $minutes, $secondes) = recup_heure($date_heure);
|
|
|
684 |
$time = mktime($heures, $minutes, $secondes, $mois, $jour, $annee);
|
|
|
685 |
return gmdate("Y-m-d\TH:i:s\Z", $time);
|
|
|
686 |
}
|
|
|
687 |
|
|
|
688 |
|
|
|
689 |
function date_anneemoisjour($d) {
|
|
|
690 |
if (!$d) $d = date("Y-m-d");
|
|
|
691 |
return substr($d, 0, 4) . substr($d, 5, 2) .substr($d, 8, 2);
|
|
|
692 |
}
|
|
|
693 |
|
|
|
694 |
function date_anneemois($d) {
|
|
|
695 |
if (!$d) $d = date("Y-m-d");
|
|
|
696 |
return substr($d, 0, 4) . substr($d, 5, 2);
|
|
|
697 |
}
|
|
|
698 |
|
|
|
699 |
function date_debut_semaine($annee, $mois, $jour) {
|
|
|
700 |
$w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
|
|
|
701 |
if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
|
|
|
702 |
$debut = $jour-$w_day;
|
|
|
703 |
return date("Ymd", mktime(0,0,0,$mois,$debut,$annee));
|
|
|
704 |
}
|
|
|
705 |
|
|
|
706 |
function date_fin_semaine($annee, $mois, $jour) {
|
|
|
707 |
$w_day = date("w", mktime(0,0,0,$mois, $jour, $annee));
|
|
|
708 |
if ($w_day == 0) $w_day = 7; // Gaffe: le dimanche est zero
|
|
|
709 |
$debut = $jour-$w_day+1;
|
|
|
710 |
return date("Ymd", mktime(0,0,0,$mois,$debut+6,$annee));
|
|
|
711 |
}
|
|
|
712 |
|
|
|
713 |
function agenda_connu($type)
|
|
|
714 |
{
|
|
|
715 |
return in_array($type, array('jour','mois','semaine','periode')) ? ' ' : '';
|
|
|
716 |
}
|
|
|
717 |
|
|
|
718 |
|
|
|
719 |
// Cette fonction memorise dans un tableau indexe par son 5e arg
|
|
|
720 |
// un evenement decrit par les 4 autres (date, descriptif, titre, URL).
|
|
|
721 |
// Appellee avec une date nulle, elle renvoie le tableau construit.
|
|
|
722 |
// l'indexation par le 5e arg autorise plusieurs calendriers dans une page
|
|
|
723 |
|
|
|
724 |
function agenda_memo($date=0 , $descriptif='', $titre='', $url='', $cal='')
|
|
|
725 |
{
|
|
|
726 |
static $agenda = array();
|
|
|
727 |
if (!$date) return $agenda;
|
|
|
728 |
$idate = date_ical($date);
|
|
|
729 |
$cal = trim($cal); // func_get_args (filtre alterner) rajoute \n !!!!
|
|
|
730 |
$agenda[$cal][(date_anneemoisjour($date))][] = array(
|
|
|
731 |
'CATEGORIES' => $cal,
|
|
|
732 |
'DTSTART' => $idate,
|
|
|
733 |
'DTEND' => $idate,
|
|
|
734 |
'DESCRIPTION' => texte_script($descriptif),
|
|
|
735 |
'SUMMARY' => texte_script($titre),
|
|
|
736 |
'URL' => $url);
|
|
|
737 |
// toujours retourner vide pour qu'il ne se passe rien
|
|
|
738 |
return "";
|
|
|
739 |
}
|
|
|
740 |
|
|
|
741 |
// Cette fonction recoit un nombre d'evenements, un type de calendriers
|
|
|
742 |
// et une suite de noms N.
|
|
|
743 |
// Elle demande a la fonction la precedente son tableau
|
|
|
744 |
// et affiche selon le type les elements indexes par N dans ce tableau.
|
|
|
745 |
// Si le suite de noms est vide, tout le tableau est pris
|
|
|
746 |
// Ces noms N sont aussi des classes CSS utilisees par http_calendrier_init
|
|
|
747 |
|
|
|
748 |
function agenda_affiche($i)
|
|
|
749 |
{
|
|
|
750 |
$args = func_get_args();
|
|
|
751 |
$nb = array_shift($args); // nombre d'evenements (on pourrait l'afficher)
|
|
|
752 |
$sinon = array_shift($args);
|
|
|
753 |
if (!$nb) return $sinon;
|
|
|
754 |
$type = array_shift($args);
|
|
|
755 |
$agenda = agenda_memo(0);
|
|
|
756 |
$evt = array();
|
|
|
757 |
foreach (($args ? $args : array_keys($agenda)) as $k) {
|
|
|
758 |
if (is_array($agenda[$k]))
|
|
|
759 |
foreach($agenda[$k] as $d => $v) {
|
|
|
760 |
$evt[$d] = $evt[$d] ? (array_merge($evt[$d], $v)) : $v;
|
|
|
761 |
}
|
|
|
762 |
}
|
|
|
763 |
if ($type != 'periode')
|
|
|
764 |
$evt = array('', $evt);
|
|
|
765 |
else
|
|
|
766 |
{
|
|
|
767 |
$d = array_keys($evt);
|
|
|
768 |
$mindate = min($d);
|
|
|
769 |
$min = substr($mindate,6,2);
|
|
|
770 |
$max = $min + ((strtotime(max($d)) - strtotime($mindate)) / (3600 * 24));
|
|
|
771 |
if ($max < 31) $max = 0;
|
|
|
772 |
$evt = array('', $evt, $min, $max);
|
|
|
773 |
$type = 'mois';
|
|
|
774 |
}
|
|
|
775 |
include('ecrire/inc_calendrier.php');
|
|
|
776 |
return http_calendrier_init('', $type, '', '', '', $evt);
|
|
|
777 |
}
|
|
|
778 |
|
|
|
779 |
//
|
|
|
780 |
// Fonctions graphiques
|
|
|
781 |
//
|
|
|
782 |
|
|
|
783 |
// Accepte en entree un tag <img ...>
|
|
|
784 |
function reduire_une_image($img, $taille, $taille_y) {
|
|
|
785 |
include_ecrire('inc_logos.php3');
|
|
|
786 |
|
|
|
787 |
// Cas du mouseover genere par les logos de survol de #LOGO_ARTICLE
|
|
|
788 |
if (eregi("onmouseover=\"this\.src=\'([^']+)\'\"", $img, $match)) {
|
|
|
789 |
$mouseover = extraire_attribut(
|
|
|
790 |
reduire_image_logo($match[1], $taille, $taille_y),
|
|
|
791 |
'src');
|
|
|
792 |
}
|
|
|
793 |
|
|
|
794 |
$image = reduire_image_logo($img, $taille, $taille_y);
|
|
|
795 |
|
|
|
796 |
if ($mouseover) {
|
|
|
797 |
$mouseout = extraire_attribut($image, 'src');
|
|
|
798 |
$js_mouseover = "onmouseover=\"this.src='$mouseover'\""
|
|
|
799 |
." onmouseout=\"this.src='$mouseout'\" />";
|
|
|
800 |
$image = preg_replace(",( /)?".">,", $js_mouseover, $image);
|
|
|
801 |
}
|
|
|
802 |
|
|
|
803 |
return $image;
|
|
|
804 |
}
|
|
|
805 |
|
|
|
806 |
// accepte en entree un texte complet, un img-log (produit par #LOGO_XX),
|
|
|
807 |
// un tag <img ...> complet, ou encore un nom de fichier *local* (passer
|
|
|
808 |
// le filtre |copie_locale si on veut l'appliquer a un document)
|
|
|
809 |
function reduire_image($texte, $taille = -1, $taille_y = -1) {
|
|
|
810 |
if (!$texte) return;
|
|
|
811 |
|
|
|
812 |
// Cas du nom de fichier local
|
|
|
813 |
if (preg_match(',^'._DIR_IMG.',', $texte)) {
|
|
|
814 |
if (!@file_exists($texte)) {
|
|
|
815 |
spip_log("Image absente : $texte");
|
|
|
816 |
return '';
|
|
|
817 |
} else {
|
|
|
818 |
return reduire_une_image("<img src='$texte' />", $taille, $taille_y);
|
|
|
819 |
}
|
|
|
820 |
}
|
|
|
821 |
|
|
|
822 |
// Cas general : trier toutes les images
|
|
|
823 |
if (preg_match_all(',<img\s.*>,Uims', $texte, $tags, PREG_SET_ORDER)) {
|
|
|
824 |
foreach ($tags as $tag) {
|
|
|
825 |
if ($reduit = reduire_une_image($tag[0], $taille, $taille_y))
|
|
|
826 |
$texte = str_replace($tag[0], $reduit, $texte);
|
|
|
827 |
}
|
|
|
828 |
}
|
|
|
829 |
|
|
|
830 |
return $texte;
|
|
|
831 |
}
|
|
|
832 |
|
|
|
833 |
function largeur($img) {
|
|
|
834 |
if (!$img) return;
|
|
|
835 |
include_ecrire('inc_logos.php3');
|
|
|
836 |
list ($h,$l) = taille_image($img);
|
|
|
837 |
return $l;
|
|
|
838 |
}
|
|
|
839 |
function hauteur($img) {
|
|
|
840 |
if (!$img) return;
|
|
|
841 |
include_ecrire('inc_logos.php3');
|
|
|
842 |
list ($h,$l) = taille_image($img);
|
|
|
843 |
return $h;
|
|
|
844 |
}
|
|
|
845 |
|
|
|
846 |
//
|
|
|
847 |
// Cree au besoin la copie locale d'un fichier distant
|
|
|
848 |
// mode = 'test' - ne faire que tester
|
|
|
849 |
// mode = 'auto' - charger au besoin
|
|
|
850 |
// mode = 'force' - charger toujours (mettre a jour)
|
|
|
851 |
//
|
|
|
852 |
function copie_locale($source, $mode='auto') {
|
|
|
853 |
include_ecrire('inc_getdocument.php3');
|
|
|
854 |
|
|
|
855 |
// Si copie_locale() est appele depuis l'espace prive
|
|
|
856 |
if (!_DIR_RESTREINT
|
|
|
857 |
AND strpos('../'.$source, _DIR_IMG) === 0)
|
|
|
858 |
return '../'.$source;
|
|
|
859 |
|
|
|
860 |
$local = fichier_copie_locale($source);
|
|
|
861 |
|
|
|
862 |
if ($source != $local) {
|
|
|
863 |
if (($mode=='auto' AND !@file_exists($local))
|
|
|
864 |
OR $mode=='force') {
|
|
|
865 |
include_ecrire('inc_sites.php3');
|
|
|
866 |
$contenu = recuperer_page($source);
|
|
|
867 |
if ($contenu) {
|
|
|
868 |
ecrire_fichier($local, $contenu);
|
|
|
869 |
|
|
|
870 |
// signaler au moteur de recherche qu'il peut reindexer ce doc
|
|
|
871 |
$a = spip_query("SELECT id_document FROM spip_documents
|
|
|
872 |
WHERE fichier='".addslashes($source)."'");
|
|
|
873 |
list($id_document) = spip_fetch_array($a);
|
|
|
874 |
if ($id_document) {
|
|
|
875 |
include_ecrire('inc_index.php3');
|
|
|
876 |
marquer_indexer('document', $id_document);
|
|
|
877 |
}
|
|
|
878 |
}
|
|
|
879 |
else
|
|
|
880 |
return false;
|
|
|
881 |
}
|
|
|
882 |
}
|
|
|
883 |
|
|
|
884 |
return $local;
|
|
|
885 |
}
|
|
|
886 |
|
|
|
887 |
|
|
|
888 |
//
|
|
|
889 |
// Recuperation de donnees dans le champ extra
|
|
|
890 |
// Ce filtre n'a de sens qu'avec la balise #EXTRA
|
|
|
891 |
//
|
|
|
892 |
function extra($letexte, $champ) {
|
|
|
893 |
$champs = unserialize($letexte);
|
|
|
894 |
return $champs[$champ];
|
|
|
895 |
}
|
|
|
896 |
|
|
|
897 |
// postautobr : transforme les sauts de ligne en _
|
|
|
898 |
function post_autobr($texte, $delim="\n_ ") {
|
|
|
899 |
$texte = str_replace("\r\n", "\r", $texte);
|
|
|
900 |
$texte = str_replace("\r", "\n", $texte);
|
|
|
901 |
list($texte, $les_echap) = echappe_html($texte, "POSTAUTOBR", true);
|
|
|
902 |
|
|
|
903 |
$debut = '';
|
|
|
904 |
$suite = $texte;
|
|
|
905 |
while ($t = strpos('-'.$suite, "\n", 1)) {
|
|
|
906 |
$debut .= substr($suite, 0, $t-1);
|
|
|
907 |
$suite = substr($suite, $t);
|
|
|
908 |
$car = substr($suite, 0, 1);
|
|
|
909 |
if (($car<>'-') AND ($car<>'_') AND ($car<>"\n") AND ($car<>"|"))
|
|
|
910 |
$debut .= $delim;
|
|
|
911 |
else
|
|
|
912 |
$debut .= "\n";
|
|
|
913 |
if (ereg("^\n+", $suite, $regs)) {
|
|
|
914 |
$debut.=$regs[0];
|
|
|
915 |
$suite = substr($suite, strlen($regs[0]));
|
|
|
916 |
}
|
|
|
917 |
}
|
|
|
918 |
$texte = $debut.$suite;
|
|
|
919 |
|
|
|
920 |
$texte = echappe_retour($texte, $les_echap, "POSTAUTOBR");
|
|
|
921 |
return $texte;
|
|
|
922 |
}
|
|
|
923 |
|
|
|
924 |
|
|
|
925 |
//
|
|
|
926 |
// Gestion des blocs multilingues
|
|
|
927 |
//
|
|
|
928 |
|
|
|
929 |
//
|
|
|
930 |
// Selection dans un tableau dont les index sont des noms de langues
|
|
|
931 |
// de la valeur associee a la langue en cours
|
|
|
932 |
//
|
|
|
933 |
|
|
|
934 |
function multi_trad ($trads) {
|
|
|
935 |
global $spip_lang;
|
|
|
936 |
|
|
|
937 |
if (isset($trads[$spip_lang])) {
|
|
|
938 |
return $trads[$spip_lang];
|
|
|
939 |
|
|
|
940 |
} // cas des langues xx_yy
|
|
|
941 |
else if (ereg('^([a-z]+)_', $spip_lang, $regs) AND isset($trads[$regs[1]])) {
|
|
|
942 |
return $trads[$regs[1]];
|
|
|
943 |
}
|
|
|
944 |
// sinon, renvoyer la premiere du tableau
|
|
|
945 |
// remarque : on pourrait aussi appeler un service de traduction externe
|
|
|
946 |
// ou permettre de choisir une langue "plus proche",
|
|
|
947 |
// par exemple le francais pour l'espagnol, l'anglais pour l'allemand, etc.
|
|
|
948 |
else return array_shift($trads);
|
|
|
949 |
}
|
|
|
950 |
|
|
|
951 |
// analyse un bloc multi
|
|
|
952 |
function extraire_trad ($bloc) {
|
|
|
953 |
$lang = '';
|
|
|
954 |
|
|
|
955 |
while (preg_match("/^(.*?)[{\[]([a-z_]+)[}\]]/si", $bloc, $regs)) {
|
|
|
956 |
$texte = trim($regs[1]);
|
|
|
957 |
if ($texte OR $lang)
|
|
|
958 |
$trads[$lang] = $texte;
|
|
|
959 |
$bloc = substr($bloc, strlen($regs[0]));
|
|
|
960 |
$lang = $regs[2];
|
|
|
961 |
}
|
|
|
962 |
$trads[$lang] = $bloc;
|
|
|
963 |
|
|
|
964 |
// faire la traduction avec ces donnees
|
|
|
965 |
return multi_trad($trads);
|
|
|
966 |
}
|
|
|
967 |
|
|
|
968 |
// repere les blocs multi dans un texte et extrait le bon
|
|
|
969 |
function extraire_multi ($letexte) {
|
|
|
970 |
if (strpos($letexte, '<multi>') === false) return $letexte; // perf
|
|
|
971 |
if (preg_match_all("@<multi>(.*?)</multi>@s", $letexte, $regs, PREG_SET_ORDER))
|
|
|
972 |
foreach ($regs as $reg)
|
|
|
973 |
$letexte = str_replace($reg[0], extraire_trad($reg[1]), $letexte);
|
|
|
974 |
return $letexte;
|
|
|
975 |
}
|
|
|
976 |
|
|
|
977 |
|
|
|
978 |
// Raccourci ancre [#ancre<-]
|
|
|
979 |
function avant_propre_ancres($texte) {
|
|
|
980 |
$regexp = "|\[#?([^][]*)<-\]|";
|
|
|
981 |
if (preg_match_all($regexp, $texte, $matches, PREG_SET_ORDER))
|
|
|
982 |
foreach ($matches as $regs)
|
|
|
983 |
$texte = str_replace($regs[0],
|
|
|
984 |
'<a name="'.entites_html($regs[1]).'"></a>', $texte);
|
|
|
985 |
return $texte;
|
|
|
986 |
}
|
|
|
987 |
|
|
|
988 |
// Raccourci typographique <sc></sc>
|
|
|
989 |
function avant_typo_smallcaps($texte) {
|
|
|
990 |
$texte = str_replace("<sc>", "<span style=\"font-variant: small-caps\">", $texte);
|
|
|
991 |
$texte = str_replace("</sc>", "</span>", $texte);
|
|
|
992 |
|
|
|
993 |
return $texte;
|
|
|
994 |
}
|
|
|
995 |
|
|
|
996 |
//
|
|
|
997 |
// Ce filtre retourne la donnee si c'est la premiere fois qu'il la voit ;
|
|
|
998 |
// possibilite de gerer differentes "familles" de donnees |unique{famille}
|
|
|
999 |
# ameliorations possibles :
|
|
|
1000 |
# 1) si la donnee est grosse, mettre son md5 comme cle
|
|
|
1001 |
# 2) purger $mem quand on change de squelette (sinon bug inclusions)
|
|
|
1002 |
//
|
|
|
1003 |
// http://www.spip.net/@unique
|
|
|
1004 |
function unique($donnee, $famille='') {
|
|
|
1005 |
static $mem;
|
|
|
1006 |
if (!($mem[$famille][$donnee]++))
|
|
|
1007 |
return $donnee;
|
|
|
1008 |
}
|
|
|
1009 |
|
|
|
1010 |
//
|
|
|
1011 |
// Filtre |alterner
|
|
|
1012 |
//
|
|
|
1013 |
// Exemple [(#COMPTEUR_BOUCLE|alterner{'bleu','vert','rouge'})]
|
|
|
1014 |
//
|
|
|
1015 |
function alterner($i) {
|
|
|
1016 |
// recuperer les arguments (attention fonctions un peu space)
|
|
|
1017 |
$num = func_num_args();
|
|
|
1018 |
$args = func_get_args();
|
|
|
1019 |
|
|
|
1020 |
// renvoyer le i-ieme argument, modulo le nombre d'arguments
|
|
|
1021 |
return $args[(intval($i)-1)%($num-1)+1];
|
|
|
1022 |
}
|
|
|
1023 |
|
|
|
1024 |
// recuperer un attribut html d'une balise
|
|
|
1025 |
// ($complet demande de retourner $r)
|
|
|
1026 |
function extraire_attribut($balise, $attribut, $complet = false) {
|
|
|
1027 |
if (preg_match(",(.*<[^>]*)([[:space:]]+$attribut=[[:space:]]*(['\"])?(.*?)\\3)([^>]*>.*),ims", $balise, $r)) {
|
|
|
1028 |
$att = $r[4];
|
|
|
1029 |
}
|
|
|
1030 |
else
|
|
|
1031 |
$att = NULL;
|
|
|
1032 |
|
|
|
1033 |
if ($complet)
|
|
|
1034 |
return array($att, $r);
|
|
|
1035 |
else
|
|
|
1036 |
return $att;
|
|
|
1037 |
}
|
|
|
1038 |
|
|
|
1039 |
// modifier (ou inserer) un attribut html dans une balise
|
|
|
1040 |
function inserer_attribut($balise, $attribut, $val, $texte_backend=true) {
|
|
|
1041 |
// preparer l'attribut
|
|
|
1042 |
if ($texte_backend) $val = texte_backend($val); # supprimer les etc
|
|
|
1043 |
|
|
|
1044 |
// echapper les ' pour eviter tout bug
|
|
|
1045 |
$val = str_replace("'", "'", $val);
|
|
|
1046 |
$insert = " $attribut='$val' ";
|
|
|
1047 |
|
|
|
1048 |
list($old,$r) = extraire_attribut($balise, $attribut, true);
|
|
|
1049 |
|
|
|
1050 |
if ($old !== NULL) {
|
|
|
1051 |
// Remplacer l'ancien attribut du meme nom
|
|
|
1052 |
$balise = $r[1].$insert.$r[5];
|
|
|
1053 |
}
|
|
|
1054 |
else {
|
|
|
1055 |
// preferer une balise " />" (comme <img />)
|
|
|
1056 |
if (preg_match(',[[:space:]]/>,', $balise))
|
|
|
1057 |
$balise = preg_replace(",[[:space:]]/>,", $insert."/>", $balise, 1);
|
|
|
1058 |
// sinon une balise <a ...> ... </a>
|
|
|
1059 |
else
|
|
|
1060 |
$balise = preg_replace(",>,", $insert.">", $balise, 1);
|
|
|
1061 |
}
|
|
|
1062 |
|
|
|
1063 |
return $balise;
|
|
|
1064 |
}
|
|
|
1065 |
|
|
|
1066 |
|
|
|
1067 |
// fabrique un bouton de type $t de Name $n, de Value $v et autres attributs $a
|
|
|
1068 |
# a placer ailleurs que dans inc_filtres
|
|
|
1069 |
function boutonne($t, $n, $v, $a='') {
|
|
|
1070 |
return "\n<input type='$t'" .
|
|
|
1071 |
(!$n ? '' : " name='$n'") .
|
|
|
1072 |
" value=\"$v\" $a />";
|
|
|
1073 |
}
|
|
|
1074 |
|
|
|
1075 |
function http_script($script, $src='', $noscript='') {
|
|
|
1076 |
return '<script type="text/javascript"'
|
|
|
1077 |
. ($src ? " src=\"$src\"" : '')
|
|
|
1078 |
. ">"
|
|
|
1079 |
. ($script ? "<!--\n$script\n//-->" : '')
|
|
|
1080 |
. "</script>\n"
|
|
|
1081 |
. (!$noscript ? '' : "<noscript>\n\t$noscript\n</noscript>\n");
|
|
|
1082 |
}
|
|
|
1083 |
|
|
|
1084 |
|
|
|
1085 |
// Un filtre ad hoc, qui retourne ce qu'il faut pour les tests de config
|
|
|
1086 |
// dans les squelettes : [(#URL_SITE_SPIP|tester_config{quoi})]
|
|
|
1087 |
function tester_config($ignore, $quoi) {
|
|
|
1088 |
switch ($quoi) {
|
|
|
1089 |
case 'mode_inscription':
|
|
|
1090 |
if (lire_meta("accepter_inscriptions") == "oui")
|
|
|
1091 |
return 'redac';
|
|
|
1092 |
else if (lire_meta("accepter_visiteurs") == "oui"
|
|
|
1093 |
OR lire_meta('forums_publics') == 'abo')
|
|
|
1094 |
return 'forum';
|
|
|
1095 |
else
|
|
|
1096 |
return '';
|
|
|
1097 |
|
|
|
1098 |
default:
|
|
|
1099 |
return '';
|
|
|
1100 |
}
|
|
|
1101 |
}
|
|
|
1102 |
|
|
|
1103 |
//
|
|
|
1104 |
// Un filtre qui, etant donne un #PARAMETRES_FORUM, retourne un URL de suivi rss
|
|
|
1105 |
// dudit forum
|
|
|
1106 |
// Attention applique a un #PARAMETRES_FORUM complexe (id_article=x&id_forum=y)
|
|
|
1107 |
// ca retourne un url de suivi du thread y (que le thread existe ou non)
|
|
|
1108 |
function url_rss_forum($param) {
|
|
|
1109 |
if (preg_match(',.*(id_.*?)=([0-9]+),', $param, $regs)) {
|
|
|
1110 |
include_ecrire('inc_acces.php3');
|
|
|
1111 |
$regs[1] = str_replace('id_forum', 'id_thread', $regs[1]);
|
|
|
1112 |
$arg = $regs[1].'-'.$regs[2];
|
|
|
1113 |
$cle = afficher_low_sec(0, "rss forum $arg");
|
|
|
1114 |
return "spip_rss.php?op=forum&args=$arg&cle=$cle";
|
|
|
1115 |
}
|
|
|
1116 |
}
|
|
|
1117 |
|
|
|
1118 |
|
|
|
1119 |
// filtre pour visualiser dans l'espace public le calendrier de l'espace de redac
|
|
|
1120 |
// Tres ad hoc, faudra ameliorer.
|
|
|
1121 |
|
|
|
1122 |
function calendrier($date='', $type='mois', $echelle='', $partie_cal='', $script='')
|
|
|
1123 |
{
|
|
|
1124 |
include_ecrire("inc_calendrier.php");
|
|
|
1125 |
include_ecrire("inc_layer.php3");
|
|
|
1126 |
if (!isset($GLOBALS['spip_ecran'])) $GLOBALS['spip_ecran'] = 'large';
|
|
|
1127 |
if (isset($GLOBALS['mois'])) $date ='';
|
|
|
1128 |
return
|
|
|
1129 |
$GLOBALS['browser_layer'] .
|
|
|
1130 |
http_script('',_DIR_RESTREINT . 'presentation.js') .
|
|
|
1131 |
http_calendrier_init($date, $type, $echelle, $partie_cal, $script);
|
|
|
1132 |
}
|
|
|
1133 |
|
|
|
1134 |
|
|
|
1135 |
//
|
|
|
1136 |
// Filtres d'URLs
|
|
|
1137 |
//
|
|
|
1138 |
|
|
|
1139 |
// Nettoyer une URL contenant des ../
|
|
|
1140 |
//
|
|
|
1141 |
// echo resolve_url('/.././/truc/chose/machin/./.././.././hopla/..');
|
|
|
1142 |
// inspire (de loin) par PEAR:NetURL:resolvePath
|
|
|
1143 |
//
|
|
|
1144 |
function resolve_path($url) {
|
|
|
1145 |
while (preg_match(',/\.?/,', $url, $regs) # supprime // et /./
|
|
|
1146 |
OR preg_match(',/[^/]*/\.\./,', $url, $regs) # supprime /toto/../
|
|
|
1147 |
OR preg_match(',^/\.\./,', $url, $regs)) # supprime les /../ du haut
|
|
|
1148 |
$url = str_replace($regs[0], '/', $url);
|
|
|
1149 |
|
|
|
1150 |
return '/'.preg_replace(',^/,', '', $url);
|
|
|
1151 |
}
|
|
|
1152 |
|
|
|
1153 |
//
|
|
|
1154 |
// Suivre un lien depuis une adresse donnee -> nouvelle adresse
|
|
|
1155 |
//
|
|
|
1156 |
// echo suivre_lien('http://rezo.net/sous/dir/../ect/ory/fi.html..s#toto',
|
|
|
1157 |
// 'a/../../titi.coco.html/tata#titi');
|
|
|
1158 |
function suivre_lien($url, $lien) {
|
|
|
1159 |
# lien absolu ? ok
|
|
|
1160 |
if (preg_match(',^([a-z0-9]+://|mailto:),i', $lien))
|
|
|
1161 |
return $lien;
|
|
|
1162 |
|
|
|
1163 |
# lien relatif, il faut verifier l'url de base
|
|
|
1164 |
if (preg_match(',^(.*?://[^/]+)(/.*?/?)?[^/]*$,', $url, $regs)) {
|
|
|
1165 |
$debut = $regs[1];
|
|
|
1166 |
$dir = $regs[2];
|
|
|
1167 |
}
|
|
|
1168 |
if (substr($lien,0,1) == '/')
|
|
|
1169 |
return $debut . resolve_path($lien);
|
|
|
1170 |
else
|
|
|
1171 |
return $debut . resolve_path($dir.$lien);
|
|
|
1172 |
}
|
|
|
1173 |
|
|
|
1174 |
// un filtre pour transformer les URLs relatives en URLs absolues ;
|
|
|
1175 |
// ne s'applique qu'aux #URL_XXXX
|
|
|
1176 |
function url_absolue($url, $base='') {
|
|
|
1177 |
if (strlen($url = trim($url)) == 0)
|
|
|
1178 |
return '';
|
|
|
1179 |
if (!$base) $base=lire_meta('adresse_site').'/';
|
|
|
1180 |
return suivre_lien($base, $url);
|
|
|
1181 |
}
|
|
|
1182 |
|
|
|
1183 |
// un filtre pour transformer les URLs relatives en URLs absolues ;
|
|
|
1184 |
// ne s'applique qu'aux textes contenant des liens
|
|
|
1185 |
function liens_absolus($texte, $base='') {
|
|
|
1186 |
if (preg_match_all(',(<a[[:space:]]+[^<>]*href=["\']?)([^"\' ><[:space:]]+)([^<>]*>),ims',
|
|
|
1187 |
$texte, $liens, PREG_SET_ORDER)) {
|
|
|
1188 |
foreach ($liens as $lien) {
|
|
|
1189 |
$abs = url_absolue($lien[2], $base);
|
|
|
1190 |
if ($abs <> $lien[2])
|
|
|
1191 |
$texte = str_replace($lien[0], $lien[1].$abs.$lien[3], $texte);
|
|
|
1192 |
}
|
|
|
1193 |
}
|
|
|
1194 |
if (preg_match_all(',(<img[[:space:]]+[^<>]*src=["\']?)([^"\' ><[:space:]]+)([^<>]*>),ims',
|
|
|
1195 |
$texte, $liens, PREG_SET_ORDER)) {
|
|
|
1196 |
foreach ($liens as $lien) {
|
|
|
1197 |
$abs = url_absolue($lien[2], $base);
|
|
|
1198 |
if ($abs <> $lien[2])
|
|
|
1199 |
$texte = str_replace($lien[0], $lien[1].$abs.$lien[3], $texte);
|
|
|
1200 |
}
|
|
|
1201 |
}
|
|
|
1202 |
return $texte;
|
|
|
1203 |
}
|
|
|
1204 |
|
|
|
1205 |
//
|
|
|
1206 |
// Ce filtre public va traiter les URL ou les <a href>
|
|
|
1207 |
//
|
|
|
1208 |
function abs_url($texte, $base='') {
|
|
|
1209 |
if ($GLOBALS['mode_abs_url'] == 'url')
|
|
|
1210 |
return url_absolue($texte, $base);
|
|
|
1211 |
else
|
|
|
1212 |
return liens_absolus($texte, $base);
|
|
|
1213 |
}
|
|
|
1214 |
|
|
|
1215 |
|
|
|
1216 |
// Image typographique
|
|
|
1217 |
|
|
|
1218 |
function printWordWrapped($image, $top, $left, $maxWidth, $font, $color, $text, $textSize, $align="left") {
|
|
|
1219 |
$words = explode(' ', strip_tags($text)); // split the text into an array of single words
|
|
|
1220 |
$line = '';
|
|
|
1221 |
while (count($words) > 0) {
|
|
|
1222 |
$dimensions = imageftbbox($textSize, 0, $font, $line.' '.$words[0]);
|
|
|
1223 |
$lineWidth = $dimensions[2] - $dimensions[0]; // get the length of this line, if the word is to be included
|
|
|
1224 |
if ($lineWidth > $maxWidth) { // if this makes the text wider that anticipated
|
|
|
1225 |
$lines[] = $line; // add the line to the others
|
|
|
1226 |
$line = ''; // empty it (the word will be added outside the loop)
|
|
|
1227 |
}
|
|
|
1228 |
$line .= ' '.$words[0]; // add the word to the current sentence
|
|
|
1229 |
$words = array_slice($words, 1); // remove the word from the array
|
|
|
1230 |
}
|
|
|
1231 |
if ($line != '') { $lines[] = $line; } // add the last line to the others, if it isn't empty
|
|
|
1232 |
$lineHeight = floor($textSize * 1.3);
|
|
|
1233 |
$height = count($lines) * $lineHeight; // the height of all the lines total
|
|
|
1234 |
// do the actual printing
|
|
|
1235 |
$i = 0;
|
|
|
1236 |
foreach ($lines as $line) {
|
|
|
1237 |
$line = ereg_replace("~", " ", $line);
|
|
|
1238 |
$dimensions = imageftbbox($textSize, 0, $font, $line);
|
|
|
1239 |
$largeur_ligne = $dimensions[2] - $dimensions[0];
|
|
|
1240 |
if ($largeur_ligne > $largeur_max) $largeur_max = $largeur_ligne;
|
|
|
1241 |
if ($align == "right") $left_pos = $maxWidth - $largeur_ligne;
|
|
|
1242 |
else if ($align == "center") $left_pos = floor(($maxWidth - $largeur_ligne)/2);
|
|
|
1243 |
else $left_pos = 0;
|
|
|
1244 |
imagefttext($image, $textSize, 0, $left + $left_pos, $top + $lineHeight * $i, $color, $font, trim($line));
|
|
|
1245 |
$i++;
|
|
|
1246 |
}
|
|
|
1247 |
$retour["height"] = $height;
|
|
|
1248 |
$retour["width"] = $largeur_max;
|
|
|
1249 |
|
|
|
1250 |
$dimensions_espace = imageftbbox($textSize, 0, $font, ' ');
|
|
|
1251 |
$largeur_espace = $dimensions_espace[2] - $dimensions_espace[0];
|
|
|
1252 |
$retour["espace"] = $largeur_espace;
|
|
|
1253 |
return $retour;
|
|
|
1254 |
}
|
|
|
1255 |
|
|
|
1256 |
|
|
|
1257 |
|
|
|
1258 |
function image_typo() {
|
|
|
1259 |
/*
|
|
|
1260 |
arguments autorises:
|
|
|
1261 |
|
|
|
1262 |
$texte : le texte a transformer; attention: c'est toujours le premier argument, et c'est automatique dans les filtres
|
|
|
1263 |
$couleur : la couleur du texte dans l'image - pas de dieze
|
|
|
1264 |
$fond: ne pas utiliser, puisque transparence du PNG
|
|
|
1265 |
$ombre: la couleur de l'ombre
|
|
|
1266 |
$ombrex, $ombrey: les decalages en pixels de l'ombre
|
|
|
1267 |
$police: nom du fichier Truetype de la police
|
|
|
1268 |
$largeur: la largeur maximale de l'image ; attention, l'image retournee a une largeur inferieure, selon les limites reelles du texte
|
|
|
1269 |
|
|
|
1270 |
$alt: pour forcer l'affichage d'un alt; attention, comme utilisation d'un span invisible pour affiche le texte, generalement inutile
|
|
|
1271 |
|
|
|
1272 |
|
|
|
1273 |
*/
|
|
|
1274 |
|
|
|
1275 |
|
|
|
1276 |
|
|
|
1277 |
// Recuperer les differents arguments
|
|
|
1278 |
$numargs = func_num_args();
|
|
|
1279 |
$arg_list = func_get_args();
|
|
|
1280 |
$texte = $arg_list[0];
|
|
|
1281 |
for ($i = 1; $i < $numargs; $i++) {
|
|
|
1282 |
if (ereg("\=", $arg_list[$i])) {
|
|
|
1283 |
$nom_variable = substr($arg_list[$i], 0, strpos($arg_list[$i], "="));
|
|
|
1284 |
$val_variable = substr($arg_list[$i], strpos($arg_list[$i], "=")+1, strlen($arg_list[$i]));
|
|
|
1285 |
|
|
|
1286 |
$variable["$nom_variable"] = $val_variable;
|
|
|
1287 |
}
|
|
|
1288 |
|
|
|
1289 |
}
|
|
|
1290 |
|
|
|
1291 |
// Construire requete et nom fichier
|
|
|
1292 |
$text = ereg_replace("\ ", "~", $texte);
|
|
|
1293 |
|
|
|
1294 |
$taille = $variable["taille"];
|
|
|
1295 |
if ($taille < 1) $taille = 16;
|
|
|
1296 |
|
|
|
1297 |
$couleur = $variable["couleur"];
|
|
|
1298 |
if (strlen($couleur) < 6) $couleur = "000000";
|
|
|
1299 |
|
|
|
1300 |
$fond = $variable["fond"];
|
|
|
1301 |
if (strlen($fond) < 6) $fond = "ffffff";
|
|
|
1302 |
|
|
|
1303 |
$alt = $texte;
|
|
|
1304 |
|
|
|
1305 |
$ombre = $variable["ombre"];
|
|
|
1306 |
$ombrex = $variable["ombrex"];
|
|
|
1307 |
$ombrey = $variable["ombrey"];
|
|
|
1308 |
if (!$variable["ombrex"]) $ombrex = 1;
|
|
|
1309 |
if (!$variable["ombrey"]) $ombrey = $ombrex;
|
|
|
1310 |
|
|
|
1311 |
$align = $variable["align"];
|
|
|
1312 |
if (!$variable["align"]) $align="left";
|
|
|
1313 |
|
|
|
1314 |
$police = $variable["police"];
|
|
|
1315 |
if (strlen($police) < 2) $police = "dustismo.ttf";
|
|
|
1316 |
|
|
|
1317 |
$largeur = $variable["largeur"];
|
|
|
1318 |
if ($largeur < 5) $largeur = 600;
|
|
|
1319 |
|
|
|
1320 |
|
|
|
1321 |
$string = "$text-$taille-$couleur-$fond-$ombre-$ombrex-$ombrey-$align-$police-$largeur";
|
|
|
1322 |
$query = md5($string);
|
|
|
1323 |
$dossier = _DIR_IMG. creer_repertoire(_DIR_IMG, 'cache-texte');
|
|
|
1324 |
$fichier = "$dossier$query.png";
|
|
|
1325 |
|
|
|
1326 |
$flag_gd_typo = function_exists("imageftbbox")
|
|
|
1327 |
&& function_exists('imageCreateTrueColor');
|
|
|
1328 |
|
|
|
1329 |
|
|
|
1330 |
if (!file_exists($fichier) AND $flag_gd_typo) {
|
|
|
1331 |
// Il faut completer avec un vrai _SPIP_PATH, de facon a pouvoir livrer des /polices dans les dossiers de squelettes
|
|
|
1332 |
$font = find_in_path("polices/$police", "ecrire");
|
|
|
1333 |
|
|
|
1334 |
$imgbidon = imageCreateTrueColor($largeur, 45);
|
|
|
1335 |
$retour = printWordWrapped($imgbidon, $taille+5, 0, $largeur, $font, $black, $text, $taille);
|
|
|
1336 |
$hauteur = $retour["height"];
|
|
|
1337 |
$largeur_reelle = $retour["width"];
|
|
|
1338 |
$espace = $retour["espace"];
|
|
|
1339 |
imagedestroy($imgbidon);
|
|
|
1340 |
|
|
|
1341 |
$im = imageCreateTrueColor($largeur_reelle+$ombrex-$espace, $hauteur+5+$ombrey);
|
|
|
1342 |
imagealphablending ($im, FALSE );
|
|
|
1343 |
imagesavealpha ( $im, TRUE );
|
|
|
1344 |
|
|
|
1345 |
// Cration de quelques couleurs
|
|
|
1346 |
if (strlen($ombre) == 6) $grey = imagecolorallocatealpha($im, hexdec("0x{".substr($ombre, 0,2)."}"), hexdec("0x{".substr($ombre, 2,2)."}"), hexdec("0x{".substr($ombre, 4,2)."}"), 50);
|
|
|
1347 |
$black = imagecolorallocatealpha($im, hexdec("0x{".substr($couleur, 0,2)."}"), hexdec("0x{".substr($couleur, 2,2)."}"), hexdec("0x{".substr($couleur, 4,2)."}"), 0);
|
|
|
1348 |
$grey2 = imagecolorallocatealpha($im, hexdec("0x{".substr($fond, 0,2)."}"), hexdec("0x{".substr($fond, 2,2)."}"), hexdec("0x{".substr($fond, 4,2)."}"), 127);
|
|
|
1349 |
|
|
|
1350 |
ImageFilledRectangle ($im,0,0,$largeur+$ombrex,$hauteur+5+$ombrey,$grey2);
|
|
|
1351 |
|
|
|
1352 |
// Le texte dessiner
|
|
|
1353 |
// Remplacez le chemin par votre propre chemin de police
|
|
|
1354 |
//global $text;
|
|
|
1355 |
|
|
|
1356 |
if (strlen($ombre) == 6) printWordWrapped($im, $taille+$ombrey+5, $ombrex, $largeur, $font, $grey, $text, $taille, $align);
|
|
|
1357 |
printWordWrapped($im, $taille+5, 0, $largeur, $font, $black, $text, $taille, $align);
|
|
|
1358 |
|
|
|
1359 |
|
|
|
1360 |
// Utiliser imagepng() donnera un texte plus claire,
|
|
|
1361 |
// compar l'utilisation de la fonction imagejpeg()
|
|
|
1362 |
imagepng($im, $fichier);
|
|
|
1363 |
imagedestroy($im);
|
|
|
1364 |
|
|
|
1365 |
$image = $fichier;
|
|
|
1366 |
|
|
|
1367 |
} else if ($flag_gd_typo) {
|
|
|
1368 |
$image = $fichier;
|
|
|
1369 |
}
|
|
|
1370 |
|
|
|
1371 |
if ($image) {
|
|
|
1372 |
$dimensions = getimagesize($image);
|
|
|
1373 |
$largeur = $dimensions[0];
|
|
|
1374 |
$hauteur = $dimensions[1];
|
|
|
1375 |
return inserer_attribut("<img src='$image' style='border: 0px; width: ".$largeur."px; height: ".$hauteur.px."' class='image_typo'>", 'alt', $alt);
|
|
|
1376 |
} else {
|
|
|
1377 |
return $texte;
|
|
|
1378 |
}
|
|
|
1379 |
|
|
|
1380 |
}
|
|
|
1381 |
|
|
|
1382 |
function modulo($nb, $mod, $add=0)
|
|
|
1383 |
{
|
|
|
1384 |
return ($nb%$mod)+$add;
|
|
|
1385 |
}
|
|
|
1386 |
?>
|