js/pageMinichat.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 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  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 function PageMinichat(client, formateur, util)
  20 {
  21    this.nom = "minichat"
  22
  23    this.client = client
  24    this.formateur = formateur
  25    this.util = util
  26
  27    // permet d'éviter d'envoyer plusieurs messages simultanément en pressant
  28    // rapidement sur "enter" par exemple
  29    this.envoieMessageEnCours = false
  30
  31    this.regexMessageTagMatch = /\{.*?\}>/g
  32    this.regexMessageTagReplace =  /^(.*?\{.*?\}>)*/
  33 }
  34
  35 PageMinichat.prototype.contenu = function()
  36 {
  37    // le fait que tout soit collé est fait exprès, permet d'éviter d'avoir des espaces supplémentaires entre les spans'
  38    var formulaireXHTML = '<form method="post" action="" id ="posterMessage">\
  39 <p>\
  40 <input class="captcha" name="captcha" type="text" size="8" maxlength="8"></input>\
  41 <input class="pseudo" name="pseudo" type="text" maxlength="50" value="' + encodeURI(conf.nickDefaut) + '"></input>\
  42 <span id="repondA"><span class="nb">0</span><span class="messages"></span></span>\
  43 <input class="message" name="message" type="text" maxlength="500" value=""></input>\
  44 <button class="smiles"></button>\
  45 <button class="return"></button>\
  46 </p>\
  47 </form>'
  48    var trollXHTML = '<div id="trollCourant">Troll de la semaine : <span class="troll"></span></div>'
  49    //var titreXHTML = '<tr id="titres"></tr>'
  50    //var messagesXHTML = '<tr id="messages"></tr>'
  51    var conversationXHTML = '<table id="conversations"><tr></tr></table>'
  52
  53    if (this.client.chatOrder == "reverse")
  54       return trollXHTML + formulaireXHTML + conversationXHTML
  55    else
  56       return trollXHTML + conversationXHTML + formulaireXHTML
  57 }
  58
  59 PageMinichat.prototype.classes = function()
  60 {
  61    return this.client.chatOrder == "reverse" ? "orderReverse" : "orderChrono"
  62 }
  63
  64 PageMinichat.prototype.charger = function()
  65 {
  66    thisPage = this
  67
  68    $("form input.pseudo").val(this.client.pseudo)
  69
  70    // cet appel ne doit pas être fait avant l'appel à 'charger'
  71    this.conversations = new Conversations(this.client, this.formateur, this.util)
  72
  73    this.conversations.rafraichirMessages(true)
  74
  75    this.util.setCaretToEnd($("form input.message")[0])
  76
  77    // les outils de bannissement (uniquement pour les ekMaster)
  78    if (this.client.ekMaster)
  79    {
  80       this.util.outilsBan = $(
  81          '<span id="outilsBan">' +
  82          '<form action=""><p><input id="raison" name="raison" type="text" size="10" maxlength="200"></input></p></form>' +
  83          '<img id="ban" src="img/ban.gif" alt="Ban de 3 jours" />' +
  84          '<img id="kick" src="img/kick.gif" alt="Ban de 15min" />' +
  85          '<img id="slap" src="img/slap.gif" alt="Avertissement" />' +
  86          '</span>'
  87       )
  88
  89       this.util.infoBulle("Slap", $("#slap", this.util.outilsBan))
  90       this.util.infoBulle("Kick (" + conf.tempsKick + "min)", $("#kick", this.util.outilsBan))
  91       this.util.infoBulle("Ban (" + conf.tempsBan / 24 / 60 + " jours)", $("#ban", this.util.outilsBan))
  92       this.util.infoBulle("La raison", $("input", this.util.outilsBan))
  93    }
  94
  95    this.util.infoBulle("Ouvrir la conversation liée au troll de la semaine", $("#trollCourant .troll"))
  96
  97    this.util.infoBulle("Cliquer sur les messages pour les enlevers de la liste",
  98       $("form#posterMessage #repondA").hover(
  99          function() { thisPage.util.afficherBoite($(".messages", this), $(this), positionTypeX.centre, positionTypeY.bas) },
 100          function() { $(".messages", this).hide() }
 101       ).click(
 102          function(e)
 103          {
 104             if ($(e.target).is(".nb"))
 105                thisPage.conversations.enleverMessagesRepond()
 106          }
 107       ),
 108       positionBulleType.droite
 109    )
 110
 111    // <smiles>
 112    $("body").append('<div id="smiles"></div>')
 113    // affichage des smiles
 114    $("#smiles").append(this.formateur.getSmilesHTML()).children().each(
 115       function(i)
 116       {
 117          var opacityBase = $(this).css("opacity")
 118          $(this).click(
 119             function()
 120             {
 121                thisPage.util.replaceSelection($("form#posterMessage input.message")[0], thisPage.formateur.smiles[$(this).attr("class")][0].source.replace(/\\/g, ""))
 122             }
 123          ).hover(
 124             function() { $(this).animate({opacity: 1}, 200) },
 125             function() { $(this).animate({opacity: opacityBase}, 200) }
 126          )
 127       }
 128    )
 129    $("form button.smiles").hover(
 130       // affichage de la boite présentant les smiles
 131       function(e){ thisPage.util.afficherBoite($("#smiles"), $(e.target), positionTypeX.centre, positionTypeY.basRecouvrement) },
 132       function(){}
 133    )
 134    $("#smiles").hover(
 135       function(){},
 136       function()
 137       {
 138          $("#smiles").hide()
 139       }
 140    )
 141    // </smiles>
 142
 143    // événements
 144    var nouveauMessage =
 145       function()
 146       {
 147          // captcha anti bot
 148          if ($("form input.captcha").val() != "") return
 149
 150          thisPage.envoyerMessage(
 151             $("form input.pseudo").val(),
 152             $("form input.message").val()
 153          )
 154
 155          $("form input.message").focus()
 156       }
 157
 158    $("form").keypress(
 159       function(e)
 160       {
 161          if (e.which == 13) // return
 162             nouveauMessage()
 163       }
 164    )
 165
 166    $("form button.return").click(nouveauMessage)
 167
 168    // interdiction de submiter le formulaire
 169    $("form").submit(function(){ return false})
 170
 171    $("input.pseudo").click(
 172       function()
 173       {
 174          var input = $("input.pseudo")[0]
 175          if (input.value == conf.pseudoDefaut)
 176             input.value = ""
 177       }
 178    )
 179 }
 180
 181 PageMinichat.prototype.decharger = function()
 182 {
 183    this.conversations.pageEvent.stopAttenteCourante()
 184
 185    $("body #smiles").remove()
 186 }
 187
 188 PageMinichat.prototype.getJSONMessage = function(pseudo, message)
 189 {
 190    var repondA = []
 191    for (var id in this.conversations.messagesRepond)
 192       repondA.push(parseInt(id)) // FIXME : une propriété ne peut pas être de type int ?
 193
 194    return {
 195       "header" : { "action" : "put_message", "version" : conf.versionProtocole },
 196       "cookie" : this.client.cookie,
 197       "nick" : pseudo,
 198       "content" : message,
 199       "answer_to" : repondA
 200    }
 201 }
 202
 203 PageMinichat.prototype.envoyerMessage = function(pseudo, message)
 204 {
 205    var thisPageMinichat = this
 206
 207    // (un pseudo vide est autorisé)
 208    pseudo = this.formateur.filtrerInputPseudo(pseudo)
 209
 210    if (pseudo == conf.nickDefaut)
 211    {
 212       this.util.messageDialogue("Le pseudo ne peut pas être " + conf.nickDefaut)
 213       return
 214    }
 215
 216    message = message.trim()
 217    if (message == "")
 218    {
 219       this.util.messageDialogue("Le message est vide")
 220       return
 221    }
 222
 223    if (!this.client.authentifie())
 224       if (!this.client.enregistrement())
 225       {
 226          this.util.messageDialogue("login impossible")
 227          return
 228       }
 229
 230    this.client.pseudo = pseudo
 231
 232    // évite le double post
 233    if (this.envoieMessageEnCours)
 234    {
 235       this.util.messageDialogue("Message en cours d'envoie...")
 236       return
 237    }
 238    this.envoieMessageEnCours = true
 239
 240    jQuery.ajax(
 241       {
 242          url : "request",
 243          type: "POST",
 244          data : this.util.jsonVersAction(this.getJSONMessage(pseudo, message)),
 245          dataType : "json",
 246          beforeSend : function(xmlHttpRequest)
 247          {
 248             // TODO : ça marche ça ??
 249             xmlHttpRequest.setRequestHeader("X-Requested-With", "")
 250          },
 251          success : function(data, textStatus)
 252          {
 253             if(data["reply"] == "ok")
 254             {
 255                // met à jour la classe des messages auquel repond celui ci (c'est un peu de la triche) TODO : ya mieux ?
 256                for (var messId in thisPageMinichat.conversations.messagesRepond)
 257                {
 258                   for (var j = 0; j < thisPageMinichat.conversations.conversations.length; j++)
 259                   {
 260                      var mess = thisPageMinichat.conversations.conversations[j].messagesParId[messId]
 261                      if (mess != undefined)
 262                         mess.clientARepondu = true
 263                   }
 264                   // TODO : ca sert à qque chose ?
 265                   //$("#conversations div#" + thisPageMinichat.conversations.messagesRepond[messId].getId()).addClass("repondu")
 266                }
 267
 268                $("form input.message").val("")
 269                thisPageMinichat.conversations.enleverMessagesRepond()
 270             }
 271             else if (data["reply"] == "error")
 272             {
 273                thisPageMinichat.util.messageDialogue(data["error_message"])
 274             }
 275             thisPageMinichat.envoieMessageEnCours = false
 276          },
 277          error : function()
 278          {
 279             thisPageMinichat.envoieMessageEnCours = false
 280          }
 281       }
 282    )
 283 }
 284
 285 ///////////////////////////////////////////////////////////////////////////////////////////////////
 286
 287 function Reponse(id, pseudo, login)
 288 {
 289    this.id = id
 290    this.pseudo = pseudo
 291    this.login = login
 292
 293    if (this.pseudo == undefined)
 294       this.pseudo = ""
 295
 296    if (this.login == undefined)
 297       this.login = ""
 298 }
 299
 300 ///////////////////////////////////////////////////////////////////////////////////////////////////
 301
 302 /**
 303   * Représente un message.
 304   */
 305 function Message(client, formateur, element)
 306 {
 307    this.client = client
 308    this.formateur = formateur
 309
 310    this.id = element["id"]
 311    this.auteurId = element["user_id"]
 312    this.racineId = element["root"]
 313    this.date = element["date"]
 314    this.pseudo = element["nick"]
 315    this.login = element["login"]
 316    this.contenu = element["content"]
 317
 318    this.appartientAuClient = element["owner"]
 319    this.clientARepondu = element["answered"]
 320    this.estUneReponse = element["is_a_reply"]
 321    this.systeme = element["system"] // est-ce un message 'système' ?
 322    this.setRepondA(element["answer_to"]) // un ensemble de reponse (voir Reponse) indexé par l'id du message de la reponses
 323    this.ekMaster = element["ek_master"]
 324    this.degreeOstentatoire = element["ostentatious_master"]
 325 }
 326
 327 /**
 328   * @param pre est un prefix permettant de créer un Id différent pour deux mêmes messages.
 329   *   Cela est utile pour afficher plusieurs mêmes messages au sein d'un document XHTML.
 330   *   voir également la fonction 'XHTML()'.
 331   */
 332 Message.prototype.getId = function(pre)
 333 {
 334    if (pre == undefined)
 335       pre = ""
 336    return pre + "mess" + this.id.toString(36)
 337 }
 338
 339 /**
 340   *
 341   */
 342 Message.prototype.setRepondA = function(repondAJSON)
 343 {
 344    var thisMessage = this
 345    this.repondA = {}
 346
 347    for(var i = 0; i < repondAJSON.length; i++)
 348    {
 349       thisMessage.repondA[repondAJSON[i]["id"]] = new Reponse(
 350          repondAJSON[i]["id"],
 351          repondAJSON[i]["nick"],
 352          repondAJSON[i]["login"]
 353       )
 354    }
 355 }
 356
 357 /**
 358   * Renvoie les messages faisant partie d'une conversation.
 359   * @param messages l'ensemble des messages de la conversation
 360   * @return les id des messages qui ont été mis en evidence sous la forme
 361   *   d'un hash (object) {id => 0 | 1 | 2 | 3}. 1 : proprietaire, 2 : reponse directe, 3 : message repondu
 362   */
 363 Message.prototype.getConversation = function(messages)
 364 {
 365    var thisMessage = this
 366
 367    // les messages faisant partie de la conversation
 368    var messagesEnEvidence = {}
 369
 370    messagesEnEvidence[this.id] = 1
 371
 372    // recherche les réponses (O(n))
 373    for (var i = 0; i < messages.messages.length; i++)
 374       if (messages.messages[i].repondA.hasOwnProperty(this.id))
 375          messagesEnEvidence[messages.messages[i].id] = 2
 376
 377    // parcours en
 378    var f = function(tabIds, premierNiveau)
 379    {
 380       for(var id in tabIds)
 381       {
 382          // si le message (id) a déjà été traité
 383          if (messagesEnEvidence[id] != undefined && !premierNiveau)
 384             continue
 385
 386          var message = messages.messagesParId[id]
 387          if (message != undefined)
 388          {
 389             messagesEnEvidence[id] = premierNiveau ? 3 : (message.auteurId == thisMessage.auteurId ? 1 : 0)
 390             f (message.repondA, false)
 391          }
 392       }
 393    }
 394    f(this.repondA, true)
 395
 396    return messagesEnEvidence
 397 }
 398
 399 /**
 400   * Renvoie le message sous la forme de code XHTML (string) prêt à être inséré dans un document.
 401   * Aucun callback n'est affecté.
 402   */
 403 Message.prototype.XHTML = function(messagePair, pre)
 404 {
 405    if (messagePair == undefined)
 406       messagePair = true
 407    if (pre == undefined)
 408       pre = ""
 409
 410    // construit l'identifiant de la personne
 411    var identifiant =
 412       this.client.nickFormat == "nick" || this.login == "" ? this.formateur.traitementComplet(this.pseudo) :
 413       (this.client.nickFormat == "login" ? this.formateur.traitementComplet(this.login) :
 414       this.formateur.traitementComplet(this.pseudo) + "<span class=\"login\">(" + this.formateur.traitementComplet(this.login) +")</span>" )
 415
 416    var XHTMLrepondA = ""
 417    var debut = true
 418    for (var id in this.repondA)
 419    {
 420       if (!debut) XHTMLrepondA += ", "
 421       XHTMLrepondA += this.formateur.traitementComplet(this.repondA[id].pseudo)
 422       debut = false
 423    }
 424    if (XHTMLrepondA != "")
 425       XHTMLrepondA = "<span class=\"repondA\">" + XHTMLrepondA + "</span><span class=\"delimitationRepondA\"></span>"
 426
 427    return "<div id=\"" + this.getId(pre) + "\" class=\"" + (messagePair ? "messagePair" : "messageImpair") + " message" +
 428          (this.appartientAuClient ? " proprietaire" : "")  +
 429          (this.clientARepondu ? " repondu" : "") +
 430          (this.estUneReponse ? " reponse" : "") +
 431          (this.systeme ? " systeme" : "") +
 432          (this.ekMaster ? " ekMaster" + this.degreeOstentatoire : "") +
 433       "\">" +
 434          "<div class=\"outilsMess\"><div class=\"extraire\"></div><div class=\"extraireCompletement\"></div></div><span class=\"entete\">" +
 435          "<span class=\"dateComplete\">[<span class=\"date\">" + this.date + "</span>]</span>" +
 436          "<span class=\"pseudo\"><span class=\"id\" style=\"display: none\">" + this.auteurId + "</span class=\"ident\">" + identifiant + "</span></span><span class=\"delimitationEntete\"></span>" +
 437          XHTMLrepondA +
 438          "<span class=\"contenu\">" + this.formateur.traitementComplet(this.contenu, this.pseudo) + "</span>" +
 439       "</div>"
 440 }
 441
 442 ///////////////////////////////////////////////////////////////////////////////////////////////////
 443
 444 /**
 445   * Représente une conversation.
 446   * Une conversation, au niveau XHTML, est formé de deux partie, le titre et les messages.
 447   * Le titre comprend la navigation par page, un bouton pour la fermer, un bouton pour la plier, un bouton
 448   * pour créer un lien ainsi que le premier message.
 449   * @param conversations l'ensemble des conversations
 450   * @param num le numéro de la conversation
 451   */
 452 function Conversation(conversations, num)
 453 {
 454    this.conversations = conversations
 455    this.num = num // peut changer au cours de la vie de la conversation, n'est pas un id !
 456    this.id = Math.floor(Math.random() * 1000000).toString(36)
 457
 458    this.util = this.conversations.util
 459    this.formateur = this.conversations.formateur
 460    this.client = this.conversations.client
 461
 462    this.idDernierMessageAffiche = 0
 463    this.racine = undefined
 464
 465    this.messages = []
 466    this.messagesParId = {}
 467
 468    this.nbMessageMax = conf.nbMessageAffiche // Le nombre de message affiché par page
 469
 470    var messagesXHTML = '<div class="messages"></div>'
 471    var messageRacineXHTML = '<div class="messageRacine"></div>'
 472    var reverse = this.client.chatOrder == "reverse"
 473
 474    var XHTML =
 475       '<td class="conversation" id="' + this.getId() + '">' +
 476          (reverse ? messagesXHTML : "") +
 477          '<div class="titre">' +
 478             (reverse ? messageRacineXHTML : "") +
 479             '<div class="nav">' +
 480                (num == 0 ? '' : '<div class="fermer"></div><div class="lien"></div><div class="reduire"></div>') +
 481                '<span class="next">&lt;</span><span class="numPage">1</span><span class="prev">&gt;</span>' +
 482             '</div>' +
 483             (reverse ? "" : messageRacineXHTML) +
 484          '</div>' +
 485          (reverse ? "" : messagesXHTML) +
 486       '</td>'
 487
 488    $("#conversations tr").append(XHTML)
 489
 490    this.util.infoBulle("Aller à la première page", $("#" + this.getId() + " .numPage"), positionBulleType.haut)
 491    if (num != 0)
 492    {
 493       this.util.infoBulle("Créer un lien vers la conversation", $("#" + this.getId() + " .lien"))
 494       this.util.infoBulle("Fermer la conversation", $("#" + this.getId() + " .fermer"))
 495    }
 496 }
 497
 498 /**
 499   * @racine un message représentant la racine de la conversation, vaut undefined pour la conversation générale
 500   */
 501 Conversation.prototype.setRacine = function(racineElement)
 502 {
 503    this.racine = new Message(this.client, this.formateur, racineElement)
 504 }
 505
 506 /**
 507   * Met à jour la racine, décide de l'afficher ou non.
 508   * On l'affiche uniquement si le message racine n'est pas déjà affiché sur la liste des messages.
 509   */
 510 Conversation.prototype.majRacine = function()
 511 {
 512    if (this.racine == undefined)
 513       return
 514
 515    if (!(this.racine.id in this.messagesParId))
 516    {
 517       this.messagesParId[this.racine.id] = this.racine
 518       var element = $(this.racine.XHTML(true, this.getId()))
 519       this.attacherEventsSurMessage(element)
 520       $("#" + this.getId() + " .titre .messageRacine").html(element)
 521    }
 522 }
 523
 524 Conversation.prototype.enleverMiseEnEvidence = function()
 525 {
 526    $("#" + this.getId() + " .message").removeClass("cache")
 527 }
 528
 529 Conversation.prototype.colorerEntetes = function()
 530 {
 531    var messagesReponse = ""
 532    var messagesRepondu = ""
 533    var messagesProprietaire = ""
 534    for (var i = 0; i < this.messages.length; i++)
 535    {
 536       if (this.messages[i].appartientAuClient)
 537          messagesProprietaire += "#" + this.messages[i].getId(this.getId()) + ","
 538       else if (this.messages[i].clientARepondu)
 539          messagesRepondu += "#" + this.messages[i].getId(this.getId()) + ","
 540       else if (this.messages[i].estUneReponse)
 541          messagesReponse += "#" + this.messages[i].getId(this.getId()) + ","
 542    }
 543    $(messagesReponse).addClass("reponse")
 544    $(messagesRepondu).addClass("repondu")
 545    $(messagesProprietaire).addClass("proprietaire")
 546 }
 547
 548 Conversation.prototype.decolorerEntetes = function()
 549 {
 550    $("#" + this.getId() + " .messages .message")
 551       .removeClass("reponse")
 552       .removeClass("repondu")
 553       .removeClass("proprietaire")
 554 }
 555
 556 /**
 557   * Défini la page courante et s'il l'on se trouve sur la dernière page.
 558   * @pageCourante la page courante
 559   * @dernierePage true si c'est la dernière page sinon false
 560   */
 561 Conversation.prototype.setPage = function(pageCourante, dernierePage)
 562 {
 563    $("#" + this.getId() + " .numPage").text(pageCourante)
 564    $("#" + this.getId() + " .next").css("display", pageCourante == 1 ? "none" : "inline")
 565    $("#" + this.getId() + " .prev").css("display", dernierePage ? "none" : "inline")
 566 }
 567
 568 /**
 569   * Evenement déclanché lors de l'insertion du lien de la conversation dans le message courant.
 570   */
 571 Conversation.prototype.eventLien = function(fun)
 572 {
 573    var thisConversation = this
 574
 575    $("#" + this.getId() + " .titre .lien").click(
 576       function()
 577       {
 578          fun(thisConversation.num)
 579       }
 580    )
 581 }
 582
 583 /**
 584   * Evenement déclanché lors de la fermeture de la conversation.
 585   */
 586 Conversation.prototype.eventFermer = function(fun)
 587 {
 588    var thisConversation = this
 589
 590    $("#" + this.getId() + " .titre .fermer").click(
 591       function()
 592       {
 593          fun(thisConversation.num)
 594       }
 595    )
 596 }
 597
 598 /**
 599   * @funNext appelé lorsque l'on passe à la page suivante (de 2 à 1 par exemple)
 600   * @funPrev appelé lorsque l'on passe à la page précédente (de 1 à 2 par exemple)
 601   * @funReset appelé lorsque l'on souhaite revenir à la page une
 602   */
 603 Conversation.prototype.setFunPage = function(funNext, funPrev, funReset)
 604 {
 605    var thisConversation = this
 606
 607    $("#" + this.getId() + " .next").click(
 608       function() { funNext(thisConversation.num) }
 609    )
 610    $("#" + this.getId() + " .prev").click(
 611       function() { funPrev(thisConversation.num) }
 612    )
 613    $("#" + this.getId() + " .numPage").click(
 614       function() { funReset(thisConversation.num) }
 615    )
 616 }
 617
 618 /**
 619   * Retourne l'id de la conversation sous la forme (par exemple) "conv3".
 620   */
 621 Conversation.prototype.getId = function()
 622 {
 623    return "conv" + this.id
 624 }
 625
 626 Conversation.prototype.ajouterMessage = function(message)
 627 {
 628    this.messages.push(message)
 629    this.messagesParId[message.id] = message
 630    if (this.messages.length > this.nbMessageMax)
 631       delete this.messagesParId[this.messages.shift().id]
 632 }
 633
 634 /**
 635   * 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 ?
 636   */
 637 Conversation.prototype.viderMessages = function()
 638 {
 639    this.messages = []
 640    this.messagesParId = {}
 641    this.idDernierMessageAffiche = 0
 642    $("#" + this.getId() + " .messages .message").remove()
 643
 644    // enlève également la racine
 645    $("#" + this.getId() + " .titre .messageRacine").empty()
 646 }
 647
 648 Conversation.prototype.idMessageFromString = function(idString)
 649 {
 650    return parseInt(idString.substr(4 + this.getId().length), 36)
 651 }
 652
 653 /**
 654   * Après l'ajout d'un ou plusieurs message cette méthode est appelée afin
 655   * d'afficher les messages non-affichés.
 656   * FIXME : méthode super lourde, à optimiser.
 657   */
 658 Conversation.prototype.flush = function()
 659 {
 660    var thisConversation = this
 661    var reverse = this.client.chatOrder == "reverse"
 662
 663    // est-ce que le prochain message est pair ? (permet d'alterner le style des messages)
 664    var messagePair = (this.idDernierMessageAffiche == 0 ? true :
 665       ($("#" + this.getId() + " .messages div:" + (reverse ? "first" : "last")).attr("class").search("messagePair") == -1)
 666    )
 667
 668    // construction de l'XHTML des messages
 669    var XHTML = ""
 670    for (var i = 0; i < this.messages.length; i++)
 671       if (this.messages[i].id > this.idDernierMessageAffiche)
 672       {
 673          XHTML += this.messages[i].XHTML(messagePair, this.getId())
 674          messagePair = !messagePair
 675       }
 676
 677    var DOM = $(XHTML)
 678
 679    // pour chaque nouveau message au niveau du document on crée ses événements
 680    DOM.each(function() { thisConversation.attacherEventsSurMessage(this) })
 681    if (reverse)
 682       DOM.prependTo("#" + this.getId() + " .messages")
 683    else
 684       DOM.appendTo("#" + this.getId() + " .messages")
 685
 686    // enlève les messages exedentaires
 687    var nbMessagesAffiche = $("#" + this.getId() + " .messages .message").size()
 688    if (nbMessagesAffiche > this.nbMessageMax)
 689    {
 690       if (reverse)
 691          $("#" + this.getId() + " .messages .message").slice(this.nbMessageMax, nbMessagesAffiche).remove()
 692       else
 693          $("#" + this.getId() + " .messages .message").slice(0, nbMessagesAffiche - this.nbMessageMax).remove()
 694    }
 695
 696    if (this.messages.length > 0)
 697       this.idDernierMessageAffiche = this.messages[this.messages.length-1].id
 698
 699    // met à jour la racine de la conversation
 700    this.majRacine()
 701 }
 702
 703 Conversation.prototype.attacherEventsSurMessage = function(element)
 704 {
 705    // l'id du message
 706    var idMess = this.idMessageFromString($(element).attr("id"))
 707
 708    this.util.infoBulle("Extraction de la conversation à partir de ce message", $(".extraire", element))
 709    this.util.infoBulle("Extraction de la conversation complète", $(".extraireCompletement", element))
 710
 711    var thisConversation = this
 712    $(".lienConv", element).click(
 713       function(event)
 714       {
 715          // FIXME : ya pas mieux ?
 716          var racine = $(event.target).text()
 717          thisConversation.conversations.ouvrirConversation(parseInt(idString.substring(1, racine.length - 1), 36))
 718          return false
 719       }
 720    )
 721
 722    $(element).click(
 723       function(event)
 724       {
 725          if ($(event.target).is("a") || $(event.target).parents("#outilsBan").length > 0) return
 726
 727           // extraction d'une conversation
 728          if ($(event.target).is(".extraire"))
 729          {
 730             thisConversation.conversations.ouvrirConversation(idMess)
 731             return
 732          }
 733
 734          if ($(event.target).is(".extraireCompletement"))
 735          {
 736             thisConversation.conversations.ouvrirConversation(thisConversation.messagesParId[idMess].racineId)
 737             return
 738          }
 739
 740          // met ou enlève la mise en evidence du message
 741          thisConversation.conversations.toggleMessageRepond(thisConversation.messagesParId[idMess])
 742
 743          // donne le focus à la ligne de saisie
 744          $("form input.message").focus()
 745       }
 746    )
 747
 748    // mise en évidence de la conversation
 749    $(".entete", element).hover(
 750       function()
 751       {
 752          thisConversation.decolorerEntetes()
 753          thisConversation.afficherConversation(idMess)
 754       },
 755       // quand on sort de l'entête du message la mise en évidence est enlevée
 756       function()
 757       {
 758          thisConversation.enleverMiseEnEvidence()
 759          thisConversation.decolorerEntetes()
 760          thisConversation.colorerEntetes()
 761       }
 762    )
 763
 764  if (thisConversation.client.viewTimes)
 765     $(".dateComplete", element).show()
 766  else
 767     $(".dateComplete", element).hide()
 768
 769  $("a[@rel*=lightbox]", element).lightBox()
 770
 771  // les outils de bannissement (uniquement pour les ekMaster)
 772  if (thisConversation.client.ekMaster)
 773     $(".pseudo", element).hover(
 774        function(e)
 775        {
 776           var userId = parseInt($(".id", this).text())
 777           var pseudo = $(this)
 778           var h = pseudo.height()
 779           var offset = pseudo.offset()
 780           thisConversation.util.outilsBan.css("top", offset.top - 2).css("left", offset.left - 2).height(h < 16 ? 16 : h).width(pseudo.width() + 16 * 3 + 4 + 64).prependTo(this).show()
 781           $("img", thisConversation.util.outilsBan).unbind("click")
 782           $("#slap", thisConversation.util.outilsBan).click(
 783              function()
 784              {
 785                 thisConversation.client.slap(userId, $("#outilsBan input").val())
 786                 $("#outilsBan input").val("")
 787                 $("#outilsBan").hide()
 788              }
 789           )
 790           $("#kick", thisConversation.util.outilsBan).click(
 791              function()
 792              {
 793                 thisConversation.client.kick(userId, $("#outilsBan input").val())
 794                 $("#outilsBan input").val("")
 795                 $("#outilsBan").hide()
 796              }
 797           )
 798           $("#ban", thisConversation.util.outilsBan).click(
 799              function()
 800              {
 801                 thisConversation.client.ban(userId, $("#outilsBan input").val())
 802                 $("#outilsBan input").val("")
 803                 $("#outilsBan").hide()
 804              }
 805           )
 806        },
 807        function()
 808        {
 809           $("#outilsBan", this).hide()
 810        }
 811     )
 812 }
 813
 814 /**
 815   * Etablit une liste des messages à mettre en evidence et des messages à cacher.
 816   * Puis applique un plan diabolique.
 817   * @param id l'id du message
 818   */
 819 Conversation.prototype.afficherConversation = function(id)
 820 {
 821    var thisConversation = this
 822
 823    var message = this.messagesParId[id]
 824    if (message == undefined) return
 825
 826    var mess = message.getConversation(this)
 827
 828    // FIXME : cet appel est très lent
 829    $("#" + this.getId() + " .messages .message").each(
 830       function()
 831       {
 832          var jq = $(this)
 833          var statut = mess[thisConversation.idMessageFromString(jq.attr("id"))]
 834          if (statut == undefined)
 835             jq.addClass("cache")
 836          else
 837          {
 838             jq.removeClass("cache")
 839             switch (statut)
 840             {
 841                // "repondu" et "reponse" sont prioritaitres à "proprietaire"
 842                // contrairement à la vue normale (sans mise en évidence d'une conversation)
 843                case 3 :
 844                   jq.addClass("repondu")
 845                   break;
 846                case 2 :
 847                   jq.addClass("reponse")
 848                   break;
 849                case 1 :
 850                   jq.addClass("proprietaire")
 851                   break;
 852             }
 853          }
 854       }
 855    )
 856 }
 857
 858 /**
 859   * Supprime une conversation.
 860   */
 861 Conversation.prototype.supprimer = function()
 862 {
 863    $("#" + this.getId()).remove()
 864 }
 865
 866 ///////////////////////////////////////////////////////////////////////////////////////////////////
 867
 868 /**
 869   * Représente l'ensemble des conversations affichés.
 870   */
 871 function Conversations(client, formateur, util)
 872 {
 873    this.client = client
 874    this.formateur = formateur
 875    this.util = util
 876
 877    // un ensemble des messages (id) auquel l'utilisateur répond (vider après l'envoie du message courant)
 878    this.messagesRepond = {}
 879
 880    this.conversations = new Array() // les conversations, la première représente la conversation principale
 881
 882    this.nouvelleConversation(0)
 883
 884    this.trollIdCourant = 0
 885
 886    this.pageEvent = new PageEvent("chat", this.util)
 887 }
 888
 889 // les messages insérés dans le document XHTML on leur id prefixé par cette valeur
 890 // cela permet de les distinguer des "vrais" messages
 891 Conversations.prototype.prefixIdMessage = "rep"
 892
 893 /**
 894   * Permet de définir un message comme étant ou n'étant plus un message auquel l'utilisateur
 895   * répond.
 896   */
 897 Conversations.prototype.toggleMessageRepond = function(mess)
 898 {
 899    // est-ce que l'on répond déjà à ce message ? si oui alors on l'enlève de la liste
 900    if (mess.id in this.messagesRepond)
 901    {
 902       this.enleverMessageRepond(mess)
 903       return
 904    }
 905
 906    this.ajouterMessageRepond(mess)
 907 }
 908
 909 /**
 910   * Enlève tous les messages auquel l'utilisateur souhaite répond.
 911   */
 912 Conversations.prototype.enleverMessagesRepond = function()
 913 {
 914    for (var messId in this.messagesRepond)
 915       this.enleverMessageRepond(this.messagesRepond[messId])
 916
 917    // on réinitialise pour être sur que tout est bien enlevé
 918    this.messagesRepond = {}
 919    $("#conversations .message").removeClass("repondEnEvidence")
 920    $("form#posterMessage #repondA .messages").empty()
 921 }
 922
 923 /**
 924   * Définit un message comme n'y répondant plus.
 925   */
 926 Conversations.prototype.enleverMessageRepond = function(mess)
 927 {
 928    $(this.exprIdsPotentiels(mess)).removeClass("repondEnEvidence")
 929    $("#" + mess.getId(this.prefixIdMessage)).remove()
 930    delete this.messagesRepond[mess.id]
 931    this.rafraichireNombreMessagesRepond()
 932 }
 933
 934 /**
 935   * Définit un message comme y répondant.
 936   */
 937 Conversations.prototype.ajouterMessageRepond = function(mess)
 938 {
 939    var thisMessages = this
 940
 941    // est-ce que le message fait partie de la même conversation que les autres messages ?
 942    // TODO : solution plus élégante pour prendre un mess parmis messagesRepond !?
 943    var mess2
 944    for(mess2 in this.messagesRepond){ break; }
 945    mess2 = this.messagesRepond[mess2]
 946
 947    if (mess2 != undefined && mess2.racineId != mess.racineId)
 948    {
 949       this.util.messageDialogue("Impossible de répondre à deux messages ne faisant pas partie de la même conversation")
 950       return
 951    }
 952
 953    $("form#posterMessage #repondA .messages").append(mess.XHTML(undefined, this.prefixIdMessage))
 954    this.messagesRepond[mess.id] = mess
 955
 956    // ajout la classe 'repondEnEvidence' au message. comme il peut se trouver potentiellement dans
 957    // chaque conversation on construit tous les id potentiels
 958    $(mess.getId(this.prefixIdMessage) + ", " + this.exprIdsPotentiels(mess)).addClass("repondEnEvidence")
 959
 960    $("#" + mess.getId(this.prefixIdMessage)).click(
 961       function()
 962       {
 963          $(this).fadeOut("normal", function(){
 964             thisMessages.enleverMessageRepond(mess)
 965             $("form#posterMessage #repondA .messages").hide()
 966          })
 967       }
 968    )
 969    this.rafraichireNombreMessagesRepond()
 970 }
 971
 972 /**
 973   * Construit tous les id potentiels d'un message, renvoie par exemple :
 974   * "conv9b28mess1h, conv9b2amess1h, conv9b32mess1h"
 975   */
 976 Conversations.prototype.exprIdsPotentiels = function(mess)
 977 {
 978    var exprMess = ""
 979    for(var i = 0; i < this.conversations.length; i++)
 980    {
 981       exprMess += (mess != "" ? ", " : "") + "#" + mess.getId(this.conversations[i].getId())
 982    }
 983    return exprMess
 984 }
 985
 986 /**
 987   * Met à jour le nombre qui indique à l'utilisateur à combien de messages il répond.
 988   */
 989 Conversations.prototype.rafraichireNombreMessagesRepond = function()
 990 {
 991    // TODO : ya pas mieux pour trouver le nombre d'objet ?
 992    var nb = 0
 993    for (var m in this.messagesRepond)
 994       nb += 1
 995    $("#posterMessage #repondA .nb").text(nb)
 996
 997    var boite = $("#posterMessage #repondA")
 998    if (nb > 0) boite.show()
 999    else boite.hide()
1000 }
1001
1002 /**
1003   * Affiche les messages auquel l'utilisateur souhaite répondre au sein des messages des conversations.
1004   * Utilisé lorsqu'une conversation est extraite.
1005   */
1006 Conversations.prototype.afficherMessagesRepondConversations = function()
1007 {
1008    var expr = ""
1009    for(var messId in this.messagesRepond)
1010       expr += "#" + this.messagesRepond[messId].getId() + ","
1011    $(expr).addClass("repondEnEvidence")
1012 }
1013
1014 /**
1015   * Crée un message JSON contenant le message demandant un rafraichissement.
1016   */
1017 Conversations.prototype.getJSONrafraichirMessages = function()
1018 {
1019    var mess =  {
1020       "message_count" : conf.nbMessageAffiche,
1021       "main_page" : this.client.pagePrincipale,
1022       "conversations" : this.getJSONConversations(),
1023       "troll_id" : this.trollIdCourant
1024    }
1025
1026    if (this.client.cookie != null) mess["cookie"] = this.client.cookie
1027    mess["last_message_id"] = this.conversations[0].idDernierMessageAffiche
1028
1029    return mess
1030 }
1031
1032 Conversations.prototype.getJSONConversations = function()
1033 {
1034    var clientConv = []
1035
1036    for (var i = 0; i < this.client.conversations.length; i++)
1037    {
1038       clientConv.push(
1039          {
1040             root : this.client.conversations[i].root,
1041             page : this.client.conversations[i].page,
1042             last_message_id : this.conversations[i + 1] == undefined ? 0 : this.conversations[i + 1].idDernierMessageAffiche
1043          }
1044       )
1045    }
1046    return clientConv
1047 }
1048
1049 /**
1050   * Ajoute un ensemble de messages puis les affiches.
1051   * @param elements un tableau d'éléments JSON représentant les messages, voir protocole.txt
1052   * @param numConversation le numéro de la conversation auquel appartiennent les messages
1053   * @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
1054   */
1055 Conversations.prototype.ajouterMessages = function(elements, numConversation)
1056 {
1057    if (elements["messages"].length == 0)
1058       return this.conversations[numConversation] != undefined
1059
1060    for (var i = 0; i < elements["messages"].length; i++)
1061       // si une nouvelle conversation a été créée alors on lui donne la racine
1062       if(this.ajouterMessage(elements["messages"][i], numConversation))
1063          this.conversations[numConversation].setRacine(elements["first"])
1064
1065    this.flush(numConversation)
1066
1067    // renseigne la conversation sur la page courante et si c'est la dernière
1068    this.conversations[numConversation].setPage(
1069       numConversation == 0 ? this.client.pagePrincipale : this.client.conversations[numConversation - 1].page,
1070       elements["last_page"]
1071    )
1072
1073    return true
1074 }
1075
1076 /**
1077   * Création d'un nouveau message.
1078   * Les message sont données dans l'ordre de leur id.
1079   * @param element un element JSON représentant le message
1080   * @param numConversation le numéro de la conversation, 0 = principale
1081   * @return true si une nouvelle conversation a été créée sinon false
1082   */
1083 Conversations.prototype.ajouterMessage = function(element, numConversation)
1084 {
1085    var thisMessages = this
1086
1087    // pas d'utilisation de jquery pour des raisons de performance
1088    var message = new Message(
1089       this.client,
1090       this.formateur,
1091       element
1092    )
1093
1094    var nouvelleConversation = false
1095
1096    if (this.conversations[numConversation] == null)
1097    {
1098       nouvelleConversation = true
1099       this.nouvelleConversation(
1100          numConversation,
1101          function(num) // fermeture de la conversation
1102          {
1103             thisMessages.supprimerConversation(num)
1104          },
1105          function(num) // insertion du lien vers la conversation
1106          {
1107                thisPage.util.replaceSelection(
1108                   $("form#posterMessage input.message")[0],
1109                   "{" + thisMessages.client.conversations[num-1].root.toString(36) + "}"
1110                )
1111          }
1112       )
1113    }
1114
1115    this.conversations[numConversation].ajouterMessage(message)
1116    return nouvelleConversation
1117 }
1118
1119 Conversations.prototype.nouvelleConversation = function(num, funFermer, funLien)
1120 {
1121    var thisMessages = this
1122
1123    this.conversations[num] = new Conversation(this, num)
1124
1125    if (funFermer != undefined)
1126       this.conversations[num].eventFermer(funFermer)
1127    if (funLien != undefined)
1128       this.conversations[num].eventLien(funLien)
1129
1130    this.conversations[num].setFunPage(
1131       function(num) // page suivante
1132       {
1133          thisMessages.client.pageSuivante(num - 1)
1134          thisMessages.rafraichirMessages(true)
1135       },
1136       function(num) // page précédente
1137       {
1138          thisMessages.client.pagePrecedente(num - 1)
1139          thisMessages.rafraichirMessages(true)
1140       },
1141       function(num) // retour à la page une
1142       {
1143          if (thisMessages.client.goPremierePage(num - 1))
1144             thisMessages.rafraichirMessages(true)
1145       }
1146    )
1147
1148    this.ajusterLargeurConversations()
1149 }
1150
1151 /**
1152   * Enlève une conversation.
1153   */
1154 Conversations.prototype.supprimerConversation = function(num)
1155 {
1156    if (num <= 0 || num >= this.conversations.length) return // la numéro 0 ne peut être supprimé
1157    this.conversations[num].supprimer()
1158
1159    // décalage TODO : supprimer le dernier élément
1160    for (var i = num; i < this.conversations.length - 1; i++)
1161    {
1162       this.conversations[i] = this.conversations[i+1]
1163       this.conversations[i].num -= 1
1164    }
1165    this.conversations.pop()
1166    this.ajusterLargeurConversations()
1167
1168    this.client.supprimerConversation(num-1)
1169
1170    this.rafraichirMessages(true)
1171 }
1172
1173 /**
1174   * Ajuste la largeur des conversations en fonction de leur nombre. modifie l'attribut CSS 'width'.
1175   */
1176 Conversations.prototype.ajusterLargeurConversations = function()
1177 {
1178    // TODO : trouver mieux !
1179    var largeurPourcent = (100 / this.conversations.length)
1180    // obsolète !?
1181    // le "- 0.01" evite que IE se chie dessus lamentablement et affiche les conversations les unes au dessus des autres
1182    //if($.browser["msie"])
1183    //    largeurPourcent -= 0.05
1184    $("#conversations td").css("width", largeurPourcent + "%")
1185 }
1186
1187 /**
1188   * Demande à toutes les conversations de se flusher (afficher les messages non-affichés).
1189   */
1190 Conversations.prototype.flushAll = function()
1191 {
1192    for (var i = 0; i < this.conversations.length; i++)
1193       this.flush(i)
1194 }
1195
1196 /**
1197   * Demande à une conversation de se flusher.
1198   */
1199 Conversations.prototype.flush = function(numConv)
1200 {
1201    this.conversations[numConv].flush()
1202 }
1203
1204 Conversations.prototype.ouvrirConversation = function(racine)
1205 {
1206    if (this.client.ajouterConversation(racine))
1207       this.rafraichirMessages(true)
1208    else
1209       this.util.messageDialogue("Cette conversation est déjà ouverte")
1210 }
1211
1212 Conversations.prototype.viderMessages = function()
1213 {
1214    for (var i = 0; i < this.conversations.length; i++)
1215       this.conversations[i].viderMessages()
1216 }
1217
1218 /**
1219   * Met à jour les messages de manière continue.
1220   * (AJAX-Comet-style proof)
1221   * @param vider vide tous les messages avant d'afficher les nouveaux
1222   */
1223 Conversations.prototype.rafraichirMessages = function(vider)
1224 {
1225    var thisMessages = this
1226
1227    if (vider == undefined)
1228       vider = false
1229
1230    if (vider)
1231       for (var i = 0; i < this.conversations.length; i++)
1232          this.conversations[i].idDernierMessageAffiche = 0
1233
1234    this.pageEvent.waitEvent(
1235       function() { return thisMessages.getJSONrafraichirMessages() },
1236       {
1237          "new_troll" :
1238             function(data)
1239             {
1240                thisMessages.trollIdCourant = data["troll_id"]
1241                $("#trollCourant .troll").html(thisMessages.formateur.traitementComplet(data["content"])).unbind("click").click(
1242                   function()
1243                   {
1244                      thisMessages.ouvrirConversation(data["message_id"])
1245                   }
1246                )
1247
1248                $("#trollCourant .troll a[@rel*=lightbox]").lightBox()
1249             },
1250          "new_messages" :
1251             function(data)
1252             {
1253                if (vider)
1254                   thisMessages.viderMessages()
1255                // ajoute les messages reçus à leur conversation respective
1256                for (var numConv = 0; numConv < data["conversations"].length; numConv++)
1257                {
1258                   if (!thisMessages.ajouterMessages(data["conversations"][numConv], numConv))
1259                   {
1260                      thisMessages.util.messageDialogue("La conversation {" + thisMessages.client.conversations[numConv -1].root.toString(36) + "} n'existe pas")
1261                      thisMessages.client.supprimerConversation(numConv - 1)
1262                   }
1263                }
1264                if (vider)
1265                   thisMessages.afficherMessagesRepondConversations()
1266                vider = false
1267             }
1268       }
1269    )
1270 }