Listing du fichier exemple1.js
00001 Pour ne pas voir les numéros de ligne, ajoutez &nl=non à la suite du nom du fichier. |
Retour à la page principale de
(gH)
Listing du fichier exemple1.js
00001// (gH) -_- exemple1.js ; TimeStamp (unix) : 16 Octobre 2009 vers 15:11
00002
00003 var SORT_ROW_INDEX;
00004 var SORT_COL_INDEX;
00005 var thead = false;
00006 var tc = new Array(); // pour cloner les tableaux originaux il faut un tableau auxilliaire
00007
00008 // ###############################################################
00009
00010 function initialisationDesTableaux() {
00011
00012 // ###############################################################
00013
00014 // On cherche les tableaux dans la page dont la classe est triCol, triLig ou triTab
00015 // et suivant les cas, on complète la première ligne/colonne
00016
00017 if (!document.getElementsByTagName) return ; // si le navigteur ne sait pas le faire, on quitte
00018
00019 tbls = document.getElementsByTagName("table") ; // on met dans tbls tous les tableaux HTML de la page
00020
00021 for (var ti=0;ti<tbls.length;ti++) {
00022 thisTbl = tbls[ti];
00023 // si le tableau courant thisTbl a le style requis,
00024 // alors on lui applique la fonction correspondante
00025 if (((' '+thisTbl.className+' ').indexOf("triCol") != -1)) {
00026 rendTriableEnColonne(thisTbl);
00027 } //fin de si
00028 if (((' '+thisTbl.className+' ').indexOf("triLig") != -1)) {
00029 rendTriableEnLigne(thisTbl);
00030 } //fin de si
00031 if (((' '+thisTbl.className+' ').indexOf("triTab") != -1)) {
00032 rendTriableEnColonne(thisTbl);
00033 rendTriableEnLigne(thisTbl);
00034 /* non : rendTriable(thisTbl); */
00035 } //fin de si
00036 } // fin de pour
00037
00038 // on est alors pret à faire une copie des tableaux
00039
00040 tbls = document.getElementsByTagName("table") ; // on met dans tbls tous les tableaux HTML de la page
00041
00042 for (var ti=0;ti<tbls.length;ti++) {
00043 thisTbl = tbls[ti];
00044 // on fait une copie de l'original
00045 tc[ti] = thisTbl.cloneNode(true);
00046 } // fin de pour
00047
00048 } // fin de fonction initialisationDesTableaux
00049
00050 // ###############################################################
00051
00052 function rendTriableEnColonne(t) {
00053
00054 // ###############################################################
00055
00056 // Cette fonction insère un bouton pour chacune des cellules de la première ligne.
00057 // Dès qu'on clique : - soit on trie le tableau dans l'ordre croissant ou décroissant suivant le sens de la flèche
00058 // - soit on recharge le tableau original
00059
00060 firstRow = testeEntete(t) ; if (!firstRow) { return ; } // s'il n'y a pas d'entete, on quitte
00061
00062 // on rend chacune des cellules de l'entete cliquable
00063
00064 for (var ic=0;ic<firstRow.cells.length;ic++) {
00065 var cell = firstRow.cells[ic];
00066 // var txt = ts_getInnerText(cell);
00067 var txtHTML = sousArbreDom(cell,1,1)
00068 if (txtHTML.indexOf("triCol")==-1) {
00069 // on retire <th> et </th>
00070 txtHTML = txtHTML.replace(/<th>/g, "");
00071 txtHTML = txtHTML.replace(/<\/th>/g, "");
00072 cell.innerHTML = txtHTML + '<span class="sortheader" onclick="tri_col(this, '+ic+');return false;">'
00073 + symboleTri("col","h",1)
00074 + '</span>' // avant, c'était juste txt au lieu de txtHTML
00075 } ; // finsi
00076 } // fin pour
00077
00078 } // fin de fonction rendTriableEnColonne
00079
00080 // ###############################################################
00081
00082 function tri_col(lnk, clid) {
00083
00084 // ###############################################################
00085
00086 // cette fonction permet de trier le tableau en lignes selon la colonne clid
00087 // lnk sert à connaitre le tableau qui contient la colonne
00088
00089 ecrit_infos("tri_col("+lnk+","+clid+")")
00090
00091 // on récupère le contenu des "<span...>"
00092 // car on y met l'attribut "sensTri" qui donne le sens du tri
00093
00094 var span;
00095 for (var ci=0;ci<lnk.childNodes.length;ci++) {
00096 if (lnk.childNodes[ci].tagName && lnk.childNodes[ci].tagName.toLowerCase() == 'span') {
00097 span = lnk.childNodes[ci];
00098 } // fin si
00099 } // fin pour
00100
00101 var spantext = ts_getInnerText(span);
00102
00103 var l=0;
00104 var td = lnk.parentNode;
00105 var column = clid ;
00106 var t = getParent(td,'TABLE');
00107
00108 if (t.rows.length <= 1) return; // on quitte s'il n'y a pas de colonne
00109
00110 nsortfn = natureDuTriCol(t,column)
00111
00112 SORT_COL_INDEX = column;
00113 var firstRow = new Array();
00114 var newRows = new Array();
00115 var newColumns = new Array();
00116
00117 for (var k=0;k<t.tBodies.length;k++) {
00118 if (!thead) {
00119 // on saute la première ligne
00120 for (var j=1;j<t.tBodies[k].rows.length;j++) {
00121 newRows[j-1] = t.tBodies[k].rows[j]; // newRows contient les lignes du tableau à trier
00122 } // fin pour
00123 } else {
00124 // on ne saute pas la première ligne
00125 for (var j=0;j<t.tBodies[k].rows.length;j++) {
00126 newRows[j] = t.tBodies[k].rows[j];
00127 } // fin pour
00128 } // fin si
00129
00130 } // fin pour
00131
00132 sensTriAtt = span.getAttribute("senstri")
00133 ecrit_infos("triCol sens = "+sensTriAtt)
00134
00135 // si le sens de tri est none, on reprend l'original
00136
00137 if (sensTriAtt == 'o') {
00138
00139 ARROW = symboleTri("col","h",1)
00140 span.setAttribute('senstri','h');
00141
00142 k=0;
00143 var m=0;
00144 var idtv= 0 ;
00145 while (m<tc.length) {
00146
00147 for(var i=0;i<tc[m].rows[0].cells.length;i++) {
00148 // si on retrouve la bonne en-tete...
00149 if (trim(ts_getInnerText(t.rows[0].cells[column]))==trim(ts_getInnerText(tc[m].rows[0].cells[i]))) {
00150 // on peut recopier le tableau original cloné
00151 idtv = m ;
00152 for(var j=0;j<newRows.length;j++) {
00153 for(var k=0;k<newRows[0].cells.length;k++) {
00154 // c'est ici que tout se joue : il faut tout enlever avant de mettre la copie clonée
00155 laCase = newRows[j].cells[k]
00156 enleveLesAttributs(laCase)
00157 while (laCase.firstChild) { laCase.removeChild(laCase.firstChild) }
00158 cn = tc[m].rows[j+1].cells[k].cloneNode(true)
00159 laCase.appendChild( cn )
00160
00161 } // fin pour k
00162 } // fin pour j
00163 break;
00164 } // fin si
00165 } // fin pour i
00166 m++;
00167 } // fintant que
00168
00169 } else {
00170
00171 // sinon, on doit trier et changer le symbole ainsi que le "span" du sens de tri
00172
00173 newRows.sort(sortfnCol);
00174
00175 if (sensTriAtt == 'b') { // pour avoir un tri inverse, on utilise reverse
00176
00177 ARROW = symboleTri("col","o",1)
00178 newRows.reverse();
00179 span.setAttribute('senstri','o');
00180
00181 } else { // ou alors, on ajuste à changer la flèche et le span
00182
00183 ARROW = symboleTri("col","b",1)
00184 span.setAttribute('senstri','b');
00185
00186 } // fin si
00187
00188 // on a bien géré newRows, on le recopie dans le tableau de départ
00189
00190 for (var i=0; i<newRows.length; i++) {
00191 if (!newRows[i].className || (newRows[i].className && (newRows[i].className.indexOf('sortbottom') == -1))) {
00192 t.tBodies[0].appendChild(newRows[i]);
00193 } // fin si
00194 } // fin pour
00195
00196 } // fin si
00197
00198 // on remet les boutons pour les autres colonnes
00199
00200 var allspans = document.getElementsByTagName("span");
00201 for (var ci=0;ci<allspans.length;ci++) {
00202 if (allspans[ci].className == 'triCol') {
00203 if (getParent(allspans[ci],"table") == getParent(lnk,"table")) { // in the same table as us?
00204 allspans[ci].innerHTML = symboleTri("col","h",0)
00205 } // fin si getParent
00206 } // allspans
00207 } // fin pour
00208
00209 span.innerHTML = ARROW;
00210
00211 } // fin de fonction tri_col
00212
00213 // ###############################################################
00214
00215 function rendTriableEnLigne(t) {
00216
00217 // ###############################################################
00218
00219 // Cette fonction insère un bouton pour chacune des cellules de la première colonne.
00220 // Dès qu'on clique : - soit on trie le tableau dans l'ordre croissant ou décroissant suivant le sens de la flèche
00221 // - soit on recharge le tableau original
00222
00223 firstRow = testeEntete(t) ; if (!firstRow) { return ; } // s'il n'y a pas d'entete, on quitte
00224
00225 // on rend chacune des cellules de la colonne 1 cliquable
00226
00227 for (var il=0; il<t.rows.length; il++) {
00228 cell = t.rows[il].cells[0];
00229 // var txt = ts_getInnerText(cell);
00230 var txtHTML = sousArbreDom(cell,1,1)
00231 if (txtHTML.indexOf("triLig")==-1) {
00232 // on retire <th> et </th>
00233 txtHTML = txtHTML.replace(/<th>/g, "");
00234 txtHTML = txtHTML.replace(/<\/th>/g, "");
00235 cell.innerHTML = '<span class="sortheader" onclick="tri_lig(this, '+ il + ');return false;">'
00236 + symboleTri("lig","d",1) + '</span>'
00237 + txtHTML; // avant, c'était juste txt
00238 } ; // finsi
00239 } // fin pour
00240
00241 } // fin de fonction rendTriableEnLigne
00242
00243 // ###############################################################
00244
00245 function tri_lig(lnk,clid) {
00246
00247 // ###############################################################
00248
00249 // cette fonction permet de trier le tableau en colonne selon la ligne clid
00250 // lnk sert à connaitre le tableau qui contient la colonne
00251
00252 // on récupère le contenu des "<span...>"
00253 // car on y met l'attribut "sensTri" qui donne le sens du tri
00254
00255 ecrit_infos("tri_lig("+lnk+","+clid+")")
00256 //ecrit_infos("le parent est "+lnk.getParent())
00257 var span;
00258 var l=0;
00259
00260 for (var ci=0;ci<lnk.childNodes.length;ci++) {
00261 if (lnk.childNodes[ci].tagName && lnk.childNodes[ci].tagName.toLowerCase() == 'span')
00262 span = lnk.childNodes[ci];
00263 } // fin pour ci
00264 var spantext = ts_getInnerText(span);
00265 var td = lnk.parentNode;
00266 var ligne = clid ;
00267 var t = getParent(td,'TABLE');
00268
00269 if (t.rows.length <= 1) return; // on quitte s'il n'y a pas de colonne
00270
00271 sortfnLig = natureDuTriLig(t,ligne)
00272
00273 SORT_ROW_INDEX = ligne;
00274 var newRows = new Array();
00275
00276 for (var k=0;k<t.tBodies.length;k++) {
00277 for (var j=0;j<t.tBodies[k].rows.length;j++) {
00278 newRows[j] = t.tBodies[k].rows[j];
00279 } // fin pour j
00280 } // fin pour k
00281
00282 var min_max;
00283 var k;
00284 var tmp;
00285
00286 // on ne peut pas appliquer la meme technique que pour le tri des lignes
00287
00288 // si le sens de tri est none, on reprend l'original
00289
00290 sensTriAtt = span.getAttribute("senstri")
00291 ecrit_infos("triLig sens = "+sensTriAtt)
00292
00293 if (sensTriAtt == 'o') {
00294 ecrit_infos("Lig partie none")
00295 ARROW = symboleTri("lig","d",1)
00296 span.setAttribute('senstri','d');
00297
00298 k=0;
00299 var m=0;
00300 while (m<tc.length) {
00301 for(var i=0;i<tc[m].rows.length;i++) {
00302 if (ts_getInnerText(t.rows[ligne].cells[0])==ts_getInnerText(tc[m].rows[i].cells[0])) {
00303 for(var j=0;j<newRows.length;j++) {
00304 for(var k=0;k<newRows[0].cells.length;k++) {
00305 // newRows[j].cells[k].innerHTML=ts_getInnerText(tc[m].rows[j].cells[k]);
00306
00307 laCase = newRows[j].cells[k]
00308 enleveLesAttributs( laCase )
00309 while (laCase.firstChild) { laCase.removeChild(laCase.firstChild) }
00310
00311 cn = tc[m].rows[j].cells[k].cloneNode(true)
00312 laCase.appendChild( cn )
00313 } // fin pour k
00314 } // fin pour j
00315 break;
00316 } // fin si
00317 } // fin pour i
00318 m++;
00319 } // fin tant
00320
00321 } else {
00322
00323 // sinon, on doit trier et changer le symbole ainsi que le "span" du sens de tri
00324
00325 if (sensTriAtt == 'g') { // pour avoir un tri inverse, on
00326
00327 for(var k=1;k<newRows[1].cells.length-1;k++) {
00328 min_max=k;
00329 for(var j=k+1;j<newRows[1].cells.length;j++) {
00330 if (sortfnLig(newRows[SORT_ROW_INDEX].cells[j],newRows[SORT_ROW_INDEX].cells[k])>0) {
00331 min_max=j;
00332 echangerCellule(tmp,newRows[SORT_ROW_INDEX].cells[k],newRows[SORT_ROW_INDEX].cells[min_max]);
00333 for(var i=0;i<newRows.length;i++) {
00334 if(i!=SORT_ROW_INDEX) {
00335 echangerCellule(tmp,newRows[i].cells[k],newRows[i].cells[min_max]);
00336 } // fin si
00337 } // fin pour i
00338 } // fin si sortfnLig
00339 } // fin pour j
00340 } // fin pour k
00341
00342 ARROW = symboleTri("lig","o",1)
00343 span.setAttribute('senstri','o');
00344
00345 } else { // ou alors, on ajuste à changer la flèche et le span
00346
00347 ARROW = symboleTri("lig","g",1)
00348 span.setAttribute('senstri','g');
00349
00350 for(var k=1;k<newRows[1].cells.length-1;k++) {
00351 min_max=k;
00352 for(var j=k+1;j<newRows[1].cells.length;j++) {
00353 if (sortfnLig(newRows[SORT_ROW_INDEX].cells[j],newRows[SORT_ROW_INDEX].cells[k])<0) {
00354 min_max=j;
00355 echangerCellule(tmp,newRows[SORT_ROW_INDEX].cells[k],newRows[SORT_ROW_INDEX].cells[min_max]);
00356 for (var i=0;i<newRows.length;i++) {
00357 if(i!=SORT_ROW_INDEX) {
00358 echangerCellule(tmp,newRows[i].cells[k],newRows[i].cells[min_max]);
00359 } //fin si
00360 } // fin pour i
00361 } // fin si sortfnLig
00362 } //fin pour j
00363 } // fin pour k
00364
00365 } // fin si
00366 } // fin si
00367
00368 // on remet les boutons pour les autres colonnes
00369
00370 var allspans = document.getElementsByTagName("span");
00371 for (var ci=0;ci<allspans.length;ci++) {
00372 if (allspans[ci].className == 'trilig') {
00373 if (getParent(allspans[ci],"table") == getParent(lnk,"table")) { // in the same table as us?
00374 allspans[ci].innerHTML = symboleTri("lig","d",0)
00375 } // fin si
00376 } // fin si
00377 } // pour
00378
00379 span.innerHTML = ARROW;
00380
00381 } // fin de fonction tri_lig
00382
00383 // ###############################################################
00384
00385 function ts_getInnerText(el) {
00386
00387 // ###############################################################
00388
00389 // cette fonction retourne le contenu d'un élément du tableau saisi en paramètre
00390
00391 if (typeof el == "string") return el;
00392 if (typeof el == "undefined") { return el };
00393 if (el.innerText) return el.innerText; // Not needed but it is faster
00394 var str = "";
00395
00396 var cs = el.childNodes;
00397 var l = cs.length;
00398 for (var i = 0; i < l; i++) {
00399 switch (cs[i].nodeType) {
00400 case 1: //ELEMENT_NODE
00401 str += ts_getInnerText(cs[i]);
00402 break;
00403 case 3: //TEXT_NODE
00404 str += cs[i].nodeValue;
00405 break;
00406 } //fin de switch
00407 } //fin de pour
00408 return str;
00409 } // fin de fonction ts_getInnerText
00410
00411 // ###############################################################
00412
00413 function echangerCellule(tmp,cell1,cell2) {
00414
00415 // ###############################################################
00416
00417 tmp1 = sousArbreDom(cell1,1,1)
00418 tmp2 = sousArbreDom(cell2,1,1)
00419 cell1.innerHTML = tmp2 ;
00420 cell2.innerHTML = tmp1 ;
00421
00422 } // fin de fonction
00423
00424 // ###############################################################
00425
00426 function echanger(tmp,cell1,cell2) {
00427
00428 // ###############################################################
00429
00430 tmp=ts_getInnerText(cell1);
00431 cell1.innerHTML=ts_getInnerText(cell2);
00432 cell2.innerHTML=tmp;
00433
00434 } // fin de fonction
00435
00436 // ###############################################################
00437
00438 function ts_sort_numeric1(a,b) {
00439
00440 // ###############################################################
00441
00442 var aa = trim(ts_getInnerText(a));
00443 aa = clean_num(aa);
00444 var bb = trim(ts_getInnerText(b));
00445 bb = clean_num(bb);
00446
00447 return compare_numeric1(aa,bb);
00448
00449 } // fin de fonction
00450
00451 // ###############################################################
00452
00453 function compare_numeric1(a,b) {
00454
00455 // ###############################################################
00456
00457 var a = parseFloat(a);
00458 a = (isNaN(a) ? 0 : a);
00459 var b = parseFloat(b);
00460 b = (isNaN(b) ? 0 : b);
00461 return a - b;
00462
00463 } // fin de fonction
00464
00465 // ###############################################################
00466
00467 function ts_sort_caseinsensitive1(a,b) {
00468
00469 // ###############################################################
00470
00471 aa = ts_getInnerText(a).toLowerCase();
00472 bb = ts_getInnerText(b).toLowerCase();
00473 if (aa==bb) {
00474 return 0;
00475 } // fin si
00476 if (aa<bb) {
00477 return -1;
00478 } // fin si
00479 return 1;
00480
00481 } // fin de fonction
00482
00483 // ###############################################################
00484
00485 function getParent(el, pTagName) {
00486
00487 // ###############################################################
00488
00489 if (el == null) {
00490 return null;
00491 } else if (el.nodeType == 1 && el.tagName.toLowerCase() == pTagName.toLowerCase()) {
00492 return el;
00493 } else {
00494 return getParent(el.parentNode, pTagName);
00495 } // finsi
00496
00497 } // fin de fonction
00498
00499 // ###############################################################
00500
00501 function sort_date(date) {
00502
00503 // ###############################################################
00504
00505 // y2k notes: two digit years less than 50 are treated as 20XX, greater than 50 are treated as 19XX
00506 dt = "00000000";
00507 if (date.length == 11) {
00508 mtstr = date.substr(3,3);
00509 mtstr = mtstr.toLowerCase();
00510 switch(mtstr) {
00511 case "jan": var mt = "01"; break;
00512 case "feb": var mt = "02"; break;
00513 case "mar": var mt = "03"; break;
00514 case "apr": var mt = "04"; break;
00515 case "may": var mt = "05"; break;
00516 case "jun": var mt = "06"; break;
00517 case "jul": var mt = "07"; break;
00518 case "aug": var mt = "08"; break;
00519 case "sep": var mt = "09"; break;
00520 case "oct": var mt = "10"; break;
00521 case "nov": var mt = "11"; break;
00522 case "dec": var mt = "12"; break;
00523 // default: var mt = "00";
00524 } // fin de switch
00525 dt = date.substr(7,4)+mt+date.substr(0,2);
00526 return dt;
00527 } else if (date.length == 10) {
00528 if (europeandate == false) {
00529 dt = date.substr(6,4)+date.substr(0,2)+date.substr(3,2);
00530 return dt;
00531 } else {
00532 dt = date.substr(6,4)+date.substr(3,2)+date.substr(0,2);
00533 return dt;
00534 } // fin si
00535 } else if (date.length == 8) {
00536 yr = date.substr(6,2);
00537 if (parseInt(yr) < 50) {
00538 yr = '20'+yr;
00539 } else {
00540 yr = '19'+yr;
00541 } // fin si
00542 if (europeandate == true) {
00543 dt = yr+date.substr(3,2)+date.substr(0,2);
00544 return dt;
00545 } else {
00546 dt = yr+date.substr(0,2)+date.substr(3,2);
00547 return dt;
00548 } // fin si
00549 } // fin si
00550 return dt;
00551
00552 } // fin de fonction
00553
00554 // ###############################################################
00555
00556 function ts_sort_date(a,b) {
00557
00558 // ###############################################################
00559
00560 dt1 = sort_date(ts_getInnerText(a.cells[SORT_COL_INDEX]));
00561 dt2 = sort_date(ts_getInnerText(b.cells[SORT_COL_INDEX]));
00562
00563 if (dt1==dt2) {
00564 return 0;
00565 } // fin si
00566 if (dt1<dt2) {
00567 return -1;
00568 } // fin si
00569 return 1;
00570
00571 } // fin de fonction
00572
00573 // ###############################################################
00574
00575 function ts_sort_numeric(a,b) {
00576
00577 // ###############################################################
00578
00579 var aa = trim(ts_getInnerText(a.cells[SORT_COL_INDEX]));
00580 aa = clean_num(aa);
00581 var bb = trim(ts_getInnerText(b.cells[SORT_COL_INDEX]));
00582 bb = clean_num(bb);
00583
00584 return compare_numeric(aa,bb);
00585
00586 } // fin de fonction
00587
00588 // ###############################################################
00589
00590 function compare_numeric(a,b) {
00591
00592 // ###############################################################
00593 var a = parseFloat(a);
00594 a = (isNaN(a) ? 0 : a);
00595 var b = parseFloat(b);
00596 b = (isNaN(b) ? 0 : b);
00597 return a - b;
00598
00599 } // fin de fonction
00600
00601 // ###############################################################
00602
00603 function ts_sort_caseinsensitive(a,b) {
00604
00605 // ###############################################################
00606
00607 aa = ts_getInnerText(a.cells[SORT_COL_INDEX]).toLowerCase();
00608 bb = ts_getInnerText(b.cells[SORT_COL_INDEX]).toLowerCase();
00609 if (aa==bb) {
00610 return 0;
00611 } // fin si
00612 if (aa<bb) {
00613 return -1;
00614 } // fin si
00615 return 1;
00616
00617 } // fin de fonction
00618
00619 // ###############################################################
00620
00621 function ts_sort_default(a,b) {
00622
00623 // ###############################################################
00624
00625 aa = ts_getInnerText(a.cells[SORT_COL_INDEX]);
00626 bb = ts_getInnerText(b.cells[SORT_COL_INDEX]);
00627 if (aa==bb) {
00628 return 0;
00629 } // fin si
00630 if (aa<bb) {
00631 return -1;
00632 } // fin si
00633 return 1;
00634
00635 } // fin de fonction
00636
00637 // ###############################################################
00638
00639 function addEvent(elm, evType, fn, useCapture) {
00640
00641 // ###############################################################
00642
00643 // addEvent and removeEvent
00644 // cross-browser event handling for IE5+, NS6 and Mozilla
00645 // By Scott Andrew
00646
00647 if (elm.addEventListener){
00648 elm.addEventListener(evType, fn, useCapture);
00649 return true;
00650 } else if (elm.attachEvent){
00651 var r = elm.attachEvent("on"+evType, fn);
00652 return r;
00653 } else {
00654 alert("Handler could not be removed");
00655 } // fin si
00656
00657 } // fin de fonction
00658
00659 // ###############################################################
00660
00661 function clean_num(str) {
00662
00663 // ###############################################################
00664
00665 str = str.replace(new RegExp(/[^-?0-9.]/g),"");
00666 return str;
00667 } // fin de fonction clean_num
00668
00669 // ###############################################################
00670
00671 function trim(s) {
00672
00673 // ###############################################################
00674
00675 return s.replace(/^\s+\s+$/g, "");
00676
00677 } // fin de fonction trim
00678
00679 // ###############################################################
00680
00681 // ###############################################################
00682
00683 function ecrit_infos(mesTxt) {
00684
00685 // ###############################################################
00686
00687 mt = document.getElementById("infos")
00688
00689 mt.value += "\n" + mesTxt ;
00690
00691 return(false)
00692
00693 } // fin de fonction ecrit_infos
00694
00695 // ###############################################################
00696
00697 function reset_infos(mesTxt) {
00698
00699 // ###############################################################
00700
00701 mt = document.getElementById("infos")
00702
00703 mt.value = ""
00704
00705 return(false)
00706
00707 } // fin de fonction reset_infos
00708
00709 // ###############################################################
00710
00711 function symboleTri(org,sens,avecSpan) {
00712
00713 // ###############################################################
00714
00715 // org vaut lig" ou "col"
00716
00717 // sens = "o" : on revient à l'original
00718 // "h" : vers le haut
00719 // "b" : vers le bas
00720 // "d" : vers la droite
00721 // "g" : vers la gauche
00722
00723 if (org=="col") { cla = "triCol" }
00724 else { cla = "triLig" }
00725 symb = sens
00726 fond = "transparent"
00727
00728 if (sens=='d') { symb = "▸" ; fond = "vert_clair" }
00729 if (sens=='h') { symb = "▴" ; fond = "vert_clair" }
00730 if (sens=='b') { symb = "▾" ; fond = "orange" }
00731 if (sens=='g') { symb = "◂" ; fond = "orange" }
00732 if (sens=='o') { symb = "o" ; fond = "original" }
00733
00734 if (avecSpan==1) { leSymbole = '<span class="'+cla+'" senstri="'+sens+'">' }
00735 else { leSymbole = '' }
00736 leSymbole += '<input class="'+fond+'" type="button" value="'+symb+'" />'
00737
00738 if (avecSpan==1) { leSymbole += '</span>' }
00739
00740 return(leSymbole)
00741
00742 } // fin de fonction reset_infos
00743
00744 // ###############################################################
00745
00746 function testeEntete(t) {
00747
00748 // ###############################################################
00749
00750 if (t.rows && t.rows.length > 0) {
00751 if (t.tHead && t.tHead.rows.length > 0) {
00752 var firstRow = t.tHead.rows[t.tHead.rows.length-1];
00753 thead = true;
00754 } else {
00755 var firstRow = t.rows[0];
00756 } //fin si
00757 } // fin si
00758
00759 return(firstRow)
00760
00761 } // fin de fonction testeEntete
00762
00763 // ###############################################################
00764
00765 function natureDuTriCol(t,column) {
00766
00767 // ###############################################################
00768
00769 sortfnCol = ts_sort_caseinsensitive;
00770
00771 var itm = "";
00772 var i = 0;
00773
00774 while (itm == "" && i < t.tBodies[0].rows.length) {
00775 var itm = ts_getInnerText(t.tBodies[0].rows[i].cells[column]);
00776 itm = trim(itm); // on supprime les espaces avant et apres la chaine itm
00777 itm=clean_num(itm);
00778 if (itm.substr(0,4) == "<!--" || itm.length == 0) {
00779 itm = "";
00780 } // fin si
00781 i++;
00782 } // fin de tant que
00783
00784 // ecrit_infos(" natureDuTri pour : "+itm)
00785
00786 if (itm == "") return(sortfnCol) ;
00787 sortfnCol = ts_sort_caseinsensitive;
00788
00789 if (itm.match(/^-?[£$€Û¢´]\d/)) {
00790 sortfnCol = ts_sort_numeric;
00791 } // fin de si
00792
00793 if (itm.match(/^-?(\d+[,\.]?)+(E[-+][\d]+)?%?$/)) {
00794 sortfnCol = ts_sort_numeric;
00795 } // fin si
00796
00797 return(sortfnCol)
00798
00799 } // fin de fonction natureDuTriCol
00800
00801 // ###############################################################
00802
00803 function natureDuTriLig(t,ligne) {
00804
00805 // ###############################################################
00806
00807 sortfnLig = ts_sort_caseinsensitive1;
00808
00809 var itm = "";
00810 var i = 0;
00811
00812 while (itm == "" && i < t.tBodies[0].rows[0].cells.length) {
00813 var itm = ts_getInnerText(t.tBodies[0].rows[ligne].cells[i]);
00814 itm = trim(itm); // on supprime les espaces avant et apres la chaine itm
00815 itm = clean_num(itm);
00816 if (itm.substr(0,4) == "<!--" || itm.length == 0) {
00817 itm = "";
00818 }
00819 i++;
00820 } // fin tant que
00821
00822 if (itm == "") return(sortfnLig) ;
00823 sortfnLig = ts_sort_caseinsensitive1;
00824
00825 if (itm.match(/^\d\d[\/\.-][a-zA-z][a-zA-Z][a-zA-Z][\/\.-]\d\d\d\d$/)) sortfnLig = ts_sort_date;
00826 if (itm.match(/^\d\d[\/\.-]\d\d[\/\.-]\d\d\d{2}?$/)) sortfnLig = ts_sort_date;
00827 if (itm.match(/^-?[£$€Û¢´]\d/)) sortfnLig = ts_sort_numeric1;
00828 if (itm.match(/^-?(\d+[,\.]?)+(E[-+][\d]+)?%?$/)) sortfnLig = ts_sort_numeric1;
00829
00830 return(sortfnLig)
00831
00832 } // fin de fonction natureDuTriLig
00833
00834 // ###############################################################
00835
00836 function enleveLesAttributs(maCase) {
00837
00838 // ###############################################################
00839
00840 // nombre d'enfants
00841
00842 nbe = maCase.childNodes.length
00843
00844 if (maCase.childNodes[0]) {
00845
00846 // type du premier noeud
00847
00848 tpe = maCase.childNodes[0].nodeType
00849
00850 // si un seul enfant et de type texte
00851
00852 if ( (nbe==1) && tpe==3) {
00853 // on peut détruire tous les attributs
00854 atd = maCase.attributes
00855 for (ida=0;ida<atd.length;ida++) {
00856 maCase.removeAttribute(atd[ida].name)
00857 } // fin pour
00858
00859 } // fin si
00860
00861 } // fin si
00862
00863 // imparfait : on 'enlève pas tout (entre <span sur élement
00864 // et <td class, il y a un 'hic'
00865
00866 } // fin de fonction enleveAttributs
00867
00868
00869 // ###############################################################
00870
00871 function surligne(elt) {
00872
00873 // ###############################################################
00874
00875 elt.className += " surligne "
00876
00877 } // fin de fonction surligne
00878
00879 // ###############################################################
00880
00881 function desurligne(elt) {
00882
00883 // ###############################################################
00884
00885 var eltcn = elt.className
00886 var er = new RegExp("(surligne)","g") ;
00887 // ecrit_infos("className avant "+eltcn)
00888 eltcn = eltcn.replace(er, ' ')
00889 // ecrit_infos("il reste encore "+eltcn)
00890 elt.className = eltcn
00891 //} ;
00892
00893 } // fin de fonction desurligne
00894
00895 // ###############################################################
00896 // ###############################################################
00897
00898 // -- fin du fichier exemple1.js
00899
00900 // ###############################################################
00901 // ###############################################################
Pour ne pas voir les numéros de ligne, ajoutez &nl=non à la suite du nom du fichier.