def __init__(self, Box):
Box_Controls = gtk.HBox()
ProgressBar = gtk.ProgressBar()
B_Play = gtk.ToolButton(gtk.STOCK_MEDIA_PLAY)
B_Play.connect("clicked", self.on_B_Play_Click)
Box_Controls.pack_start(B_Play, False)
Box_Controls.pack_start(ProgressBar)
ZoneVideo = gtk.DrawingArea()
ZoneVideo.add_events(gtk.gdk.BUTTON_PRESS_MASK)
ZoneVideo.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
self.fullscreen = False
self.DA_Parent = Box
ZoneVideo.connect("button-press-event", self.on_DA_click)
Box.pack_start(ZoneVideo)
Box.pack_start(Box_Controls, False)
Box.show_all()
Player.__init__(self, ProgressBar, B_Play)
self.movie_window = ZoneVideo
self.movie_window.realize()
self._player.set_xwindow(self.movie_window.window.xid)
#self.bus.enable_sync_message_emission()
#self.bus.connect("sync-message::element", self.on_sync_message)
messager.inscrire(self.lire_fichier, 'video_a_lire')
def __init__(self, Box):
BB = gtk.HButtonBox()
B_Prev = gtk.ToolButton(gtk.STOCK_MEDIA_PREVIOUS)
B_Play = gtk.ToolButton(gtk.STOCK_MEDIA_PLAY)
B_Next = gtk.ToolButton(gtk.STOCK_MEDIA_NEXT)
B_Stop = gtk.ToolButton(gtk.STOCK_MEDIA_STOP)
B_Prev.connect("clicked", self.on_B_Prev_Click)
B_Play.connect("clicked", self.on_B_Play_Click)
B_Next.connect("clicked", self.on_B_Next_clicked)
B_Stop.connect("clicked", self.stop)
Box.pack_start(B_Prev, False)
Box.pack_start(B_Play, False)
Box.pack_start(B_Next, False)
Box.pack_start(B_Stop, False)
BB.set_spacing(10)
B_Volume = gtk.VolumeButton()
B_Volume.connect("value-changed", self.on_volume_change)
Box.pack_start(B_Volume, False)
#Box.pack_start(BB, False)
ProgressBar = gtk.ProgressBar()
Box.pack_start(ProgressBar)
Box.show_all()
Player.__init__(self, ProgressBar, B_Play)
#on "coupe" la sortie vidéo
messager.inscrire(self.lire_fichier, 'musique_a_lire')
messager.inscrire(self.stop, 'arret_musique')
def __init__(self, playerWidget):
#gtk.rc_parse_string("style \"ephy-tab-close-button-style\"\n"
#"{\n"
#"GtkWidget::focus-padding = 0\n"
#"GtkWidget::focus-line-width = 0\n"
#"xthickness = 0\n"
#"ythickness = 0\n"
#"}\n"
#"widget \"*.ephy-tab-close-button\" style \"ephy-tab-close-button-style\"")
gtk.VBox.__init__(self)
self.NoteBook = gtk.Notebook()
self.playerWidget = playerWidget
self.playerWidget.queueManager = self
#DEPRECATED Abonnement à certains types de messages auprès du messager
#messager.inscrire(self.charger_playlist, 'playlist')
messager.inscrire(self.ajouter_selection, 'desPistes')
messager.inscrire(self.charger_playlist, 'playlistData')
self.IM = icons.IconManager()
self.queue_jouee = None
self.playing_iter = None
self.dest_row = None
# On ajoute une liste pour commencer
self.loadState()
self.initialisation_raccourcis()
glib.timeout_add_seconds(300, self.save_state)
actionBox = gtk.HBox()
scrollToCurrentButton = gtk.ToolButton(gtk.STOCK_JUMP_TO)
scrollToCurrentButton.connect('clicked', self.scrollToCurrent)
searchEntry = gtk.Entry()
searchEntry.connect('activate', self.filter)
actionBox.pack_start(scrollToCurrentButton, False)
actionBox.pack_start(searchEntry)
self.pack_start(self.NoteBook)
self.pack_start(actionBox, False)
self.NoteBook.connect('expose-event', self.redrawAddTabButton)
self.NoteBook.connect('button-release-event', self.onButtonRelease)
def __init__(self, db, queueManager):
#Attributs:
self.mdb = db
self.queueManager = queueManager
self.TV = gtk.TreeView()
self.model = gtk.TreeStore(gtk.gdk.Pixbuf, int, str) #icon, ID, titre
pixbuf_dir = gtk.ToolButton().render_icon(gtk.STOCK_DIRECTORY, gtk.ICON_SIZE_BUTTON)
self.pere = self.model.append(None, [pixbuf_dir, 0, "Static playlists"])
for f in os.listdir(self.FOLDER):
pixbuf = gtk.gdk.pixbuf_new_from_file('icons/playlist.png')
if os.path.isfile(os.path.join(self.FOLDER, f)):
self.model.append(self.pere, [pixbuf, 0, f])
self.intelligent_pere = self.model.append(None, [pixbuf_dir, 0, _("Dynamic playlists")])
for f in os.listdir(self.DYNAMIC_FOLDER):
if os.path.isfile(os.path.join(self.DYNAMIC_FOLDER, f)):
self.model.append(self.intelligent_pere, [pixbuf, 0, f])
self.TV.set_model(self.model)
colonne = gtk.TreeViewColumn('Column 0')
self.TV.append_column(colonne)
cell = gtk.CellRendererText()
pb = gtk.CellRendererPixbuf()
colonne.pack_start(pb, False)
colonne.pack_start(cell, True)
colonne.add_attribute(cell, 'text', 2)
colonne.set_attributes(pb, pixbuf=0)
self.TV.expand_all()
#Signaux
self.TV.connect('row-activated', self.charger_playlist)
self.TV.connect("button-press-event", self.surClicDroit)
#Abonnements
messager.inscrire(self.ajouter_playlist, 'playlist_ajoutee')
gtk.VBox.__init__(self)
self.pack_start(self.TV)
def __init__(self, Box):
ProgressBar = gtk.ProgressBar()
B_Play = gtk.ToolButton(gtk.STOCK_MEDIA_PLAY)
Player.__init__(self, ProgressBar, B_Play)
BB = gtk.HButtonBox()
B_Prev = gtk.ToolButton(gtk.STOCK_MEDIA_PREVIOUS)
self.connect('pause', self.set_play_icon, B_Play)
self.connect('unpause', self.set_pause_icon, B_Play)
B_Next = gtk.ToolButton(gtk.STOCK_MEDIA_NEXT)
B_Stop = gtk.ToolButton(gtk.STOCK_MEDIA_STOP)
B_Prev.connect("clicked", self.on_B_Prev_Click)
B_Play.connect("clicked", self.on_B_Play_Click)
B_Next.connect("clicked", self.on_B_Next_clicked)
B_Stop.connect("clicked", self.stop)
Box.pack_start(B_Prev, False)
Box.pack_start(B_Play, False)
Box.pack_start(B_Next, False)
Box.pack_start(B_Stop, False)
BB.set_spacing(10)
B_Volume = gtk.VolumeButton()
B_Volume.connect("value-changed", self.on_volume_change)
Box.pack_start(B_Volume, False)
#Box.pack_start(BB, False)
Box.pack_start(ProgressBar)
Box.show_all()
#on "coupe" la sortie vidéo
fakesink = gst.element_factory_make("fakesink", "my-fakesink")
self._player.set_property("video-sink", fakesink)
messager.inscrire(self.lire_fichier, 'musique_a_lire')
messager.inscrire(self.stop, 'arret_musique')
def __init__(self, manager, label):
self.modified = False #pour les playlists enregistrées
self.manager = manager
#police, icon_playing, icon_stopping, ID, path, titre, album, artiste, length, count, pixbuf_note, note, bridge_src key
self.model = gtk.ListStore(str, gtk.gdk.Pixbuf, gtk.gdk.Pixbuf, int, str, str, str, str, str, int, gtk.gdk.Pixbuf, int, str)
self.TreeView = gtk.TreeView(self.model)
self.TreeView.set_rules_hint(True)
self.TreeView.set_reorderable(True)
self.TreeView.connect("row-activated", self.activated)
self.TreeView.connect("button-press-event", self.onButtonClick)
self.TreeView.connect("key-press-event", self.executerRaccourci)
self.model.connect('row-deleted', self.onRowDeleted)
self.model.connect('row-inserted', self.onRowInserted)
self.model.connect('rows-reordered', self.onRowsReordered)
self.isMoving = False # Tells if there is currently a drag operation initiated by this TreeView
#On s'occupe du "label" de l'onglet
tab_label_box = gtk.EventBox()
tab_label_box.set_visible_window(False) #make event box don't change anything lookwise
tab_label_box.connect('event', self.on_tab_click, self.TreeView)
self.tab_label = gtk.Label(label)
self.tab_label.set_max_width_chars(20)
hbox = gtk.HBox(False, 2)
hbox.pack_start(self.tab_label, False, False)
close_icon = gtk.Image()
close_icon.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
close_button = gtk.Button()
close_button.set_relief(gtk.RELIEF_NONE)
close_button.set_focus_on_click(False)
close_button.set_tooltip_text(_("Close Tab"))
close_button.add(close_icon)
close_button.set_size_request(24,24) # avoid big padding
close_button.connect('clicked', manager.closeQueue, self)
hbox.pack_end(close_button, False, False)
tab_label_box.add(hbox)
tab_label_box.show_all()
cell = gtk.CellRendererText()
pb = gtk.CellRendererPixbuf()
pb2 = gtk.CellRendererPixbuf()
cellr = etoiles.RatingCellRenderer()
cellr.connect('rating-changed', self.on_cell_rating_changed)
#col = gtk.TreeViewColumn('header', cell, text=0, font=1)
Col_Titre = BSColumn('col_title', _('Title'), expand=True)
Col_Artiste = BSColumn('col_artist', _('Artist'), expand=True)
Col_Album = BSColumn('col_album', _('Album'), expand=True)
Col_Duree = BSColumn('col_length', _('Length'))
Col_Count = BSColumn('col_playcount', _('Playcount'), cell, model_text=9)
Col_Note = BSColumn('col_rating', _('Rating'), cellr, pixbuf=10, default_width=85)
Col_Titre.name = 'col_title'
Col_Artiste.name = 'col_artist'
self.TreeView.append_column(Col_Titre)
self.TreeView.append_column(Col_Album)
self.TreeView.append_column(Col_Artiste)
self.TreeView.append_column(Col_Duree)
self.TreeView.append_column(Col_Count)
self.TreeView.append_column(Col_Note)
self.TreeView.set_enable_search(False)
self.TreeView.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
#self.TreeView.set_rubber_banding(True) #séléction multiple by dragging
#Le TreeView accepte les données droppées
self.TreeView.enable_model_drag_dest([('text/plain', 0, 0), ('GTK_TREE_MODEL_ROW', 0, 0)],
gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_MOVE)
self.TreeView.connect("drag-data-received", self.on_drag_data_received)
self.TreeView.connect("drag-begin", self.on_drag_begin)
Col_Titre.pack_start(pb, False)
Col_Titre.pack_start(pb2, False)
Col_Titre.pack_start(cell, True)
Col_Artiste.pack_start(cell, True)
Col_Album.pack_start(cell, True)
Col_Duree.pack_start(cell, True)
Col_Titre.set_attributes(cell, text=5, font=0)
Col_Titre.add_attribute(pb, 'pixbuf', 1)
Col_Titre.add_attribute(pb2, 'pixbuf', 2)
Col_Artiste.add_attribute(cell, 'text', 7)
Col_Album.add_attribute(cell, 'text', 6)
Col_Duree.add_attribute(cell, 'text', 8)
Col_Titre.set_sort_column_id(5)
Col_Album.set_sort_column_id(6)
Col_Artiste.set_sort_column_id(7)
Col_Count.set_sort_column_id(9)
Col_Note.set_sort_column_id(11)
self.columnsFields = {5:'title', 6:'album', 7:'artist', 9:'playcount', 11:'rating'}
cols = [Col_Titre, Col_Artiste, Col_Album, Col_Count, Col_Note]
for col in cols:
col.connect('clicked', self.on_column_clicked)
#Col_Titre.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
#Col_Titre.set_fixed_width(40)
messager.inscrire(self.updateView, 'track_data_changed')
self.tracks = []
gtk.ScrolledWindow.__init__(self)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.add(self.TreeView)
manager.NoteBook.append_page(self, tab_label_box)
manager.show_all()
def __init__(self):
db_path = os.path.join(xdg.get_data_home(), "data.db")
if os.path.exists(db_path):
self.conn = sqlite3.connect(db_path)
self.conn.row_factory = sqlite3.Row
self.c = self.conn.cursor()
else:
self.conn = sqlite3.connect(db_path)
self.conn.row_factory = sqlite3.Row
self.c = self.conn.cursor()
self.creer_tables()
# self.scanner_dossier("/home/piccolo/Musique")
# xdg.make_missing_dirs()
BDD.initNetwork()
# Abonnement à certains types de messages auprès du messager
messager.inscrire(self.charger_playlist, "ID_playlist")
# messager.inscrire(self.fill_library_browser, 'TS_bibliotheque')
# messager.inscrire(self.remplir_liste_sections, 'liste_sections')
messager.inscrire(self.get_tracks_data, "need_tracks")
messager.inscrire(self.get_track_data, "queue_add_track")
# messager.inscrire(self.get_data_of, 'need_data_of')
messager.inscrire(self.add_file_in, "fileIN")
messager.inscrire(self.add_file_in, "fileINuniverse", None, "univers_ID")
messager.inscrire(self.ajouter_section, "new_category", None, "categorie")
messager.inscrire(self.ajouter_section, "new_universe", None, "univers")
# messager.inscrire(self.create_intelligent_playlist, 'intelligent_playlist_request')
print ("BDD initialisée")
def __init__(self, module, elementSelector):
AbstractPanel.__init__(self, module)
self.elementSelector = elementSelector
#Ini panel dossiers
self.folderModel = gtk.TreeStore(str, str, str, int, gtk.gdk.Pixbuf, str, str)
TreeView = ContainerBrowser(self.folderModel, 'folder')
#TreeView.set_headers_visible(False)
#Ini panel catégories : container_ID, container_type, container_label, container_icon, background, foreground
self.categoriesModel = gtk.TreeStore(int, str, str, int, gtk.gdk.Pixbuf, str, str)
self.universesModel = gtk.TreeStore(int, str, str, int, gtk.gdk.Pixbuf, str, str)
TV_universes = ContainerBrowser(self.universesModel, 'universe')
TV_categories = ContainerBrowser(self.categoriesModel, 'category')
self.treeViews = {'universe':TV_universes, 'category':TV_categories, 'folder':TreeView}
modeCB = gtk.ComboBox()
tvLayout = gtk.HBox()
for key in ('folder', 'category', 'universe'):
tv = self.treeViews[key]
if key != 'folder':
tv.connect("drag-data-received", self.on_drag_data_receive)
tv.connect("button-press-event", self.onContainerClicked)
tv.enable_model_drag_dest([('text/plain', 0, 0)],gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_MOVE)
else:
tv.connect("button-press-event", self.on_folder_click)
tv.connect("row-activated", self.onContainerActivated)
SW = gtk.ScrolledWindow()
SW.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
SW.add(tv)
tvLayout.pack_start(SW)
# DEPRECATED
#self.columns = {}
#self.columns["universe"] = col
#self.columns["category"] = col
messager.inscrire(self.reload_sections, "new_category")
messager.inscrire(self.reload_sections, "new_universe")
B_refresh = gtk.ToolButton(gtk.STOCK_REFRESH)
B_refresh.connect('clicked', self.load)
modeModel = gtk.ListStore(str, str)
modeModel.append([None, _('None')])
modeModel.append(["category", _("Categories")])
modeModel.append(["universe", _("Universes")])
modeModel.append(["folder", _("Folders")])
cell = gtk.CellRendererText()
modeCB.pack_start(cell)
modeCB.add_attribute(cell, "text", 1)
modeCB.set_model(modeModel)
modeCB.set_active(0)
modeCB.connect("changed", self.filteringTreeViewChanged)
self.filterLabel = gtk.Label(_('No active filters'))
#On assemble tout graphiquement
gtk.VBox.__init__(self)
BB = gtk.HBox()
BB.pack_start(B_refresh, False)
BB.pack_start(modeCB, False)
BB.pack_start(self.filterLabel, True)
self.pack_start(BB, False)
self.searchEntry = gtk.Entry()
self.searchEntry.connect('activate', self.load)
self.pack_start(tvLayout)
self.pack_start(self.searchEntry, False)
self.set_size_request(700, -1)
self.toggled = {'category': False, 'universe': False, 'folder':False}
self.filters = {}
filterIndex = settings.get_option(self.module + 's/container_filter', 0)
if filterIndex != 0:
modeCB.set_active(filterIndex) # trigger filteringTreeViewChanged() and thus load
else:
self.load()
def __init__(self, type, elementSelector):
AbstractPanel.__init__(self, type)
self.elementSelector = elementSelector
#Ini panel catégories : container_ID, container_type, container_label, container_rating, container_icon
self.model = gtk.TreeStore(int, str, str, int, gtk.gdk.Pixbuf, str, str)
#messager.diffuser('liste_sections', self, [self.module, "category", self.model])
TreeView = ContainerBrowser(self.model)
TreeView.set_headers_visible(False)
self.treeViews = {'folder':TreeView, 'category':TreeView, 'universe':TreeView}
modeCB = gtk.ComboBox()
TreeView.connect("row-activated", self.onContainerActivated)
TreeView.connect("drag-data-received", self.on_drag_data_receive)
TreeView.connect("button-press-event", self.onContainerClicked)
#Le TreeView sera la destination à toucher avec la souris
TreeView.enable_model_drag_dest([('text/plain', 0, 0)], gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_MOVE)
modeModel = gtk.ListStore(str, str)
modeModel.append(["category", "Categories"])
modeModel.append(["universe", _("Universes")])
modeModel.append(["folder", _("Folders")])
cell = gtk.CellRendererText()
modeCB.pack_start(cell)
modeCB.add_attribute(cell, "text", 1)
modeCB.set_model(modeModel)
modeCB.set_active(0)
modeCB.connect("changed", self.changer_mode)
self.modeCB = modeCB
messager.inscrire(self.reload_sections, "new_category")
messager.inscrire(self.reload_sections, "new_universe")
B_refresh = gtk.ToolButton(gtk.STOCK_REFRESH)
B_refresh.connect('clicked', self.load)
self.showAntagonistic = gtk.CheckButton(_("Show antagonistic"))
self.showAntagonistic.set_active(settings.get_option(self.module + 's/show_antagonistic', False))
self.showAntagonistic.connect('toggled', self.toggleAntagonisitc)
#On assemble tout graphiquement
gtk.VBox.__init__(self)
Box_mode = gtk.HBox()
Box_mode.pack_start(self.showAntagonistic, False)
Box_mode.pack_start(modeCB)
Box_mode.pack_start(B_refresh, False)
self.pack_start(Box_mode, False)
SW = gtk.ScrolledWindow()
SW.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
SW.add(TreeView)
self.pack_start(SW)
self.searchEntry = gtk.Entry()
self.searchEntry.connect('activate', self.load)
self.pack_start(self.searchEntry, False)
self.set_size_request(300, -1)
self.filters = {}
self.load()
