// coding: utf-8
// Copyright 2008 Grégory Burri
//
// This file is part of Euphorik.
//
// Euphorik is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Euphorik is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Euphorik. If not, see .
/**
* Contient la base javascript pour le site euphorik.ch.
* Chaque page possède son propre fichier js nommé "page.js".
* Auteur : GBurri
* Date : 6.11.2007
*/
// tout euphorik est contenu dans cet objet
var euphorik = {}
// ;; euphorik.include =
// ;; euphorik.include = function(f) { var s = document.createElement('script'); s.type = 'text/javascript'; s.src = "js/" + f + ".js"; document.getElementsByTagName('head')[0].appendChild(s); }
// version jQuery : function(f) { jQuery.ajax({async : false, url : "js/" + f + ".js", dataType : "script"}) }
// mais comme il n'est pas encore chargé...
;; euphorik.include = function(f) {
;; var req, url = 'js/' + f + '.js'
;; if (window.XMLHttpRequest) {
;; req = new XMLHttpRequest(); req.open("GET", url, false /* async */); req.send(null);
;; } else if (window.ActiveXObject) {
;; req = new ActiveXObject((navigator.userAgent.toLowerCase().indexOf('msie 5') != -1) ? "Microsoft.XMLHTTP" : "Msxml2.XMLHTTP");
;; if (req) { req.open("GET", url, false); req.send(); }
;; }
;; if (req!==false) { if (req.status==200) { window.eval(req.responseText); } else if (req.status==404) { alert("erreur de chargement (404) de : " + url) } }
;; }
;; euphorik.include("jquery")
;; euphorik.include("jquery.lightbox")
;; euphorik.include("md5")
;; euphorik.include("json2")
;; euphorik.include("conf")
;; euphorik.include("util")
;; euphorik.include("pageMinichat")
;; euphorik.include("pageAdmin")
;; euphorik.include("pageProfile")
;; euphorik.include("pageRegister")
;; euphorik.include("pageAbout")
///////////////////////////////////////////////////////////////////////////////////////////////////
String.prototype.trim = function()
{
return jQuery.trim(this) // anciennement : this.replace(/^\s+|\s+$/g, "");
}
String.prototype.ltrim = function()
{
return this.replace(/^\s+/, "");
}
String.prototype.rtrim = function()
{
return this.replace(/\s+$/, "");
}
///////////////////////////////////////////////////////////////////////////////////////////////////
function Pages()
{
this.pageCourante = null
this.pages = {}
}
/**
* Accepte soit un objet soit un string.
* un string correspond au nom de la page, par exemple : "page" -> "page.html"
*/
Pages.prototype.ajouterPage = function(page)
{
if (typeof page == "string")
{
this.pages[page] = page
}
else
{
page.pages = this // la magie des langages dynamiques : le foutoire
this.pages[page.nom] = page
}
}
Pages.prototype.afficherPage = function(nomPage, forcerChargement)
{
if (forcerChargement == undefined) forcerChargement = false
var page = this.pages[nomPage]
if (page == undefined || (!forcerChargement && page == this.pageCourante)) return
if (this.pageCourante != null && this.pageCourante.decharger)
this.pageCourante.decharger()
$("#menu li").removeClass("courante")
$("#menu li." + nomPage).addClass("courante")
this.pageCourante = page
var contenu = ""
if (typeof page == "string")
$.ajax({async: false, url: "pages/" + page + ".html", success : function(page) { contenu += page }})
else
{
contenu += this.pageCourante.contenu()
}
$("#page").html(contenu).removeClass().addClass(this.pageCourante.nom +
(this.pageCourante.classes != undefined ? " " + this.pageCourante.classes() : "") // l'objet peut fournire des classes css supplémentaires sous la forme d'un string
)
if (this.pageCourante.charger)
this.pageCourante.charger()
}
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Classe permettant de formater du texte par exemple pour la substitution des liens dans les
* message par "[url]".
* TODO : améliorer l'efficacité des méthods notamment lié au smiles.
*/
function Formateur()
{
this.smiles = euphorik.conf.smiles
this.protocoles = "http|https|ed2k"
this.regexUrl = new RegExp("(?:(?:" + this.protocoles + ")://|www\\.)[^ ]*", "gi")
this.regexImg = new RegExp("^.*?\\.(gif|jpg|png|jpeg|bmp|tiff)$", "i")
this.regexDomaine = new RegExp("^(?:(?:" + this.protocoles + ")://|www\\.).*?([^/.]+\\.[^/.]+)(?:$|/).*$", "i")
this.regexTestProtocoleExiste = new RegExp("^(?:" + this.protocoles + ")://.*$", "i")
this.regexNomProtocole = new RegExp("^(.*?)://")
}
/**
* Formate un pseudo saise par l'utilisateur.
* @param pseudo le pseudo brut
* @return le pseudo filtré
*/
Formateur.prototype.filtrerInputPseudo = function(pseudo)
{
return pseudo.replace(/{|}/g, "").trim()
}
Formateur.prototype.getSmilesHTML = function()
{
var XHTML = ""
for (var sNom in this.smiles)
{
XHTML += ""
}
return XHTML
}
/**
* Formatage complet d'un texte.
* @M le message
* @pseudo facultatif, permet de contruire le label des images sous la forme : " : "
*/
Formateur.prototype.traitementComplet = function(M, pseudo)
{
return this.traiterLiensConv(this.traiterSmiles(this.traiterURL(this.traiterWikiSyntaxe(this.remplacerBalisesHTML(M)), pseudo)))
}
/**
* Transforme les liens en entités clickables.
* Un lien vers une conversation permet d'ouvrire celle ci, elle se marque comme ceci dans un message :
* "{5F}" ou 5F est la racine de la conversation.
* Ce lien sera transformer en {5F} pouvant être clické pour créer la conv 5F.
*/
Formateur.prototype.traiterLiensConv = function(M)
{
return M.replace(
/\{\w+\}/g,
function(lien)
{
return "" + lien + ""
}
)
}
/**
* FIXME : Cette méthode est attrocement lourde ! A optimiser.
* moyenne sur échantillon : 234ms
*/
Formateur.prototype.traiterSmiles = function(M)
{
for (var sNom in this.smiles)
{
var ss = this.smiles[sNom]
for (var i = 0; i < ss.length; i++)
M = M.replace(ss[i], "")
}
return M
}
Formateur.prototype.remplacerBalisesHTML = function(M)
{
return M.replace(//g, ">").replace(/"/g, """)
}
Formateur.prototype.traiterURL = function(M, pseudo)
{
var thisFormateur = this
var traitementUrl = function(url)
{
// si ya pas de protocole on rajoute "http://"
if (!thisFormateur.regexTestProtocoleExiste.test(url))
url = "http://" + url
var extension = thisFormateur.getShort(url)
return "[" + extension[0] + "]"
}
return M.replace(this.regexUrl, traitementUrl)
}
/**
* Formatage en utilisant un sous-ensemble des règles de mediwiki.
* par exemple ''italic'' devient italic
*/
Formateur.prototype.traiterWikiSyntaxe = function(M)
{
return M.replace(
/'''(.*?)'''/g,
function(texte, capture)
{
return "" + capture + ""
}
).replace(
/''(.*?)''/g,
function(texte, capture)
{
return "" + capture + ""
}
)
}
/**
* Renvoie une version courte de l'url.
* par exemple : http://en.wikipedia.org/wiki/Yakov_Smirnoff devient wikipedia.org
*/
Formateur.prototype.getShort = function(url)
{
var estUneImage = false
var versionShort = null
var rechercheImg = this.regexImg.exec(url)
if (rechercheImg != null)
{
versionShort = rechercheImg[1].toLowerCase()
if (versionShort == "jpeg") versionShort = "jpg" // jpeg -> jpg
estUneImage = true
}
else
{
var rechercheDomaine = this.regexDomaine.exec(url)
if (rechercheDomaine != null && rechercheDomaine.length >= 2)
versionShort = rechercheDomaine[1]
else
{
var nomProtocole = this.regexNomProtocole.exec(url)
if (nomProtocole != null && nomProtocole.length >= 2)
versionShort = nomProtocole[1]
}
}
return [versionShort == null ? "url" : versionShort, estUneImage]
}
/**
* Traite les pseudo et messages à être affiché dans le titre d'une image visualisé avec lightbox.
*/
Formateur.prototype.traiterPourFenetreLightBox = function(M, urlCourante)
{
var thisFormateur = this
var traitementUrl = function(url)
{
return "[" + thisFormateur.getShort(url)[0] + (urlCourante == url ? "*" : "") + "]"
}
return this.remplacerBalisesHTML(M).replace(this.regexUrl, traitementUrl)
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// les statuts possibes du client
var statutType = {
// mode enregistré, peut poster des messages et modifier son profile
auth_registered : 0,
// mode identifié, peut poster des messages mais n'a pas accès au profile
auth_not_registered : 1,
// mode déconnecté, ne peut pas poster de message
deconnected : 2
}
function Client(util)
{
this.util = util
this.cookie = null
this.regexCookie = new RegExp("^cookie=([^;]*)")
// données personnels
this.resetDonneesPersonnelles()
this.setStatut(statutType.deconnected)
// si true alors chaque modification du client est mémorisé sur le serveur
this.autoflush = $.browser["opera"]
}
Client.prototype.resetDonneesPersonnelles = function()
{
this.id = 0
this.pseudo = euphorik.conf.pseudoDefaut
this.login = ""
this.password = ""
this.email = ""
this.css = $("link#cssPrincipale").attr("href")
this.chatOrder = "reverse"
this.nickFormat = "nick"
this.viewTimes = true
this.viewTooltips = true
this.cookie = undefined
this.pagePrincipale = 1
this.ekMaster = false
this.ostentatiousMaster = "light"
// les conversations, une conversation est un objet possédant les attributs suivants :
// - root (entier)
// - page (entier)
// - reduit (bool)
this.conversations = []
}
Client.prototype.setCss = function(css)
{
if (this.css == css || css == "")
return
this.css = css
$("link#cssPrincipale").attr("href", this.css)
if (this.autoflush) this.flush(true)
}
Client.prototype.pageSuivante = function(numConv)
{
if (numConv < 0 && this.pagePrincipale > 1)
this.pagePrincipale -= 1
else if (this.conversations[numConv].page > 1)
this.conversations[numConv].page -= 1
}
Client.prototype.pagePrecedente = function(numConv)
{
if (numConv < 0)
this.pagePrincipale += 1
else
this.conversations[numConv].page += 1
}
/**
* Définit la première page pour la conversation donnée.
* @return true si la page a changé sinon false
*/
Client.prototype.goPremierePage = function(numConv)
{
if (numConv < 0)
{
if (this.pagePrincipale == 1)
return false
this.pagePrincipale = 1
}
else
{
if (this.conversations[numConv].page == 1)
return false
this.conversations[numConv].page = 1
}
return true
}
/**
* Ajoute une conversation à la vue de l'utilisateur.
* Le profile de l'utilisateur est directement sauvegardé sur le serveur.
* @param racines la racine de la conversation (integer)
* @return true si la conversation a été créée sinon false (par exemple si la conv existe déjà)
*/
Client.prototype.ajouterConversation = function(racine)
{
// vérification s'il elle n'existe pas déjà
for (var i = 0; i < this.conversations.length; i++)
if (this.conversations[i].root == racine)
return false
this.conversations.push({root : racine, page : 1, reduit : false})
if (this.autoflush) this.flush(true)
return true
}
Client.prototype.supprimerConversation = function(num)
{
if (num < 0 || num >= this.conversations.length) return
// décalage TODO : supprimer le dernier élément
for (var i = num; i < this.conversations.length - 1; i++)
this.conversations[i] = this.conversations[i+1]
this.conversations.pop()
if (this.autoflush) this.flush(true)
}
Client.prototype.getJSONLogin = function(login, password)
{
return {
"header" : { "action" : "authentification", "version" : euphorik.conf.versionProtocole },
"login" : login,
"password" : password
}
}
Client.prototype.getJSONLoginCookie = function()
{
return {
"header" : { "action" : "authentification", "version" : euphorik.conf.versionProtocole },
"cookie" : this.cookie
}
}
/**
* le couple (login, password) est facultatif. S'il n'est pas fournit alors il ne sera pas possible
* de s'autentifier avec (login, password).
*/
Client.prototype.getJSONEnregistrement = function(login, password)
{
var mess = { "header" : { "action" : "register", "version" : euphorik.conf.versionProtocole }}
if (login != undefined && password != undefined)
{
mess["login"] = login
mess["password"] = password
}
return mess;
}
Client.prototype.getJSONConversations = function()
{
var conversations = new Array()
for (var i = 0; i < this.conversations.length; i++)
conversations.push({root : this.conversations[i].root, minimized : this.conversations[i].reduit})
return conversations
}
Client.prototype.getJSONProfile = function()
{
return {
"header" : { "action" : "set_profile", "version" : euphorik.conf.versionProtocole },
"cookie" : this.cookie,
"login" : this.login,
"password" : this.password,
"nick" : this.pseudo,
"email" : this.email,
"css" : this.css,
"chat_order" : this.chatOrder,
"nick_format" : this.nickFormat,
"view_times" : this.viewTimes,
"view_tooltips" : this.viewTooltips,
"conversations" : this.getJSONConversations(),
"ostentatious_master" : this.ostentatiousMaster
}
}
/**
* Renvoie null si pas définit.
*/
Client.prototype.getCookie = function()
{
var cookie = this.regexCookie.exec(document.cookie)
if (cookie == null) this.cookie = null
else this.cookie = cookie[1]
}
Client.prototype.delCookie = function()
{
document.cookie = "cookie=; max-age=0"
}
Client.prototype.setCookie = function()
{
if (this.cookie == null || this.cookie == undefined)
return
// ne fonctionne pas sous IE....
/*document.cookie = "cookie=" + this.cookie + "; max-age=" + (60 * 60 * 24 * 365) */
document.cookie =
"cookie="+this.cookie+"; expires=" + new Date(new Date().getTime() + 1000 * 60 * 60 * 24 * 365).toUTCString()
}
Client.prototype.authentifie = function()
{
return this.statut == statutType.auth_registered || this.statut == statutType.auth_not_registered
}
Client.prototype.setStatut = function(statut)
{
// conversation en "enum" si en "string"
if (typeof(statut) == "string")
{
statut =
statut == "auth_registered" ?
statutType.auth_registered :
(statut == "auth_not_registered" ? statutType.auth_not_registered : statutType.deconnected)
}
if (statut == this.statut) return
this.statut = statut
this.majMenu()
this.majLogo()
}
/**
* Effectue la connexion vers le serveur.
* Cette fonction est bloquante tant que la connexion n'a pas été établie.
* S'il existe un cookie en local on s'authentifie directement avec lui.
* Si il n'est pas possible de s'authentifier alors on affiche un captcha anti-bot.
*/
Client.prototype.connexionCookie = function()
{
this.getCookie()
if (this.cookie == null) return false;
return this.connexion(this.getJSONLoginCookie())
}
Client.prototype.connexionLogin = function(login, password)
{
return this.connexion(this.getJSONLogin(login, password))
}
Client.prototype.enregistrement = function(login, password)
{
if (this.authentifie())
{
this.login = login
this.password = password
if(this.flush())
{
this.setStatut(statutType.auth_registered)
return true
}
return false
}
else
{
return this.connexion(this.getJSONEnregistrement(login, password))
}
}
/**
* Connexion. Réalisé de manière synchrone.
*/
Client.prototype.connexion = function(messageJson)
{
var thisClient = this
jQuery.ajax(
{
async: false,
type: "POST",
url: "request",
dataType: "json",
data: this.util.jsonVersAction(messageJson),
success:
function(data)
{
if (data["reply"] == "error")
{
thisClient.util.messageDialogue(data["error_message"])
// suppression du cookie actuel, cas où le cookie du client ne permet pas une authentification
thisClient.delCookie()
}
else
thisClient.chargerDonnees(data)
}
}
)
return this.authentifie()
}
Client.prototype.deconnexion = function()
{
this.flush(true)
this.delCookie()
this.resetDonneesPersonnelles()
this.setStatut(statutType.deconnected) // deconnexion
}
Client.prototype.chargerDonnees = function(data)
{
// la modification du statut qui suit met à jour le menu, le menu dépend (page admin)
// de l'état ekMaster
this.ekMaster = data["ek_master"] != undefined ? data["ek_master"] : false
this.setStatut(data["status"])
if (this.authentifie())
{
this.cookie = data["cookie"]
this.setCookie()
this.id = data["id"]
this.login = data["login"]
this.pseudo = data["nick"]
this.email = data["email"]
this.setCss(data["css"])
this.chatOrder = data["chat_order"]
this.nickFormat = data["nick_format"]
this.viewTimes = data["view_times"]
this.viewTooltips = data["view_tooltips"]
this.ostentatiousMaster = data["ostentatious_master"]
// la page de la conversation principale
this.pagePrincipale = 1
// les conversations
this.conversations = data["conversations"]
for (var i = 0; i < this.conversations.length; i++)
this.conversations[i] = {root : this.conversations[i].root, page : 1, reduit : this.conversations[i].minimized}
this.majBulle()
this.majCssSelectionee()
//this.majLogo()
}
}
/**
* Met à jour les données personne sur serveur.
* @param async de manière asynchrone ? défaut = true
* @return false si le flush n'a pas pû se faire sinon true
*/
Client.prototype.flush = function(async)
{
if (async == undefined)
async = false
if (!this.authentifie())
return false
var thisClient = this
var ok = true
jQuery.ajax(
{
async: async,
type: "POST",
url: "request",
dataType: "json",
data: this.util.jsonVersAction(this.getJSONProfile()),
success:
function(data)
{
if (data["reply"] == "error")
{
thisClient.util.messageDialogue(data["error_message"])
ok = false
}
else
{
thisClient.majBulle()
}
}
}
)
return ok
}
Client.prototype.majMenu = function()
{
var displayType = "block"
$("#menu .admin").css("display", this.ekMaster ? displayType : "none")
// met à jour le menu
if (this.statut == statutType.auth_registered)
{
$("#menu .profile").css("display", displayType).text("profile")
$("#menu .logout").css("display", displayType)
$("#menu .register").css("display", "none")
}
else if (this.statut == statutType.auth_not_registered)
{
$("#menu .profile").css("display", "none")
$("#menu .logout").css("display", displayType)
$("#menu .register").css("display", displayType)
}
else
{
$("#menu .profile").css("display", displayType).text("login")
$("#menu .logout").css("display", "none")
$("#menu .register").css("display", displayType)
}
}
/**
* Met à jour l'affichage des infos bulles en fonction du profile.
*/
Client.prototype.majBulle = function()
{
this.util.bulleActive = this.viewTooltips
}
/**
* Met à jour la css sélectionnée, lors du chargement des données.
*/
Client.prototype.majCssSelectionee = function()
{
// extraction du numéro de la css courante
var numCssCourante = this.css.match(/^.*?\/(\d)\/.*$/)
if (numCssCourante != null && numCssCourante[1] != undefined)
{
$("#menuCss option").removeAttr("selected")
$("#menuCss option[value=" + numCssCourante[1]+ "]").attr("selected", "selected")
}
}
/**
* Change la "class" du logo en fonction du statut de ekMaster.
*/
Client.prototype.majLogo = function()
{
if (this.ekMaster)
$("#logo").addClass("ekMaster")
else
$("#logo").removeClass("ekMaster")
}
Client.prototype.slap = function(userId, raison)
{
var thisClient = this
jQuery.ajax({
type: "POST",
url: "request",
dataType: "json",
data: this.util.jsonVersAction(
{
"header" : { "action" : "slap", "version" : euphorik.conf.versionProtocole },
"cookie" : thisClient.cookie,
"user_id" : userId,
"reason" : raison
}),
success:
function(data)
{
if (data["reply"] == "error")
thisClient.util.messageDialogue(data["error_message"])
}
})
}
Client.prototype.ban = function(userId, raison, minutes)
{
var thisClient = this
// par défaut un ban correspond à 3 jours
if (typeof(minutes) == "undefined")
minutes = euphorik.conf.tempsBan;
jQuery.ajax({
type: "POST",
url: "request",
dataType: "json",
data: this.util.jsonVersAction(
{
"header" : { "action" : "ban", "version" : euphorik.conf.versionProtocole },
"cookie" : thisClient.cookie,
"duration" : minutes,
"user_id" : userId,
"reason" : raison
}),
success:
function(data)
{
if (data["reply"] == "error")
thisClient.util.messageDialogue(data["error_message"])
}
})
}
Client.prototype.kick = function(userId, raison)
{
this.ban(userId, raison, euphorik.conf.tempsKick)
}
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
* classe permettant de gérer les événements (push serveur).
* l'information envoyé est sous la forme :
* {
* "header" : {"action" : "wait_event", "version" : },
* "page" :
* [..]
* }
* l'information reçu est sous la forme :
* {
* "reply" :
* }
* @page la page
*/
function PageEvent(page, util)
{
this.page = page
this.util = util
// l'objet JSONHttpRequest représentant la connexion d'attente
this.attenteCourante = null
// le multhreading du pauvre, merci javascript de m'offrire autant de primitives pour la gestion de la concurrence...
this.stop = false
}
/**
* Arrête l'attente courante s'il y en a une.
*/
PageEvent.prototype.stopAttenteCourante = function()
{
this.stop = true
if (this.attenteCourante != null)
{
this.attenteCourante.abort()
}
}
/**
* Attend un événement lié à la page.
* @funSend une fonction renvoyant les données json à envoyer
* @funsReceive est un objet comprenant les fonctions à appeler en fonction du "reply"
* les fonctions acceptent un paramètre correspondant au données reçues.
* exemple : {"new_message" : function(data){ ... }}
*/
PageEvent.prototype.waitEvent = function(funSend, funsReceive)
{
this.stopAttenteCourante()
this.stop = false
var thisPageEvent = this
// on doit conserver l'ordre des valeurs de l'objet JSON (le serveur les veut dans l'ordre définit dans le protocole)
// TODO : ya pas mieux ?
var dataToSend =
{
"header" : { "action" : "wait_event", "version" : euphorik.conf.versionProtocole },
"page" : this.page
}
var poulpe = funSend()
for (var v in poulpe)
dataToSend[v] = poulpe[v]
this.attenteCourante = jQuery.ajax({
type: "POST",
url: "request",
dataType: "json",
// TODO : doit disparaitre
timeout: 180000, // timeout de 3min. Gros HACK pas beau. FIXME problème décrit ici : http://groups.google.com/group/jquery-en/browse_thread/thread/8724e64af3333a76
data: this.util.jsonVersAction(dataToSend),
success:
function(data)
{
funsReceive[data["reply"]](data)
// rappel de la fonction dans 100 ms
setTimeout(function(){ thisPageEvent.waitEvent2(funSend, funsReceive) }, 100)
},
error:
function(XMLHttpRequest, textStatus, errorThrown)
{
;; console.log("Connexion perdue dans waitEvent")
setTimeout(function(){ thisPageEvent.waitEvent2(funSend, funsReceive) }, 1000)
}
})
}
/**
* Si un stopAttenteCourante survient un peu n'importe quand il faut imédiatement arreter de boucler.
*/
PageEvent.prototype.waitEvent2 = function(funSend, funsReceive)
{
if (this.stop)
return
this.waitEvent(funSend, funsReceive)
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// le main
$(document).ready(
function()
{
var formateur = new Formateur()
var util = new euphorik.Util(formateur)
var client = new Client(util)
var pages = new Pages()
// connexion vers le serveur (utilise un cookie qui traine)
client.connexionCookie()
$("#menuCss").change(function(){ client.setCss("styles/" + $("option:selected", this).attr("value") + "/euphorik.css")})
// FIXME : ne fonctionne pas sous opera
// voir : http://dev.jquery.com/ticket/2892#preview
$(window).unload(function(){client.flush()})
$("#menu .minichat").click(function(){ pages.afficherPage("minichat") })
$("#menu .admin").click(function(){ pages.afficherPage("admin") })
$("#menu .profile").click(function(){ pages.afficherPage("profile") })
$("#menu .logout").click(function(){
util.messageDialogue("Êtes-vous sur de vouloir vous délogger ?", euphorik.Util.messageType.question,
{"Oui" : function()
{
client.deconnexion();
pages.afficherPage("minichat", true)
},
"Non" : function(){}
}
)
})
$("#menu .register").click(function(){ pages.afficherPage("register") })
$("#menu .about").click(function(){ pages.afficherPage("about") })
// TODO : simplifier et pouvoir créer des liens par exemple : Conditions d'utilisation
$("#footer .conditions").click(function(){ pages.afficherPage("conditions_utilisation") })
pages.ajouterPage(new PageMinichat(client, formateur, util))
pages.ajouterPage(new PageAdmin(client, formateur, util))
pages.ajouterPage(new PageProfile(client, formateur, util))
pages.ajouterPage(new PageRegister(client, formateur, util))
pages.ajouterPage(new PageAbout(client, formateur, util))
pages.ajouterPage("conditions_utilisation")
pages.afficherPage("minichat")
}
)