Mise en route du suivi.
[aidenligne_francais_universite.git] / ecrire / inc / ortho.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 if (!defined("_ECRIRE_INC_VERSION")) return;
14
15 // Mettre a jour la liste locale des miroirs
16 // http://doc.spip.org/@maj_miroirs_ortho
17 function maj_miroirs_ortho() {
18 $liste = explode(" ", $GLOBALS['meta']["liste_miroirs_ortho"]);
19 $miroirs_old = array();
20 foreach ($liste as $index) {
21 list($url) = explode(" ", $GLOBALS['meta']["miroir_ortho_$index"]);
22 $miroirs_old[$url] = $index;
23 }
24
25 $page = recuperer_page($GLOBALS['services']['ortho']?$GLOBALS['services']['ortho']:'http://www.spip.net/services/ortho.txt');
26 $urls=array();
27 foreach(explode("\n", $page) as $ligne) {
28 if(trim($ligne)=="") continue;
29 $t= explode(";", $ligne);
30 $urls[$t[0]]=$t[1];
31 }
32
33 $liste = array();
34 $miroirs_new = array();
35 $index = 1;
36 foreach ($urls as $url => $contact) {
37 if ($index_old = $miroirs_old[$url]) {
38 $s = $GLOBALS['meta']["miroir_ortho_$index_old"];
39 }
40 else {
41 $s = $url." ".time();
42 }
43 $miroirs_new[$index] = $s;
44 $liste[] = $index++;
45 }
46 foreach ($miroirs_old as $index) {
47 effacer_meta("miroir_ortho_$index");
48 }
49 foreach ($miroirs_new as $index => $s) {
50 ecrire_meta("miroir_ortho_$index", $s);
51 }
52 ecrire_meta("liste_miroirs_ortho", join(" ", $liste));
53 }
54
55 // Lire la liste des miroirs et les langues associees
56 // http://doc.spip.org/@lire_miroirs_ortho
57 function lire_miroirs_ortho() {
58 global $miroirs_ortho, $index_miroirs_ortho, $duree_cache_miroirs_ortho;
59
60 $miroirs_ortho = array();
61 $index_miroirs_ortho = array();
62
63 $t = time();
64 $maj = $GLOBALS['meta']["maj_miroirs_ortho"];
65 if ($maj < $t - $duree_cache_miroirs_ortho) {
66 maj_miroirs_ortho();
67 ecrire_meta("maj_miroirs_ortho", $t);
68 lire_metas();
69 }
70
71 $liste = explode(" ", $GLOBALS['meta']["liste_miroirs_ortho"]);
72 foreach ($liste as $index) {
73 $s = explode(" ", $GLOBALS['meta']["miroir_ortho_$index"]);
74 $url = $s[0];
75 $maj = $s[1];
76 $langs = explode(",", $s[2]);
77 // Reinitialiser periodiquement la liste des langues non-supportees
78 if ($maj < $t - $duree_cache_miroirs_ortho) {
79 foreach ($langs as $key => $lang) {
80 if (substr($lang, 0, 1) == '!') unset($langs[$key]);
81 }
82 $s[1] = $t;
83 $s[2] = join(",", $langs);
84 ecrire_meta("miroir_ortho_$index", join(" ", $s));
85 }
86 $index_miroirs_ortho[$url] = $index;
87 $miroirs_ortho[$url] = array();
88 foreach ($langs as $lang) {
89 if ($lang) $miroirs_ortho[$url][$lang] = $lang;
90 }
91 }
92 lire_metas();
93 mt_srand(time());
94 }
95
96 // Sauvegarder les infos de langues pour le miroir
97 // http://doc.spip.org/@ecrire_miroir_ortho
98 function ecrire_miroir_ortho($url, $langs) {
99 global $index_miroirs_ortho;
100
101 $index = $index_miroirs_ortho[$url];
102 $s = explode(" ", $GLOBALS['meta']["miroir_ortho_$index"]);
103 $s[2] = join(",", $langs);
104 ecrire_meta("miroir_ortho_$index", join(" ", $s));
105 }
106
107 // http://doc.spip.org/@ajouter_langue_miroir
108 function ajouter_langue_miroir($url, $lang) {
109 global $miroirs_ortho;
110 $langs = $miroirs_ortho[$url];
111 $langs[$lang] = $lang;
112 unset($langs["!$lang"]);
113 ecrire_miroir_ortho($url, $langs);
114 }
115
116 // http://doc.spip.org/@enlever_langue_miroir
117 function enlever_langue_miroir($url, $lang) {
118 global $miroirs_ortho;
119 $langs = $miroirs_ortho[$url];
120 unset($langs[$lang]);
121 $langs["!$lang"] = "!$lang";
122 ecrire_miroir_ortho($url, $langs);
123 }
124
125 // http://doc.spip.org/@reset_miroir
126 function reset_miroir($url) {
127 global $miroirs_ortho;
128 ecrire_miroir_ortho($url, array());
129 }
130
131 //
132 // Renvoie la liste des miroirs utilisables pour une langue donnee
133 //
134 // http://doc.spip.org/@chercher_miroirs_ortho
135 function chercher_miroirs_ortho($lang) {
136 global $miroirs_ortho;
137
138 $result = array();
139 $chercher = true;
140 foreach ($miroirs_ortho as $url => $langs) {
141 if ($langs[$lang]) {
142 $result[] = $url;
143 }
144 else if ($chercher && !$langs["!$lang"]) {
145 if (verifier_langue_miroir($url, $lang)) $result[] = $url;
146 // Ne recuperer la langue d'un miroir qu'une seule fois par requete
147 if ($result) $chercher = false;
148 }
149 }
150 return $result;
151 }
152
153 // http://doc.spip.org/@choisir_miroirs_ortho
154 function choisir_miroirs_ortho($lang) {
155 $liste = chercher_miroirs_ortho($lang);
156 if (!count($liste)) return false;
157 foreach ($liste as $url) {
158 $miroirs[md5(mt_rand().$url.rand())] = $url;
159 }
160 ksort($miroirs);
161 return $miroirs;
162 }
163
164 //
165 // Envoyer une requete a un serveur d'orthographe
166 //
167 // http://doc.spip.org/@post_ortho
168 function post_ortho($url, $texte, $lang) {
169
170 $gz = ($GLOBALS['flag_gz'] && strlen($texte) >= 200);
171 $boundary = '';
172 $vars = array(
173 'op' => 'spell',
174 'lang' => $lang,
175 'texte' => $texte,
176 'gz' => $gz ? 1 : 0
177 );
178 // Si le texte est petit, l'overhead du multipart est dispendieux
179 // Sinon, on passe en multipart pour compresser la chaine a corriger
180 if ($gz) {
181 // Il faut eliminer les caracteres 0 sinon PHP ne lit pas la suite du parametre
182 // passe en multipart/form-data (gros hack bien sale)
183 $texte_gz = gzcompress($texte);
184 for ($echap = 255; $echap > 0; $echap--) {
185 $str_echap = chr($echap ^ 1).chr($echap).chr($echap).chr($echap ^ 2);
186 if (!is_int(strpos($texte_gz, $str_echap))) break;
187 }
188 $texte_gz = str_replace("\x00", $str_echap, $texte_gz);
189 $vars['texte'] = $texte_gz;
190 $vars['nul_echap'] = $str_echap;
191 $boundary = substr(md5(rand().'ortho'), 0, 8);
192 }
193
194 $r = recuperer_page($url, false, false, 1048576, $vars, $boundary, true);
195
196 // decompression de GZ ortho
197 if ($gz) $r = gzuncompress($r);
198 return $r;
199
200 /*
201 * Note a propos de la compression : si on ne refuse pas le gz dans recuperer_page(),
202 * le serveur d'ortho va retourner des donnees compressees deux fois ; le code
203 * saurait les decompresser deux fois, mais on perd alors beaucoup de temps (on
204 * passe, dans un test, de 5 s a 25 s de delai !)
205 */
206
207 }
208
209 //
210 // Verifier si un serveur gere une langue donnee
211 //
212 // http://doc.spip.org/@verifier_langue_miroir
213 function verifier_langue_miroir($url, $lang) {
214 // Envoyer une requete bidon
215 $result = post_ortho($url, " ", $lang);
216 if (!preg_match(',<ortho>.*</ortho>,s', $result)) {
217 reset_miroir($url);
218 return false;
219 }
220 if (!preg_match(',<erreur>.*<code>E_LANG_ABSENT</code>.*</erreur>,s', $result)) {
221 ajouter_langue_miroir($url, $lang);
222 return true;
223 }
224 enlever_langue_miroir($url, $lang);
225 return false;
226 }
227
228
229 //
230 // Gestion du dictionnaire local
231 //
232 // http://doc.spip.org/@suggerer_dico_ortho
233 function suggerer_dico_ortho(&$mots, $lang) {
234 $result = spip_query("SELECT mot FROM spip_ortho_dico WHERE lang=" . _q($lang) . " AND mot IN (".join(", ", array_map('_q', $mots)).")");
235
236 $mots = array_flip($mots);
237 $bons = array();
238 if (isset($mots[''])) unset($mots['']);
239 while ($row = spip_fetch_array($result)) {
240 $mot = $row['mot'];
241 if (isset($mots[$mot])) {
242 unset($mots[$mot]);
243 $bons[] = $mot;
244 }
245 }
246
247 if (count($mots)) $mots = array_flip($mots);
248 else $mots = array();
249 return $bons;
250 }
251
252 // http://doc.spip.org/@ajouter_dico_ortho
253 function ajouter_dico_ortho($mot, $lang) {
254 global $connect_id_auteur;
255
256 spip_query("INSERT IGNORE INTO spip_ortho_dico (lang, mot, id_auteur) VALUES (" . _q($lang) . ", " . _q($mot) . ", $connect_id_auteur)");
257
258 }
259
260 // http://doc.spip.org/@supprimer_dico_ortho
261 function supprimer_dico_ortho($mot, $lang) {
262 spip_query("DELETE FROM spip_ortho_dico WHERE lang=" . _q($lang) . " AND mot=" . _q($mot));
263
264 }
265
266 // http://doc.spip.org/@gerer_dico_ortho
267 function gerer_dico_ortho($lang) {
268 global $ajout_ortho, $supp_ortho;
269 if ($mot = strval($ajout_ortho)) {
270 ajouter_dico_ortho($mot, $lang);
271 }
272 if ($mot = strval($supp_ortho)) {
273 supprimer_dico_ortho($mot, $lang);
274 }
275 }
276
277
278 //
279 // Gestion du cache de corrections
280 //
281 // http://doc.spip.org/@suggerer_cache_ortho
282 function suggerer_cache_ortho(&$mots, $lang) {
283 global $duree_cache_ortho;
284
285 $result = spip_query("SELECT mot, ok, suggest FROM spip_ortho_cache WHERE lang=" . _q($lang) . " AND mot IN (".join(", ", array_map('_q', $mots)).") AND maj > FROM_UNIXTIME(".(time() - $duree_cache_ortho).")");
286
287
288 $mots = array_flip($mots);
289 $suggest = array();
290 if (isset($mots[''])) unset($mots['']);
291 while ($row = spip_fetch_array($result)) {
292 $mot = $row['mot'];
293 if (isset($mots[$mot])) {
294 unset($mots[$mot]);
295 if (!$row['ok']) {
296 if (strlen($row['suggest']))
297 $suggest[$mot] = explode(",", $row['suggest']);
298 else
299 $suggest[$mot] = array();
300 }
301 }
302 }
303 if (count($mots)) $mots = array_flip($mots);
304 else $mots = array();
305 return $suggest;
306 }
307
308 // http://doc.spip.org/@ajouter_cache_ortho
309 function ajouter_cache_ortho($tous, $mauvais, $lang) {
310 global $duree_cache_ortho;
311
312 $values = array();
313 $lang = _q($lang);
314 if (count($mauvais)) {
315 foreach ($mauvais as $mot => $suggest) {
316 $values[] = "($lang, " . _q($mot) . ", 0, "._q(join(",", $suggest)).")";
317 }
318 }
319 if (count($tous)) {
320 foreach ($tous as $mot) {
321 if (!isset($mauvais[$mot]))
322 $values[] = "($lang, " . _q($mot) . ", 1, '')";
323 }
324 }
325 if (count($values)) {
326 spip_query("DELETE FROM spip_ortho_cache WHERE maj < FROM_UNIXTIME(".(time() - $duree_cache_ortho).")");
327
328 spip_query("INSERT IGNORE INTO spip_ortho_cache (lang, mot, ok, suggest) VALUES ".join(", ", $values));
329
330 }
331 }
332
333
334 //
335 // Cette fonction doit etre appelee pour reecrire le texte en utf-8 "propre"
336 //
337 // http://doc.spip.org/@preparer_ortho
338 function preparer_ortho($texte, $lang) {
339 include_spip('inc/charsets');
340
341 $charset = $GLOBALS['meta']['charset'];
342
343 if ($charset == 'utf-8')
344 return unicode_to_utf_8(html2unicode($texte));
345 else
346 return unicode_to_utf_8(html2unicode(charset2unicode($texte, $charset, true)));
347 }
348
349 // http://doc.spip.org/@afficher_ortho
350 function afficher_ortho($texte) {
351 $charset = $GLOBALS['meta']['charset'];
352 if ($charset == 'utf-8') return $texte;
353
354 if (!is_array($texte)) return charset2unicode($texte, 'utf-8');
355 foreach ($texte as $key => $val) {
356 $texte[$key] = afficher_ortho($val);
357 }
358 return $texte;
359 }
360
361 //
362 // Cette fonction envoie le texte prepare a un serveur d'orthographe
363 // et retourne un tableau de mots mal orthographies associes chacun a un tableau de mots suggeres
364 //
365 // http://doc.spip.org/@corriger_ortho
366 function corriger_ortho($texte, $lang, $charset = 'AUTO') {
367 include_spip('inc/charsets');
368 include_spip("inc/indexation");
369 include_spip('inc/filtres');
370
371 $texte = preg_replace(',<code>.*?</code>,is', '', $texte);
372 $texte = preg_replace(',<cadre>.*?</cadre>,is', '', $texte);
373 $texte = preg_replace(',\[([^][]*)->([^][]*)\],is', '\\1', $texte);
374 $texte = supprimer_tags($texte);
375
376 $texte = " ".$texte." ";
377
378 // Virer les caracteres non-alphanumeriques
379 if (test_pcre_unicode()) {
380 $texte = preg_replace(',[^-\''.pcre_lettres_unicode().']+,us', ' ', $texte);
381 }
382 else {
383 // Ici bidouilles si PCRE en mode UTF-8 ne fonctionne pas correctement ...
384 // Caracteres non-alphanumeriques de la plage latin-1 + saloperies non-conformes
385 $texte = preg_replace(',\xC2[\x80-\xBF],', ' ', $texte);
386 // Poncutation etendue (unicode)
387 $texte = preg_replace(",".plage_punct_unicode().",", ' ', $texte);
388 // Caracteres ASCII non-alphanumeriques
389 $texte = preg_replace(",[^-a-zA-Z0-9\x80-\xFF']+,", ' ', $texte);
390 }
391 $texte = preg_replace(', [-\']+,', ' ', $texte); // tirets de typo
392 $texte = preg_replace(',\' ,', ' ', $texte); // apostrophes utilisees comme guillemets
393
394 // Virer les mots contenant au moins un chiffre
395 $texte = preg_replace(', ([^ ]*\d[^ ]* )+,', ' ', $texte);
396
397 // Melanger les mots
398 $mots = preg_split(', +,', $texte);
399 sort($mots);
400 $mots = array_unique($mots);
401
402 // 1. Enlever les mots du dico local
403 $bons = suggerer_dico_ortho($mots, $lang);
404
405 // 2. Enlever les mots du cache local
406 $result_cache = suggerer_cache_ortho($mots, $lang);
407
408 // 3. Envoyer les mots restants a un serveur
409 $mauvais = array();
410 if (count($mots)) {
411 $texte = join(' ', $mots);
412
413 // Hack : ligatures en francais pas gerees par aspell
414 unset($trans_rev);
415 $texte_envoi = $texte;
416 if ($lang == 'fr') {
417 $trans = array(chr(197).chr(146) => 'OE', chr(197).chr(147) => 'oe',
418 chr(195).chr(134) => 'AE', chr(195).chr(166) => 'ae');
419 $texte_envoi = strtr($texte_envoi, $trans);
420 $trans_rev = array_flip($trans);
421 }
422
423 // POST de la requete et recuperation du resultat XML
424 $urls = choisir_miroirs_ortho($lang);
425 if (!$urls) return false;
426 unset($ok);
427 $erreur = false;
428 foreach ($urls as $url) {
429 $xml = post_ortho($url, $texte_envoi, $lang);
430 if ($xml && preg_match(',<ortho>(.*)</ortho>,s', $xml, $r)) {
431 $xml = $r[1];
432 if (preg_match(',<erreur>.*<code>(.*)</code>.*</erreur>,s', $xml, $r))
433 $erreur = $r[1];
434 if (preg_match(',<ok>(.*)</ok>,s', $xml, $r)) {
435 $ok = $r[1];
436 break;
437 }
438 }
439 reset_miroir($url);
440 }
441 if (!isset($ok)) return $erreur;
442
443 // Remplir le tableau des resultats (mots mal orthographies)
444 if ($trans_rev) {
445 $assoc_mots = array_flip($mots);
446 }
447 while (preg_match(',<mot>(.*?)</mot>(\s*<suggest>(.*?)</suggest>)?,s', $ok, $r)) {
448 $p = strpos($ok, $r[0]);
449 $ok = substr($ok, $p + strlen($r[0]));
450 $mot = $r[1];
451 if ($suggest = $r[3])
452 $s = preg_split('/[ ,]+/', $suggest);
453 else
454 $s = array();
455 // Hack ligatures
456 if ($trans_rev) {
457 $mot_rev = strtr($mot, $trans_rev);
458 if ($mot != $mot_rev) {
459 if ($assoc_mots[$mot])
460 $mauvais[$mot] = $s;
461 if ($assoc_mots[$mot_rev])
462 $mauvais[$mot_rev] = $s;
463 }
464 else $mauvais[$mot] = $s;
465 }
466 else $mauvais[$mot] = $s;
467 }
468 }
469 if (!$erreur) ajouter_cache_ortho($mots, $mauvais, $lang);
470
471 // Retour a l'envoyeur
472 $mauvais = array_merge($result_cache, $mauvais);
473 $result = array(
474 'bons' => $bons,
475 'mauvais' => $mauvais
476 );
477 if ($erreur) $result['erreur'] = $erreur;
478 return $result;
479 }
480
481 //
482 // Fonctions d'affichage HTML
483 //
484
485 // http://doc.spip.org/@panneau_ortho
486 function panneau_ortho($ortho_result) {
487 global $id_suggest;
488
489 $id_suggest = array();
490 $i = 1;
491
492 $mauvais = $ortho_result['mauvais'];
493 $bons = $ortho_result['bons'];
494 if (!count($mauvais) && !count($bons)) return;
495 ksort($mauvais);
496
497 $panneau = "<script type='text/javascript'><!--
498 var curr_suggest = null;
499 // http://doc.spip.org/@suggest
500 function suggest(id) {
501 var menu_box;
502 if (curr_suggest)
503 document.getElementById('suggest' + curr_suggest).className = 'suggest-inactif';
504 if (1 || id!=curr_suggest) {
505 document.getElementById('suggest' + id).className = 'suggest-actif';
506 curr_suggest = id;
507 }
508 else curr_suggest = null;
509 menu_box = document.getElementById('select_ortho');
510 if (menu_box.length > id) menu_box.selectedIndex = id;
511 }";
512 $panneau .= "//--></script>";
513
514 $panneau .= "<form class='form-ortho verdana2' action='' method='get'>\n";
515 $panneau .= "<select name='select_ortho' id='select_ortho' onChange='suggest(this.selectedIndex);'>\n";
516 $panneau .= "<option value='0'>... "._T('ortho_mots_a_corriger')." ...</option>\n";
517 foreach ($mauvais as $mot => $suggest) {
518 $id = $id_suggest[$mot] = "$i";
519 $i++;
520 $mot_html = afficher_ortho($mot);
521 $panneau .= "<option value='$id'>$mot_html</option>\n";
522 }
523 foreach ($bons as $mot) {
524 $id = $id_suggest[$mot] = "$i";
525 $i++;
526 }
527 $panneau .= "</select>\n";
528 $panneau .= "</form>\n";
529 // Mots mal orthographies :
530 // liste des suggestions plus lien pour ajouter au dico
531 foreach ($mauvais as $mot => $suggest) {
532 $id = $id_suggest[$mot];
533 $mot_html = afficher_ortho($mot);
534 $panneau .= "<div class='suggest-inactif' id='suggest$id'>";
535 $panneau .= "<span class='ortho'>$mot_html</span>\n";
536 $panneau .= "<div class='detail'>\n";
537 if (is_array($suggest) && count($suggest)) {
538 $panneau .= "<ul>\n";
539 $i = 0;
540 foreach ($suggest as $sug) {
541 if (++$i > 12) {
542 $panneau .= "<li><i>(...)</i></li>\n";
543 break;
544 }
545 $panneau .= "<li>".typo(afficher_ortho($sug))."</li>\n";
546 }
547 $panneau .= "</ul>\n";
548 }
549 else {
550 $panneau .= "<i>"._T('ortho_aucune_suggestion')."</i>";
551 }
552 $panneau .= "<br />";
553 $lien = parametre_url(self(), 'supp_ortho', '');
554 $lien = parametre_url($lien, 'ajout_ortho', $mot);
555 $panneau .= icone_horizontale(_T('ortho_ajouter_ce_mot'), $lien, "ortho-24.gif", "creer.gif", false);
556 $panneau .= "</div>\n";
557 $panneau .= "</div>\n\n";
558 }
559 // Mots trouves dans le dico :
560 // message plus lien pour retirer du dico
561 foreach ($bons as $mot) {
562 $id = $id_suggest[$mot];
563 $mot_html = afficher_ortho($mot);
564 $panneau .= "<div class='suggest-inactif' id='suggest$id'>";
565 $panneau .= "<span class='ortho-dico'>$mot_html</span>";
566 $panneau .= "<div class='detail'>\n";
567 $panneau .= "<i>"._T('ortho_ce_mot_connu')."</i>";
568 $panneau .= "<br />";
569 $lien = parametre_url(self(), 'ajout_ortho', '');
570 $lien = parametre_url($lien, 'supp_ortho', $mot);
571 $panneau .= icone_horizontale(_T('ortho_supprimer_ce_mot'), $lien, "ortho-24.gif", "supprimer.gif");
572 $panneau .= "</div>\n";
573 $panneau .= "</div>\n";
574 }
575 return $panneau;
576 }
577
578
579 // http://doc.spip.org/@souligner_match_ortho
580 function souligner_match_ortho(&$texte, $cherche, $remplace) {
581 // Eviter les &mdash;, etc.
582 if ($cherche{0} == '&' AND $cherche{strlen($cherche) - 1} == ';') return;
583
584 if ($cherche{0} == '>')
585 $texte = str_replace($cherche, $remplace, $texte);
586 else {
587 // Ne pas remplacer a l'interieur des tags HTML
588 $table = explode($cherche, $texte);
589 unset($avant);
590 $texte = '';
591 foreach ($table as $s) {
592 if (!isset($avant)) {
593 $avant = $s;
594 continue;
595 }
596 $ok = true;
597 $texte .= $avant;
598 // Detecter si le match a eu lieu dans un tag HTML
599 if (is_int($deb_tag = strrpos($texte, '<'))) {
600 if (strrpos($texte, '>') <= $deb_tag)
601 $ok = false;
602 }
603 if ($ok) $texte .= $remplace;
604 else $texte .= $cherche;
605 $avant = $s;
606 }
607 $texte .= $avant;
608 }
609 }
610
611 // http://doc.spip.org/@souligner_ortho
612 function souligner_ortho($texte, $lang, $ortho_result) {
613 global $id_suggest;
614 $vu = array();
615
616 $mauvais = $ortho_result['mauvais'];
617 $bons = $ortho_result['bons'];
618
619 // Neutraliser l'apostrophe unicode pour surligner correctement les fautes
620 $texte = " ".str_replace("\xE2\x80\x99", "'", $texte)." ";
621 // Chercher et remplacer les mots un par un
622 $delim = '[^-\''.pcre_lettres_unicode().']';
623 foreach ($mauvais as $mot => $suggest) {
624 $pattern = ",$delim".$mot."$delim,us";
625 // Recuperer les occurences du mot dans le texte
626 if (preg_match_all($pattern, $texte, $regs, PREG_SET_ORDER)) {
627 $id = $id_suggest[$mot];
628 $mot_html = afficher_ortho($mot);
629 foreach ($regs as $r) {
630 if ($vu[$cherche = $r[0]]) continue;
631 $vu[$cherche] = 1;
632 $html = "<a class='ortho' onclick=\"suggest($id);return false;\" href=''>$mot_html</a>";
633 $remplace = str_replace($mot, $html, $cherche);
634 souligner_match_ortho($texte, $cherche, $remplace);
635 }
636 }
637 }
638 foreach ($bons as $mot) {
639 $pattern = ",$delim".$mot."$delim,us";
640 // Recuperer les occurences du mot dans le texte
641 if (preg_match_all($pattern, $texte, $regs, PREG_SET_ORDER)) {
642 $id = $id_suggest[$mot];
643 $mot_html = afficher_ortho($mot);
644 foreach ($regs as $r) {
645 if ($vu[$cherche = $r[0]]) continue;
646 $vu[$cherche] = 1;
647 $html = "<a class='ortho-dico' onclick=\"suggest($id);return false;\" href=''>$mot_html</a>";
648 $remplace = str_replace($mot, $html, $cherche);
649 souligner_match_ortho($texte, $cherche, $remplace);
650 }
651 }
652 }
653
654 $texte = preg_replace(',(^ | $),', '', $texte);
655 return $texte;
656 }
657
658 // http://doc.spip.org/@init_ortho
659 function init_ortho() {
660 global $duree_cache_ortho, $duree_cache_miroirs_ortho;
661
662 $duree_cache_ortho = 7 * 24 * 3600;
663 $duree_cache_miroirs_ortho = 24 * 3600;
664 lire_miroirs_ortho();
665 }
666
667 init_ortho();
668
669 ?>