Le principal
[euphorik.git] / js / pageMinichat.js
1 // coding: utf-8
2
3 function PageMinichat(client, formateur, util)
4 {
5 this.nom = "minichat"
6
7 this.client = client
8 this.formateur = formateur
9 this.util = util
10
11 this.regexMessageTagMatch = /\{.*?\}>/g
12 this.regexMessageTagReplace = /^(.*?\{.*?\}>)*/
13 }
14
15 PageMinichat.prototype.contenu = function()
16 {
17 return '\
18 <form method="post" action="">\
19 <p>\
20 <input class="captcha" name="captcha" type="text" size="8" maxlength="8"></input>\
21 <input class="pseudo" name="pseudo" type="text" size="12" maxlength="50" value="&lt;nick&gt;"></input>\
22 <input class="message" name="message" type="text" size="80" maxlength="500" value=""></input>\
23 <button class="smiles"></button>\
24 <button class="return"></button>\
25 </p>\
26 </form>\
27 <div id="conversations"></div>'
28 }
29
30 PageMinichat.prototype.charger = function()
31 {
32 thisPage = this
33
34 jQuery("form input.pseudo").val(this.client.pseudo)
35
36 // cet appel ne doit pas être fait avant l'appel à 'charger'
37 this.messages = new Messages(this.client, this.formateur, this.util)
38
39 this.messages.rafraichirMessages(true)
40
41 this.util.setCaretToEnd(jQuery("form input.message")[0])
42
43 // <smiles>
44 jQuery("body").append("<div id=\"smiles\"></div>")
45 // affichage des smiles
46 jQuery("#smiles").append(this.formateur.getSmilesHTML()).children().each(
47 function(i)
48 {
49 var opacityBase = jQuery(this).css("opacity")
50 jQuery(this).click(
51 function(event)
52 {
53 thisPage.util.replaceSelection(jQuery("form input.message")[0], thisPage.formateur.smiles[jQuery(this).attr("class")][0].source.replace(/\\/g, ""))
54 }
55 )
56 .hover(
57 function()
58 {
59 jQuery(this).animate(
60 {
61 opacity: 1
62 }, 200
63 )
64 },
65 function()
66 {
67 jQuery(this).animate(
68 {
69 opacity: opacityBase
70 }, 200
71 )
72 }
73 )
74 }
75 )
76 jQuery("form button.smiles").hover(
77 function(e)
78 {
79 var offset = jQuery(e.target).offset()
80 jQuery("#smiles").css("top", offset.top).css("left", offset.left).show()
81 },
82 function(e){}
83 )
84 jQuery("#smiles").hover(
85 function(){},
86 function(e)
87 {
88 jQuery("#smiles").hide()
89 }
90 )
91 // </smiles>
92
93 // événements
94 var nouveauMessage =
95 function()
96 {
97 // captcha anti bot
98 if (jQuery("form input.captcha").val() != "") return
99
100 thisPage.envoyerMessage(
101 jQuery("form input.pseudo").val(),
102 jQuery("form input.message").val()
103 )
104
105 jQuery("form input.message")[0].focus()
106 }
107
108 jQuery("form").keypress(
109 function(e)
110 {
111 if (e.which == 13) // return
112 nouveauMessage()
113 }
114 )
115
116 jQuery("form button.return").click(nouveauMessage)
117
118 // interdiction de submiter le formulaire
119 jQuery("form").submit(function(){ return false})
120
121 jQuery("input.pseudo").click(
122 function()
123 {
124 var input = jQuery("input.pseudo")[0]
125 if (input.value == conf.pseudoDefaut)
126 input.value = ""
127 }
128 )
129 }
130
131 PageMinichat.prototype.decharger = function()
132 {
133 //alert(this.attenteCourante)
134 this.messages.stopAttenteCourante()
135
136 jQuery("body #smiles").remove()
137 }
138
139 PageMinichat.prototype.getJSONMessage = function(pseudo, message, repondA)
140 {
141 return {
142 "action" : "put_message",
143 "cookie" : this.client.cookie,
144 "nick" : pseudo,
145 "content" : message,
146 "answer_to" : repondA
147 }
148 }
149
150 PageMinichat.prototype.envoyerMessage = function(pseudo, message)
151 {
152 var thisPageMinichat = this
153
154 // (un pseudo vide est autorisé)
155 pseudo = this.formateur.filtrerInputPseudo(pseudo)
156
157 // extraction des id des messages (en base 36 évidemment) auquels le user répond
158 var repondA = []
159 var tags = message.match(this.regexMessageTagMatch)
160 if (tags != null)
161 {
162 for(var i = 0; i < tags.length; i++)
163 repondA.push(parseInt(/\{(.*?)\}>/.exec(tags[i])[1], 36))
164 message = message.replace(this.regexMessageTagReplace, "")
165 }
166
167 message = message.trim()
168 if (message == "")
169 {
170 this.util.messageDialogue("Le message est vide")
171 return
172 }
173
174 if (!this.client.authentifie())
175 if (!this.client.enregistrement())
176 {
177 this.util.messageDialogue("login impossible")
178 return
179 }
180
181 this.client.pseudo = pseudo
182
183 ;;; dumpObj(this.getJSONMessage(pseudo, message, repondA))
184 jQuery.ajax(
185 {
186 url : "request",
187 type: "POST",
188 data : this.util.jsonVersAction(this.getJSONMessage(pseudo, message, repondA)),
189 dataType : "json",
190 beforeSend : function(xmlHttpRequest)
191 {
192 xmlHttpRequest.setRequestHeader("X-Requested-With", "")
193 },
194 success : function(data, textStatus)
195 {
196 ;;; dumpObj(data)
197
198 if(data["reply"] == "ok")
199 {
200 jQuery("form input.message").val("")
201
202 // met à jour la classe des messages auquel repond celui ci (c'est un peu de la triche)
203 for (var i = 0; i < repondA.length; i++)
204 {
205 jQuery("#conversations div#" + repondA[i]).addClass("repondu")
206 /* Ca sert à rien, TODO : tester/virer
207 for (var c = 0; c < thisPageMinichat.messages.conversations.length; c++)
208 for (var m = 0; m < thisPageMinichat.messages.conversations[c].messages.length; m++)
209 thisPageMinichat.messages.conversations[c].messages[m].clientARepondu = true
210 */
211 }
212 }
213 }
214 }
215 )
216 }
217
218 ///////////////////////////////////////////////////////////////////////////////////////////////////
219
220 function Reponse(id, pseudo, login)
221 {
222 this.id = id
223 this.pseudo = pseudo
224 this.login = login
225
226 if (this.pseudo == undefined)
227 this.pseudo = ""
228
229 if (this.login == undefined)
230 this.login = ""
231 }
232
233 ///////////////////////////////////////////////////////////////////////////////////////////////////
234
235 /**
236 * Représente un message.
237 * @param id (string)
238 * @param date (string)
239 * @param pseudo
240 * @param contenu
241 */
242 function Message(id, date, pseudo, login, contenu)
243 {
244 this.id = id
245 this.date = date
246 this.pseudo = pseudo
247 this.login = login
248 this.contenu = contenu
249
250 this.appartientAuClient = false
251 this.clientARepondu = false
252 this.estUneReponse = false
253 this.ekMaster = false
254
255 this.systeme = false // est-ce un message 'système' ?
256
257 this.repondA = {} // un ensemble de reponse (voir Reponse) indexé par l'id du message de la reponses
258 }
259
260 /**
261 *
262 */
263 Message.prototype.setRepondA = function(repondAJSON)
264 {
265 var thisMessage = this
266 this.repondA = {}
267
268 for(var i = 0; i < repondAJSON.length; i++)
269 {
270 thisMessage.repondA[repondAJSON[i]["id"]] = new Reponse(
271 repondAJSON[i]["id"],
272 repondAJSON[i]["nick"],
273 repondAJSON[i]["login"]
274 )
275 }
276 }
277
278 /**
279 * Renvoie les messages faisant partie d'une conversation.
280 * @param messages l'ensemble des messages de la conversation
281 * @return les id des messages qui ont été mis en evidence sous la forme d'un hash (object) {id => bool}
282 */
283 Message.prototype.getConversation = function(messages)
284 {
285 // les messages faisant partie de la conversation
286 var messagesEnEvidence = {}
287
288 messagesEnEvidence[this.id] = true
289
290 // recherche les réponses (O(n))
291 for (var i = 0; i < messages.messages.length; i++)
292 if (messages.messages[i].repondA.hasOwnProperty(this.id))
293 messagesEnEvidence[messages.messages[i].id] = true
294
295 var f = function(tabIds)
296 {
297 for(var id in tabIds)
298 {
299 var message = messages.messagesParId[id]
300 if (message != undefined)
301 {
302 messagesEnEvidence[id] = true
303 f (message.repondA)
304 }
305 }
306 }
307 f(this.repondA)
308
309 return messagesEnEvidence
310 }
311
312 ///////////////////////////////////////////////////////////////////////////////////////////////////
313
314 /**
315 * Représente une conversation.
316 * @param numConv le numéro (appelé id) de la conversation
317 * @param formateur outil permettant la mise en forme du texte des messages
318 */
319 function Conversation(num, util, formateur, client)
320 {
321 var thisConversation = this
322
323 this.num = num // peut changer au cours de la vie de la conversation
324 this.id = Math.random() * 100000000000000000
325 this.messageOver = null // le message sur lequel se trouve le curseur
326 this.util = util
327 this.formateur = formateur
328 this.client = client
329 this.idDernierMessageAffiche = 0
330
331 this.messages = new Array()
332 this.messagesParId = new Object()
333
334 this.nbMessageMax = conf.nbMessageAffiche // Le nombre de message affiché par page
335
336 jQuery("#conversations").append(
337 '<div id="' + this.getId() + '" class="conversation">\
338 <div class="titre">' +
339 (num == 0 ? '' : '<div class="fermer">x</div><div class="lien">c</div>') +
340 '<span class="next">&lt;</span><span class="numPage">1</span><span class="prev">&gt;</span>\
341 </div>\
342 </div>'
343 )
344
345 // enlève la mise en évidence pour la conversation
346 jQuery("#conversations #" + this.getId()).hover(
347 function(){},
348 function(event)
349 {
350 jQuery("#conversations .message").removeClass("cache")
351 thisConversation.messageOver = null
352 }
353 )
354 }
355
356 /**
357 * Défini la page courante et s'il l'on se trouve sur la dernière page.
358 * @pageCourante la page courante
359 * @dernierePage true si c'est la dernière page sinon false
360 */
361 Conversation.prototype.setPage = function(pageCourante, dernierePage)
362 {
363 jQuery("#conversations #" + this.getId() + " .numPage").text(pageCourante)
364 jQuery("#conversations #" + this.getId() + " .next").css("display", pageCourante == 1 ? "none" : "inline")
365 jQuery("#conversations #" + this.getId() + " .prev").css("display", dernierePage ? "none" : "inline")
366 }
367
368 /**
369 * Evenement déclanché lors de l'insertion du lien de la conversation dans le message courant.
370 */
371 Conversation.prototype.eventLien = function(fun)
372 {
373 var thisConversation = this
374
375 jQuery("#conversations #" + this.getId() + " .titre .lien").click(
376 function()
377 {
378 fun(thisConversation.num)
379 }
380 )
381 }
382
383 /**
384 * Evenement déclanché lors de la fermeture de la conversation.
385 */
386 Conversation.prototype.eventFermer = function(fun)
387 {
388 var thisConversation = this
389
390 jQuery("#conversations #" + this.getId() + " .titre .fermer").click(
391 function()
392 {
393 fun(thisConversation.num)
394 }
395 )
396 }
397
398 /**
399 * @funNext appelé lorsque l'on passe à la page suivante (de 2 à 1 par exemple)
400 * @funPrev appelé lorsque l'on passe à la page précédente (de 1 à 2 par exemple)
401 * @funReset appelé lorsque l'on souhaite revenir à la page une
402 */
403 Conversation.prototype.setFunPage = function(funNext, funPrev, funReset)
404 {
405 var thisConversation = this
406
407 jQuery("#conversations #" + this.getId() + " .next").click(
408 function() { funNext(thisConversation.num) }
409 )
410 jQuery("#conversations #" + this.getId() + " .prev").click(
411 function() { funPrev(thisConversation.num) }
412 )
413 jQuery("#conversations #" + this.getId() + " .numPage").click(
414 function() { funReset(thisConversation.num) }
415 )
416 }
417
418 /**
419 * Retourne l'id de la conversation sous la forme (par exemple) "conv3".
420 */
421 Conversation.prototype.getId = function()
422 {
423 return "conv" + this.id
424 }
425
426 Conversation.prototype.ajouterMessage = function(message)
427 {
428 this.messages.push(message)
429 this.messagesParId[message.id] = message
430 if (this.messages.length > this.nbMessageMax)
431 delete this.messagesParId[this.messages.shift().id]
432 }
433
434 /**
435 * FIXME : méthode très lourde. ne serait-ce pas mieux de virer d'un coup l'élément conversation et d'en remettre un vide ?
436 */
437 Conversation.prototype.viderMessages = function()
438 {
439 this.messages = new Array()
440 this.idDernierMessageAffiche = 0
441 jQuery("#conversations #" + this.getId() + " .message").remove()
442 }
443
444 /**
445 * Après l'ajout d'un ou plusieurs message cette méthode est appelée afin
446 * d'afficher les messages non-affichés.
447 * FIXME : méthode super lourde, à optimiser.
448 * @param funClickExtract fonction (fun(numMess)) appellée lors du clic sur un bouton "extraire"
449 */
450 Conversation.prototype.flush = function(funClickOuvrirConv)
451 {
452 var thisConversation = this
453
454 // est-ce que le prochain message est pair ? (permet d'alterner le style des messages)
455 var messagePair = (this.idDernierMessageAffiche == 0 ? true :
456 (jQuery("#conversations #" + this.getId() + " div:first").attr("class").search("messagePair") == -1)
457 )
458
459 // construction de l'XHTML des messages
460 var XHTML = ""
461 for (var i = this.messages.length - 1; i >= 0; i--)
462 if (this.messages[i].id > this.idDernierMessageAffiche)
463 {
464 var message = this.messages[i]
465
466 // construit l'identifiant de la personne
467 var identifiant =
468 this.client.nickFormat == "nick" ? this.formateur.traitementComplet(message.pseudo) :
469 (this.client.nickFormat == "login" ? this.formateur.traitementComplet(message.login) :
470 this.formateur.traitementComplet(message.pseudo) + "<span class=\"login\">(" + this.formateur.traitementComplet(message.login) +")</span>" )
471
472 var XHTMLrepondA = ""
473 for (var id in message.repondA)
474 XHTMLrepondA += this.formateur.traitementComplet(message.repondA[id].pseudo) + "&gt; "
475 XHTMLrepondA = "<span class=\"repondA\">" + XHTMLrepondA + "</span>"
476
477 XHTML +=
478 "<div id=\"" + message.id.toString(36) + "\" class=\"" + (messagePair ? "messagePair" : "messageImpair") + " message" +
479 (this.messages[i].appartientAuClient ? " proprietaire" : "") +
480 (this.messages[i].clientARepondu ? " repondu" : "") +
481 (this.messages[i].estUneReponse ? " reponse" : "") +
482 (this.messages[i].systeme ? " systeme" : "") +
483 (this.messages[i].ekMaster ? " ekMaster" : "") +
484 "\">" +
485 "<div class=\"extraire\">&gt;</div>" +
486 "[<span class=\"date\">" + message.date + "</span>]" +
487 "<span class=\"pseudo\">" + identifiant + "</span>:" +
488 XHTMLrepondA +
489 "<span class=\"contenu\">" + (message.systeme ? this.formateur.remplacerBalisesHTML(message.contenu) : this.formateur.traitementComplet(message.contenu, message.pseudo)) + "</span>" +
490 "</div>"
491
492 messagePair = !messagePair
493 }
494
495 jQuery("#conversations #" + this.getId()).prepend(XHTML)
496
497 // mise à jour des images (LightBox) après l'ajout de message
498 if (myLightbox != null)
499 myLightbox.updateImageList()
500
501 // enlève les messages exedentaires
502 var nbMessagesAffiche = jQuery("#conversations #" + this.getId() + " .message").size()
503
504 if (nbMessagesAffiche > this.nbMessageMax)
505 jQuery("#conversations #" + this.getId() + " .message").slice(this.nbMessageMax, nbMessagesAffiche).empty()
506
507 // ajoute les événements liés à chaque nouveau message
508 jQuery("#conversations #" + this.getId() + " .message").filter(function(){return parseInt(jQuery(this).attr("id"), 36) > thisConversation.idDernierMessageAffiche}).each(
509 function()
510 {
511 jQuery(".lienConv", this).click(
512 function(event)
513 {
514 // FIXME : ya pas mieux ?
515 var racine = jQuery(event.target).text()
516 funClickOuvrirConv(parseInt(racine.substring(1, racine.length - 1), 36))
517 return false
518 }
519 )
520
521 jQuery(this).click(
522 function(event)
523 {
524 if (jQuery(event.target).is("a")) return
525
526 // l'id du message
527 idMess = jQuery(this).attr("id")
528
529 // extraction d'une conversation
530 if (jQuery(event.target).is(".extraire"))
531 {
532 funClickOuvrirConv(parseInt(idMess, 36))
533 return
534 }
535
536 var valCourant = jQuery("input.message").val()
537 if (valCourant == undefined) valCourant = ""
538 var tag = jQuery(".pseudo", this).text() + "{" + idMess + "}" + ">"
539 if (valCourant.indexOf(tag, 0) == -1)
540 jQuery("input.message").val(tag + " " + valCourant)
541 thisConversation.util.setCaretToEnd(jQuery("form input.message")[0])
542 }
543 )
544 // Q : pourquoi pas un .hover ?
545 // R : simplement pour éviter que lorsqu'un message arrive cela n'affecte la conversation actuellement mise en évidence (uniquement pour Firefox)
546 .mousemove(
547 function(e)
548 {
549 if (this !== thisConversation.messageOver)
550 {
551 thisConversation.afficherConversation(this)
552 thisConversation.messageOver = this
553 }
554 }
555 )
556 }
557 )
558
559 if (this.messages.length > 0)
560 this.idDernierMessageAffiche = this.messages[this.messages.length-1].id
561 }
562
563 /**
564 * Etablit une liste des messages à mettre en evidence et des messages à cacher.
565 * Puis applique un plan diabolique.
566 * @param element un message de la liste des messages
567 */
568 Conversation.prototype.afficherConversation = function(element)
569 {
570 // cherche le message selectionné
571 var id = parseInt(jQuery(element).attr("id"), 36)
572
573 var message = this.messagesParId[id]
574 if (message == undefined) return
575
576 mess = message.getConversation(this)
577
578 // FIXME : cet appel est très lent
579 jQuery("#conversations #" + this.getId() + " .message").each(
580 function()
581 {
582 var jq = jQuery(this)
583 if (!mess.hasOwnProperty(parseInt(jq.attr("id"), 36)))
584 jq.addClass("cache")
585 else
586 jq.removeClass("cache")
587 }
588 )
589 }
590
591 /**
592 * Supprime une conversation.
593 */
594 Conversation.prototype.supprimer = function()
595 {
596 jQuery("#conversations #" + this.getId()).remove()
597 }
598
599 ///////////////////////////////////////////////////////////////////////////////////////////////////
600
601 /**
602 * Représente l'ensemble des messages affichés.
603 */
604 function Messages(client, formateur, util)
605 {
606 var thisMessages = this
607
608 this.client = client
609 this.formateur = formateur
610 this.util = util
611
612 this.conversations = new Array() // les conversations, la première représente la conversation principale
613 this.nouvelleConversation(0)
614
615 // Obsolète
616 //this.idDernierMessage = null // l'id du dernier message connu
617
618 // l'objet JSONHttpRequest représentant la connexion d'attente
619 this.attenteCourante = null
620 }
621
622 /**
623 * Crée un message JSON contenant le message demandant un rafraichissement.
624 */
625 Messages.prototype.getJSONrafraichirMessages = function()
626 {
627 var mess = {
628 "action" : "wait_event",
629 "page" : "chat",
630 "message_count" : conf.nbMessageAffiche,
631 "main_page" : this.client.pagePrincipale,
632 "conversations" : this.getJSONConversations()
633 }
634
635 if (this.client.cookie != null) mess["cookie"] = this.client.cookie;
636 mess["last_message_id"] = this.conversations[0].idDernierMessageAffiche
637
638 // obsolète
639 //if (this.idDernierMessage != null) mess["last_message_id"] = this.idDernierMessage
640
641 return mess
642 }
643
644 Messages.prototype.getJSONConversations = function()
645 {
646 var clientConv = this.client.getJSONConversations()
647 for (var i = 1; i < this.conversations.length; i++)
648 {
649 clientConv[i-1]["last_message_id"] = this.conversations[i].idDernierMessageAffiche
650 }
651 return clientConv
652 }
653
654 /**
655 * Ajoute un ensemble de messages puis les affiches.
656 * @param elements un tableau d'éléments JSON représentant les messages, voir protocole.txt
657 * @param numConversation le numéro de la conversation auquel appartiennent les messages
658 * @return true si les messages on été ajoutés, false si la conversation n'existe pas et qu'il n'y a pas de message
659 */
660 Messages.prototype.ajouterMessages = function(elements, numConversation)
661 {
662 if (elements["messages"].length == 0 && typeof(this.conversations[numConversation]) == "undefined")
663 return false
664
665 for (var i = 0; i < elements["messages"].length; i++)
666 this.ajouterMessage(elements["messages"][i], numConversation)
667 this.flush(numConversation)
668
669 // renseigne la conversation sur la page courante et si c'est la dernière
670 this.conversations[numConversation].setPage(
671 numConversation == 0 ? this.client.pagePrincipale : this.client.conversations[numConversation - 1].page,
672 elements["last_page"]
673 )
674
675 return true
676 }
677
678 /**
679 * Création d'un nouveau message.
680 * Les message sont données dans l'ordre de leur id.
681 * @param element un element JSON représentant le message
682 * @param numConversation le numéro de la conversation, 0 = principale
683 */
684 Messages.prototype.ajouterMessage = function(element, numConversation)
685 {
686 var thisMessages = this
687
688 // pas d'utilisation de jquery pour des raisons de performance
689 var id = element["id"]
690
691 var message = new Message(
692 id,
693 element["date"],
694 element["nick"],
695 element["login"],
696 element["content"]
697 )
698
699 message.appartientAuClient = element["owner"]
700 message.clientARepondu = element["answered"]
701 message.estUneReponse = element["is_a_reply"]
702 message.systeme = element["system"]
703 message.setRepondA(element["answer_to"])
704 message.ekMaster = element["ek_master"]
705
706 if (this.conversations[numConversation] == null)
707 {
708 this.nouvelleConversation(
709 numConversation,
710 function(num) // fermeture de la conversation
711 {
712 thisMessages.supprimerConversation(num)
713 },
714 function(num) // insertion du lien vers la conversation
715 {
716 thisPage.util.replaceSelection(
717 jQuery("form input.message")[0],
718 "{" + thisMessages.client.conversations[num-1].root.toString(36) + "}"
719 )
720 }
721 )
722 }
723
724 this.conversations[numConversation].ajouterMessage(message)
725 }
726
727 Messages.prototype.nouvelleConversation = function(num, funFermer, funLien)
728 {
729 var thisMessages = this
730
731 this.conversations[num] = new Conversation(num, this.util, this.formateur, this.client)
732 if (funFermer != undefined)
733 this.conversations[num].eventFermer(funFermer)
734 if (funLien != undefined)
735 this.conversations[num].eventLien(funLien)
736
737 this.conversations[num].setFunPage(
738 function(num) // page suivante
739 {
740 thisMessages.client.pageSuivante(num - 1)
741 thisMessages.rafraichirMessages(true)
742 },
743 function(num) // page précédente
744 {
745 thisMessages.client.pagePrecedente(num - 1)
746 thisMessages.rafraichirMessages(true)
747 },
748 function(num) // retour à la page une
749 {
750 if (thisMessages.client.goPremierePage(num - 1))
751 thisMessages.rafraichirMessages(true)
752 }
753 )
754
755 this.ajusterLargeurConversations()
756 }
757
758 /**
759 * Enlève une conversation.
760 */
761 Messages.prototype.supprimerConversation = function(num)
762 {
763 if (num <= 0 || num >= this.conversations.length) return // la numéro 0 ne peut être supprimé
764 this.conversations[num].supprimer()
765
766 // décalage TODO : supprimer le dernier élément
767 for (var i = num; i < this.conversations.length - 1; i++)
768 {
769 this.conversations[i] = this.conversations[i+1]
770 this.conversations[i].num -= 1
771 }
772 this.conversations.pop()
773 this.ajusterLargeurConversations()
774
775 this.client.supprimerConversation(num-1)
776
777 this.rafraichirMessages(true)
778 }
779
780 /**
781 * Ajuste la largeur des conversations en fonction de leur nombre. modifie l'attribut CSS 'width'.
782 */
783 Messages.prototype.ajusterLargeurConversations = function()
784 {
785 jQuery("#conversations .conversation").css("width", 100 / this.conversations.length + "%")
786 }
787
788 /**
789 * Demande à toutes les conversations de se flusher (afficher les messages non-affichés).
790 */
791 Messages.prototype.flushAll = function()
792 {
793 for (var i = 0; i < this.conversations.length; i++)
794 this.flush(i)
795 }
796
797 /**
798 * Demande à une conversation de se flusher.
799 */
800 Messages.prototype.flush = function(numConv)
801 {
802 var thisMessages = this
803
804 this.conversations[numConv].flush(
805 function(racine) // appelé lorsqu'un utilisateur click sur un lien vers une conversation
806 {
807 thisMessages.ouvrirConversation(racine)
808 }
809 )
810 }
811
812 Messages.prototype.ouvrirConversation = function(racine)
813 {
814 if (this.client.ajouterConversation(racine))
815 this.rafraichirMessages(true)
816 else
817 this.util.messageDialogue("Cette conversation est déjà ouverte")
818 }
819
820 Messages.prototype.viderMessages = function()
821 {
822 // Obsolète
823 //this.idDernierMessage = null
824
825 for (var i = 0; i < this.conversations.length; i++)
826 this.conversations[i].viderMessages()
827 }
828
829 /**
830 * Arrete l'attente courante s'il y en a une.
831 */
832 Messages.prototype.stopAttenteCourante = function()
833 {
834 if (this.attenteCourante != null)
835 this.attenteCourante.abort()
836 }
837
838 /**
839 * Met à jour les messages de manière continue.
840 * (AJAX-Comet-style proof)
841 * @param vider vide tous les messages avant d'afficher les nouveaux
842 */
843 Messages.prototype.rafraichirMessages = function(vider)
844 {
845 var thisMessages = this // caisupair javacrypte
846
847 if (vider == undefined)
848 vider = false
849
850 this.stopAttenteCourante()
851
852 /*if (vider)
853 this.idDernierMessage = null*/
854 if (vider)
855 for (var i = 0; i < this.conversations.length; i++)
856 this.conversations[i].idDernierMessageAffiche = 0
857
858 dumpObj(this.getJSONrafraichirMessages())
859 this.attenteCourante = jQuery.ajax({
860 type: "POST",
861 url: "request",
862 dataType: "json",
863 data: this.util.jsonVersAction(this.getJSONrafraichirMessages()),
864 success:
865 function(data)
866 {
867 ;;; dumpObj(data)
868
869 if (vider)
870 thisMessages.viderMessages()
871
872 // ajoute les messages reçus à leur conversation respective
873 for (var numConv = 0; numConv < data["conversations"].length; numConv++)
874 {
875 // ya pas de nouveaux message -> on passe à la prochaine conversation FIXME : marche pas
876 //if (data["conversations"][numConv]["messages"].length == 0) continue
877
878 if (! thisMessages.ajouterMessages(data["conversations"][numConv], numConv))
879 {
880 thisMessages.util.messageDialogue("La conversation {" + thisMessages.client.conversations[numConv -1].root.toString(36) + "} n'existe pas")
881 thisMessages.client.supprimerConversation(numConv - 1)
882 }
883 }
884
885 // rappel de la fonction dans 100 ms
886 setTimeout(function(){ thisMessages.rafraichirMessages() }, 100);
887 },
888 error:
889 function(XMLHttpRequest, textStatus, errorThrown)
890 {
891 setTimeout(function(){ thisMessages.rafraichirMessages() }, 1000);
892 }
893 })
894 }