class GtImporter(object):
'''
Shows a dialog that allows importing of grouping tags
from a directory not included in the current collection.
'''
def __init__(self, exaile, uris):
self.exaile = exaile
self._init_builder()
self.collection = Collection("GT Import Collection")
for uri in uris:
self.collection.add_library(Library(uri))
self.manager = ProgressManager(self.content_area)
self.rescan_thread = CollectionScanThread(self.collection)
self.rescan_thread.connect('done', lambda t: glib.idle_add(self._on_rescan_done))
self.update_thread = None
self.import_thread = None
self.manager.add_monitor(self.rescan_thread, _("Importing tracks"), gtk.STOCK_REFRESH)
def _init_builder(self):
builder = gtk.Builder()
builder.add_from_file(os.path.join(os.path.dirname(__file__), 'gt_import.ui'))
# retrieve widgets
self.window = builder.get_object('window')
self.content_area = builder.get_object('content_area')
self.ok_button = builder.get_object('ok_button')
self.tags_model = builder.get_object('tags_model')
self.tags_view = builder.get_object('tags_view')
self.tags_vbox = builder.get_object('tags_vbox')
self.radio_merge = builder.get_object('radio_merge')
self.radio_replace = builder.get_object('radio_replace')
# signals
signals = { 'on_cancel_button_clicked': self._on_cancel_button_clicked,
'on_import_checkbox_toggled': self._on_import_checkbox_toggled,
'on_ok_button_clicked': self._on_ok_button_clicked,
'on_window_destroy': self._on_window_destroy }
builder.connect_signals(signals, None)
def show(self):
return self.window.show()
#
# Status routines
#
def _on_rescan_done(self):
'''Called when the collection is finished loading'''
if self.rescan_thread is None:
return
self.rescan_thread = None
logger.info('Import directory scan completed, importing groups')
# now that the collection has loaded, import the groups from them
self.import_thread = TrackImportThread(self.collection, self.exaile.collection)
self.import_thread.connect('done', self._on_import_done)
self.manager.add_monitor(self.import_thread, _("Importing groups"), gtk.STOCK_JUMP_TO)
def _on_import_done(self, thread):
'''Called when the grouping data is retrieved'''
if self.import_thread is None:
return
track_data = self.import_thread.track_data
self.import_thread = None
logger.info('Group import finished, %s new tracks found' % len(track_data))
if len(track_data) == 0:
self.window.destroy()
# TODO: this isn't on another thread, but if we don't call
# threads_enter/leave then it deadlocks. Not sure why...
locations = ';'.join([l.get_location() for l in self.collection.get_libraries()])
gtk.gdk.threads_enter()
dialogs.info(self.window, 'No new tracks found at "%s"' % locations)
gtk.gdk.threads_leave()
return
self.tags_view.freeze_child_notify()
self.tags_view.set_model(None)
# add the data to the model
for old_group_str, new_group_str, matched_track, newgroups in track_data:
self.tags_model.append((True, str(matched_track), old_group_str, new_group_str, matched_track, newgroups))
self.tags_view.set_model(self.tags_model)
self.tags_view.thaw_child_notify()
self.ok_button.set_sensitive(True)
self.tags_vbox.set_visible(True)
def _on_update_done(self, thread):
if self.update_thread is None:
return
self.update_thread = None
logger.info('Track update complete')
self.window.destroy()
#
# Widget events
#
def _on_cancel_button_clicked(self, widget):
if self.rescan_thread is not None:
self.rescan_thread.stop()
elif self.import_thread is not None:
self.import_thread.stop()
elif self.update_thread is not None:
self.update_thread.stop()
self.window.destroy()
def _on_import_checkbox_toggled(self, cell, path):
self.tags_model[path][0] = not cell.get_active()
def _on_ok_button_clicked(self, widget):
self.ok_button.set_sensitive(False)
self.tags_vbox.set_sensitive(False)
data = [(row[4], row[5]) for row in self.tags_model if row[0] == True]
logger.info('Updating %s tracks' % len(data))
self.update_thread = TrackUpdateThread(data, self.radio_replace.get_active())
self.update_thread.connect('done', self._on_update_done)
self.manager.add_monitor(self.update_thread, _("Updating groups"), gtk.STOCK_CONVERT)
def _on_window_destroy(self, widget):
self.collection.close()
class GtImporter(Gtk.Window):
'''
Shows a dialog that allows importing of grouping tags
from a directory not included in the current collection.
'''
__gtype_name__ = 'GtImporter'
content_area, \
ok_button, \
tags_model, \
tags_view, \
tags_vbox, \
radio_merge, \
radio_replace = GtkTemplate.Child.widgets(7)
def __init__(self, exaile, uris):
Gtk.Window.__init__(self, transient_for=exaile.gui.main.window)
self.init_template()
self.exaile = exaile
self.collection = Collection("GT Import Collection")
for uri in uris:
self.collection.add_library(Library(uri))
self.manager = ProgressManager(self.content_area)
self.rescan_thread = CollectionScanThread(self.collection)
self.rescan_thread.connect('done', lambda t: GLib.idle_add(self._on_rescan_done))
self.update_thread = None
self.import_thread = None
self.manager.add_monitor(self.rescan_thread, _("Importing tracks"), Gtk.STOCK_REFRESH)
#
# Status routines
#
def _on_rescan_done(self):
'''Called when the collection is finished loading'''
if self.rescan_thread is None:
return
self.rescan_thread = None
logger.info('Import directory scan completed, importing groups')
# now that the collection has loaded, import the groups from them
self.import_thread = TrackImportThread(self.collection, self.exaile.collection)
self.import_thread.connect('done', self._on_import_done)
self.manager.add_monitor(self.import_thread, _("Importing groups"), Gtk.STOCK_JUMP_TO)
def _on_import_done(self, thread):
'''Called when the grouping data is retrieved'''
if self.import_thread is None:
return
track_data = self.import_thread.track_data
self.import_thread = None
logger.info('Group import finished, %s new tracks found' % len(track_data))
if len(track_data) == 0:
self.destroy()
locations = ';'.join([l.get_location() for l in self.collection.get_libraries()])
dialogs.info(self.exaile.gui.main.window, 'No new tracks found at "%s"' % locations)
return
self.tags_view.freeze_child_notify()
self.tags_view.set_model(None)
# add the data to the model
for old_group_str, new_group_str, matched_track, newgroups in track_data:
self.tags_model.append((True, str(matched_track), old_group_str, new_group_str, matched_track, newgroups))
self.tags_view.set_model(self.tags_model)
self.tags_view.thaw_child_notify()
self.ok_button.set_sensitive(True)
self.tags_vbox.set_visible(True)
def _on_update_done(self, thread):
if self.update_thread is None:
return
self.update_thread = None
logger.info('Track update complete')
self.destroy()
#
# Widget events
#
@GtkTemplate.Callback
def on_cancel_button_clicked(self, widget):
if self.rescan_thread is not None:
self.rescan_thread.stop()
elif self.import_thread is not None:
self.import_thread.stop()
elif self.update_thread is not None:
self.update_thread.stop()
self.destroy()
@GtkTemplate.Callback
def on_import_checkbox_toggled(self, cell, path):
self.tags_model[path][0] = not cell.get_active()
@GtkTemplate.Callback
def on_ok_button_clicked(self, widget):
self.ok_button.set_sensitive(False)
self.tags_vbox.set_sensitive(False)
data = [(row[4], row[5]) for row in self.tags_model if row[0] == True]
logger.info('Updating %s tracks' % len(data))
self.update_thread = TrackUpdateThread(data, self.radio_replace.get_active())
self.update_thread.connect('done', self._on_update_done)
self.manager.add_monitor(self.update_thread, _("Updating groups"), Gtk.STOCK_CONVERT)
@GtkTemplate.Callback
def on_window_destroy(self, widget):
self.collection.close()
class GtImporter(Gtk.Window):
'''
Shows a dialog that allows importing of grouping tags
from a directory not included in the current collection.
'''
__gtype_name__ = 'GtImporter'
content_area, \
ok_button, \
tags_model, \
tags_view, \
tags_vbox, \
radio_merge, \
radio_replace = GtkTemplate.Child.widgets(7)
def __init__(self, exaile, uris):
Gtk.Window.__init__(self, transient_for=exaile.gui.main.window)
self.init_template()
self.exaile = exaile
self.collection = Collection("GT Import Collection")
for uri in uris:
self.collection.add_library(Library(uri))
self.manager = ProgressManager(self.content_area)
self.rescan_thread = CollectionScanThread(self.collection)
self.rescan_thread.connect('done', self._on_rescan_done)
self.import_thread = None
self.manager.add_monitor(self.rescan_thread, _("Importing tracks"),
'document-open')
#
# Status routines
#
@idle_add()
def _on_rescan_done(self, thread):
'''Called when the collection is finished loading'''
if self.rescan_thread is None:
return
self.rescan_thread = None
logger.info('Import directory scan completed, importing groups')
# now that the collection has loaded, import the groups from them
self.import_track_data = []
self.import_thread = SimpleProgressThread(track_import_thread,
self.collection,
self.exaile.collection,
self.import_track_data)
self.import_thread.connect('done', self._on_import_done)
self.manager.add_monitor(self.import_thread, _("Importing groups"),
'document-open')
@idle_add()
def _on_import_done(self, thread):
'''Called when the grouping data is retrieved'''
if self.import_thread is None:
return
track_data = self.import_track_data
self.import_thread = None
self.import_track_data = None
logger.info('Group import finished, %s new tracks found',
len(track_data))
if len(track_data) == 0:
self.destroy()
locations = ';'.join(
[l.get_location() for l in self.collection.get_libraries()])
dialogs.info(self.exaile.gui.main.window,
'No new tracks found at "%s"' % locations)
return
self.tags_view.freeze_child_notify()
self.tags_view.set_model(None)
# add the data to the model
for old_group_str, new_group_str, matched_track, newgroups in track_data:
self.tags_model.append((True, str(matched_track), old_group_str,
new_group_str, matched_track, newgroups))
self.tags_view.set_model(self.tags_model)
self.tags_view.thaw_child_notify()
self.ok_button.set_sensitive(True)
self.tags_vbox.set_visible(True)
@idle_add()
def _on_update_done(self, thread):
if self.update_thread is None:
return
self.update_thread = None
logger.info('Track update complete')
self.destroy()
#
# Widget events
#
@GtkTemplate.Callback
def on_cancel_button_clicked(self, widget):
if self.rescan_thread is not None:
self.rescan_thread.stop()
elif self.import_thread is not None:
self.import_thread.stop()
elif self.update_thread is not None:
self.update_thread.stop()
self.destroy()
@GtkTemplate.Callback
def on_import_checkbox_toggled(self, cell, path):
self.tags_model[path][0] = not cell.get_active()
@GtkTemplate.Callback
def on_ok_button_clicked(self, widget):
self.ok_button.set_sensitive(False)
self.tags_vbox.set_sensitive(False)
data = [(row[4], row[5]) for row in self.tags_model if row[0]]
logger.info('Updating %s tracks', len(data))
self.update_thread = SimpleProgressThread(
track_update_thread, data, self.radio_replace.get_active())
self.update_thread.connect('done', self._on_update_done)
self.manager.add_monitor(self.update_thread, _("Updating groups"),
'system-run')
@GtkTemplate.Callback
def on_window_destroy(self, widget):
self.collection.close()
class GtImporter(object):
'''
Shows a dialog that allows importing of grouping tags
from a directory not included in the current collection.
'''
def __init__(self, exaile, uris):
self.exaile = exaile
self._init_builder()
self.collection = Collection("GT Import Collection")
for uri in uris:
self.collection.add_library(Library(uri))
self.manager = ProgressManager(self.content_area)
self.rescan_thread = CollectionScanThread(self.collection)
self.rescan_thread.connect(
'done', lambda t: glib.idle_add(self._on_rescan_done))
self.update_thread = None
self.import_thread = None
self.manager.add_monitor(self.rescan_thread, _("Importing tracks"),
gtk.STOCK_REFRESH)
def _init_builder(self):
builder = gtk.Builder()
builder.add_from_file(
os.path.join(os.path.dirname(__file__), 'gt_import.ui'))
# retrieve widgets
self.window = builder.get_object('window')
self.content_area = builder.get_object('content_area')
self.ok_button = builder.get_object('ok_button')
self.tags_model = builder.get_object('tags_model')
self.tags_view = builder.get_object('tags_view')
self.tags_vbox = builder.get_object('tags_vbox')
self.radio_merge = builder.get_object('radio_merge')
self.radio_replace = builder.get_object('radio_replace')
# signals
signals = {
'on_cancel_button_clicked': self._on_cancel_button_clicked,
'on_import_checkbox_toggled': self._on_import_checkbox_toggled,
'on_ok_button_clicked': self._on_ok_button_clicked,
'on_window_destroy': self._on_window_destroy
}
builder.connect_signals(signals, None)
def show(self):
return self.window.show()
#
# Status routines
#
def _on_rescan_done(self):
'''Called when the collection is finished loading'''
if self.rescan_thread is None:
return
self.rescan_thread = None
logger.info('Import directory scan completed, importing groups')
# now that the collection has loaded, import the groups from them
self.import_thread = TrackImportThread(self.collection,
self.exaile.collection)
self.import_thread.connect('done', self._on_import_done)
self.manager.add_monitor(self.import_thread, _("Importing groups"),
gtk.STOCK_JUMP_TO)
def _on_import_done(self, thread):
'''Called when the grouping data is retrieved'''
if self.import_thread is None:
return
track_data = self.import_thread.track_data
self.import_thread = None
logger.info('Group import finished, %s new tracks found' %
len(track_data))
if len(track_data) == 0:
self.window.destroy()
# TODO: this isn't on another thread, but if we don't call
# threads_enter/leave then it deadlocks. Not sure why...
locations = ';'.join(
[l.get_location() for l in self.collection.get_libraries()])
gtk.gdk.threads_enter()
dialogs.info(self.window,
'No new tracks found at "%s"' % locations)
gtk.gdk.threads_leave()
return
self.tags_view.freeze_child_notify()
self.tags_view.set_model(None)
# add the data to the model
for old_group_str, new_group_str, matched_track, newgroups in track_data:
self.tags_model.append((True, str(matched_track), old_group_str,
new_group_str, matched_track, newgroups))
self.tags_view.set_model(self.tags_model)
self.tags_view.thaw_child_notify()
self.ok_button.set_sensitive(True)
self.tags_vbox.set_visible(True)
def _on_update_done(self, thread):
if self.update_thread is None:
return
self.update_thread = None
logger.info('Track update complete')
self.window.destroy()
#
# Widget events
#
def _on_cancel_button_clicked(self, widget):
if self.rescan_thread is not None:
self.rescan_thread.stop()
elif self.import_thread is not None:
self.import_thread.stop()
elif self.update_thread is not None:
self.update_thread.stop()
self.window.destroy()
def _on_import_checkbox_toggled(self, cell, path):
self.tags_model[path][0] = not cell.get_active()
def _on_ok_button_clicked(self, widget):
self.ok_button.set_sensitive(False)
self.tags_vbox.set_sensitive(False)
data = [(row[4], row[5]) for row in self.tags_model if row[0] == True]
logger.info('Updating %s tracks' % len(data))
self.update_thread = TrackUpdateThread(data,
self.radio_replace.get_active())
self.update_thread.connect('done', self._on_update_done)
self.manager.add_monitor(self.update_thread, _("Updating groups"),
gtk.STOCK_CONVERT)
def _on_window_destroy(self, widget):
self.collection.close()