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()