def main():
try:
app = QApplication(sys.argv)
#app.setStyle('cleanlooks')
app.setStyleSheet(qdarkstyle.load_stylesheet())
db = Database('sample.db')
icon = QIcon('app.ico')
app.setWindowIcon(icon)
# set the default font for the app
app.setFont(MEDIUM_FONT)
app.setStyle(BUTTON_STYLE)
main_view = MainView()
main_view.showMaximized()
main_view.show()
app.exec_()
# clean up and exit code
for model in main_view.models:
model.submitAll() # commit all pending changes to all models
db.close()
app.quit()
sys.exit(0)
#os._exit(0)
except SystemExit:
print("Closing Window...")
except Exception as e:
print(str(e))
def main():
app = QApplication(sys.argv)
CONFIG_FILE = 'config.json'
CONFIG_PYSIDE_RCC = 'pyside_rcc'
CONFIG_PYSIDE_UIC = 'pyside_uic'
json_ = json.load(open(CONFIG_FILE, mode='r+'))
pyside_rcc = json_[CONFIG_PYSIDE_RCC] if os.path.exists(json_[CONFIG_PYSIDE_RCC]) else get_pyside_rcc()
pyside_uic = json_[CONFIG_PYSIDE_UIC] if os.path.exists(json_[CONFIG_PYSIDE_RCC]) else get_pyside_uic()
if len(pyside_rcc) == 0 or len(pyside_uic) == 0:
raise SystemExit
subprocess.Popen([pyside_rcc, '../resources/MainResource.qrc', '-o', 'MainResource_rc.py'])
subprocess.Popen([pyside_uic, '../ui/MainWindow.ui', '-o', 'MainWindow.py'])
subprocess.Popen([pyside_uic, '../ui/SettingsWindow.ui', '-o', 'SettingsWindow.py'])
subprocess.Popen([pyside_uic, '../ui/ErrorLogWindow.ui', '-o', 'ErrorLogWindow.py'])
json_[CONFIG_PYSIDE_RCC] = pyside_rcc
json_[CONFIG_PYSIDE_UIC] = pyside_uic
with open(CONFIG_FILE, 'w') as json_file:
json.dump(json_, json_file, sort_keys=True, indent=4, separators=(',', ':'))
app.quit()
def closeEvent(self, *args, **kwargs):
self.logger.info("Saving to file")
savefile = open(os.path.join(windows.data_dir(), 'desuratools.json'),
'w')
savefile.write(
json.dumps({
'desuraname': self.current_profileid,
'steamname': self.steamID_input.currentText()
}))
savefile.close()
QApplication.quit()
def closeEvent(self, *args, **kwargs):
self.logger.info("Saving to file")
savefile = open(os.path.join(windows.data_dir(), 'desuratools.json'), 'w')
savefile.write(
json.dumps({
'desuraname': self.current_profileid,
'steamname': self.steamID_input.currentText()
})
)
savefile.close()
QApplication.quit()
def applyRulesAutomatically(self):
if self.needToApplyRules():
# FIXME: there should be transaction here -- all stuff should be done together or not at all
self.createEnvelopeForNewWeek()
self.transferAllFromLastWeek()
self.__ruleMgr.executeAllRules()
try:
self.markWeekAsRulesApplied()
except Exception:
QMessageBox.critical(self, "Error marking this week as rules applied",
"This error should be fixed manually")
QApplication.quit()
self.loadExpenses()
class Shell(ShellBase):
""" Shell implementation using PySide
"""
def __init__(self):
super(Shell, self).__init__()
self.app = QApplication(sys.argv)
self.app.setQuitOnLastWindowClosed(False) # 1
self.icon = QIcon(resource_path('res/icon.png'))
self.menu = None
self.wnd = MainWnd(self, self.icon)
def quit_app(self):
self.app.quit()
def run(self):
_logger.info("Shell is running...")
self.app.exec_()
class qtPodder(QObject):
def __init__(self, args, gpodder_core, dbus_bus_name):
QObject.__init__(self)
self.dbus_bus_name = dbus_bus_name
# TODO: Expose the same D-Bus API as the Gtk UI D-Bus object (/gui)
# TODO: Create a gpodder.dbusproxy.DBusPodcastsProxy object (/podcasts)
self.app = QApplication(args)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.quit.connect(self.on_quit)
self.episodeUpdated.connect(self.on_episode_updated)
self.setEpisodeListModel.connect(self.on_set_episode_list_model)
self.core = gpodder_core
self.config = self.core.config
self.db = self.core.db
self.model = self.core.model
self.config_proxy = ConfigProxy(self.config)
# Initialize the gpodder.net client
self.mygpo_client = my.MygPoClient(self.config)
gpodder.user_extensions.on_ui_initialized(self.model,
self.extensions_podcast_update_cb,
self.extensions_episode_download_cb)
self.view = DeclarativeView()
self.view.closing.connect(self.on_quit)
self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
self.controller = Controller(self)
self.media_buttons_handler = helper.MediaButtonsHandler()
self.tracker_miner_config = helper.TrackerMinerConfig()
self.podcast_model = gPodderPodcastListModel()
self.episode_model = gPodderEpisodeListModel(self.config, self)
self.last_episode = None
# A dictionary of episodes that are currently active
# in some way (i.e. playing back or downloading)
self.active_episode_wrappers = {}
engine = self.view.engine()
# Add the cover art image provider
self.cover_provider = images.LocalCachedImageProvider()
engine.addImageProvider('cover', self.cover_provider)
root_context = self.view.rootContext()
root_context.setContextProperty('controller', self.controller)
root_context.setContextProperty('configProxy', self.config_proxy)
root_context.setContextProperty('mediaButtonsHandler',
self.media_buttons_handler)
root_context.setContextProperty('trackerMinerConfig',
self.tracker_miner_config)
# Load the QML UI (this could take a while...)
self.view.setSource(QUrl.fromLocalFile(QML('main_default.qml')))
# Proxy to the "main" QML object for direct access to Qt Properties
self.main = helper.QObjectProxy(self.view.rootObject().property('main'))
self.main.podcastModel = self.podcast_model
self.main.episodeModel = self.episode_model
self.view.setWindowTitle('gPodder')
if gpodder.ui.harmattan:
self.view.showFullScreen()
else:
# On the Desktop, scale to fit my small laptop screen..
desktop = self.app.desktop()
if desktop.height() < 1000:
FACTOR = .8
self.view.scale(FACTOR, FACTOR)
size = self.view.size()
size *= FACTOR
self.view.resize(size)
self.view.show()
self.do_start_progress.connect(self.on_start_progress)
self.do_end_progress.connect(self.on_end_progress)
self.do_show_message.connect(self.on_show_message)
podcasts = self.load_podcasts()
self.resumable_episodes = None
self.do_offer_download_resume.connect(self.on_offer_download_resume)
util.run_in_background(self.find_partial_downloads(podcasts))
def find_partial_downloads(self, podcasts):
def start_progress_callback(count):
self.start_progress(_('Loading incomplete downloads'))
def progress_callback(title, progress):
self.start_progress('%s (%d%%)' % (
_('Loading incomplete downloads'),
progress*100))
def finish_progress_callback(resumable_episodes):
self.end_progress()
self.resumable_episodes = resumable_episodes
self.do_offer_download_resume.emit()
common.find_partial_downloads(podcasts,
start_progress_callback,
progress_callback,
finish_progress_callback)
do_offer_download_resume = Signal()
def on_offer_download_resume(self):
if self.resumable_episodes:
def download_episodes():
for episode in self.resumable_episodes:
qepisode = self.wrap_simple_episode(episode)
self.controller.downloadEpisode(qepisode)
def delete_episodes():
logger.debug('Deleting incomplete downloads.')
common.clean_up_downloads(delete_partial=True)
message = _('Incomplete downloads from a previous session were found.')
title = _('Resume')
self.controller.confirm_action(message, title, download_episodes, delete_episodes)
def add_active_episode(self, episode):
self.active_episode_wrappers[episode.id] = episode
episode.episode_wrapper_refcount += 1
def remove_active_episode(self, episode):
episode.episode_wrapper_refcount -= 1
if episode.episode_wrapper_refcount == 0:
del self.active_episode_wrappers[episode.id]
def load_last_episode(self):
last_episode = None
last_podcast = None
for podcast in self.podcast_model.get_podcasts():
for episode in podcast.get_all_episodes():
if not episode.last_playback:
continue
if last_episode is None or \
episode.last_playback > last_episode.last_playback:
last_episode = episode
last_podcast = podcast
if last_episode is not None:
self.last_episode = self.wrap_episode(last_podcast, last_episode)
# FIXME: Send last episode to player
#self.select_episode(self.last_episode)
def on_episode_deleted(self, episode):
# Remove episode from play queue (if it's in there)
self.main.removeQueuedEpisode(episode)
# If the episode that has been deleted is currently
# being played back (or paused), stop playback now.
if self.main.currentEpisode == episode:
self.main.togglePlayback(None)
def enqueue_episode(self, episode):
self.main.enqueueEpisode(episode)
def run(self):
return self.app.exec_()
quit = Signal()
def on_quit(self):
# Make sure the audio playback is stopped immediately
self.main.togglePlayback(None)
self.save_pending_data()
self.view.hide()
self.core.shutdown()
self.app.quit()
episodeUpdated = Signal(int)
def on_episode_updated(self, episode_id):
self.main.episodeUpdated(episode_id)
setEpisodeListModel = Signal(object)
def on_set_episode_list_model(self, prepared):
self.main.setEpisodeListModel(prepared)
do_show_message = Signal(unicode)
@Slot(unicode)
def on_show_message(self, message):
self.main.showMessage(message)
def show_message(self, message):
self.do_show_message.emit(message)
def show_input_dialog(self, message, value='', accept=_('OK'),
reject=_('Cancel'), is_text=True):
self.main.showInputDialog(message, value, accept, reject, is_text)
def open_context_menu(self, items):
self.main.openContextMenu(items)
do_start_progress = Signal(str)
@Slot(str)
def on_start_progress(self, text):
self.main.startProgress(text)
def start_progress(self, text=_('Please wait...')):
self.do_start_progress.emit(text)
do_end_progress = Signal()
@Slot()
def on_end_progress(self):
self.main.endProgress()
def end_progress(self):
self.do_end_progress.emit()
def resort_podcast_list(self):
self.podcast_model.sort()
def insert_podcast(self, podcast):
self.podcast_model.insert_object(podcast)
self.mygpo_client.on_subscribe([podcast.url])
self.mygpo_client.flush()
def remove_podcast(self, podcast):
# Remove queued episodes for this specific podcast
self.main.removeQueuedEpisodesForPodcast(podcast)
if self.main.currentEpisode is not None:
# If the currently-playing episode is in the podcast
# that is to be deleted, stop playback immediately.
if self.main.currentEpisode.qpodcast == podcast:
self.main.togglePlayback(None)
self.podcast_model.remove_object(podcast)
self.mygpo_client.on_unsubscribe([podcast.url])
self.mygpo_client.flush()
def load_podcasts(self):
podcasts = map(model.QPodcast, self.model.get_podcasts())
self.podcast_model.set_podcasts(self.db, podcasts)
return podcasts
def wrap_episode(self, podcast, episode):
try:
return self.active_episode_wrappers[episode.id]
except KeyError:
return model.QEpisode(self, podcast, episode)
def wrap_simple_episode(self, episode):
for podcast in self.podcast_model.get_podcasts():
if podcast.id == episode.podcast_id:
return self.wrap_episode(podcast, episode)
return None
def select_podcast(self, podcast):
if isinstance(podcast, model.QPodcast):
# Normal QPodcast instance
wrap = functools.partial(self.wrap_episode, podcast)
objects = podcast.get_all_episodes()
self.episode_model.set_is_subset_view(False)
else:
# EpisodeSubsetView
wrap = lambda args: self.wrap_episode(*args)
objects = podcast.get_all_episodes_with_podcast()
self.episode_model.set_is_subset_view(True)
self.episode_model.set_objects(map(wrap, objects))
self.main.state = 'episodes'
def save_pending_data(self):
current_ep = self.main.currentEpisode
if isinstance(current_ep, model.QEpisode):
current_ep.save()
def podcast_to_qpodcast(self, podcast):
podcasts = filter(lambda p: p._podcast == podcast,
self.podcast_model.get_podcasts())
assert len(podcasts) <= 1
if podcasts:
return podcasts[0]
return None
def extensions_podcast_update_cb(self, podcast):
logger.debug('extensions_podcast_update_cb(%s)', podcast)
try:
qpodcast = self.podcast_to_qpodcast(podcast)
if qpodcast is not None and not qpodcast.pause_subscription:
qpodcast.qupdate(
finished_callback=self.controller.update_subset_stats)
except Exception, e:
logger.exception('extensions_podcast_update_cb(%s): %s', podcast, e)
class qtPodder(QObject):
def __init__(self, args, gpodder_core, dbus_bus_name):
QObject.__init__(self)
self.dbus_bus_name = dbus_bus_name
# TODO: Expose the same D-Bus API as the Gtk UI D-Bus object (/gui)
# TODO: Create a gpodder.dbusproxy.DBusPodcastsProxy object (/podcasts)
self.app = QApplication(args)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.quit.connect(self.on_quit)
self.episodeUpdated.connect(self.on_episode_updated)
self.setEpisodeListModel.connect(self.on_set_episode_list_model)
self.core = gpodder_core
self.config = self.core.config
self.db = self.core.db
self.model = self.core.model
self.config_proxy = ConfigProxy(self.config)
# Initialize the gpodder.net client
self.mygpo_client = my.MygPoClient(self.config)
gpodder.user_extensions.on_ui_initialized(
self.model, self.extensions_podcast_update_cb,
self.extensions_episode_download_cb)
self.view = DeclarativeView()
self.view.closing.connect(self.on_quit)
self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
self.controller = Controller(self)
self.media_buttons_handler = helper.MediaButtonsHandler()
self.tracker_miner_config = helper.TrackerMinerConfig()
self.podcast_model = gPodderPodcastListModel()
self.episode_model = gPodderEpisodeListModel(self.config, self)
self.last_episode = None
# A dictionary of episodes that are currently active
# in some way (i.e. playing back or downloading)
self.active_episode_wrappers = {}
engine = self.view.engine()
# Add the cover art image provider
self.cover_provider = images.LocalCachedImageProvider()
engine.addImageProvider('cover', self.cover_provider)
root_context = self.view.rootContext()
root_context.setContextProperty('controller', self.controller)
root_context.setContextProperty('configProxy', self.config_proxy)
root_context.setContextProperty('mediaButtonsHandler',
self.media_buttons_handler)
root_context.setContextProperty('trackerMinerConfig',
self.tracker_miner_config)
# Load the QML UI (this could take a while...)
self.view.setSource(QUrl.fromLocalFile(QML('main_default.qml')))
# Proxy to the "main" QML object for direct access to Qt Properties
self.main = helper.QObjectProxy(
self.view.rootObject().property('main'))
self.main.podcastModel = self.podcast_model
self.main.episodeModel = self.episode_model
self.view.setWindowTitle('gPodder')
if gpodder.ui.harmattan:
self.view.showFullScreen()
else:
# On the Desktop, scale to fit my small laptop screen..
desktop = self.app.desktop()
if desktop.height() < 1000:
FACTOR = .8
self.view.scale(FACTOR, FACTOR)
size = self.view.size()
size *= FACTOR
self.view.resize(size)
self.view.show()
self.do_start_progress.connect(self.on_start_progress)
self.do_end_progress.connect(self.on_end_progress)
self.do_show_message.connect(self.on_show_message)
podcasts = self.load_podcasts()
self.resumable_episodes = None
self.do_offer_download_resume.connect(self.on_offer_download_resume)
util.run_in_background(self.find_partial_downloads(podcasts))
def find_partial_downloads(self, podcasts):
def start_progress_callback(count):
self.start_progress(_('Loading incomplete downloads'))
def progress_callback(title, progress):
self.start_progress(
'%s (%d%%)' %
(_('Loading incomplete downloads'), progress * 100))
def finish_progress_callback(resumable_episodes):
self.end_progress()
self.resumable_episodes = resumable_episodes
self.do_offer_download_resume.emit()
common.find_partial_downloads(podcasts, start_progress_callback,
progress_callback,
finish_progress_callback)
do_offer_download_resume = Signal()
def on_offer_download_resume(self):
if self.resumable_episodes:
def download_episodes():
for episode in self.resumable_episodes:
qepisode = self.wrap_simple_episode(episode)
self.controller.downloadEpisode(qepisode)
def delete_episodes():
logger.debug('Deleting incomplete downloads.')
common.clean_up_downloads(delete_partial=True)
message = _(
'Incomplete downloads from a previous session were found.')
title = _('Resume')
self.controller.confirm_action(message, title, download_episodes,
delete_episodes)
def add_active_episode(self, episode):
self.active_episode_wrappers[episode.id] = episode
episode.episode_wrapper_refcount += 1
def remove_active_episode(self, episode):
episode.episode_wrapper_refcount -= 1
if episode.episode_wrapper_refcount == 0:
del self.active_episode_wrappers[episode.id]
def load_last_episode(self):
last_episode = None
last_podcast = None
for podcast in self.podcast_model.get_podcasts():
for episode in podcast.get_all_episodes():
if not episode.last_playback:
continue
if last_episode is None or \
episode.last_playback > last_episode.last_playback:
last_episode = episode
last_podcast = podcast
if last_episode is not None:
self.last_episode = self.wrap_episode(last_podcast, last_episode)
# FIXME: Send last episode to player
#self.select_episode(self.last_episode)
def on_episode_deleted(self, episode):
# Remove episode from play queue (if it's in there)
self.main.removeQueuedEpisode(episode)
# If the episode that has been deleted is currently
# being played back (or paused), stop playback now.
if self.main.currentEpisode == episode:
self.main.togglePlayback(None)
def enqueue_episode(self, episode):
self.main.enqueueEpisode(episode)
def run(self):
return self.app.exec_()
quit = Signal()
def on_quit(self):
# Make sure the audio playback is stopped immediately
self.main.togglePlayback(None)
self.save_pending_data()
self.view.hide()
self.core.shutdown()
self.app.quit()
episodeUpdated = Signal(int)
def on_episode_updated(self, episode_id):
self.main.episodeUpdated(episode_id)
setEpisodeListModel = Signal(object)
def on_set_episode_list_model(self, prepared):
self.main.setEpisodeListModel(prepared)
do_show_message = Signal(unicode)
@Slot(unicode)
def on_show_message(self, message):
self.main.showMessage(message)
def show_message(self, message):
self.do_show_message.emit(message)
def show_input_dialog(self,
message,
value='',
accept=_('OK'),
reject=_('Cancel'),
is_text=True):
self.main.showInputDialog(message, value, accept, reject, is_text)
def open_context_menu(self, items):
self.main.openContextMenu(items)
do_start_progress = Signal(str)
@Slot(str)
def on_start_progress(self, text):
self.main.startProgress(text)
def start_progress(self, text=_('Please wait...')):
self.do_start_progress.emit(text)
do_end_progress = Signal()
@Slot()
def on_end_progress(self):
self.main.endProgress()
def end_progress(self):
self.do_end_progress.emit()
def resort_podcast_list(self):
self.podcast_model.sort()
def insert_podcast(self, podcast):
self.podcast_model.insert_object(podcast)
self.mygpo_client.on_subscribe([podcast.url])
self.mygpo_client.flush()
def remove_podcast(self, podcast):
# Remove queued episodes for this specific podcast
self.main.removeQueuedEpisodesForPodcast(podcast)
if self.main.currentEpisode is not None:
# If the currently-playing episode is in the podcast
# that is to be deleted, stop playback immediately.
if self.main.currentEpisode.qpodcast == podcast:
self.main.togglePlayback(None)
self.podcast_model.remove_object(podcast)
self.mygpo_client.on_unsubscribe([podcast.url])
self.mygpo_client.flush()
def load_podcasts(self):
podcasts = map(model.QPodcast, self.model.get_podcasts())
self.podcast_model.set_podcasts(self.db, podcasts)
return podcasts
def wrap_episode(self, podcast, episode):
try:
return self.active_episode_wrappers[episode.id]
except KeyError:
return model.QEpisode(self, podcast, episode)
def wrap_simple_episode(self, episode):
for podcast in self.podcast_model.get_podcasts():
if podcast.id == episode.podcast_id:
return self.wrap_episode(podcast, episode)
return None
def select_podcast(self, podcast):
if isinstance(podcast, model.QPodcast):
# Normal QPodcast instance
wrap = functools.partial(self.wrap_episode, podcast)
objects = podcast.get_all_episodes()
self.episode_model.set_is_subset_view(False)
else:
# EpisodeSubsetView
wrap = lambda args: self.wrap_episode(*args)
objects = podcast.get_all_episodes_with_podcast()
self.episode_model.set_is_subset_view(True)
self.episode_model.set_objects(map(wrap, objects))
self.main.state = 'episodes'
def save_pending_data(self):
current_ep = self.main.currentEpisode
if isinstance(current_ep, model.QEpisode):
current_ep.save()
def podcast_to_qpodcast(self, podcast):
podcasts = filter(lambda p: p._podcast == podcast,
self.podcast_model.get_podcasts())
assert len(podcasts) <= 1
if podcasts:
return podcasts[0]
return None
def extensions_podcast_update_cb(self, podcast):
logger.debug('extensions_podcast_update_cb(%s)', podcast)
try:
qpodcast = self.podcast_to_qpodcast(podcast)
if qpodcast is not None and not qpodcast.pause_subscription:
qpodcast.qupdate(
finished_callback=self.controller.update_subset_stats)
except Exception, e:
logger.exception('extensions_podcast_update_cb(%s): %s', podcast,
e)
class qtPodder(QObject):
def __init__(self, args, gpodder_core, dbus_bus_name):
QObject.__init__(self)
self.dbus_bus_name = dbus_bus_name
# TODO: Expose the same D-Bus API as the Gtk UI D-Bus object (/gui)
# TODO: Create a gpodder.dbusproxy.DBusPodcastsProxy object (/podcasts)
self.app = QApplication(args)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.quit.connect(self.on_quit)
self.core = gpodder_core
self.config = self.core.config
self.db = self.core.db
self.model = self.core.model
self.config_proxy = ConfigProxy(self.config)
# Initialize the gpodder.net client
self.mygpo_client = my.MygPoClient(self.config)
gpodder.user_extensions.on_ui_initialized(self.model,
self.extensions_podcast_update_cb,
self.extensions_episode_download_cb)
self.view = DeclarativeView()
self.view.closing.connect(self.on_quit)
self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
self.controller = Controller(self)
self.media_buttons_handler = helper.MediaButtonsHandler()
self.tracker_miner_config = helper.TrackerMinerConfig()
self.podcast_model = gPodderPodcastListModel()
self.episode_model = gPodderEpisodeListModel(self.config, self)
self.last_episode = None
# A dictionary of episodes that are currently active
# in some way (i.e. playing back or downloading)
self.active_episode_wrappers = {}
engine = self.view.engine()
# Add the cover art image provider
self.cover_provider = images.LocalCachedImageProvider()
engine.addImageProvider('cover', self.cover_provider)
root_context = self.view.rootContext()
root_context.setContextProperty('controller', self.controller)
root_context.setContextProperty('configProxy', self.config_proxy)
root_context.setContextProperty('mediaButtonsHandler',
self.media_buttons_handler)
root_context.setContextProperty('trackerMinerConfig',
self.tracker_miner_config)
root_context.setContextProperty('podcastModel', self.podcast_model)
root_context.setContextProperty('episodeModel', self.episode_model)
for folder in gpodder.ui_folders:
path = os.path.join(folder, 'harmattan')
if os.path.exists(path):
logger.info('Adding QML Import Path: %s', path)
engine.addImportPath(path)
# Load the QML UI (this could take a while...)
self.view.setSource(QUrl.fromLocalFile(QML('main_default.qml')))
self.view.setWindowTitle('gPodder')
if gpodder.ui.harmattan:
self.view.showFullScreen()
else:
# On the Desktop, scale to fit my small laptop screen..
desktop = self.app.desktop()
if desktop.height() < 1000:
FACTOR = .8
self.view.scale(FACTOR, FACTOR)
size = self.view.size()
size *= FACTOR
self.view.resize(size)
self.view.show()
podcasts = self.load_podcasts()
self.resumable_episodes = None
self.do_offer_download_resume.connect(self.on_offer_download_resume)
util.run_in_background(self.find_partial_downloads(podcasts))
def find_partial_downloads(self, podcasts):
def start_progress_callback(count):
self.controller.startProgress.emit(_('Loading incomplete downloads'))
def progress_callback(title, progress):
self.controller.startProgress.emit('%s (%d%%)' % (
_('Loading incomplete downloads'),
progress*100))
def finish_progress_callback(resumable_episodes):
self.controller.endProgress.emit()
self.resumable_episodes = resumable_episodes
self.do_offer_download_resume.emit()
common.find_partial_downloads(podcasts,
start_progress_callback,
progress_callback,
finish_progress_callback)
do_offer_download_resume = Signal()
def on_offer_download_resume(self):
if self.resumable_episodes:
def download_episodes():
for episode in self.resumable_episodes:
qepisode = self.wrap_simple_episode(episode)
self.controller.downloadEpisode(qepisode)
def delete_episodes():
logger.debug('Deleting incomplete downloads.')
common.clean_up_downloads(delete_partial=True)
message = _('Incomplete downloads from a previous session were found.')
title = _('Resume')
self.controller.confirm_action(message, title, download_episodes, delete_episodes)
def add_active_episode(self, episode):
self.active_episode_wrappers[episode.id] = episode
episode.episode_wrapper_refcount += 1
def remove_active_episode(self, episode):
episode.episode_wrapper_refcount -= 1
if episode.episode_wrapper_refcount == 0:
del self.active_episode_wrappers[episode.id]
def load_last_episode(self):
last_episode = None
last_podcast = None
for podcast in self.podcast_model.get_podcasts():
for episode in podcast.get_all_episodes():
if not episode.last_playback:
continue
if last_episode is None or \
episode.last_playback > last_episode.last_playback:
last_episode = episode
last_podcast = podcast
if last_episode is not None:
self.last_episode = self.wrap_episode(last_podcast, last_episode)
# FIXME: Send last episode to player
#self.select_episode(self.last_episode)
def run(self):
return self.app.exec_()
quit = Signal()
def on_quit(self):
self.controller.on_quit()
self.view.hide()
self.core.shutdown()
self.app.quit()
def resort_podcast_list(self):
self.podcast_model.sort()
def insert_podcast(self, podcast):
self.podcast_model.insert_object(podcast)
self.mygpo_client.on_subscribe([podcast.url])
self.mygpo_client.flush()
def load_podcasts(self):
podcasts = map(model.QPodcast, self.model.get_podcasts())
self.podcast_model.set_podcasts(self.db, podcasts)
return podcasts
def wrap_episode(self, podcast, episode):
try:
return self.active_episode_wrappers[episode.id]
except KeyError:
return model.QEpisode(self, podcast, episode)
def wrap_simple_episode(self, episode):
for podcast in self.podcast_model.get_podcasts():
if podcast.id == episode.podcast_id:
return self.wrap_episode(podcast, episode)
return None
def select_podcast(self, podcast):
if isinstance(podcast, model.QPodcast):
# Normal QPodcast instance
wrap = functools.partial(self.wrap_episode, podcast)
objects = podcast.get_all_episodes()
self.episode_model.set_is_subset_view(False)
else:
# EpisodeSubsetView
wrap = lambda args: self.wrap_episode(*args)
objects = podcast.get_all_episodes_with_podcast()
self.episode_model.set_is_subset_view(True)
self.episode_model.set_objects(map(wrap, objects))
def podcast_to_qpodcast(self, podcast):
podcasts = filter(lambda p: p._podcast == podcast,
self.podcast_model.get_podcasts())
assert len(podcasts) <= 1
if podcasts:
return podcasts[0]
return None
def extensions_podcast_update_cb(self, podcast):
logger.debug('extensions_podcast_update_cb(%s)', podcast)
try:
qpodcast = self.podcast_to_qpodcast(podcast)
if qpodcast is not None and not qpodcast.pause_subscription:
qpodcast.qupdate(
finished_callback=self.controller.update_subset_stats)
except Exception, e:
logger.exception('extensions_podcast_update_cb(%s): %s', podcast, e)
config_file = 'config.json'
parser = argparse.ArgumentParser(
description = ""
)
parser.add_argument(
'-c',
'--config',
default = config_file,
help = 'Configuration file, default is %s' % config_file
)
arg = parser.parse_args()
app = QApplication(sys.argv)
win = app.desktop().screenGeometry()
cfg = config.XiboConfig(arg.config)
signal.signal(signal.SIGINT, lambda s, f: app.quit())
if not os.path.isfile(arg.config):
print
print 'The configuration file %s is not exists.' % arg.config
print 'Creating default configuration ...'
cfg.save()
print "Please edit the '%s' file and then rerun xibopy again." % arg.config
print
sys.exit(0)
r = -1
with ui.XiboWindow(cfg) as w:
t = QTimer()
t.setSingleShot(True)
t.timeout.connect(w.showFullScreen)
class qtPodder(QObject):
def __init__(self, args, gpodder_core):
QObject.__init__(self)
# Enable OpenGL rendering without requiring QtOpenGL
# On Harmattan we let the system choose the best graphicssystem
if '-graphicssystem' not in args and not gpodder.ui.harmattan and not gpodder.win32:
args += ['-graphicssystem', 'opengl']
self.app = QApplication(args)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.quit.connect(self.on_quit)
self.core = gpodder_core
self.config = self.core.config
self.db = self.core.db
self.model = self.core.model
# Initialize the gpodder.net client
self.mygpo_client = my.MygPoClient(self.config)
gpodder.user_hooks.on_ui_initialized(self.model,
self.hooks_podcast_update_cb,
self.hooks_episode_download_cb)
self.view = DeclarativeView()
self.view.closing.connect(self.on_quit)
self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
self.controller = Controller(self)
self.media_buttons_handler = helper.MediaButtonsHandler()
self.podcast_model = gPodderPodcastListModel()
self.episode_model = gPodderListModel()
self.last_episode = None
# A dictionary of episodes that are currently active
# in some way (i.e. playing back or downloading)
self.active_episode_wrappers = {}
engine = self.view.engine()
# Maemo 5: Experimental Qt Mobility packages are installed in /opt
if gpodder.ui.fremantle:
for path in ('/opt/qtm11/imports', '/opt/qtm12/imports'):
engine.addImportPath(path)
elif gpodder.win32:
for path in (r'C:\QtSDK\Desktop\Qt\4.7.4\msvc2008\imports',):
engine.addImportPath(path)
# Add the cover art image provider
self.cover_provider = images.LocalCachedImageProvider()
engine.addImageProvider('cover', self.cover_provider)
root_context = self.view.rootContext()
root_context.setContextProperty('controller', self.controller)
root_context.setContextProperty('mediaButtonsHandler',
self.media_buttons_handler)
# Load the QML UI (this could take a while...)
if gpodder.ui.harmattan:
self.view.setSource(QUrl.fromLocalFile(QML('main_harmattan.qml')))
else:
self.view.setSource(QUrl.fromLocalFile(QML('main_default.qml')))
# Proxy to the "main" QML object for direct access to Qt Properties
self.main = helper.QObjectProxy(self.view.rootObject().property('main'))
self.main.podcastModel = self.podcast_model
self.main.episodeModel = self.episode_model
self.view.setWindowTitle('gPodder')
if gpodder.ui.harmattan:
self.view.showFullScreen()
elif gpodder.ui.fremantle:
self.view.setAttribute(Qt.WA_Maemo5AutoOrientation, True)
self.view.showFullScreen()
else:
self.view.show()
self.do_start_progress.connect(self.on_start_progress)
self.do_end_progress.connect(self.on_end_progress)
self.load_podcasts()
def add_active_episode(self, episode):
self.active_episode_wrappers[episode.id] = episode
episode.episode_wrapper_refcount += 1
def remove_active_episode(self, episode):
episode.episode_wrapper_refcount -= 1
if episode.episode_wrapper_refcount == 0:
del self.active_episode_wrappers[episode.id]
def load_last_episode(self):
last_episode = None
last_podcast = None
for podcast in self.podcast_model.get_podcasts():
for episode in podcast.get_all_episodes():
if not episode.last_playback:
continue
if last_episode is None or \
episode.last_playback > last_episode.last_playback:
last_episode = episode
last_podcast = podcast
if last_episode is not None:
self.last_episode = self.wrap_episode(last_podcast, last_episode)
# FIXME: Send last episode to player
#self.select_episode(self.last_episode)
def run(self):
return self.app.exec_()
quit = Signal()
def on_quit(self):
self.save_pending_data()
self.view.hide()
self.core.shutdown()
self.app.quit()
def show_message(self, message):
self.main.showMessage(message)
def show_input_dialog(self, message, value='', accept=_('OK'),
reject=_('Cancel'), is_text=True):
self.main.showInputDialog(message, value, accept, reject, is_text)
def open_context_menu(self, items):
self.main.openContextMenu(items)
do_start_progress = Signal(str)
@Slot(str)
def on_start_progress(self, text):
self.main.startProgress(text)
def start_progress(self, text=_('Please wait...')):
self.do_start_progress.emit(text)
do_end_progress = Signal()
@Slot()
def on_end_progress(self):
self.main.endProgress()
def end_progress(self):
self.do_end_progress.emit()
def resort_podcast_list(self):
self.podcast_model.sort()
def insert_podcast(self, podcast):
self.podcast_model.insert_object(podcast)
self.mygpo_client.on_subscribe([podcast.url])
self.mygpo_client.flush()
def remove_podcast(self, podcast):
self.podcast_model.remove_object(podcast)
self.mygpo_client.on_unsubscribe([podcast.url])
self.mygpo_client.flush()
def load_podcasts(self):
podcasts = map(model.QPodcast, self.model.get_podcasts())
self.podcast_model.set_podcasts(self.db, podcasts)
def wrap_episode(self, podcast, episode):
try:
return self.active_episode_wrappers[episode.id]
except KeyError:
return model.QEpisode(self, podcast, episode)
def select_podcast(self, podcast):
if isinstance(podcast, model.QPodcast):
# Normal QPodcast instance
wrap = functools.partial(self.wrap_episode, podcast)
objects = podcast.get_all_episodes()
else:
# EpisodeSubsetView
wrap = lambda args: self.wrap_episode(*args)
objects = podcast.get_all_episodes_with_podcast()
self.episode_model.set_objects(map(wrap, objects))
self.main.state = 'episodes'
def save_pending_data(self):
current_ep = self.main.currentEpisode
if isinstance(current_ep, model.QEpisode):
current_ep.save()
def podcast_to_qpodcast(self, podcast):
podcasts = filter(lambda p: p._podcast == podcast,
self.podcast_model.get_podcasts())
assert len(podcasts) <= 1
if podcasts:
return podcasts[0]
return None
def hooks_podcast_update_cb(self, podcast):
logger.debug('hooks_podcast_update_cb(%s)', podcast)
try:
qpodcast = self.podcast_to_qpodcast(podcast)
if qpodcast is not None:
qpodcast.qupdate(
finished_callback=self.controller.update_subset_stats)
except Exception, e:
logger.exception('hooks_podcast_update_cb(%s): %s', podcast, e)
else:
athlete = False
print "No athlete created. Pushup-app quitting"
elif len(athletes) == 1:
athlete = athletes[0]
elif len(athletes) > 1:
profileSelection = ProfileSelector(athletes)
profileSelection.runSelectionDialog()
athlete = profileSelection.getSelectedAthlete()
return athlete
#
# Application starts here !
#
qtApplication = QApplication(sys.argv)
athlete = getAthleteProfile()
if athlete is not False:
mainController = MainWindow(athlete)
mainController.showMainWindow()
sys.exit(qtApplication.exec_())
else:
sys.exit(qtApplication.quit())
def sigint_handler(*args):
#sys.exit()
QApplication.quit()
import sys
from PySide.QtCore import Qt
from PySide.QtGui import QApplication, QPixmap, QSplashScreen
from dialog.directory_dialog import DirectoryDialog
from indexer.indexer import Indexer
from gui.mainwindow import MainWindow
if __name__ == "__main__":
app = QApplication(sys.argv)
dir = DirectoryDialog()
if dir.exec_() and dir.result() != "" and dir.result() != None:
app.indexer = Indexer(dir.result())
splash_pix = QPixmap('res/SplashScreen.png')
splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
splash.setMask(splash_pix.mask())
splash.show()
app.processEvents()
app.indexer.load_data()
app.doclist = None
app.webview = None
app.currentWord = None
app.mainWindow = MainWindow()
splash.finish(app.mainWindow)
app.mainWindow.show()
sys.exit(app.exec_())
else:
app.quit()
database.store(athlete)
else :
athlete = False
print "No athlete created. Pushup-app quitting"
elif len(athletes) == 1:
athlete = athletes[0]
elif len(athletes) > 1:
profileSelection = ProfileSelector(athletes)
profileSelection.runSelectionDialog()
athlete = profileSelection.getSelectedAthlete()
return athlete
#
# Application starts here !
#
qtApplication = QApplication(sys.argv)
athlete = getAthleteProfile()
if athlete is not False:
mainController = MainWindow(athlete)
mainController.showMainWindow()
sys.exit(qtApplication.exec_())
else:
sys.exit(qtApplication.quit())
class PodpyQt(object):
"""graphical interface for Podpy"""
def __init__(self):
super(PodpyQt, self).__init__()
def __enter__(self):
prefs = settings.Settings()
self.playing_entry = None
self.app = QApplication(prefs.qtOptions)
self.player = player.Player()
self.torrent = torrent.TorrentDownloader()
self.main_window = qtmainwindow.ControlMainWindow()
self.main_window.show()
self.update_feeds()
self.main_window.ui.feed_view.activated.connect(self.update_entries)
self.main_window.ui.entry_view.activated.connect(self.select_entry)
self.main_window.ui.feed_edit.returnPressed.connect(self.add_feed)
self.main_window.ui.play_pause_button.clicked.connect(self.toggle_play_pause)
self.main_window.ui.actionAbout_Qt.triggered.connect(self.app.aboutQt)
self.about_podpy = about_podpy.ControlMainWindow()
self.preferences_dialog = preferences_dialog.ControlMainWindow()
self.main_window.ui.action_About_Podpy.triggered.connect(self.about_podpy.show)
self.main_window.ui.action_About_Podpy.triggered.connect(self.disable_main_window)
self.main_window.ui.action_Preferences.triggered.connect(self.enable_pref_window)
self.main_window.ui.action_Preferences.triggered.connect(self.disable_main_window)
self.preferences_dialog.finished.connect(self.prefs_finished)
self.about_podpy.finished.connect(self.enable_main_window)
def __exit__(self, exc_type, exc_value, traceback):
self.app.quit()
return True
def start(self):
exit_code = self.app.exec_()
self.terminate()
return exit_code
def terminate(self):
if not self.playing_entry is None:
self.playing_entry.timer.stop()
del self.playing_entry.timer
prefs = settings.Settings()
self.player.terminate()
self.torrent.stop()
prefs.write_prefs()
def select_entry(self, index):
prefs = settings.Settings()
feed_number = self.main_window.ui.feed_view.currentIndex().row()
entry = prefs.feeds[feed_number].sorted_encs()[index.row()]
dir_name = os.path.abspath(
os.path.join(prefs.savePath,
prefs.feeds[feed_number].title.lower().replace(' ', '_')
)
)
if not os.path.isdir(dir_name):
os.mkdir(dir_name)
if entry.done:
self.play_sound(entry)
else:
entry.dir = dir_name
if entry.href.endswith(".torrent"):
self.torrent_downloader.addTorrent(dir_name, entry.href, entry)
else:
entry_name = entry.href.split("/")[-1]
entry.file_name = entry_name
if os.path.exists(entry.path()):
entry.done = True
entry.downloaded = entry.size = os.path.getsize(entry.path())
return
httpdownloader.download(entry,
entry.path(),
self.main_window.ui.entry_view.model().hook_for_urlretrieve)
def add_feed(self):
prefs = settings.Settings()
prefs.feeds.append(feed.Feed(self.main_window.ui.feed_edit.text()))
self.update_feeds()
def update_feeds(self):
prefs = settings.Settings()
for feed in prefs.feeds:
feed.update_encs()
self.main_window.ui.feed_view.setModel(QStringListModel([x.title for x in prefs.feeds]))
def update_entries(self, index):
prefs = settings.Settings()
feed = prefs.feeds[index.row()]
model = entrymodel.EntryModel(feed.sorted_encs())
self.main_window.ui.entry_view.setModel(model)
def play_sound(self, entry):
if not self.playing_entry is None:
self.playing_entry.timer.stop()
del self.playing_entry.timer
self.playing_entry = entry
self.main_window.ui.now_playing_display.setText(entry.title)
self.player.play(entry)
time.sleep(0.001)
self.player.seek(entry.seek)
self.main_window.ui.seek_slider.setRange(0, int(entry.duration/(10**9)))
self.main_window.ui.seek_slider.setSingleStep(int(int(entry.duration/(10**9))/1000))
self.main_window.ui.seek_slider.setPageStep(int(int(entry.duration/(10**9))/100))
self.playing_entry.timer = QTimer()
self.playing_entry.timer.timeout.connect(self.update_time_display)
self.playing_entry.timer.start()
self.update_play_pause_icon()
def update_time_display(self):
self.player.update()
seek = timedelta(microseconds=(self.playing_entry.seek/1000))
duration = timedelta(microseconds=(self.playing_entry.duration/1000))
self.main_window.ui.time_display.setText(str(seek)[0:-5] + " / " + str(duration)[0:-5])
self.main_window.ui.seek_slider.setValue(seek.total_seconds())
def toggle_play_pause(self):
self.player.toggle_play_pause()
self.update_play_pause_icon()
def update_play_pause_icon(self):
if self.player.state is player.Player.PLAYING:
self.main_window.ui.play_pause_button.setIcon(QIcon("podpyclient/icons/pause.svg"))
elif self.player.state is player.Player.PAUSED:
self.main_window.ui.play_pause_button.setIcon(QIcon("podpyclient/icons/play.svg"))
def disable_main_window(self):
self.main_window.setDisabled(True)
def enable_main_window(self):
self.main_window.setEnabled(True)
def enable_pref_window(self):
prefs = settings.Settings()
ui = self.preferences_dialog.ui
ui.port_start_spin_box.setValue(prefs.torrent_port_start)
ui.port_range_spin_box.setValue(prefs.torrent_port_range)
ui.download_rate_spin_box.setValue(prefs.torrent_download_rate)
ui.upload_rate_spin_box.setValue(prefs.torrent_upload_rate)
ui.save_path_line_edit.setText(prefs.savePath)
self.preferences_dialog.show()
def prefs_finished(self, result):
if result is 1:
prefs = settings.Settings()
ui = self.preferences_dialog.ui
prefs.torrent_port_start = ui.port_start_spin_box.value()
prefs.torrent_port_range = ui.port_range_spin_box.value()
prefs.torrent_download_rate = ui.download_rate_spin_box.value()
prefs.torrent_upload_rate = ui.upload_rate_spin_box.value()
prefs.savePath = ui.save_path_line_edit.text()
self.enable_main_window()
