def set_tag(self, tag, value):
Tags.setValue(self.path, tag, value)
query = 'UPDATE tracks SET ' + tag + ' = ? WHERE track_ID = ?'
t = (value, self.ID)
bdd.execute(query, t)
self.tags[tag] = value
messager.diffuser('track_data_changed', self, self)
def togglePause(self):
if self.is_paused():
self.play()
elif self.isStopped():
messager.diffuser('need_piste_suivante', self, 'click')
else:
self.pause()
def valider(self, edit):
name = self.E_Name.get_text()
fichier = open(self.DYNAMIC_FOLDER + name, 'w')
fichier.write(str(self.c_manager.get_config()))
#if(self.RB_Random.get_active()):
#fichier.write("random" + "\n")
#else:
#fichier.write("notrandom" + "\n")
#if(self.RB_Criterion.get_active()):
#fichier.write(" OR " + "\n")
#else:
#fichier.write(" AND " + "\n")
#for critere in self.Box_Criteres:
#children = critere.get_children()
#criterion = children[0].get_active_text()
#operator = children[1].get_active_text()
#condition = children[2].get_text()
#t = [criterion, operator, condition]
##column, operator, condition = criterion
#fichier.write(str(t) + "\n")
#fichier.close()
if(edit == None): #Pas une édition
messager.diffuser('playlist_ajoutee', self, ["intelligent", name])
def charger_playlist(self, data):
ID_list = data[0] # data[1] = l'instance de queue
# Charge une playlist
table = []
for ID in ID_list:
table.append(self.get_track_data(int(ID)))
messager.diffuser("desPistes", self, table, False)
data[1].Liste.connect("row-changed", data[1].setModified)
def recule(self, data):
if self.numero > 0:
self.demarquer_piste()
self.numero -= 1
self.playing_iter = self.queue_jouee.get_iter(self.numero)
chemin = self.queue_jouee[self.numero][4]
messager.diffuser('musique_a_lire', self, chemin)
self.marquer_piste()
def on_drag_data_receive(self, TreeView, drag_context, x, y, selection_data, info, timestamp):
#fin d'un DND
T_elements_ID = eval(selection_data.get_text()) # eval => permet de retransformer la chaîne de caractères en tableau
numero_tuple = TreeView.get_dest_row_at_pos(x, y)[0]
dic = self.what_is(numero_tuple, TreeView.get_model())
for key in dic.iterkeys():
messager.diffuser('fileIN', self, [self.module, T_elements_ID, key, dic[key]])
def toggle_pause(self):
if self.is_paused():
self.play()
self.emit('unpause')
elif self.is_stopped():
self.emit('unpause')
messager.diffuser('need_piste_suivante', self, 'click')
else:
self.pause()
self.emit('pause')
def on_message(self, bus, message):
t = message.type
#EOS = End Of Song
if t == gst.MESSAGE_EOS:
messager.diffuser('need_piste_suivante', self, 'eos')
#self.stop()
elif t == gst.MESSAGE_ERROR:
self.stop()
err, debug = message.parse_error()
print "Error: %s" % err, debug
def initialisation_raccourcis(self):
raccourcis = (
('<Control>W', lambda *e: self.closeQueue()),
('<Control>T', lambda *e: self.addQueue()),
)
accel_group = gtk.AccelGroup()
for key, function in raccourcis:
key, mod = gtk.accelerator_parse(key)
accel_group.connect_group(key, mod, gtk.ACCEL_VISIBLE,
function)
messager.diffuser('desRaccourcis', self, accel_group)
def add_file_in(self, data):
"""
Détails paramètres : data[0] = type (~ table a modifier), data[1] = tableau contenant des ID, data[2] = nom champ conteneur (univers_ID ou categorie_ID), data[3] = valeur identifiant conteneur
Ajoute les enregistrements dont l'ID est contenue dans le tableau data[1] au conteneur dont l'ID est contenu dans data[3]
Les ID de sections étant des entiers pour tous les types de sections, une chaîne (type) est fournie en fonction du message reçu par la BDD
"""
##self.c.execute('INSERT INTO lien_IC VALUES (?, ?)', t) abandonné
type = data[0]
query = "UPDATE " + type + "s SET " + data[2] + " = ? WHERE " + type + "_ID = ?"
for ID in data[1]:
t = (data[3], ID)
self.c.execute(query, t)
self.conn.commit()
messager.diffuser("notification_etat", self, data[2] + " des " + type + "(s) modifié avec succès")
def charger_playlist(self, w, i, colonne, stop_mod=False):
level = len(i)
if(level == 2): #On est bien sur une playlist
nom = self.model[i][2]
if(i[0] == 0): #On est sur une playlist perso
fichier = open(self.FOLDER + nom,'r')
liste = fichier.readlines()
fichier.close()
#On envoie la liste d'ID à la BDD, elle va la traiter et renvoyer les infos au queue_manager
messager.diffuser('playlistData', self, [liste, nom, stop_mod])
else: #On est sur une playlist intelligente
fichier = open(self.DYNAMIC_FOLDER + nom,'r')
data = fichier.readlines()
fichier.close()
self.queueManager.addQueue()
self.queueManager.addSelection(self.mdb.getDynamicListTracks(eval(data[0])))
def enregistrer(self, button):
DN = gtk.Dialog()
Entry = gtk.Entry()
hbox = gtk.HBox()
hbox.pack_start(gtk.Label(_("Name") + " : "), False, 5, 5)
hbox.pack_end(Entry)
DN.vbox.add(hbox)
DN.add_button('OK', 1)
DN.add_button(_("Cancel"), 0)
DN.show_all()
action = DN.run()
nom = Entry.get_text()
DN.destroy()
if(action == 1):
self.save(nom)
messager.diffuser('playlist_ajoutee', self, ['personalised', nom])
def add_playlist(self, button):
DN = gtk.Dialog()
Entry = gtk.Entry()
hbox = gtk.HBox()
hbox.pack_start(gtk.Label(_("Name") + " : "), False, 5, 5)
hbox.pack_end(Entry)
DN.vbox.add(hbox)
DN.add_button("OK", 1)
DN.add_button(_("Cancel"), 0)
DN.show_all()
action = DN.run()
name = Entry.get_text()
DN.destroy()
if action == 1:
fichier = open(os.path.join(xdg.get_data_home(), "playlists" + os.sep) + name, "w")
fichier.close()
messager.diffuser("playlist_ajoutee", self, ["personalised", name])
def set_categorie_on_image(self, b, CB):
if self.index == -1:
return False
image_ID = self.liste[self.index][0]
liste = CB.get_model()
categorie = CB.get_active_text()
i = 0
while (i < len(liste) - 1) and (liste[i][1] != categorie):
i += 1
if liste[i][1] != categorie:
Dialog = gtk.MessageDialog(
buttons=gtk.BUTTONS_YES_NO, message_format="Cette catégorie n'existe pas, voulez vous la créer?"
)
reponse = Dialog.run()
Dialog.destroy()
if reponse == -8: # Oui
messager.diffuser("nouvelle_categorieI", self, categorie)
messager.diffuser("liste_sectionsI", self, liste)
elif reponse == -9: # Non
return False
i = 0
while (i < len(liste) - 1) and (liste[i][1] != categorie):
i += 1
# TODO
if liste[i][1] == categorie:
categorie_ID = liste[i][0]
messager.diffuser("imageINcategory", self, [image_ID, categorie_ID])
def get_tracks_data(self, data, send_message=True):
"""
Créer une liste (tableau) de données sur les pistes correspondant aux critères passés en paramètre
@param data : soit un dictionnaire (AND), soit une liste de dictionnaire (OU)
@param send_message : si vrai envoie un message avec le résultat, si faux retourne directement le résultat
"""
t = []
if type(data).__name__ == "dict":
for key in data.iterkeys():
try:
query += " AND " + key + " = ?"
except NameError:
query = "SELECT * FROM tracks WHERE " + key + " = ?"
t.append(unicode(data[key]))
else:
for dic in data:
try:
query += " OR ("
except NameError:
query = "SELECT * FROM tracks WHERE ("
for key in dic.iterkeys():
try:
part += " AND " + key + " = ?"
except NameError:
part = key + " = ?"
t.append(unicode(dic[key]))
query += part + ")"
del part
print (query)
self.c.execute(query, t)
table = []
for row in self.c:
table.append((row[0], row[1], row[2], row[3], row[4], row[6], row[7], row[8]))
if send_message:
messager.diffuser("desPistes", self, table)
else:
return table
def change_rating(self, w, new_rating):
query = "UPDATE tracks SET rating = " + str(new_rating) + " WHERE track_ID = " + self.ID
bdd.execute(query)
self.rating = new_rating
messager.diffuser('track_data_changed', self, self)
def on_folder_activated(self, w, i, c):
dossier = self.folderModel[i][0]
messager.diffuser("need_data_of", self, [self.module, "dossier", dossier])
def on_message(self, event):
messager.diffuser('need_piste_suivante', self, 'eos')
def percentage(self):
pos = round(self._player.get_position(), 2)
if(pos == 1.0):
messager.diffuser('need_piste_suivante', self, 'eos')
return pos
def get_data_of(self, data):
"""
Séléctionne toutes les infos sur les fichiers du type donné (image ou video) et appartenant à la section data[1] (categorie_ID, univers_ID, dossier)
Data[0] contient le type de données et définit donc les tables sur lesquelles on va s'appuyer
Data[1] contient une chaîne permettant de savoir quelle(s) section(s) est (sont) visée(s)
"""
type = data[0]
mode = data[1] # category, universe, category_and_universe or folder
critere = data[2] # category_ID, universe_ID or folder path
dig = True
t = []
query = "SELECT " + type + "_ID, fichier, dossier, note, categorie_ID, univers_ID FROM " + type + "s "
def dig_in(ID, query):
for c_ID in self.categories[ID]:
query += " OR categorie_ID = ?"
t.append(c_ID)
dig_in(c_ID, query)
if mode == "dossier":
t = (unicode(critere),)
query += "WHERE dossier = ? ORDER BY fichier"
elif mode == "category":
t.append(int(critere))
query += "WHERE categorie_ID = ?"
if dig is True:
dig_in(int(critere), query)
query += " ORDER BY fichier"
elif mode == "universe":
t = (int(critere),)
query += "WHERE univers_ID = ? ORDER BY fichier"
elif mode == "category_and_universe":
universe_ID = data[3]
t = (int(critere), universe_ID)
query += "WHERE categorie_ID = ? AND univers_ID = ? ORDER BY fichier"
else:
t = (unicode(critere),)
query += "ORDER BY fichier"
self.c.execute(query, t)
table = []
for row in self.c:
path = unicode(row[2] + os.sep + row[1])
print (path)
ID = str(row[0])
thumbnail_path = "thumbnails/" + type + "s/" + ID + ".jpg"
if not os.path.exists(thumbnail_path):
if type == "picture":
im = Image.open(path)
im.thumbnail((128, 128), Image.ANTIALIAS)
im.save(thumbnail_path, "JPEG")
elif type == "video":
cmd = ["totem-video-thumbnailer", path, thumbnail_path]
ret = subprocess.call(cmd)
else:
thumbnail_path = "thumbnails/none.jpg"
# if os.path.exists(thumbnail_path):
# thumbnail = gtk.gdk.pixbuf_new_from_file(thumbnail_path)
# else:
thumbnail = gtk.gdk.pixbuf_new_from_file(thumbnail_path)
# On veut : ID, chemin, libellé, apperçu, note, categorie_ID, univers_ID
table.append((row[0], path, row[1], thumbnail, row[3], row[4], row[5]))
logger.debug(query)
messager.diffuser("des_" + type + "s", self, table)
return table
def charger_playlist(self, data):
#data[0] = tracks ID, data[1] = playlist name
queue = self.addQueue(data[1])
messager.diffuser('ID_playlist', self, [data[0], queue], False)
def avance_ou_arrete(self, motif):
'''
Méthode primordiale permettant au MusicPlayer d'avoir sa piste sur demande (démarrage ou enchaînement)
'''
# Tout d'abord on incrémente si fin de piste atteinte et on vire le marquage de l'ancienne piste courante
if(motif == "eos"):
#ID_courant = self.queue_jouee.get_value(self.playing_iter, 3)
self.incrementPlayedTrack()
self.demarquer_piste()
try:
if (self.queue_jouee.get_value(self.playing_iter, 2) is None):
not_a_stop_track = True
else:
not_a_stop_track = False
except:
not_a_stop_track = True
try:
di = self.directList[0]
self.directList.remove(di)
if(di.row == None):
di = None
except IndexError:
di = None
if(not_a_stop_track): #On vérifie d'abord qu'on ne doit pas s'arrêter avant de mouliner
#Quelle est la piste à jouer? 3 possibilités :
if(di != None): # 1/ une piste prioritaire
self.playing_track = Track(di.get_model()[di.get_path()][3])
if di.temp:
self.temp_queue_jouee = di.get_model()
self.temp_playing_iter = self.temp_queue_jouee.get_iter(di.get_path())
else:
self.queue_jouee = di.get_model()
self.playing_iter = self.queue_jouee.get_iter(di.get_path())
messager.diffuser('musique_a_lire', self, self.playing_track)
self.marquer_piste()
else:
if(self.playing_iter): # 2/ la piste qui suit la dernière piste lue
bridge_key = self.queue_jouee.get_value(self.playing_iter, 12)
if(bridge_key != None):
try:
ref = self.bridges_dest[bridge_key]
queue = ref.get_model()
next_iter = queue.get_iter(ref.get_path())
self.queue_jouee = queue
except:
next_iter = self.queue_jouee.iter_next(self.playing_iter)
else:
next_iter = self.queue_jouee.iter_next(self.playing_iter)
else: # 3/ la première piste de la queue visible
self.queue_jouee = self.visibleQueue
next_iter = self.queue_jouee.get_iter_first()
if(next_iter): # Après recherche, on a obtenu une piste
self.playing_iter = next_iter
self.playing_track = Track(self.queue_jouee.get_value(self.playing_iter, 3))
messager.diffuser('musique_a_lire', self, self.playing_track)
self.marquer_piste()
else: # Il n'y a pas de suivant
self.queue_jouee.set_value(self.playing_iter, 2, None)
messager.diffuser('arret_musique', self, True)
print("Liste de lecture terminée ou stoppée")
else: # On s'arrête simplement
self.queue_jouee.set_value(self.playing_iter, 2, None)
messager.diffuser('arret_musique', self, True)
print("Liste de lecture terminée ou stoppée")
def stop(self, b=None):
super(MusicPlayer, self).stop(b)
messager.diffuser('MusicPlayerStopped', self, True)
def on_B_Prev_Click(self, w):
messager.diffuser('need_piste_precedente', self, None)
def on_B_Next_clicked(self, w):
#Joue la piste suivante de la queue courante, seulement si il y en a une (de piste hein)
messager.diffuser('need_piste_suivante', self, 'demarre')
