def ChBoutonMod(self):
'''Met à jour le texte du bouton pour afficher "Installer" ou "Supprimer" suivant si le module séléctionné existe sur le disque ou pas'''
if self.listeMod[self.ListeModules.currentRow()][0] == 'titre':
self.BouttonInstModules.setEnabled(False)
else:
self.BouttonInstModules.setEnabled(True)
if os.path.exists(
self.repMod + "/" +
self.listeMod[self.ListeModules.currentRow()][0]):
self.BouttonInstModules.setText(i18n.traduc("Supprimer"))
else:
self.BouttonInstModules.setText(i18n.traduc("Installer"))
self.AffMajMod()
def traducsModules(self):
#self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_5), i18n.traduc("Gestionnaire des modules"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_5),
i18n.traduc("Modules"))
self.tabWidget.setTabIcon(
self.tabWidget.indexOf(self.tab_5),
QtGui.QIcon(dossier_racine + '/res/ajouter.png'))
self.tabModules.setTabText(0, i18n.traduc("Depot"))
self.tabModules.setTabIcon(
0, QtGui.QIcon(dossier_racine + '/res/txt_oxygen.png'))
self.BouttonInstModules.setText(i18n.traduc("Installer"))
self.BouttonMajMod.setText(i18n.traduc("Mettre a jour"))
def retranslateUi(self, Dialog):
'''Affiche le texte dans l'interface'''
Dialog.setWindowTitle(i18n.traduc("Ajouter un raccourci"))
self.bouton_parcourir_ico.setText(i18n.traduc("Parcourir..."))
self.bouton_parcourir_rep.setText(i18n.traduc("Parcourir..."))
self.label.setText(i18n.traduc("Nom du jeu:"))
#self.label_2.setText("Version (optionnel):")
self.label_3.setText(i18n.traduc("Icone:"))
self.label_4.setText(i18n.traduc("Commande du jeu:"))
self.label_5.setText(i18n.traduc("Repertoire") + ":")
self.bouton_parcourir_cmd.setText(i18n.traduc("Parcourir..."))
self.bouton_sauver.setText(i18n.traduc("Sauvegarder et fermer"))
def ajout_utilisateur_irc(self):
'''Ajoute un utilisateur dans la liste sur le canal IRC donné'''
canal = variables.even_irc[1]
nom_utilisateur = variables.even_irc[2]
# print "Ajout utiliseur:", canal, self.canal_courant
# Ajoute de la liste des utilisateurs celui qui vient de se connecter:
if not self.pseudo in nom_utilisateur:
if self.canal_courant == canal:
img_b = QtGui.QPixmap(dossier_racine + '/icone.png')
item = QtGui.QListWidgetItem(self.listWidget_chat)
item.setIcon(QtGui.QIcon(img_b))
item.setText(str(nom_utilisateur))
self.listWidget_chat.addItem(item)
chaine = "--><span style='color: rgb(0, 255, 0);'> " + \
i18n.traduc(
"Utilisateur connecte") + ': ' + nom_utilisateur + '\n' + "</span>"
self.Aliste_txt_irc(chaine, canal, 0)
try:
variables.liste_utilisateurs[canal].append(nom_utilisateur)
except KeyError, x:
print("ajout_utilisateur_irc():" + str(x))
pass
def verif_liste_fichiers(self, addr, liste_fichiers):
'''Parcours la liste des fichiers en ligne et vérifi si ils existent en dur'''
boucle = 0
while boucle < len(liste_fichiers):
liste_fichiers[boucle] = liste_fichiers[boucle].replace('\n', '')
# Vérifi si les fichiers existent:
if os.path.exists(racine + '/' + liste_fichiers[boucle]) == False or self.restaure == 1:
print i18n.traduc_ascii("Le fichier:"), liste_fichiers[boucle], i18n.traduc("est manquant, il sera telecharge")
# Sinon, on les téléchargent:
# Si les fichiers sont contenus dans un dossier:
if '/' in liste_fichiers[boucle]:
dossier = liste_fichiers[boucle].split('/')
# Vérifi si le dossier n'existe pas déjà
# if os.path.exists(racine + '/' + dossier[0]) == False:
boucle_ = 0
ancienne_var = ''
# Créé l'arborescence de fichiers avant le téléchargements:
while boucle_ < len(dossier) - 1:
# Sinon, on le créé:
var = ancienne_var + '/' + dossier[boucle_]
try:
os.mkdir(racine + '/' + var)
except:
pass
ancienne_var = var
boucle_ = boucle_ + 1
# Télécharge les fichiers:
urllib.urlretrieve(
addr + '/' + liste_fichiers[boucle],
filename=racine + '/' + liste_fichiers[boucle],
reporthook=None)
# else: print '>', liste_fichiers[boucle]
boucle = boucle + 1
def verif_processus(self):
'''Vérifi si un processus djl n'est pas déjà lancé'''
processus = os.popen('ps -ef |grep djl_main |grep python')
retour = processus.readlines()
retour_final = []
for i in range(len(retour)):
if not 'ps -ef' in retour[i]:
retour_final.append(retour[i])
if len(retour_final) >= 1:
app = QtGui.QApplication(sys.argv)
titre = i18n.traduc("Attention")
#message=i18n.traduc("djl est deja lance")
message = i18n.traduc("djl est deja lance")
avertissement(titre, message, quitte=i)
def init_IRC(self):
'''Se connecte automatiquement sur IRC ou pas, suivant la configuration'''
# Envoi la connexion au canal IRC suivant la configuration
self.etat_irc = 1
if int(config(info=12)) == 1:
self.connexion_irc()
else:
self.Button_connect_chat.setText(i18n.traduc("Connection"))
def etat(self, nom_jeu):
'''Permet de savoir si le jeu est installé ou non
Si etat = 0: pas installé, 1 = installé, 2 = téléchargé mais pas installé'''
repertoire = config(info=2) + '/etat_jeux/'
fichier = repertoire + nom_jeu
if os.path.isdir(fichier):
return
# Vérifi si le fichier etat existe et l'utilise
if os.path.exists(fichier) == True:
txt_etat = open(fichier, 'r')
etat = int(txt_etat.read())
txt_etat.close()
# Si le fichier etat qui n'existe pas, on part du principe que le jeu n'est pas installé
else:
etat = 0
# print nom_jeu, str(etat)
if etat == 0:
self.boutton_installer.setText(i18n.traduc("Installer"))
self.boutton_installer.setEnabled(True)
self.boutton_supprimer.setEnabled(False)
self.boutton_maj.setEnabled(False)
self.label_4.setText(i18n.traduc("Etat: Non installe"))
# print 'Le jeu n\'est pas installé'
if etat == 1:
self.label_4.setText(i18n.traduc("Etat: Installe"))
self.boutton_installer.setText(i18n.traduc("Jouer"))
self.boutton_installer.setEnabled(True)
self.boutton_supprimer.setEnabled(True)
# Verifi si la mise à jour est possible:
self.verif_maj_jeu(nom_jeu)
# print 'Le jeu est installé'
if etat == 2:
self.label_4.setText(i18n.traduc("Etat: Telecharge"))
self.boutton_installer.setText(i18n.traduc("Installer"))
self.boutton_installer.setEnabled(True)
self.boutton_maj.setEnabled(False)
# self.boutton_supprimer.setEnabled(True)
# print 'Le jeu est en cours d\'installation'
# Si l'etat est à 4, c'est qu'on a annulé le téléchargement
if etat == 4:
self.label_4.setText(i18n.traduc("Etat: Non installe"))
self.boutton_installer.setText(i18n.traduc("Installer"))
self.boutton_installer.setEnabled(True)
self.boutton_supprimer.setEnabled(False)
self.boutton_maj.setEnabled(False)
modif_etat(nom_jeu, val_etat=0)
etat = 0
self.etat_actuel = etat
def maj_depot(self):
'''Met à jour le dépot côté client (Normalement au démarrage ou manuellement (réservé à la version de développement))'''
# Créé la liste des langues du depot:
# self.liste_lang=self.clientSOAP.listeLang()
# Récupère la liste des types de jeux:
self.liste_genre = self.clientSOAP.listeType(self.lang)[0]
# Recupère la liste des licenses:
self.listelicense = self.clientSOAP.listeLicence(self.lang)
# On récupère la liste des jeux (avec toutes les infos qui vont avec,
# commande de lancement, icone, etc...):
self.liste_jeux = self.clientSOAP.listeJeux()
# print self.liste_jeux
# Récupère le nombre de jeux:
self.nb_jeux = len(self.liste_jeux[0])
# print self.nb_jeux
self.liste_nom_jeux = []
for i in range(self.nb_jeux): # Récupère les noms de jeux
self.liste_nom_jeux.append(self.parse_listejeux(i, 0))
if self.int_etendue == 1:
self.filtre_liste()
# Affiche dans la boite adéquat la liste des type de jeux:
self.comboBox.clear()
for i in range(len(self.liste_genre)):
chaine = self.parse_listegenre(i, 1)
if chaine == "Tous":
chaine = (i18n.traduc("Tous"))
self.comboBox.addItem(chaine)
self.comboBox.setCurrentIndex(0)
# Affiche dans la combobox la liste des licenses:
self.combo_license.clear()
for i in range(len(self.listelicense)):
chaine = self.parse_listelicence(i)
if chaine == "Toutes":
chaine = (i18n.traduc("Tous"))
self.combo_license.addItem(chaine)
self.combo_license.setCurrentIndex(0)
def desactive_client(self):
'''On vient de se deconnecter, on désactive le client'''
#self.connecte = 0
self.textEdit_chat.setText("")
self.textEdit_chat.insertPlainText(i18n.traduc("Deconnecte") + "\n")
self.listWidget_chat.clear()
self.listeW_canaux.clear()
# self.textEdit_chat.setEnabled(False)
self.line_Edit_chat.setEnabled(False)
self.pushButton_chat.setEnabled(False)
self.listWidget_chat.setEnabled(False)
self.listeW_canaux.setEnabled(False) # Liste des canaux
def maj_description(self):
'''Dès que l'on change de jeu dans la liste, affiche la description dans la zone correspondante: (Depot)'''
# Si la liste des jeux n'est pas encore prete, on sort de la fonction
if len(self.liste_jeux_ok) == 0:
return
nom_jeu = self.nom_jeu_depot()
# print nom_jeu
no_description = self.trouve_index(nom_jeu)
# print variables.installe
version = self.parse_listejeux(no_description, 1).split('-r')[0]
nom = self.parse_listejeux(no_description, 0)
# Affiche le nom du jeu dans la description:
self.label_4_2.setText(nom)
# Affiche la version du jeu dans la description:
self.label_4_v.setText(i18n.traduc("Version:") + " " + version)
# Trouve le type de jeu depuis le webservice:
gr = self.detail_jeux(no_description,
type_info='genre') # id (entier) du genre
for i in range(len(self.liste_genre)):
if gr == self.parse_listegenre(i, 0):
gr = i
break
# Si il trouve quelque chose:
if gr != '':
try:
genre = self.parse_listegenre(int(gr), 1)
except (TypeError, IndexError), x:
print "Genre: ", str(x)
genre = "?"
# Affiche le type de jeu dans le 'label' prévu à cet effet:
self.label_5.setText(i18n.traduc("Genre") + ": " + genre)
def recup(self):
if not VarsDep.init: # Si c'est le premier lancement de la classe...
VarsDep.init = True
VarsDep.instance = GestionLibs()
self.creer_liste()
# Récupère la librairie:
trouve = False
for i in range(len(VarsDep.liste)):
if VarsDep.liste[i] == self.nom_lib:
trouve = True
VarsDep.instance.Telecharge(self.nom_lib)
break
if trouve:
#interface.info_box(i18n.traduc("Librairie manquante trouvé:") + ' ' + self.nom_lib)
# Si la librairie manquante a été installée, on tente de relancer le jeu:
variables.instance.lance()
else:
interface.info_box(
i18n.traduc("La librairie n'a pas ete trouvee") + ': ' +
self.nom_lib + '\n' +
i18n.traduc("Merci de rapporter le probleme au developpeur."))
def setupUi(self, MainWindow, parent):
'''Envoi l'affichage de la fenêtre'''
MainWindow.setObjectName("MainWindow")
x, y = 321, 536
MainWindow.resize(x, y)
MainWindow.setMinimumSize(QtCore.QSize(x, y))
MainWindow.setMaximumSize(QtCore.QSize(x, y))
# Place de fenêtre au centre de la fenêtre principale
posx = parent.pos().x() + parent.width() / 2
posy = parent.pos().y() + parent.height() / 2
self.move(posx - (x / 2), posy - (y / 2))
#/
icone = QtGui.QIcon(dossier_racine + '/icone.png')
MainWindow.setWindowIcon(icone)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setGeometry(QtCore.QRect(0, 0, 321, 536))
self.centralwidget.setObjectName("centralwidget")
self.pushButton = QtGui.QPushButton(self.centralwidget)
self.pushButton.setGeometry(QtCore.QRect(30, 505, 121, 27))
self.pushButton.setObjectName("pushButton")
self.pushButton_2 = QtGui.QPushButton(self.centralwidget)
self.pushButton_2.setGeometry(QtCore.QRect(170, 505, 121, 27))
self.pushButton_2.setObjectName("pushButton_2")
self.listWidget = QtGui.QListWidget(self.centralwidget)
self.listWidget.setGeometry(QtCore.QRect(0, 60, 321, 441))
self.listWidget.setObjectName("listWidget")
self.checkBox = QtGui.QCheckBox(self.centralwidget)
self.checkBox.setGeometry(QtCore.QRect(10, 2, 311, 31))
self.checkBox.setObjectName("checkBox")
self.lineEdit = QtGui.QLineEdit(self.centralwidget)
self.lineEdit.setGeometry(QtCore.QRect(66, 30, 253, 28))
self.lineEdit.setObjectName("lineEdit")
self.lineEdit.setEnabled(False)
self.label = QtGui.QLabel(self)
self.label.setGeometry(QtCore.QRect(3, 30, 60, 28))
self.label.setObjectName("label")
self.label.setText(i18n.traduc("Chercher") + ":")
# Etat par défaut que la checkbox (Doit on ou non n'afficher que les jeux ?)
self.checkBox.setChecked(True)
# MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def __init__(self, texte="", titre="Attention"):
'''Affiche une boite de dialogue avec le texte avec la police choisie dans la config et un simple bouton "Fermer'''
QtGui.QMessageBox.__init__(self)
texte = texte.replace("\n", "<br>")
#texte = _(texte)
titre = _(titre)
taille_police = str(config(info=15) + 2)
# temp:
texte = texte
q_texte = QtCore.QString("<font style=\"font-size: " + taille_police +
"px;\">" + texte + "</font>")
QtGui.QMessageBox.information(self, titre, q_texte,
i18n.traduc("Fermer"))
def active_client(self):
'''On vient d'être connecté, on active le client IRC'''
# Défini la position du curseur actuel, servira plus tard pour ajouter le texte à la fin.
#self.curseur_chat = self.textEdit_chat.textCursor()
self.textEdit_chat.setEnabled(True)
self.line_Edit_chat.setEnabled(True)
self.pushButton_chat.setEnabled(True)
self.listWidget_chat.setEnabled(True)
self.listeW_canaux.setEnabled(True) # Liste des canaux
self.listeW_canaux.setCurrentRow(0)
self.line_Edit_chat.setText("")
self.canal_courant = self.canaux_IRC[0]
self.insert_txt_irc(i18n.traduc("Connecte !") + "<br />", 1)
self.change_canal()
variables.connecte = 2
def supprime_utilisateur_irc(self):
'''Supprime un utilisateur de la liste sur IRC et affiche la nouvelle liste'''
canal = variables.even_irc[1]
nom_utilisateur = variables.even_irc[2]
# print canal, self.canal_courant
chaine = "--><span style='color: rgb(187, 111, 61);'> " + \
i18n.traduc(
"Utilisateur deconnecte") + ': ' + nom_utilisateur + '\n' + "</span>"
# print ">0", variables.liste_utilisateurs[canal]
# Enlève l'utilisateur déconnecté de la liste:
if canal is None: # Si l'utilisateur a quitté complètement IRC (commande /quit)
# Rappel, liste_utilisateur est un dico, id est une chaine.
for id in variables.liste_utilisateurs:
if nom_utilisateur in variables.liste_utilisateurs[id]:
# On donne à la fonction d'envoi des message des notifications le nom du
# canal où l'utilisateur vient que faire /quit:
variables.even_irc[1] = id
try:
variables.liste_utilisateurs[id].remove(str(nom_utilisateur))
except ValueError:
print "Problème de deconexion>>>", nom_utilisateur
self.Aliste_txt_irc(chaine, id)
if id == self.canal_courant:
self.cree_liste_utilisateurs_irc(id)
else:
try:
self.Aliste_txt_irc(chaine, canal)
variables.liste_utilisateurs[canal].remove(str(nom_utilisateur))
except ValueError:
print "Problème de deconexion>>>", nom_utilisateur
# Créé une nouvelle liste d'utilisateurs
# print ">1", variables.liste_utilisateurs[canal]
if canal == self.canal_courant:
self.cree_liste_utilisateurs_irc(canal)
def ch_tab(self):
'''Quand on change d'onglet...'''
if self.tabWidget.currentIndex() == 2: # Dépôt...
if self.connecte_ws == 0: # Si on est pas connecté au WS, on le fait maintenant
# self.Thread_depot()
self.listWidget.clear()
if int(
config(info=3)
) == 1 and QtGui.QSystemTrayIcon.isSystemTrayAvailable():
self.menu_lance.clear()
# Créé un nouvelle liste des jeux installés
self.liste_jeux_installe()
# Pareil pour les raccourcis
self.liste_raccourcis()
try:
self.maj_description()
except AttributeError:
pass
self.widget_liste_jeux.setFocus(
) # Donne le focus à la liste des jeux
elif self.tabWidget.currentIndex() == 3: # IRC.
# Si on affiche le canal IRC, on remet le titre "normal" qui a put être
# modifié avec l'arrivée d'un nouveau message
self.clignote_IRC = 0
self.tabWidget.setTabIcon(
3, QtGui.QIcon(dossier_racine + '/res/irc_crystal.png'))
if int(config(info=3)
) == 1 and QtGui.QSystemTrayIcon.isSystemTrayAvailable():
self.tray.setIcon(QtGui.QIcon(dossier_racine + '/icone.png'))
self.tabWidget.setTabText(3, i18n.traduc("IRC"))
# On donne le focus à la barre de texte pour envoyer le message:
self.line_Edit_chat.setFocus()
elif self.tabWidget.currentIndex() == 1: # Liste des jeux principale.
# Donne le focus à la barre de recherche.
self.recherche_jeu.setFocus()
elif self.tabWidget.currentIndex() == 4: # Modules
self.chTabMod()
def c_err(self):
'''Recherche une éventuelle exception dans la sortie d'erreur'''
app = QtGui.QApplication(sys.argv)
nb_err_copie = 0
while (1):
# Compte le nombre d'erreurs reperés dans le fichier:
nb_err = 0
f = open(home + '/.djl/stderr', 'r')
fichier = f.readlines()
for it in range(len(fichier)):
if "Traceback (most recent call last):" in fichier[it]:
nb_err += 1
# Si le nombre d'erreurs reperés dans le fichier diffère du nombre
# d'erreurs déjà affichés, on affiche un message d'erreur avec le contenu
# de la sortie d'erreur.
if nb_err_copie != nb_err:
msg_err = self.parse_err(fichier)
chaine = msg_err + '\n' + \
i18n.traduc("Merci de rapporter le probleme au developpeur.")
#message = QtGui.QApplication.translate("MainWindow", chaine, None, QtGui.QApplication.UnicodeUTF8)
print msg_err
avertissement("stderr " + r_date(), chaine, 0)
nb_err_copie = nb_err
f.close()
# Si djl est fermé on quitte la boucle et donc le thread
if self.p.poll() is not None:
break
time.sleep(1)
def filtre_liste(self):
'''Créé la liste des jeux affichés dans le dépôt en fonction des filtres seléctionnés'''
filtre_genre = self.parse_listegenre(self.comboBox.currentIndex(), 0)
filtre_licence = self.combo_license.currentIndex()
self.liste_jeux_ok = []
self.liste_index = []
self.widget_liste_jeux.clear()
for i in range(self.nb_jeux):
type_jeu = self.parse_listejeux(i, 5) # Recupère le type de jeu
licence = self.parse_listejeux(i, 9) # Recupère la licence du jeu
# Filtre ici les jeux par genre
if (int(type_jeu) == int(filtre_genre)) | (int(filtre_genre) == 0):
# Filtre ici les jeux par licence
if (int(licence) == int(filtre_licence)) | (int(filtre_licence)
== 0):
nom_jeu = self.parse_listejeux(i, 0)
# Si on a la version de développement, on ajoute un * au nom du jeu si il
# n'est pas validé, afin de le reconnaitre:
if variables.version_dev == 1:
if self.parse_listejeux(i, 8) == "0":
nom_jeu = "* " + nom_jeu
self.widget_liste_jeux.addItem(nom_jeu)
nom_rep = self.parse_listejeux(i, 2)
self.liste_jeux_ok.append(nom_rep)
self.liste_index.append(self.parse_listejeux(i, 6))
# print '>>>' + str(len(self.liste_jeux_ok))
self.label.setText(
i18n.traduc("Liste des jeux disponible: (") +
str(len(self.liste_jeux_ok)) + '/' + str(self.nb_jeux) + ')')
def lance(self, Qitem='', Djeu='', Darguments=''):
'''On lance un jeu ici (jeu séléctionné dans la liste de jeux principale ou défini par la variable Djeu), avec si besoin des arguments'''
# if self.tabWidget.currentIndex() == 1: #liste principale
# self.lance()
# elif self.tabWidget.currentIndex() == 2: #depot
# self.maj_description()
# self.installer_jouer()
if self.int_etendue:
# Si on ne défini pas de jeu, on prend l'objet séléctionné dans la liste
# de jeux principale
if Djeu == '':
if self.tabWidget.currentIndex() == 1: # liste principale
jeu_actuel = self.nom_jeu_pr()
elif self.tabWidget.currentIndex() == 2: # depot
jeu_actuel = self.nom_jeu_depot()
else:
jeu_actuel = self.nom_jeu_pr()
else:
for i in range(len(self.liste_jeux_f)):
if Djeu == self.liste_jeux_f[i]:
jeu_actuel = Djeu
break
else: # Si on utilise l'interface simple...
jeu_actuel = self.nom_jeu_pr()
# print '>', jeu_actuel, Darguments, Djeu
diff.ecrit_historique(str(jeu_actuel) + i18n.traduc("lance"))
# On lance la fonction qui va bien au module 'Dlog', si il existe
try:
self.trouve_module('Dlog', 1).lance(jeu_actuel)
except:
pass # Mieux vaut ignorer les exception, sinon on ne peut plus lancer les jeux
# Bloque l'interface graphique quelques secondes avant de lancer le jeu:
# Si le jeu met un peu de temps à se lancer, l'utilisateur ne pourra pas
# lancer (bêtement) plusieurs fois le jeu
self.listWidget.setEnabled(False)
self.bloque_ui = 1
# Si c'est un fichier .desktop, on lance le jeu comme il faut:
if '.desktop' in jeu_actuel:
cmd = self.lit_fichier_desktop(fichier=jeu_actuel,
type_info='Exec')
# print '>Commande: ', str(cmd), '/', str(jeu_actuel), self.listWidget.currentRow()
# Si le raccourcis utilise une variable path pour définir le réperoire du jeu
dir_jeu = self.lit_fichier_desktop(fichier=jeu_actuel,
type_info='Path')
# Supprime les espaces dans la ligne de commande et les remplace par '\ '
# if ' ' in cmd:
# if '\ ' in cmd:
# pass
# else:
#cmd=cmd.replace(' ', '\ ')
# Ajoute les arguments de lancement défini par l'utilisateur (si il y en a)
cmd = cmd + ' ' + Darguments + ' ' + str(
self.trouve_args(jeu_actuel))
th_lance = lance(jeu_actuel, cmd, dir_jeu, raccourci=1)
th_lance.start()
# Sinon, c'est un jeu installé depuis le dépot, on le lance donc différemment:
else:
# On récupère la commande du jeu:
cmd = self.trouve_commande(dossier=jeu_actuel)
# Ajoute les arguments (si il y en a)
cmd = cmd + ' ' + str(
self.trouve_args(jeu_actuel)) + ' ' + Darguments
# On lance le jeu avec la class lance() dans installe.py:
th_lance = lance(jeu_actuel, cmd)
th_lance.start()
print("- " + jeu_actuel + ">" + cmd)
# Affiche la sortie dans une boite de dialogue (en fonction de la configuration):
if int(config(info=7)) == 1:
self.affiche_sortie_jeu()
# Affiche la boite de dialogue "En cours de lancement" pendent 3 secondes:
self.MessageLancement = diff.MessageLancement(3, self)
self.MessageLancement.show()
def traducsDepot(self):
self.widget_liste_jeux.clear()
self.boutton_installer.setText(i18n.traduc("Jouer"))
self.boutton_supprimer.setText(i18n.traduc("Supprimer"))
self.boutton_maj.setText(i18n.traduc("Mettre a jour"))
self.texte_description.setHtml(
i18n.traduc("Choisissez un jeu pour avoir une description."))
self.label.setText(i18n.traduc("Liste des jeux disponible:"))
self.label_2.setText(i18n.traduc("Description:"))
# self.label_5.setText(i18n.traduc("Genre"))
# self.label_6.setText(i18n.traduc("Taille"))
self.label_7.setText(i18n.traduc("Plate-forme: x86"))
self.label_8.setText(i18n.traduc("Trier les jeux:"))
# self.label_9.setText(i18n.traduc("Licence"))
self.b_article.setText(i18n.traduc("Plus d'informations..."))
self.b_site.setText(i18n.traduc("Site internet") + "...")
self.tabDepot.setTabText(0, i18n.traduc("Depot"))
self.tabDepot.setTabText(1, i18n.traduc("Telechargement"))
def timerEventDepot(self):
'''Cette fonction est appellée toutes les secondes, ça permet de mettre à jour l'affichage et le calcul du débit par seconde du téléchargement.'''
# print "-------"
# print self.listeTelechargement
# print variables.installe
# Fais clignoter la barre de titre du dépôt si demandé:
# if self.clignote_depot:
# if self.val_clignote_depot == 0:
#self.tabDepot.setTabIcon(1, self.IconOngletTelechargement1)
#self.val_clignote_depot = 1
# else:
#self.tabDepot.setTabIcon(1, self.IconOngletTelechargement2)
#self.val_clignote_depot = 0
# Parcours la liste des téléchargements pour mettre à jour l'affichage
for id in range(len(self.listeTelechargement)):
obj = self.listeTelechargement[id]
# Récupère les informations de téléchargement sur le Thread:
nb_blocs, taille_bloc, taille_fichier = obj[0].renvoi_infos()
# Tant que le téléchargement n'est pas lancé, on n'affiche rien
if taille_fichier != 1:
if (nb_blocs * taille_bloc) <= taille_fichier:
# Calcul la taille de ce qui a déjà été téléchargé (en octets)
telecharge = nb_blocs * taille_bloc
# Calcul la taille de ce qu'il reste à télécharger (en octets):
reste = taille_fichier - telecharge
# Calcul le total de données téléchargés et divise par le nombre de
# secondes afin d'avoir le débit kb/S
debit = (telecharge / self.iterationBoucleTele) / 1024
if debit > 0:
# Calcul le pourcentage d'avancement du téléchargement:
pourcentage = int(((telecharge + 0.) / taille_fichier + 0.) * 100)
# Calcule le temps restant à télécharger en fonction du débit et du
# reste...
temps_restant = (reste / 1024) / debit
# Récupère le nombre de minutes en divisant simplement par 60
temps_restant_minutes = temps_restant / 60
# Recupère le nombre de secondes restantes
temps_restant_secondes = temps_restant - (temps_restant_minutes * 60)
if temps_restant_secondes < 10:
temps_restant_secondes = "0" + str(temps_restant_secondes)
nom_jeu = obj[3]
# On demande d'éditer la ligne, on récupère l'index, puis l'objet depuis
# l'index et enfin on édite l'objet
item = self.listWidgetTelechargement.item(id)
item.setText(nom_jeu + ' - ' + str(pourcentage) + ' % - ' + str(taille_fichier / 1048576) + " " + _('Mo') + ' - ' + str(debit)
+ ' ' + _('Ko/s') + ' - ' + i18n.traduc("Temps restant:") + " " + str(temps_restant_minutes) + ":" + str(temps_restant_secondes))
else:
#item = self.listWidgetTelechargement.item(self.listWidgetTelechargement.currentRow())
item = self.listWidgetTelechargement.item(id)
try:
item.setText(i18n.traduc("Decompression de l'archive en cours..."))
except AttributeError, x:
print x
continue
# Vérifi si l'installation est terminée:
if variables.installe[obj[2]]:
print "Terminé:" + str(obj[2])
# Supprime la ligne de la liste (Widget)
self.listWidgetTelechargement.takeItem(id)
modif_etat(obj[2], val_etat=1) # Met l'etat du jeu a 'installé'
self.maj_liste() # Met à jour la liste de jeux principale
del variables.installe[obj[2]]
del self.listeTelechargement[id]
return (
# On passe l'itération du timer pour éviter les problèmes suite à la
# suppression des éléments dans les listes
)
self.gridlayout_2T.addWidget(self.listWidgetTelechargement)
self.listWidgetTelechargement.contextMenuEvent = self.contextMenuEventDepot
self.timerTelechargement = QtCore.QTimer(self)
QtCore.QObject.connect(
self.timerTelechargement,
QtCore.SIGNAL("timeout()"),
self.timerEventDepot)
self.timerTelechargement.start(1000)
# /
# Definition du menu contextuel:
self.menuCDepot = QtGui.QMenu(self)
self.menuCDepot.setFont(self.font)
self.act_AnnuleTelechargement = QtGui.QAction(_((i18n.traduc("Annuler"))), self)
self.act_AnnuleTelechargement.connect(
self.act_AnnuleTelechargement,
QtCore.SIGNAL("triggered()"),
self.StopTelechargement)
self.menuCDepot.addAction(self.act_AnnuleTelechargement)
icone = QtGui.QIcon(dossier_racine + '/res/redemarre_oxygen.png')
self.act_AnnuleTelechargement.setIcon(icone)
# /
self.connexionsDepot()
self.traducsDepot()
def connexionsDepot(self):
# Lève un évènement quand on change d'onglet dans le dépôt
self.tabDepot.connect(
if gr == self.parse_listegenre(i, 0):
gr = i
break
# Si il trouve quelque chose:
if gr != '':
try:
genre = self.parse_listegenre(int(gr), 1)
except (TypeError, IndexError), x:
print "Genre: ", str(x)
genre = "?"
# Affiche le type de jeu dans le 'label' prévu à cet effet:
self.label_5.setText(i18n.traduc("Genre") + ": " + genre)
else:
self.label_5.setText(i18n.traduc("Genre: Non defini"))
# Trouve la taille de l'archive depuis le webservice:
tl = self.detail_jeux(no_description, type_info='taille')
if tl == '':
self.label_6.setText(i18n.traduc("Taille: Non definie"))
else:
self.label_6.setText(i18n.traduc("Taille: ~") + str(tl) + ' Mo')
# Trouve la licence dans depuis le webservice:
licence = self.detail_jeux(no_description, type_info='licence')
if licence != '':
licence = licence.capitalize()
self.label_9.setText(i18n.traduc("Licence") + ": " + licence)
else:
self.label_9.setText(i18n.traduc("Licence: Non definie"))
def retranslateUi(self, Dialog):
'''Ajoute le texte dans l'interface'''
Dialog.setWindowTitle("Configuration")
fichier_cfg = self.home + '/.djl/config'
if not os.path.exists(fichier_cfg):
self.label.setText(
i18n.traduc(
"Ceci est le premier demarrage de djl, vous pouvez le configurer maintenant \n"
" ou passer cette etape pour vous en tenir a la configuration par defaut."
))
self.ligne_pseudo.setText(str(os.environ["USER"]).capitalize())
else:
self.label.setText(
i18n.traduc(
"Ceci est le menu de configuration de djl. \n"
"Certaines actions necessiteront le redemarrage du logiciel."
))
self.label_onglet_def.setText(i18n.traduc("Onglet par defaut") + ":")
self.label_2.setText(
i18n.traduc("Repertoire d'installation des jeux:"))
self.label_3.setText(i18n.traduc("Navigateur internet:"))
self.b_parcourir.setText(i18n.traduc("Parcourir..."))
self.b_parcourir_nav.setText(i18n.traduc("Parcourir..."))
self.check_b_suppr_archive.setText(
i18n.traduc("Supprimer les archives des jeux apres installation."))
self.check_b_lancer_jeu.setText(
i18n.traduc("Lancer les jeux apres installation."))
self.check_b_icone_barre.setText(
i18n.traduc(
"Iconifier djl dans la barre a miniature. (necessite redemarrage)"
))
self.check_b_maj_demarrage.setText(
i18n.traduc("Verifier la mise a jour de djl au demarrage."))
self.check_b_debug.setText(
i18n.traduc("Afficher la sortie des jeux a leur lancement."))
self.check_b_composition.setText(
i18n.traduc(
"Lancer les jeux dans un serveur graphique separe\n(Permet d'eviter les problemes lies a l'utilisation de Compiz"
))
self.check_b_dependances.setText(
i18n.traduc(
"Installer automatiquement les dependances manquantes."))
self.b_valider.setText(i18n.traduc("Valider"))
self.b_fermer.setText(i18n.traduc("Fermer"))
self.label_taille_police.setText(i18n.traduc("Taille des polices:"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab),
i18n.traduc("djl"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2),
i18n.traduc("IRC"))
# Partie config IRC:
self.label_irc.setText(i18n.traduc("Pseudo:"))
self.label_2_irc.setText(i18n.traduc("Couleur de fond:"))
self.label_canaux.setText(
i18n.traduc("Canaux a utiliser (sur irc.freenode.net"))
self.couleur_irc.addItem(i18n.traduc("Blanc"))
self.couleur_irc.addItem(i18n.traduc("Noir"))
self.chk_conn_irc.setText(i18n.traduc("Se connecter au demarrage"))
liste_onglets = (i18n.traduc("Actualites"), i18n.traduc("Jeux"),
i18n.traduc("Depot"), i18n.traduc("IRC"))
for i in range(len(liste_onglets)):
# print liste_onglets[i]
self.comboBox.addItem(liste_onglets[i])
def __init__(self, parent=None):
'''Affiche la fenêtre de configuration de djl (On charge toute la config à l'init)'''
QtGui.QDialog.__init__(self, parent)
QtGui.QDialog.__init__(self)
self.home = os.path.expanduser('~')
self.adresse = ''
self.setupUi(self)
# Défini le texte de la boite pour créer le raccourcis de djl dans le menu
# KDE/Gnome, en fonction si le fichier existe ou pas
if os.path.exists(home +
'/.local/share/applications/djl.desktop') == True:
self.b_raccourci.setText(
i18n.traduc("Supprimer raccourci de djl du menu KDE/Gnome"))
else:
self.b_raccourci.setText(
i18n.traduc(
"Ajouter un raccourci de djl dans le menu KDE/Gnome"))
self.b_parcourir.connect(self.b_parcourir, QtCore.SIGNAL("clicked()"),
self.parcours_rep)
self.b_parcourir_nav.connect(self.b_parcourir_nav,
QtCore.SIGNAL("clicked()"),
self.parcours_nav)
self.b_valider.connect(self.b_valider, QtCore.SIGNAL("clicked()"),
self.valider)
self.b_fermer.connect(self.b_fermer, QtCore.SIGNAL("clicked()"),
self.ferme)
self.b_raccourci.connect(self.b_raccourci, QtCore.SIGNAL("clicked()"),
self.raccourci)
self.taille_police.connect(self.taille_police,
QtCore.SIGNAL("valueChanged(int)"),
self.ch_police)
# Si le fichier de configuration, existe, on affiche la configuration dans l'interface:
fichier_cfg = self.home + '/.djl/config'
if os.path.exists(fichier_cfg) == True:
fichier = open(fichier_cfg, 'r')
texte_fichier = fichier.readlines()
# Affiche les 'checkboxs' validés ou non suivant la config:
chk_valide = texte_fichier[0]
chk_valide = chk_valide.replace('telecharger_lancer = ', '')
chk_valide = chk_valide.replace('\n', '')
if int(chk_valide) == 1:
self.check_b_lancer_jeu.setChecked(True)
else:
self.check_b_lancer_jeu.setChecked(False)
chk_suppr = texte_fichier[1]
chk_suppr = chk_suppr.replace('telecharger_supprimer = ', '')
chk_suppr = chk_suppr.replace('\n', '')
if int(chk_suppr) == 1:
self.check_b_suppr_archive.setChecked(True)
else:
self.check_b_suppr_archive.setChecked(False)
# Affiche l'adresse d'installation des jeux dans le champ correspondant:
addr = texte_fichier[2]
addr = addr.replace('rep_jeux = ', '')
addr = addr.replace('\n', '')
self.ligne_adresse.setText(addr)
chk_affiche_miniature = texte_fichier[3]
chk_affiche_miniature = chk_affiche_miniature.replace(
'afficher_miniature = ', '')
chk_affiche_miniature = chk_affiche_miniature.replace('\n', '')
if int(chk_affiche_miniature) == 1:
self.check_b_icone_barre.setChecked(True)
else:
self.check_b_icone_barre.setChecked(False)
try:
chk_maj_demarrage = texte_fichier[4]
chk_maj_demarrage = chk_maj_demarrage.replace(
'maj_demarrage = ', '')
chk_maj_demarrage = chk_maj_demarrage.replace('\n', '')
if int(chk_maj_demarrage) == 1:
self.check_b_maj_demarrage.setChecked(True)
else:
self.check_b_maj_demarrage.setChecked(False)
except IndexError:
# Si il y a exception (parce que la ligne dans le fichier de configuration
# est manquante) on remplace par le choix par defaut::
self.check_b_maj_demarrage.setChecked(True)
# Onglet à afficher au démarrage:
try:
onglet = texte_fichier[5]
onglet = onglet.replace('onglet = ', '')
onglet = onglet.replace('\n', '')
self.comboBox.setCurrentIndex(int(onglet))
except:
self.comboBox.setCurrentIndex(0)
try:
nav = texte_fichier[6]
nav = nav.replace('navigateur = ', '')
nav = nav.replace('\n', '')
except:
nav = '/usr/bin/firefox'
self.ligne_navigateur.setText(nav)
# Configuration si l'on doit afficher la sortie des jeux à leur lancement
try:
chk_debug = texte_fichier[7]
chk_debug = chk_debug.replace('debug = ', '')
chk_debug = chk_debug.replace('\n', '')
if int(chk_debug) == 1:
self.check_b_debug.setChecked(True)
else:
self.check_b_debug.setChecked(False)
except IndexError:
# Si il y a exception (parce que la ligne dans le fichier de configuration
# est manquante) on remplace par le choix par defaut::
self.check_b_debug.setChecked(False)
# Vérifi si la gestion des dépendances est activé ou non:
try:
chk_dependances = texte_fichier[16]
chk_dependances = chk_dependances.replace('dependances = ', '')
chk_dependances = chk_dependances.replace('\n', '')
if int(chk_dependances) == 1:
self.check_b_dependances.setChecked(True)
else:
self.check_b_dependances.setChecked(False)
except IndexError:
# Si il y a exception (parce que la ligne dans le fichier de configuration
# est manquante) on remplace par le choix par defaut::
self.check_b_dependances.setChecked(False)
# Vérifi si les jeux doivent être lancé dans un second serveur graphique:
try:
chk_composition = texte_fichier[8]
chk_composition = chk_composition.replace('composition = ', '')
chk_composition = chk_composition.replace('\n', '')
if int(chk_composition) == 1:
self.check_b_composition.setChecked(True)
else:
self.check_b_composition.setChecked(False)
except IndexError:
# Si il y a exception (parce que la ligne dans le fichier de configuration
# est manquante) on remplace par le choix par defaut::
self.check_b_composition.setChecked(False)
# Réécrit si l'on utilise l'interface étendue ou simple:
try:
self.type_gui = texte_fichier[10]
self.type_gui = self.type_gui.replace('type_gui = ', '')
self.type_gui = self.type_gui.replace('\n', '')
except IndexError:
self.type_gui = "1"
# Partie pseudo sur IRC:
try:
txt_pseudo = texte_fichier[11]
txt_pseudo = txt_pseudo.replace('pseudo = ', '')
txt_pseudo = txt_pseudo.replace('\n', '')
#txt_pseudo = txt_pseudo.replace("-djl","")
self.ligne_pseudo.setText(txt_pseudo)
except IndexError:
self.ligne_pseudo.setText(str(os.environ["USER"]).capitalize())
# Démarrage (ou pas) du client IRC au démarrage
try:
conn_irc_demarrage = texte_fichier[12]
conn_irc_demarrage = conn_irc_demarrage.replace(
'conn_irc_demarrage = ', '')
conn_irc_demarrage = conn_irc_demarrage.replace('\n', '')
if int(conn_irc_demarrage) == 1:
self.chk_conn_irc.setChecked(True)
else:
self.chk_conn_irc.setChecked(False)
except IndexError:
self.chk_conn_irc.setChecked(True)
# Couleur de fond du client IRC:
try:
fond_irc = texte_fichier[13]
fond_irc = fond_irc.replace('fond_irc = ', '')
fond_irc = fond_irc.replace('\n', '')
self.couleur_irc.setCurrentIndex(int(fond_irc))
except IndexError:
self.couleur_irc.setCurrentIndex(0)
# Taille des polices:
try:
taille_police = texte_fichier[14]
taille_police = taille_police.replace('taille_police = ', '')
taille_police = taille_police.replace('\n', '')
self.taille_police.setValue(int(taille_police))
except IndexError:
self.taille_police.setValue(9)
# Canaux IRC
try:
canaux = texte_fichier[15]
canaux = canaux.replace('canaux_IRC = ', '')
canaux = canaux.replace('\n', '')
self.ligne_canaux.setText(canaux)
except IndexError:
try:
loc = getdefaultlocale()[0].split("_")[0]
except:
loc = "en"
self.ligne_canaux.setText("#djl" + " " + "#djl-" + str(loc))
# Si le fichier de configuration n'existe pas, on affiche les choix par défaut
else:
self.ligne_adresse.setText(self.home + '/.djl')
self.check_b_suppr_archive.setChecked(True)
self.check_b_lancer_jeu.setChecked(False)
self.check_b_icone_barre.setChecked(True)
self.check_b_maj_demarrage.setChecked(True)
self.check_b_debug.setChecked(False)
self.check_b_composition.setChecked(False)
self.check_b_dependances.setChecked(False)
self.chk_conn_irc.setChecked(False)
self.type_gui = "1"
self.taille_police.setValue(9)
try:
loc = getdefaultlocale()[0].split("_")[0]
except:
loc = "en"
self.ligne_canaux.setText("#djl" + " " + "#djl-" + str(loc))
# Raccourcis claviers:
QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Escape), self,
self.close)
QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Return), self,
self.valider)
QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Enter), self,
self.valider)
def contextMenuEvent(self, event):
'''Affiche le menu contextuel'''
if not self.int_etendue: # Régression, temp
event.ignore() # Régression, temp
return # Régression, temp
var_ok = 0
# Si le jeu actuellement selectionné est un raccourci...
if '.desktop' in self.nom_jeu_pr():
raccourci = 1
else:
raccourci = 0
# print '>>', str(self.listWidget.currentRow())
if self.int_etendue: # Si c'est l'interface étendue...
if self.listWidget.currentRow(
) == -1: # Si aucun jeu n'est séléctionné, on ignore
event.ignore()
return
if self.tabWidget.currentIndex() == 1:
var_ok = 1
else:
event.ignore()
return
if not self.int_etendue or var_ok == 1: # Si c'est l'interface simple...
if var_ok == 0:
if self.listWidget.currentRow(
) == -1: # Si aucun jeu n'est séléctionné, on ignore
event.ignore()
return
menu = QtGui.QMenu(self)
menu.setFont(self.font)
self.act_lance = QtGui.QAction(_((i18n.traduc("Jouer"))), self)
self.act_lance.connect(self.act_lance,
QtCore.SIGNAL("triggered()"), self.lance)
menu.addAction(self.act_lance)
icone = QtGui.QIcon(dossier_racine + '/res/jeux_oxygen.png')
self.act_lance.setIcon(icone)
if self.connecte_ws == 1 or raccourci == 1:
self.act_infos = QtGui.QAction(
_((i18n.traduc("Informations"))), self)
self.act_infos.connect(self.act_infos,
QtCore.SIGNAL("triggered()"),
self.boite_infos)
icone = QtGui.QIcon(dossier_racine + '/res/information.png')
self.act_infos.setIcon(icone)
menu.addAction(self.act_infos)
self.act_argument = QtGui.QAction(
_((i18n.traduc("Arguments de lancement"))), self)
self.act_argument.connect(self.act_argument,
QtCore.SIGNAL("triggered()"),
self.fen_arguments)
icone = QtGui.QIcon(dossier_racine + '/res/arg_oxygen.png')
self.act_argument.setIcon(icone)
menu.addAction(self.act_argument)
if raccourci == 0: # Si c'est un jeu installé en dur, on a le menu complet
# Vérifi que l'on ne tourne pas sur x86_64
if os.uname()[4] != 'x86_64' or os.path.exists(
'/usr/bin/ldd32'):
self.act_verif_depend = QtGui.QAction(
_((i18n.traduc("Verifier les dependances"))), self)
self.act_verif_depend.connect(self.act_verif_depend,
QtCore.SIGNAL("triggered()"),
self.verif_dependances)
menu.addAction(self.act_verif_depend)
icone = QtGui.QIcon(dossier_racine +
'/res/recherche_oxygen.png')
self.act_verif_depend.setIcon(icone)
self.act_supr = QtGui.QAction((i18n.traduc("Supprimer")), self)
self.act_supr.connect(self.act_supr,
QtCore.SIGNAL("triggered()"),
self.confirmation_menu_c_suppr)
menu.addAction(self.act_supr)
icone = QtGui.QIcon(dossier_racine +
'/res/supprimer_oxygen.png')
self.act_supr.setIcon(icone)
# Si on trouve le lien, on affiche la ligne pour le vister
if variables.lien_site == 1:
self.act_site = QtGui.QAction(
_((i18n.traduc("Visiter le site"))), self)
self.act_site.connect(self.act_site,
QtCore.SIGNAL("triggered()"),
self.navigateur_site)
menu.addAction(self.act_site)
icone = QtGui.QIcon(dossier_racine + '/res/actus.png')
self.act_site.setIcon(icone)
# Si c'est un raccourci on affiche dans le menu que lancer le jeu et
# supprimer le raccourci
else:
self.act_modif = QtGui.QAction(
i18n.traduc("Modifier le raccourci"), self)
self.act_modif.connect(self.act_modif,
QtCore.SIGNAL("triggered()"),
self.modif_jeu_)
self.act_supr = QtGui.QAction(
i18n.traduc("Supprimer le raccourci"), self)
self.act_supr.connect(self.act_supr,
QtCore.SIGNAL("triggered()"),
self.confirmation_suppr_desk)
self.act_recherche = QtGui.QAction(
i18n.traduc("Rechercher des informations sur internet"),
self)
self.act_recherche.connect(self.act_recherche,
QtCore.SIGNAL("triggered()"),
self.recherche_internet_jeu)
menu.addAction(self.act_modif)
menu.addAction(self.act_supr)
menu.addAction(self.act_recherche)
icone = QtGui.QIcon(dossier_racine + '/res/ajouter.png')
self.act_modif.setIcon(icone)
icone = QtGui.QIcon(dossier_racine +
'/res/supprimer_oxygen.png')
self.act_supr.setIcon(icone)
icone = QtGui.QIcon(dossier_racine + '/res/actus.png')
self.act_recherche.setIcon(icone)
self.var_liste_select = 0
menu.exec_(event.globalPos())
def retranslateUi(self, MainWindow):
'''Envoi le texte de la fenêtre'''
MainWindow.setWindowTitle(i18n.traduc("Importer un raccourci"))
self.pushButton.setText(i18n.traduc("Ajouter"))
self.pushButton_2.setText(i18n.traduc("Fermer"))
self.checkBox.setText(i18n.traduc("N'afficher que les jeux"))
def verif_dependances(self):
'''Vérifi les dépendances pour le jeu actuellement seléctionné dans la liste de jeux principale
(uniquement les jeux de djl, pas les raccourcis).'''
jeu_actuel = self.nom_jeu_pr()
commande = 'nul'
cmd = self.trouve_commande(dossier=jeu_actuel)
rep = config(info=2) + '/jeux/' + jeu_actuel
if os.path.exists('/usr/bin/ldd32'):
ldd = 'ldd32'
else:
ldd = 'ldd'
liste = os.listdir(rep)
if len(
liste
) <= 2: # Si le répertoire ne contient que 2 éléments ou moins, c'est normal
for i in range(len(liste)):
if os.path.isdir(rep + '/' + liste[i]):
repertoire = rep + '/' + liste[i]
else: # Si il y a plusieurs répertoires dans le répertoire du jeu, on binaire doit être là
repertoire = rep
# Créé la variable d'environnement qui va bien avant de vérifier les librairies:
if os.path.exists(repertoire + '/lib'):
LIBRARY_PATH = repertoire + ':' + repertoire + \
'/lib:' + config(info=2) + "/libs" + ':/usr/lib'
elif os.path.exists(repertoire + '/libs'):
LIBRARY_PATH = repertoire + ':' + repertoire + \
'/libs:' + config(info=2) + "/libs" + ':/usr/lib'
else:
LIBRARY_PATH = repertoire + ':' + config(
info=2) + "/libs" + ':/usr/lib'
os.putenv("LD_LIBRARY_PATH", LIBRARY_PATH)
commande = repertoire + '/' + cmd
dep_ok = ''
dep_manque = ''
chaine = ''
trouve = False
retour = os.popen(ldd + ' ' + commande).readlines() # str() temp
#retour = retour.replace(' ', '')
if len(retour) > 2:
for i in range(len(retour)):
# Si il semble manquer la librairie, on l'ajoute dans la chaine des
# dependances manquantes
if "not found" in retour[i]:
trouve = True
dep_manque = dep_manque + retour[i] # + "<br>"
# Si il a trouve la librairie, on l'ajoute à la chaine des dépendances satisfaites
else:
dep_ok = dep_ok + retour[i]
if trouve: # Si il y a au moins une librairie manquante
chaine = _(
'Dependances non satisfaites') + ':' + "\n\n" + dep_manque
else: # Si toutes les dépendances semblent ok
chaine = _('Toutes les dependances semblent satisfaites'
) + ':' + "\n\n" + dep_ok
# Si la sortie ne fais pas au moins 2 lignes, on affiche directement le
# message, c'est surement une erreur (binaire on trouvé)
else:
chaine = i18n.traduc("Erreur") + ":\n"
for i in range(len(retour)):
chaine = chaine + retour[i]
interface.info_box(chaine, _('Verifier les dependances'))
def setupUiIRC(self):
'''Tout ce qui concerne le dessin de l'onglet IRC'''
self.gridlayout_3 = QtGui.QGridLayout(self.tab_3)
self.gridlayout_3.setObjectName("gridlayout_3")
self.gridlayout_3_1 = QtGui.QGridLayout()
self.gridlayout_3_1.setObjectName("gridlayout_3_1")
self.gridlayout_3_2 = QtGui.QGridLayout()
self.gridlayout_3_2.setObjectName("gridlayout_3_2")
self.gridlayout_3.addLayout(self.gridlayout_3_1, 0, 0)
self.gridlayout_3.addLayout(self.gridlayout_3_2, 1, 0)
self.listeW_canaux = QtGui.QListWidget(self.tab_3)
self.listeW_canaux.setMinimumSize(QtCore.QSize(160, 200))
self.listeW_canaux.setMaximumSize(QtCore.QSize(160, 1280))
self.listeW_canaux.setObjectName("listeW_canaux")
self.listeW_canaux.setEnabled(False)
self.gridlayout_3_1.addWidget(self.listeW_canaux, 1, 0)
self.textEdit_chat = QtGui.QTextEdit(self.tab_3)
self.textEdit_chat.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.textEdit_chat.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.textEdit_chat.setReadOnly(True)
self.textEdit_chat.setEnabled(False)
self.textEdit_chat.setObjectName("textEdit_chat")
self.textEdit_chat.setAcceptRichText(False)
self.gridlayout_3_1.addWidget(self.textEdit_chat, 1, 1)
# Change la couleur de fond de l'onglet IRC (si l'utilisateur a choisi en noir):
if int(config(info=13)) == 1:
from palette_irc import Palette_IRC
self.textEdit_chat.setPalette(Palette_IRC.palette)
self.line_Edit_chat = QtGui.QLineEdit(self.tab_3)
self.line_Edit_chat.setObjectName("line_Edit_chat")
self.line_Edit_chat.setEnabled(False)
self.gridlayout_3_2.addWidget(self.line_Edit_chat, 0, 0)
# self.gridlayout_3.addWidget(self.line_Edit_chat,3,1)
self.pushButton_chat = QtGui.QPushButton(self.tab_3)
self.pushButton_chat.setObjectName("pushButton_chat")
self.pushButton_chat.setEnabled(False)
self.gridlayout_3_2.addWidget(self.pushButton_chat, 0, 1)
# self.gridlayout_3.addWidget(self.pushButton_chat,3,2)
self.Button_connect_chat = QtGui.QPushButton(self.tab_3)
self.Button_connect_chat.setObjectName("pushButton_chat")
self.Button_connect_chat.setEnabled(True)
self.Button_connect_chat.setMinimumSize(QtCore.QSize(160, 25))
self.Button_connect_chat.setMaximumSize(QtCore.QSize(160, 25))
self.gridlayout_3_1.addWidget(self.Button_connect_chat, 0, 0)
self.listWidget_chat = QtGui.QListWidget(self.tab_3)
self.listWidget_chat.setMinimumSize(QtCore.QSize(160, 200))
self.listWidget_chat.setMaximumSize(QtCore.QSize(160, 1280))
self.listWidget_chat.setObjectName("listWidget_chat")
self.listWidget_chat.setEnabled(False)
self.gridlayout_3_1.addWidget(self.listWidget_chat, 1, 2)
self.pushButton_chat.setText(i18n.traduc("Envoyer"))
self.listeW_canaux.connect(
self.listeW_canaux,
QtCore.SIGNAL("itemSelectionChanged()"),
self.change_canal)
self.pushButton_chat.connect(
self.pushButton_chat,
QtCore.SIGNAL("clicked()"),
self.envoi_irc)
self.Button_connect_chat.connect(
self.Button_connect_chat,
QtCore.SIGNAL("clicked()"),
self.connexion_irc)
# Pareil sur la liste des utilisateurs sur le canal IRC:
self.listWidget_chat.connect(
self.listWidget_chat,
QtCore.SIGNAL("itemClicked(QListWidgetItem*)"),
self.message_pv_irc)
