(no commit message)
[euphorik.git] / js / euphorik.js
1 // coding: utf-8
2 // Copyright 2008 Grégory Burri
3 //
4 // This file is part of Euphorik.
5 //
6 // Euphorik is free software: you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License as published by
8 // the Free Software Foundation, either version 3 of the License, or
9 // (at your option) any later version.
10 //
11 // Euphorik is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 //
16 // You should have received a copy of the GNU General Public License
17 // along with Euphorik. If not, see <http://www.gnu.org/licenses/>.
18
19 /**
20 * Contient la base javascript pour le site euphorik.ch.
21 * Chaque page possède son propre fichier js nommé "page<nom de la page>.js".
22 * Auteur : GBurri
23 * Date : 6.11.2007
24 */
25
26
27 /**
28 * La configuration.
29 * Normalement 'const' à la place de 'var' mais non supporté par IE7.
30 */
31 var conf = {
32 nbMessageAffiche : 40, // (par page)
33 pseudoDefaut : "<nick>",
34 tempsAffichageMessageDialogue : 4000, // en ms
35 tempsKick : 15, // en minute
36 tempsBan : 60 * 24 * 3, // en minutes (3jours)
37 smiles : {
38 "smile" : [/:\)/g, /:-\)/g],
39 "bigsmile" : [/:D/g, /:-D/g],
40 "clin" : [/;\)/g, /;-\)/g],
41 "cool" : [/8\)/g, /8-\)/g],
42 "eheheh" : [/:P/g, /:-P/g],
43 "lol" : [/\[-lol\]/g],
44 "spliff" : [/\[-spliff\]/g],
45 "oh" : [/:o/g, /:O/g],
46 "heink" : [/\[-heink\]/g],
47 "hum" : [/\[-hum\]/g],
48 "boh" : [/\[-boh\]/g],
49 "sniff" : [/:\(/g, /:-\(/g],
50 "triste" : [/\[-triste\]/g],
51 "pascontent" : [/>\(/g, /&gt;\(/g],
52 "argn" : [/\[-argn\]/g],
53 "redface" : [/\[-redface\]/g],
54 "bunny" : [/\[-lapin\]/g],
55 "chat" : [/\[-chat\]/g],
56 "renne" : [/\[-renne\]/g],
57 "star" : [/\[-star\]/g],
58 "kirby" : [/\[-kirby\]/g],
59 "slurp" : [/\[-slurp\]/g],
60 "agreed" : [/\[-agreed\]/g],
61 "dodo" : [/\[-dodo\]/g],
62 "bn" : [/\[-bn\]/g]
63 }
64 }
65
66 ///////////////////////////////////////////////////////////////////////////////////////////////////
67
68 String.prototype.trim = function()
69 {
70 return jQuery.trim(this) // anciennement : this.replace(/^\s+|\s+$/g, "");
71 }
72
73 String.prototype.ltrim = function()
74 {
75 return this.replace(/^\s+/, "");
76 }
77
78 String.prototype.rtrim = function()
79 {
80 return this.replace(/\s+$/, "");
81 }
82
83 ///////////////////////////////////////////////////////////////////////////////////////////////////
84
85 /**
86 * Cette classe regroupe des fonctions utilitaires (helpers).
87 * @formateur est permet de formater les messages affichés à l'aide de messageDialogue (facultatif)
88 */
89 function Util(formateur)
90 {
91 $("#info .fermer").click(function(){
92 $("#info").slideUp(50)
93 })
94
95 $("body").append('<div id="flecheBulle"></div>').append('<div id="messageBulle"><p></p></div>')
96
97 this.formateur = formateur
98 this.bulleActive = true
99 }
100
101 var messageType = {informatif: 0, question: 1, erreur: 2}
102
103 /**
104 * Affiche une boite de dialogue avec un message à l'intérieur.
105 * @param message le message (string)
106 * @param type voir 'messageType'. par défaut messageType.informatif
107 * @param les boutons sous la forme d'un objet ou les clefs sont les labels des boutons
108 * et les valeurs les fonctions executées lorsqu'un bouton est activé.
109 * @param formate faut-il formaté le message ? true par défaut
110 */
111 Util.prototype.messageDialogue = function(message, type, boutons, formate)
112 {
113 var thisUtil = this
114
115 if (type == undefined)
116 type = messageType.informatif
117
118 if (formate == undefined)
119 formate = true
120
121 if (this.timeoutMessageDialogue != undefined)
122 clearTimeout(this.timeoutMessageDialogue)
123
124 var fermer = function(){$("#info").slideUp(100)}
125 fermer()
126
127 $("#info .message").html(thisUtil.formateur == undefined || !formate ? message : thisUtil.formateur.traitementComplet(message))
128 switch(type)
129 {
130 case messageType.informatif : $("#info #icone").attr("class", "information"); break
131 case messageType.question : $("#info #icone").attr("class", "interrogation"); break
132 case messageType.erreur : $("#info #icone").attr("class", "exclamation"); break
133 }
134 $("#info .boutons").html("")
135 for (var b in boutons)
136 $("#info .boutons").append("<div>" + b + "</div>").find("div:last").click(boutons[b]).click(fermer)
137
138 $("#info").slideDown(200)
139 this.timeoutMessageDialogue = setTimeout(fermer, conf.tempsAffichageMessageDialogue)
140 }
141
142 /**
143 * Affiche un info bulle lorsque le curseur survole l'élément donné.
144 * FIXME : le width de element ne tient pas compte du padding !?
145 */
146 Util.prototype.infoBulle = function(message, element)
147 {
148 var thisUtil = this
149
150 var cacherBulle = function()
151 {
152 $("#flecheBulle").hide()
153 $("#messageBulle").hide()
154 }
155
156 element.hover(
157 function(e)
158 {
159 if (!thisUtil.bulleActive)
160 return
161
162 var m = $("#messageBulle")
163 var f = $("#flecheBulle")
164
165 // remplie le paragraphe de la bulle avec le message
166 $("p", m).html(message)
167
168 // réinitialise la position, évite le cas ou la boite est collé à droite et remplie avec un texte la faisant dépassé
169 // dans ce cas la hauteur n'est pas calculé correctement
170 m.css("top", 0).css("left", 0)
171
172 var positionFleche = {
173 left : element.offset().left + element.width() / 2 - f.width() / 2,
174 top : element.offset().top - f.height()
175 }
176 var positionMessage = {
177 left : element.offset().left + element.width() / 2 - m.width() / 2,
178 top : element.offset().top - f.height() - m.height()
179 }
180 var depassementDroit = (positionMessage.left + m.width()) - $("body").width()
181 if (depassementDroit > 0)
182 positionMessage.left -= depassementDroit
183 else
184 {
185 if (positionMessage.left < 0)
186 positionMessage.left = 0
187 }
188
189 m.css("top", positionMessage.top).css("left", positionMessage.left).show()
190 f.css("top", positionFleche.top).css("left", positionFleche.left).show()
191 },
192 cacherBulle
193 ).click(cacherBulle)
194 }
195
196 /**
197 * Utilisé pour l'envoie de donnée avec la méthode ajax de jQuery.
198 */
199 Util.prototype.jsonVersAction = function(json)
200 {
201 return {action : JSON.stringify(json) }
202 }
203
204 Util.prototype.md5 = function(chaine)
205 {
206 return hex_md5(chaine)
207 }
208
209 // pompé de http://www.faqts.com/knowledge_base/view.phtml/aid/13562/fid/130
210 Util.prototype.setSelectionRange = function(input, selectionStart, selectionEnd)
211 {
212 if (input.setSelectionRange)
213 {
214 input.focus()
215 input.setSelectionRange(selectionStart, selectionEnd)
216 }
217 else if (input.createTextRange)
218 {
219 var range = input.createTextRange()
220 range.collapse(true)
221 range.moveEnd('character', selectionEnd)
222 range.moveStart('character', selectionStart)
223 range.select()
224 }
225 }
226
227 Util.prototype.setCaretToEnd = function(input)
228 {
229 this.setSelectionRange(input, input.value.length, input.value.length)
230 }
231 Util.prototype.setCaretToBegin = function(input)
232 {
233 this.setSelectionRange(input, 0, 0)
234 }
235 Util.prototype.setCaretToPos = function(input, pos)
236 {
237 this.setSelectionRange(input, pos, pos)
238 }
239 Util.prototype.selectString = function(input, string)
240 {
241 var match = new RegExp(string, "i").exec(input.value)
242 if (match)
243 {
244 this.setSelectionRange (input, match.index, match.index + match[0].length)
245 }
246 }
247 Util.prototype.replaceSelection = function(input, replaceString) {
248 if (input.setSelectionRange)
249 {
250 var selectionStart = input.selectionStart
251 var selectionEnd = input.selectionEnd
252 input.value = input.value.substring(0, selectionStart) + replaceString + input.value.substring(selectionEnd)
253
254 if (selectionStart != selectionEnd) // has there been a selection
255 this.setSelectionRange(input, selectionStart, selectionStart + replaceString.length)
256 else // set caret
257 this.setCaretToPos(input, selectionStart + replaceString.length)
258 }
259 else if (document.selection)
260 {
261 input.focus()
262 var range = document.selection.createRange()
263 if (range.parentElement() == input)
264 {
265 var isCollapsed = range.text == ''
266 range.text = replaceString
267 if (!isCollapsed)
268 {
269 range.moveStart('character', -replaceString.length);
270 }
271 }
272 }
273 }
274
275 Util.prototype.rot13 = function(chaine)
276 {
277 var ACode = 'A'.charCodeAt(0)
278 var aCode = 'a'.charCodeAt(0)
279 var MCode = 'M'.charCodeAt(0)
280 var mCode = 'm'.charCodeAt(0)
281 var ZCode = 'Z'.charCodeAt(0)
282 var zCode = 'z'.charCodeAt(0)
283
284 var f = function(ch, pos) {
285 if (pos == ch.length)
286 return ""
287
288 var c = ch.charCodeAt(pos);
289 return String.fromCharCode(
290 c +
291 (c >= ACode && c <= MCode || c >= aCode && c <= mCode ? 13 :
292 (c > MCode && c <= ZCode || c > mCode && c <= zCode ? -13 : 0))
293 ) + f(ch, pos + 1)
294 }
295 return f(chaine, 0)
296 }
297
298 ///////////////////////////////////////////////////////////////////////////////////////////////////
299
300 function Pages()
301 {
302 this.pageCourante = null
303 this.pages = {}
304 }
305
306 /**
307 * Accepte soit un objet soit un string.
308 * un string correspond au nom de la page, par exemple : "page" -> "page.html"
309 */
310 Pages.prototype.ajouterPage = function(page)
311 {
312 if (typeof page == "string")
313 {
314 this.pages[page] = page
315 }
316 else
317 {
318 page.pages = this // la magie des langages dynamiques : le foutoire
319 this.pages[page.nom] = page
320 }
321 }
322
323 Pages.prototype.afficherPage = function(nomPage, forcerChargement)
324 {
325 if (forcerChargement == undefined) forcerChargement = false
326
327 var page = this.pages[nomPage]
328 if (page == undefined || (!forcerChargement && page == this.pageCourante)) return
329
330 if (this.pageCourante != null && this.pageCourante.decharger)
331 this.pageCourante.decharger()
332
333 $("#menu li").removeClass("courante")
334 $("#menu li." + nomPage).addClass("courante")
335
336 this.pageCourante = page
337 var contenu = ""
338 if (typeof page == "string")
339 $.ajax({async: false, url: "pages/" + page + ".html", success : function(page) { contenu += page }})
340 else
341 contenu += this.pageCourante.contenu()
342 $("#page").html(contenu).removeClass().addClass(this.pageCourante.nom)
343
344 if (this.pageCourante.charger)
345 this.pageCourante.charger()
346 }
347
348 ///////////////////////////////////////////////////////////////////////////////////////////////////
349
350 /**
351 * Classe permettant de formater du texte par exemple pour la substitution des liens dans les
352 * message par "[url]".
353 * TODO : améliorer l'efficacité des méthods notamment lié au smiles.
354 */
355 function Formateur()
356 {
357 this.smiles = conf.smiles
358 this.protocoles = "http|https|ed2k"
359
360 this.regexUrl = new RegExp("(?:(?:" + this.protocoles + ")://|www\\.)[^ ]*", "gi")
361 this.regexImg = new RegExp("^.*?\\.(gif|jpg|png|jpeg|bmp|tiff)$", "i")
362 this.regexDomaine = new RegExp("^(?:(?:" + this.protocoles + ")://|www\\.).*?([^/.]+\\.[^/.]+)(?:$|/).*$", "i")
363 this.regexTestProtocoleExiste = new RegExp("^(?:" + this.protocoles + ")://.*$", "i")
364 this.regexNomProtocole = new RegExp("^(.*?)://")
365 }
366
367 /**
368 * Formate un pseudo saise par l'utilisateur.
369 * @param pseudo le pseudo brut
370 * @return le pseudo filtré
371 */
372 Formateur.prototype.filtrerInputPseudo = function(pseudo)
373 {
374 return pseudo.replace(/{|}/g, "").trim()
375 }
376
377 Formateur.prototype.getSmilesHTML = function()
378 {
379 var XHTML = ""
380 for (var sNom in this.smiles)
381 {
382 XHTML += "<img class=\"" + sNom + "\" src=\"img/smileys/" + sNom + ".gif\" alt =\"" + sNom + "\" />"
383 }
384 return XHTML
385 }
386
387 /**
388 * Formatage complet d'un texte.
389 * @M le message
390 * @pseudo facultatif, permet de contruire le label des images sous la forme : "<Pseudo> : <Message>"
391 */
392 Formateur.prototype.traitementComplet = function(M, pseudo)
393 {
394 return this.traiterLiensConv(this.traiterSmiles(this.traiterURL(this.traiterWikiSyntaxe(this.remplacerBalisesHTML(M)), pseudo)))
395 }
396
397 /**
398 * Transforme les liens en entités clickables.
399 * Un lien vers une conversation permet d'ouvrire celle ci, elle se marque comme ceci dans un message :
400 * "{5F}" ou 5F est la racine de la conversation.
401 * Ce lien sera transformer en <span class="lienConv">{5F}</span> pouvant être clické pour créer la conv 5F.
402 */
403 Formateur.prototype.traiterLiensConv = function(M)
404 {
405 return M.replace(
406 /\{\w+\}/g,
407 function(lien)
408 {
409 return "<span class=\"lienConv\">" + lien + "</span>"
410 }
411 )
412 }
413
414 /**
415 * FIXME : Cette méthode est attrocement lourde ! A optimiser.
416 * moyenne sur échantillon : 234ms
417 */
418 Formateur.prototype.traiterSmiles = function(M)
419 {
420 for (var sNom in this.smiles)
421 {
422 ss = this.smiles[sNom]
423 for (var i = 0; i < ss.length; i++)
424 M = M.replace(ss[i], "<img src=\"img/smileys/" + sNom + ".gif\" alt =\"" + sNom + "\" />")
425 }
426 return M
427 }
428
429 Formateur.prototype.remplacerBalisesHTML = function(M)
430 {
431 return M.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;")
432 }
433
434 Formateur.prototype.traiterURL = function(M, pseudo)
435 {
436 thisFormateur = this
437
438 var traitementUrl = function(url)
439 {
440 // si ya pas de protocole on rajoute "http://"
441 if (!thisFormateur.regexTestProtocoleExiste.test(url))
442 url = "http://" + url
443 var extension = thisFormateur.getShort(url)
444 return "<a " + (extension[1] ? "title=\"" + (pseudo == undefined ? "" : thisFormateur.traiterPourFenetreLightBox(pseudo, url) + ": ") + thisFormateur.traiterPourFenetreLightBox(M, url) + "\"" + " rel=\"lightbox\"" : "") + " href=\"" + url + "\" >[" + extension[0] + "]</a>"
445 }
446 return M.replace(this.regexUrl, traitementUrl)
447 }
448
449 /**
450 * Formatage en utilisant un sous-ensemble des règles de mediwiki.
451 * par exemple ''italic'' devient <i>italic</i>
452 */
453 Formateur.prototype.traiterWikiSyntaxe = function(M)
454 {
455 return M.replace(
456 /'''(.*?)'''/g,
457 function(texte, capture)
458 {
459 return "<b>" + capture + "</b>"
460 }
461 ).replace(
462 /''(.*?)''/g,
463 function(texte, capture)
464 {
465 return "<i>" + capture + "</i>"
466 }
467 )
468 }
469
470 /**
471 * Renvoie une version courte de l'url.
472 * par exemple : http://en.wikipedia.org/wiki/Yakov_Smirnoff devient wikipedia.org
473 */
474 Formateur.prototype.getShort = function(url)
475 {
476 var estUneImage = false
477 var versionShort = null
478 var rechercheImg = this.regexImg.exec(url)
479
480 if (rechercheImg != null)
481 {
482 versionShort = rechercheImg[1].toLowerCase()
483 if (versionShort == "jpeg") versionShort = "jpg" // jpeg -> jpg
484 estUneImage = true
485 }
486 else
487 {
488 var rechercheDomaine = this.regexDomaine.exec(url)
489 if (rechercheDomaine != null && rechercheDomaine.length >= 2)
490 versionShort = rechercheDomaine[1]
491 else
492 {
493 var nomProtocole = this.regexNomProtocole.exec(url)
494 if (nomProtocole != null && nomProtocole.length >= 2)
495 versionShort = nomProtocole[1]
496 }
497 }
498
499 return [versionShort == null ? "url" : versionShort, estUneImage]
500 }
501
502 /**
503 * Traite les pseudo et messages à être affiché dans le titre d'une image visualisé avec lightbox.
504 */
505 Formateur.prototype.traiterPourFenetreLightBox = function(M, urlCourante)
506 {
507 thisFormateur = this
508 var traitementUrl = function(url)
509 {
510 return "[" + thisFormateur.getShort(url)[0] + (urlCourante == url ? "*" : "") + "]"
511 }
512
513 return this.remplacerBalisesHTML(M).replace(this.regexUrl, traitementUrl)
514 }
515
516
517 ///////////////////////////////////////////////////////////////////////////////////////////////////
518
519 // les statuts possibes du client
520 var statutType = {
521 // mode enregistré, peut poster des messages et modifier son profile
522 auth_registered : 0,
523 // mode identifié, peut poster des messages mais n'a pas accès au profile
524 auth_not_registered : 1,
525 // mode déconnecté, ne peut pas poster de message
526 deconnected : 2
527 }
528
529 function Client(util)
530 {
531 this.util = util
532
533 this.cookie = null
534 this.regexCookie = new RegExp("^cookie=([^;]*)")
535
536 // données personnels
537 this.resetDonneesPersonnelles()
538
539 this.setStatut(statutType.deconnected)
540
541 // si true alors chaque modification du client est mémorisé sur le serveur
542 this.autoflush = $.browser["opera"]
543 }
544
545 Client.prototype.resetDonneesPersonnelles = function()
546 {
547 this.id = 0
548 this.pseudo = conf.pseudoDefaut
549 this.login = ""
550 this.password = ""
551 this.email = ""
552 this.css = $("link#cssPrincipale").attr("href")
553 this.nickFormat = "nick"
554 this.viewTimes = true
555 this.viewTooltips = true
556 this.cookie = undefined
557
558 this.pagePrincipale = 1
559 this.ekMaster = false
560
561 // les conversations, une conversation est un objet possédant les attributs suivants :
562 // - racine (entier)
563 // - page (entier)
564 this.conversations = new Array()
565 }
566
567 Client.prototype.setCss = function(css)
568 {
569 if (this.css == css || css == "")
570 return
571
572 this.css = css
573 $("link#cssPrincipale").attr("href", this.css)
574 if (this.autoflush) this.flush(true)
575 }
576
577 Client.prototype.pageSuivante = function(numConv)
578 {
579 if (numConv < 0 && this.pagePrincipale > 1)
580 this.pagePrincipale -= 1
581 else if (this.conversations[numConv].page > 1)
582 this.conversations[numConv].page -= 1
583 }
584
585 Client.prototype.pagePrecedente = function(numConv)
586 {
587 if (numConv < 0)
588 this.pagePrincipale += 1
589 else
590 this.conversations[numConv].page += 1
591 }
592
593 /**
594 * Définit la première page pour la conversation donnée.
595 * @return true si la page a changé sinon false
596 */
597 Client.prototype.goPremierePage = function(numConv)
598 {
599 if (numConv < 0)
600 {
601 if (this.pagePrincipale == 1)
602 return false
603 this.pagePrincipale = 1
604 }
605 else
606 {
607 if (this.conversations[numConv].page == 1)
608 return false
609 this.conversations[numConv].page = 1
610 }
611 return true
612 }
613
614 /**
615 * Ajoute une conversation à la vue de l'utilisateur.
616 * Le profile de l'utilisateur est directement sauvegardé sur le serveur.
617 * @param racines la racine de la conversation (integer)
618 * @return true si la conversation a été créée sinon false (par exemple si la conv existe déjà)
619 */
620 Client.prototype.ajouterConversation = function(racine)
621 {
622 // vérification s'il elle n'existe pas déjà
623 for (var i = 0; i < this.conversations.length; i++)
624 if (this.conversations[i].root == racine)
625 return false
626
627 this.conversations.push({root : racine, page : 1})
628
629 if (this.autoflush) this.flush(true)
630
631 return true
632 }
633
634 Client.prototype.supprimerConversation = function(num)
635 {
636 if (num < 0 || num >= this.conversations.length) return
637
638 // décalage TODO : supprimer le dernier élément
639 for (var i = num; i < this.conversations.length - 1; i++)
640 this.conversations[i] = this.conversations[i+1]
641 this.conversations.pop()
642
643 if (this.autoflush) this.flush(true)
644 }
645
646 Client.prototype.getJSONLogin = function(login, password)
647 {
648 return {
649 "action" : "authentification",
650 "login" : login,
651 "password" : password
652 }
653 }
654
655 Client.prototype.getJSONLoginCookie = function()
656 {
657 return {
658 "action" : "authentification",
659 "cookie" : this.cookie
660 }
661 }
662
663 /**
664 * le couple (login, password) est facultatif. S'il n'est pas fournit alors il ne sera pas possible
665 * de s'autentifier avec (login, password).
666 */
667 Client.prototype.getJSONEnregistrement = function(login, password)
668 {
669 var mess = { "action" : "register" }
670
671 if (login != undefined && password != undefined)
672 {
673 mess["login"] = login
674 mess["password"] = password
675 }
676
677 return mess;
678 }
679
680 Client.prototype.getJSONConversations = function()
681 {
682 var conversations = new Array()
683 for (var i = 0; i < this.conversations.length; i++)
684 conversations.push({ "root" : this.conversations[i].root, "page" : this.conversations[i].page})
685 return conversations
686 }
687
688 Client.prototype.getJSONProfile = function()
689 {
690 return {
691 "action" : "set_profile",
692 "cookie" : this.cookie,
693 "login" : this.login,
694 "password" : this.password,
695 "nick" : this.pseudo,
696 "email" : this.email,
697 "css" : this.css,
698 "nick_format" : this.nickFormat,
699 "view_times" : this.viewTimes,
700 "view_tooltips" : this.viewTooltips,
701 "main_page" : this.pagePrincipale < 1 ? 1 : this.pagePrincipale,
702 "conversations" : this.getJSONConversations()
703 }
704 }
705
706 /**
707 * Renvoie null si pas définit.
708 */
709 Client.prototype.getCookie = function()
710 {
711 var cookie = this.regexCookie.exec(document.cookie)
712 if (cookie == null) this.cookie = null
713 else this.cookie = cookie[1]
714 }
715
716 Client.prototype.delCookie = function()
717 {
718 document.cookie = "cookie=; max-age=0"
719 }
720
721 Client.prototype.setCookie = function()
722 {
723 if (this.cookie == null || this.cookie == undefined)
724 return
725
726 // ne fonctionne pas sous IE....
727 /*document.cookie = "cookie=" + this.cookie + "; max-age=" + (60 * 60 * 24 * 365) */
728
729 document.cookie =
730 "cookie="+this.cookie+"; expires=" + new Date(new Date().getTime() + 1000 * 60 * 60 * 24 * 365).toUTCString()
731 }
732
733 Client.prototype.authentifie = function()
734 {
735 return this.statut == statutType.auth_registered || this.statut == statutType.auth_not_registered
736 }
737
738 Client.prototype.setStatut = function(statut)
739 {
740 // conversation en "enum" si en "string"
741 if (typeof(statut) == "string")
742 {
743 statut =
744 statut == "auth_registered" ?
745 statutType.auth_registered :
746 (statut == "auth_not_registered" ? statutType.auth_not_registered : statutType.deconnected)
747 }
748
749 if (statut == this.statut) return
750
751 this.statut = statut
752 this.majMenu()
753 }
754
755 /**
756 * Effectue la connexion vers le serveur.
757 * Cette fonction est bloquante tant que la connexion n'a pas été établie.
758 * S'il existe un cookie en local on s'authentifie directement avec lui.
759 * Si il n'est pas possible de s'authentifier alors on affiche un captcha anti-bot.
760 */
761 Client.prototype.connexionCookie = function()
762 {
763 this.getCookie()
764 if (this.cookie == null) return false;
765 return this.connexion(this.getJSONLoginCookie())
766 }
767
768 Client.prototype.connexionLogin = function(login, password)
769 {
770 return this.connexion(this.getJSONLogin(login, password))
771 }
772
773 Client.prototype.enregistrement = function(login, password)
774 {
775 if (this.authentifie())
776 {
777 this.login = login
778 this.password = password
779 if(this.flush())
780 {
781 this.setStatut(statutType.auth_registered)
782 return true
783 }
784 return false
785 }
786 else
787 {
788 return this.connexion(this.getJSONEnregistrement(login, password))
789 }
790 }
791
792 Client.prototype.connexion = function(messageJson)
793 {
794 ;; dumpObj(messageJson)
795 thisClient = this
796 jQuery.ajax(
797 {
798 async: false,
799 type: "POST",
800 url: "request",
801 dataType: "json",
802 data: this.util.jsonVersAction(messageJson),
803 success:
804 function(data)
805 {
806 ;; dumpObj(data)
807 if (data["reply"] == "error")
808 thisClient.util.messageDialogue(data["error_message"])
809 else
810 thisClient.chargerDonnees(data)
811 }
812 }
813 )
814 return this.authentifie()
815 }
816
817 Client.prototype.deconnexion = function()
818 {
819 this.flush(true)
820 this.delCookie()
821 this.resetDonneesPersonnelles()
822 this.setStatut(statutType.deconnected) // deconnexion
823 }
824
825 Client.prototype.chargerDonnees = function(data)
826 {
827 // la modification du statut qui suit met à jour le menu, le menu dépend (page admin)
828 // de l'état ekMaster
829 this.ekMaster = data["ek_master"] != undefined ? data["ek_master"] : false
830
831 this.setStatut(data["status"])
832
833 if (this.authentifie())
834 {
835 this.cookie = data["cookie"]
836 this.setCookie()
837
838 this.id = data["id"]
839 this.login = data["login"]
840 this.pseudo = data["nick"]
841 this.email = data["email"]
842 this.setCss(data["css"])
843 this.nickFormat = data["nick_format"]
844 this.viewTimes = data["view_times"]
845 this.viewTooltips = data["view_tooltips"]
846
847 // la page de la conversation principale
848 this.pagePrincipale = data["main_page"] == undefined ? 1 : data["main_page"]
849
850 // les conversations
851 this.conversations = data["conversations"]
852
853 this.majBulle()
854 this.majCssSelectionee()
855 }
856 }
857
858 /**
859 * Met à jour les données personne sur serveur.
860 * @param async de manière asynchrone ? défaut = true
861 * @return false si le flush n'a pas pû se faire sinon true
862 */
863 Client.prototype.flush = function(async)
864 {
865 if (async == undefined)
866 async = false
867
868 if (!this.authentifie())
869 return false
870
871 var thisClient = this
872 var ok = true
873
874 ;; dumpObj(this.getJSONProfile())
875 jQuery.ajax(
876 {
877 async: async,
878 type: "POST",
879 url: "request",
880 dataType: "json",
881 data: this.util.jsonVersAction(this.getJSONProfile()),
882 success:
883 function(data)
884 {
885 ;; dumpObj(data)
886 if (data["reply"] == "error")
887 {
888 thisClient.util.messageDialogue(data["error_message"])
889 ok = false
890 }
891 else
892 {
893 thisClient.majBulle()
894 }
895 }
896 }
897 )
898
899 return ok
900 }
901
902 Client.prototype.majMenu = function()
903 {
904 displayType = "block"
905
906 $("#menu .admin").css("display", this.ekMaster ? displayType : "none")
907
908 // met à jour le menu
909 if (this.statut == statutType.auth_registered)
910 {
911 $("#menu .profile").css("display", displayType).text("profile")
912 $("#menu .logout").css("display", displayType)
913 $("#menu .register").css("display", "none")
914 }
915 else if (this.statut == statutType.auth_not_registered)
916 {
917 $("#menu .profile").css("display", "none")
918 $("#menu .logout").css("display", displayType)
919 $("#menu .register").css("display", displayType)
920 }
921 else
922 {
923 $("#menu .profile").css("display", displayType).text("login")
924 $("#menu .logout").css("display", "none")
925 $("#menu .register").css("display", displayType)
926 }
927 }
928
929 /**
930 * Met à jour l'affichage des infos bulles en fonction du profile.
931 */
932 Client.prototype.majBulle = function()
933 {
934 this.util.bulleActive = this.viewTooltips
935 }
936
937 /**
938 * Met à jour la css sélectionnée, lors du chargement des données.
939 */
940 Client.prototype.majCssSelectionee = function()
941 {
942 // extraction du numéro de la css courante
943 var numCssCourante = this.css.match(/^.*?\/(\d)\/.*$/)
944 if (numCssCourante[1] != undefined)
945 {
946 $("#menuCss option").removeAttr("selected")
947 $("#menuCss option[value=" + numCssCourante[1]+ "]").attr("selected", "selected")
948 }
949 }
950
951 Client.prototype.slap = function(userId, raison)
952 {
953 var thisClient = this
954
955 jQuery.ajax({
956 type: "POST",
957 url: "request",
958 dataType: "json",
959 data: this.util.jsonVersAction(
960 {
961 "action" : "slap",
962 "cookie" : thisClient.cookie,
963 "user_id" : userId,
964 "reason" : raison
965 }),
966 success:
967 function(data)
968 {
969 if (data["reply"] == "error")
970 thisClient.util.messageDialogue(data["error_message"])
971 }
972 })
973 }
974
975 Client.prototype.ban = function(userId, raison, minutes)
976 {
977 var thisClient = this
978
979 // par défaut un ban correspond à 3 jours
980 if (typeof(minutes) == "undefined")
981 minutes = conf.tempsBan;
982
983 jQuery.ajax({
984 type: "POST",
985 url: "request",
986 dataType: "json",
987 data: this.util.jsonVersAction(
988 {
989 "action" : "ban",
990 "cookie" : thisClient.cookie,
991 "duration" : minutes,
992 "user_id" : userId,
993 "reason" : raison
994 }),
995 success:
996 function(data)
997 {
998 if (data["reply"] == "error")
999 thisClient.util.messageDialogue(data["error_message"])
1000 }
1001 })
1002 }
1003
1004 Client.prototype.kick = function(userId, raison)
1005 {
1006 this.ban(userId, raison, conf.tempsKick)
1007 }
1008
1009 ///////////////////////////////////////////////////////////////////////////////////////////////////
1010
1011 /**
1012 * classe permettant de gérer les événements (push serveur).
1013 * l'information envoyé est sous la forme :
1014 * {
1015 * "action" : "wait_event"
1016 * "page" : <page>
1017 * [..]
1018 * }
1019 * l'information reçu est sous la forme :
1020 * {
1021 * "reply" : <reply>
1022 * }
1023 * @page la page
1024 */
1025 function PageEvent(page, util)
1026 {
1027 this.page = page
1028 this.util = util
1029
1030 // l'objet JSONHttpRequest représentant la connexion d'attente
1031 this.attenteCourante = null
1032
1033 // le multhreading du pauvre, merci javascript de m'offrire autant de primitives pour la gestion de la concurrence...
1034 this.stop = false
1035 }
1036
1037 /**
1038 * Arrête l'attente courante s'il y en a une.
1039 */
1040 PageEvent.prototype.stopAttenteCourante = function()
1041 {
1042 this.stop = true
1043
1044 if (this.attenteCourante != null)
1045 {
1046 this.attenteCourante.abort()
1047 }
1048 }
1049
1050 /**
1051 * Attend un événement lié à la page.
1052 * @funSend une fonction renvoyant les données json à envoyer
1053 * @funsReceive est un objet comprenant les fonctions à appeler en fonction du "reply"
1054 * les fonctions acceptent un paramètre correspondant au données reçues.
1055 * exemple : {"new_message" : function(data){ ... }}
1056 */
1057 PageEvent.prototype.waitEvent = function(funSend, funsReceive)
1058 {
1059 this.stopAttenteCourante()
1060
1061 this.stop = false
1062
1063 var thisPageEvent = this
1064
1065 // on doit conserver l'ordre des valeurs de l'objet JSON (le serveur les veut dans l'ordre définit dans le protocole)
1066 // TODO : ya pas mieux ?
1067 var dataToSend =
1068 {
1069 "action" : "wait_event",
1070 "page" : this.page
1071 }
1072 var poulpe = funSend()
1073 for (v in poulpe)
1074 dataToSend[v] = poulpe[v]
1075
1076 ;; dumpObj(dataToSend)
1077
1078 this.attenteCourante = jQuery.ajax({
1079 type: "POST",
1080 url: "request",
1081 dataType: "json",
1082 // Obsolète (voir TODO)
1083 //timeout: 300000, // timeout de 5min. Gros HACK pas beau. FIXME problème décrit ici : http://groups.google.com/group/jquery-en/browse_thread/thread/8724e64af3333a76
1084 data: this.util.jsonVersAction(dataToSend),
1085 success:
1086 function(data)
1087 {
1088 ;; dumpObj(data)
1089
1090 funsReceive[data["reply"]](data)
1091
1092 // rappel de la fonction dans 100 ms
1093 setTimeout(function(){ thisPageEvent.waitEvent2(funSend, funsReceive) }, 100)
1094 },
1095 error:
1096 function(XMLHttpRequest, textStatus, errorThrown)
1097 {
1098 ;; console.log("Connexion perdue dans waitEvent")
1099 setTimeout(function(){ thisPageEvent.waitEvent2(funSend, funsReceive) }, 1000)
1100 }
1101 })
1102 }
1103
1104 /**
1105 * Si un stopAttenteCourante survient un peu n'importe quand il faut imédiatement arreter de boucler.
1106 */
1107 PageEvent.prototype.waitEvent2 = function(funSend, funsReceive)
1108 {
1109 if (this.stop)
1110 return
1111 this.waitEvent(funSend, funsReceive)
1112 }
1113
1114 ///////////////////////////////////////////////////////////////////////////////////////////////////
1115
1116 function initialiserListeStyles(client)
1117 {
1118 $("#menuCss").change(
1119 function()
1120 {
1121 client.setCss("css/" + $("option:selected", this).attr("value") + "/euphorik.css")
1122 }
1123 )
1124 }
1125
1126 // charge dynamiquement le script de debug
1127 ;; jQuery.ajax({async : false, url : "js/debug.js", dataType : "script"})
1128
1129 // le main
1130 $(document).ready(
1131 function()
1132 {
1133 var formateur = new Formateur()
1134 var util = new Util(formateur)
1135 var client = new Client(util)
1136 var pages = new Pages()
1137
1138 // connexion vers le serveur (utilise un cookie qui traine)
1139 client.connexionCookie()
1140
1141 initialiserListeStyles(client)
1142
1143 // FIXME : ne fonctionne pas sous opera
1144 // voir : http://dev.jquery.com/ticket/2892#preview
1145 $(window).unload(function(){client.flush()})
1146
1147 $("#menu .minichat").click(function(){ pages.afficherPage("minichat") })
1148 $("#menu .admin").click(function(){ pages.afficherPage("admin") })
1149 $("#menu .profile").click(function(){ pages.afficherPage("profile") })
1150 $("#menu .logout").click(function(){
1151 util.messageDialogue("Êtes-vous sur de vouloir vous délogger ?", messageType.question,
1152 {"Oui" : function()
1153 {
1154 client.deconnexion();
1155 pages.afficherPage("minichat", true)
1156 },
1157 "Non" : function(){}
1158 }
1159 )
1160 })
1161 $("#menu .register").click(function(){ pages.afficherPage("register") })
1162 $("#menu .about").click(function(){ pages.afficherPage("about") })
1163
1164 // TODO : simplifier et pouvoir créer des liens par exemple : <span class="lien" href="conditions">Conditions d'utilisation</span>
1165 $("#footer .conditions").click(function(){ pages.afficherPage("conditions_utilisation") })
1166
1167 pages.ajouterPage(new PageMinichat(client, formateur, util))
1168 pages.ajouterPage(new PageAdmin(client, formateur, util))
1169 pages.ajouterPage(new PageProfile(client, formateur, util))
1170 pages.ajouterPage(new PageRegister(client, formateur, util))
1171 pages.ajouterPage(new PageAbout(client, formateur, util))
1172 pages.ajouterPage("conditions_utilisation")
1173
1174 pages.afficherPage("minichat")
1175 }
1176 )