def file_import(self):
(fileNames, _) = QFileDialog.getOpenFileNames(self,
"Open Activity File",
"",
"Activity Files (*.tcx *.fit *.csv)")
if fileNames:
QCoreApplication.instance().import_files(*fileNames)
def move(self, i, j):
tiles = self.tile.map.tiles
self.tile.removeUnit(self)
tiles[i][j].addUnit(self)
self.tile.setChosenByDist(-1)
self.tile.ensureVisible()
QCoreApplication.instance().processEvents()
def __init__(self):
super(STMainWindow, self).__init__()
self.createActions()
self.createMenus()
layout = QVBoxLayout()
self.tabs = QTabWidget()
self.tabs.setTabPosition(QTabWidget.West)
self.tabs.currentChanged[int].connect(self.tabChanged)
self.sessiontab = sweattrails.qt.sessiontab.SessionTab(self)
self.tabs.addTab(self.sessiontab, "Sessions")
self.tabs.addTab(sweattrails.qt.fitnesstab.FitnessTab(self),
"Fitness")
self.tabs.addTab(sweattrails.qt.profiletab.ProfileTab(self),
"Profile")
self.usertab = sweattrails.qt.usertab.UserTab(self)
self.tabs.addTab(self.usertab, "Users")
self.usertab.hide()
layout.addWidget(self.tabs)
w = QWidget(self)
w.setLayout(layout)
self.setCentralWidget(w)
self.statusmessage = QLabel()
self.statusmessage.setMinimumWidth(200)
self.statusBar().addPermanentWidget(self.statusmessage)
self.progressbar = QProgressBar()
self.progressbar.setMinimumWidth(100)
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
self.statusBar().addPermanentWidget(self.progressbar)
self.setWindowTitle("SweatTrails")
self.setWindowIconText("SweatTrails")
icon = QPixmap("image/sweatdrops.png")
self.setWindowIcon(QIcon(icon))
QCoreApplication.instance().refresh.connect(self.userSet)
class SkDesktopProxy(QObject):
def __init__(self, parent=None):
super(SkDesktopProxy, self).__init__(parent)
d = QCoreApplication.instance().desktop()
d.resized.connect(self.refresh)
def refresh(self):
self.xChanged.emit(self.x)
self.yChanged.emit(self.y)
self.widthChanged.emit(self.width)
self.heightChanged.emit(self.height)
dprint("pass")
def __property(type, method):
"""
@param type type
@param method method
"""
sig = Signal(type)
prop = Property(type, method, notify=sig)
return prop, sig
x, xChanged = __property(int,
lambda _: QCoreApplication.instance().desktop().x())
y, yChanged = __property(int,
lambda _: QCoreApplication.instance().desktop().y())
width, widthChanged = __property(int,
lambda _: QCoreApplication.instance().desktop().width())
height, heightChanged = __property(int,
lambda _: QCoreApplication.instance().desktop().height())
def __init__(self, parent = None):
super(UserList, self).__init__(parent = parent)
query = grizzle.User.query(keys_only = False)
query.add_sort("email")
self.setQueryAndColumns(query, "email", "display_name", "status")
#self.setMinimumSize(400, 600)
QCoreApplication.instance().refresh.connect(self.refresh)
def setUpClass(cls):
if not QCoreApplication.instance():
cls.app = QApplication(sys.argv)
else:
cls.app = QCoreApplication.instance()
cls.window = mainwidget.MainWindow()
cls.form = cls.window.ui
def __init__(self, interval, parent = None):
super(IntervalPage, self).__init__(parent,
grumble.qt.bridge.FormButtons.AllButtons
if interval.basekind() == "session"
else grumble.qt.bridge.FormButtons.EditButtons)
with gripe.db.Tx.begin():
interval = interval()
self.interval = interval
if isinstance(interval, sweattrails.session.Session):
self.addProperty(sweattrails.session.Session, "sessiontype", 0, 0,
readonly = True, has_label = False, rowspan = 3,
bridge = grumble.qt.bridge.Image, height = 64,
displayconverter = sweattrails.qt.view.SessionTypeIcon())
self.addProperty(sweattrails.session.Session, "start_time", 0, 1, readonly = True)
self.addProperty(sweattrails.session.Session, "description", 1, 1, colspan = 3)
col = 1
row = 2
else:
self.addProperty(sweattrails.session.Interval, "timestamp", 0, 0, colspan = 3,
readonly = True)
col = 0
row = 1
self.addProperty(sweattrails.session.Interval, "elapsed_time", row, col,
readonly = True)
self.addProperty(sweattrails.session.Interval, "duration", row, col + 2,
readonly = True)
row += 1
self.addProperty(sweattrails.session.Interval, "distance", row, col,
readonly = True, displayconverter = sweattrails.qt.view.Distance())
row += 1
self.addProperty(sweattrails.session.Interval, "average_speed", row, col,
readonly = True, displayconverter = sweattrails.qt.view.PaceSpeed("Average"))
self.addProperty(sweattrails.session.Interval, "max_speed", row, col + 2,
readonly = True,
displayconverter = sweattrails.qt.view.PaceSpeed({"Pace": "Best", "Speed": "Maximum"}))
row += 1
self.setInstance(interval)
intervals = sweattrails.session.Interval.query(parent = interval).fetchall()
if len(intervals) > 1:
page = IntervalListPage(self)
self.addTab(page, "Intervals")
page.list.objectSelected.connect(parent.addInterval)
self.partSpecificContent(interval)
self.addTab(GraphPage(self, interval), "Graphs")
self.addTab(MapPage(self, interval), "Map")
self.addTab(MiscDataPage(self, interval), "Other Data")
if interval.basekind() == "session":
self.addTab(RawDataPage(self), "Raw Data")
self.statusMessage.connect(QCoreApplication.instance().status_message)
self.exception.connect(QCoreApplication.instance().status_message)
self.instanceSaved.connect(QCoreApplication.instance().status_message)
self.instanceDeleted.connect(QCoreApplication.instance().status_message)
self.setInstance(interval)
def createActions(self):
self.switchUserAct = QAction("&Switch User", self, shortcut = "Ctrl+U", statusTip = "Switch User", triggered = self.switch_user)
self.importFileAct = QAction("&Import", self, shortcut = "Ctrl+I", statusTip = "Import Session", triggered = self.file_import)
self.downloadAct = QAction("&Download", self, shortcut = "Ctrl+D",
statusTip = "Download activities from device",
triggered = QCoreApplication.instance().download)
self.downloadAct = QAction("&Withings", self,
statusTip = "Download Withings data",
triggered = QCoreApplication.instance().withings)
self.exitAct = QAction("E&xit", self, shortcut = "Ctrl+Q", statusTip = "Exit SweatTrails", triggered = self.close)
self.aboutAct = QAction("&About", self, triggered = self.about)
self.aboutQtAct = QAction("About &Qt", self, triggered = QApplication.aboutQt)
def __init__(self, user = None, parent = None):
super(SessionList, self).__init__(parent = parent)
if not user:
user = QCoreApplication.instance().user
query = sweattrails.session.Session.query(keys_only = False)
query.add_filter("athlete", "=", user)
query.add_sort("start_time")
self.setQueryAndColumns(query,
grumble.qt.model.TableColumn("start_time", format = "%A %B %d", header = "Date"),
grumble.qt.model.TableColumn("start_time", format = "%H:%M", header = "Time"),
DescriptionColumn())
QCoreApplication.instance().refresh.connect(self.refresh)
def app_version():
"""
Detect and return the application version for the running application. The
following locations are searched, in this order, for a version string:
1. ``siding.plugins.version``
2. :func:`PySide.QtCore.QCoreApplication.applicationVersion`
3. ``__main__.version``
4. ``__main__.__version__``
If the version is not found in one of those locations, a
:class:`RuntimeError` will be raised.
"""
if version:
return version
ver = QCoreApplication.instance().applicationVersion()
if ver:
return ver
import __main__
if hasattr(__main__, 'version'):
return __main__.version
elif hasattr(__main__, '__version__'):
return __main__.__version__
raise RuntimeError("Application version not set.")
def app_version():
"""
Detect and return the application version for the running application. The
following locations are searched, in this order, for a version string:
1. ``siding.plugins.version``
2. :func:`PySide.QtCore.QCoreApplication.applicationVersion`
3. ``__main__.version``
4. ``__main__.__version__``
If the version is not found in one of those locations, a
:class:`RuntimeError` will be raised.
"""
if version:
return version
ver = QCoreApplication.instance().applicationVersion()
if ver:
return ver
import __main__
if hasattr(__main__, 'version'):
return __main__.version
elif hasattr(__main__, '__version__'):
return __main__.__version__
raise RuntimeError("Application version not set.")
def install(app=None, timeout=0.02, engine=None):
"""
Creates a :class:`~PySide.QtCore.QTimer` instance that will be triggered
continuously to call :func:`Engine.poll() <pants.engine.Engine.poll>`,
ensuring that Pants remains responsive.
========= ======== ============
Argument Default Description
========= ======== ============
app None *Optional.* The :class:`~PySide.QtCore.QCoreApplication` to attach to. If no application is provided, it will attempt to find an existing application in memory, or, failing that, create a new application instance.
timeout ``0.02`` *Optional.* The maximum time to wait, in seconds, before running :func:`Engine.poll() <pants.engine.Engine.poll>`.
engine *Optional.* The :class:`pants.engine.Engine` instance to use.
========= ======== ============
"""
global timer
global _timeout
global _engine
_engine = engine or Engine.instance()
_engine._install_poller(_Qt())
if app is None:
app = QCoreApplication.instance()
if app is None:
app = QCoreApplication([])
_timeout = timeout * 1000
timer = QTimer(app)
timer.timeout.connect(do_poll)
timer.start(_timeout)
def quit(self):
if self.hasQuit:
return
self.hasQuit = True
dprint("schedule to kill all python instances in a few seconds")
skevents.runlater(lambda:
os.system("tskill pythonw & tskill python"),
config.QT_QUIT_TIMEOUT + config.QT_THREAD_TIMEOUT)
# wait for for done or kill all threads
from PySide.QtCore import QThreadPool
if QThreadPool.globalInstance().activeThreadCount():
dwarn("warning: wait for active threads")
QThreadPool.globalInstance().waitForDone(config.QT_THREAD_TIMEOUT)
dprint("leave qthread pool")
dprint("send quit signal to qApp")
qApp = QCoreApplication.instance()
# Make sure settings.sync is the last signal conneced with aboutToQuit
#qApp.aboutToQuit.connect(self.settings.sync)
skevents.runlater(qApp.quit)
def __init__(self, user, parent = None):
super(UserDetails, self).__init__(parent)
self.addProperty(grizzle.User, "email", 0, 0, readonly = True)
self.addProperty(grizzle.User, "display_name", 1, 0)
self.addProperty(grizzle.User, "status", 2, 0)
self.addProperty(grizzle.User, "has_roles", 3 , 0)
self.statusMessage.connect(QCoreApplication.instance().status_message)
def create(self):
password = self.pwd.text()
if password != self.pwd_again.text():
QMessageBox.critical(self, "Passwords don't match",
"The passwords entered are different")
self.reject()
try:
QCoreApplication.instance().add_user(self.email.text(),
password,
self.display_name.text(),
self.savecreds.isChecked())
self.accept()
except Exception as e:
logger.exception("Exception creating user")
QMessageBox.critical(self, "Error", str(e))
self.reject()
def __init__(self, parent = None):
super(SettingsPage, self).__init__(parent)
self.setMinimumSize(800, 600)
self.addProperty(grizzle.User, "email", 0, 0)
self.addProperty(grizzle.User, "display_name", 1, 0)
self.addProperty(sweattrails.userprofile.UserProfile,
"_userprofile.dob", 2, 0)
self.addProperty(sweattrails.userprofile.UserProfile,
"_userprofile.gender", 3, 0,
style = "radio")
self.addProperty(sweattrails.userprofile.UserProfile,
"_userprofile.height", 4, 0,
min = 100, max = 240, suffix = "cm")
self.addProperty(sweattrails.userprofile.UserProfile,
"_userprofile.units", 5, 0,
style = "radio")
withingsB = QGroupBox("Withings Support", self)
withingsL = QGridLayout(withingsB)
self.enableWithings = QCheckBox("Enable Withings", withingsB)
self.enableWithings.toggled.connect(self.toggleWithings)
withingsL.addWidget(self.enableWithings, 0, 0)
withingsL.addWidget(QLabel("Withings User ID"), 1, 0)
self.withingsUserID = QLineEdit(withingsB)
withingsL.addWidget(self.withingsUserID, 1, 1)
withingsL.addWidget(QLabel("Withings Key"), 2, 0)
self.withingsKey = QLineEdit(withingsB)
withingsL.addWidget(self.withingsKey, 2, 1)
self.addWidget(withingsB, self.form.rowCount(), 0, 1, 2)
self.addStretch()
self.statusMessage.connect(QCoreApplication.instance().status_message)
def install(app=None, timeout=0.02):
"""
Creates a :class:`~PySide.QtCore.QTimer` instance that will be triggered
continuously to call :func:`Engine.poll() <pants.engine.Engine.poll>`,
ensuring that Pants remains responsive.
========= ======== ============
Argument Default Description
========= ======== ============
app None *Optional.* The :class:`~PySide.QtCore.QCoreApplication` to attach to. If no application is provided, it will attempt to find an existing application in memory, or, failing that, create a new application instance.
timeout ``0.02`` *Optional.* The maximum time to wait, in seconds, before running :func:`Engine.poll() <pants.engine.Engine.poll>`.
========= ======== ============
"""
global timer
global _timeout
Engine.instance()._install_poller(_Qt())
if app is None:
app = QCoreApplication.instance()
if app is None:
app = QCoreApplication([])
_timeout = timeout * 1000
timer = QTimer(app)
timer.timeout.connect(do_poll)
timer.start(_timeout)
def init_config(self, args):
save = False
self.user = self.user_id = None
if "qtapp" not in gripe.Config:
gripe.Config.qtapp = {}
self.config = gripe.Config.qtapp
if "settings" not in self.config:
self.config["settings"] = {}
save = True
if save:
self.config = gripe.Config.set("qtapp", self.config)
save = False
if args.user and args.password:
if QCoreApplication.instance().has_users():
self.authenticate(args.user, args.password, args.savecreds)
else:
self.add_user(args.user, args.password, args.user, args.savecreds)
else:
if "user" in self.config.settings:
user_settings = self.config.settings.user
uid = user_settings.user_id if "user_id" in user_settings else None
password = user_settings.password if "password" in user_settings else None
logger.debug("Auto-login uid %s", uid)
if not uid or not self.authenticate(uid, password, False):
del self.config.settings["user"]
save = True
if save:
self.config = gripe.Config.set("qtapp", self.config)
def quit(self):
if self.hasQuit:
return
self.hasQuit = True
import curtheme
curtheme.unload()
for w in self.widgets:
if w.isVisible():
w.hide()
# wait for for done or kill all threads
from PySide.QtCore import QThreadPool
if QThreadPool.globalInstance().activeThreadCount():
dwarn("warning: wait for active threads")
QThreadPool.globalInstance().waitForDone(config.QT_THREAD_TIMEOUT)
dprint("leave qthread pool")
dprint("send quit signal to qApp")
qApp = QCoreApplication.instance()
# Make sure settings.sync is the last signal conneced with aboutToQuit
#qApp.aboutToQuit.connect(self.settings.sync)
skevents.runlater(qApp.quit)
def doit():
try:
app = QApplication([])
except RuntimeError:
app = QCoreApplication.instance()
main_window = main_window_factory()
main_window.show()
app.exec_()
def doit():
try:
app = QApplication([])
except RuntimeError:
app = QCoreApplication.instance()
main_window = main_window_factory()
main_window.show()
app.exec_()
def select_user(self):
ret = False
if QCoreApplication.instance().user:
return True
elif QCoreApplication.instance().has_users():
dialog = SelectUser(self)
dialog.select()
ret = QCoreApplication.instance().is_authenticated()
if ret:
self.refresh()
else:
dialog = CreateUser(self)
dialog.exec_()
ret = QCoreApplication.instance().is_authenticated()
if ret:
self.refresh()
return ret
def __init__(self):
self._reads = {}
self._writes = {}
self._notifiers = {}
self._timer = QTimer()
self._timer.setSingleShot(True)
QObject.connect(self._timer, SIGNAL("timeout()"), self.iterate)
if QCoreApplication.instance() is None:
# Application Object has not been started yet
self.qApp=QCoreApplication([])
self._ownApp=True
else:
self.qApp = QCoreApplication.instance()
self._ownApp=False
self._blockApp = None
posixbase.PosixReactorBase.__init__(self)
def __init__(self, parent=None):
super(TrayIcon, self).__init__(parent)
self.setIcon(rc.icon('logo-reader'))
self.setToolTip(QCoreApplication.instance().applicationName())
self.activated.connect(self.onActivated)
self.__d = _TrayIcon(self)
TrayIcon.instance = self
def __init__(self):
self._reads = {}
self._writes = {}
self._notifiers = {}
self._timer = QTimer()
self._timer.setSingleShot(True)
QObject.connect(self._timer, SIGNAL("timeout()"), self.iterate)
if QCoreApplication.instance() is None:
# Application Object has not been started yet
self.qApp = QCoreApplication([])
self._ownApp = True
else:
self.qApp = QCoreApplication.instance()
self._ownApp = False
self._blockApp = None
posixbase.PosixReactorBase.__init__(self)
def __init__(self, parent=None, f=0):
super(_Window, self).__init__(parent, f)
self.__canClose = False
self.setWindowIcon(rc.icon('logo-reader'))
self.setWindowTitle(QCoreApplication.instance().applicationName())
self.showNothing()
self.setStyleSheet(''.join(imap(rc.qss, config.QT_STYLESHEETS)))
def downloader(self):
from dl import Downloader
ret = Downloader(self.q, self.networkAccessManager)
ret.finished.connect(self._continue, Qt.QueuedConnection)
ret.aborted.connect(self._retry)
qApp = QCoreApplication.instance()
qApp.aboutToQuit.connect(ret.abort)
return ret
def wraith():
matplotlib.rcParams['mathtext.fontset'] = 'stixsans'
app = QCoreApplication.instance()
app.form = Form()
#style choices common to both modes
QApplication.setStyle(QStyleFactory.create('Plastique'))
QApplication.setPalette(QApplication.style().standardPalette())
#do it
app.form.show()
def __init__(self, parent=None):
self.__d = _NameInputManager()
from PySide.QtCore import QCoreApplication
qApp = QCoreApplication.instance()
qApp.aboutToQuit.connect(self.hide)
import dataman
dataman.manager().loginChanged.connect(lambda name: name or self.hide())
def confirmQuit():
"""
@return bool
"""
from PySide.QtCore import QCoreApplication
appName = QCoreApplication.instance().applicationName()
return Yes == QMessageBox.question(_parent(), appName,
my.tr("Quit {0}?").format(appName),
Yes | No, No)
def __init__(self, property = "speed", **kwargs):
super(PaceSpeedColumn, self).__init__(property, **kwargs)
self.what = kwargs.get("what")
if not self.what:
interval = kwargs.get("interval")
session = interval.get_session()
self.what = session.sessiontype.speedPace
self.units = kwargs.get("units",
QCoreApplication.instance().user.get_part("userprofile").units)
def authenticate(self):
password = self.pwd.text()
uid = self.email.text()
savecreds = self.savecreds.isChecked()
if QCoreApplication.instance().authenticate(uid, password, savecreds):
self.accept()
else:
QMessageBox.critical(self, "Wrong Password",
"The user ID and password entered do not match.")
def __init__(self, parent = None):
super(MainWindow, self).__init__(parent)
self.app = app = QCoreApplication.instance()
self.setWindowTitle('Button Size Test')
self.stupidSize = 3
self.dummyWidget = QFrame()
self.dummyWidget.setFrameStyle(QFrame.Box)
self.organizeContent(self.dummyWidget)
self.setCentralWidget(self.dummyWidget)
def __init__(self):
self.__d = _SubtitleEditorManager()
from PySide.QtCore import QCoreApplication
qApp = QCoreApplication.instance()
qApp.aboutToQuit.connect(self.hide)
import dataman
dataman.manager().loginChanged.connect(lambda name: name or self.hide())
def __init__(self, path, parent=None): # unicode
super(WbNetworkCookieJar, self).__init__(parent)
self.path = path
self.load()
self._injectCookies()
# Automatically save cookies using timer
from PySide.QtCore import QCoreApplication
qApp = QCoreApplication.instance()
qApp.aboutToQuit.connect(self.save)
def __init__(self, parent = None, interval = None):
super(RawDataList, self).__init__(parent = parent)
query = sweattrails.session.Waypoint.query(parent = interval,
keys_only = False)
query.add_sort("timestamp")
self.setQueryAndColumns(query,
grumble.qt.model.TableColumn("timestamp", header = "Timestamp"),
grumble.qt.model.TableColumn("location"),
grumble.qt.model.TableColumn("elevation"),
grumble.qt.model.TableColumn("corrected_elevation", header = "Corrected"),
grumble.qt.model.TableColumn("speed"),
grumble.qt.model.TableColumn("distance"),
grumble.qt.model.TableColumn("cadence"),
grumble.qt.model.TableColumn("heartrate"),
grumble.qt.model.TableColumn("power"),
grumble.qt.model.TableColumn("torque"),
grumble.qt.model.TableColumn("temperature"))
QCoreApplication.instance().refresh.connect(self.refresh)
def keyPressed(self, key):
""" Called when the Game Engine gets a keyPressed event """
if key == Qt.Key_Left:
self.level.ship.left()
elif key == Qt.Key_Right:
self.level.ship.right()
elif key == Qt.Key_Down:
self.level.ship.down()
elif key == Qt.Key_Up:
self.level.ship.up()
elif key == Qt.Key_Space:
if len(self.level.lasers) < LevelController.MAX_LASERS and not self.level.over and not self.level.paused:
self.level.addLaser()
self.window.addLaser()
elif key == Qt.Key_Return or key == Qt.Key_Enter:
if self.level.over:
QCoreApplication.instance().quit()
else:
self.performPauseAction()
def __init__(self, parent=None):
super(TopicEditorManager, self).__init__(parent)
self.__d = _TopicEditorManager()
from PySide.QtCore import QCoreApplication
qApp = QCoreApplication.instance()
qApp.aboutToQuit.connect(self.hide)
import dataman
dataman.manager().loginChanged.connect(lambda name: name or name == 'guest' or self.hide())
def getConfiguration(self):
iniPath = self._getConfigurationFilePath()
self._parseConfigFile(iniPath)
#
# Watch out for the method self._overrideConfigWithArgs when you're adding custom multi-word command line arguments
#
if self._config['language']:
setLanguage(self._config['language'])
self._argparser = argparse.ArgumentParser(description=getMessage("argument-description"),
epilog=getMessage("argument-epilog"))
self._argparser.add_argument('--no-gui', action='store_true', help=getMessage("nogui-argument"))
self._argparser.add_argument('-a', '--host', metavar='hostname', type=str, help=getMessage("host-argument"))
self._argparser.add_argument('-n', '--name', metavar='username', type=str, help=getMessage("name-argument"))
self._argparser.add_argument('-d', '--debug', action='store_true', help=getMessage("debug-argument"))
self._argparser.add_argument('-g', '--force-gui-prompt', action='store_true', help=getMessage("force-gui-prompt-argument"))
self._argparser.add_argument('--no-store', action='store_true', help=getMessage("no-store-argument"))
self._argparser.add_argument('-r', '--room', metavar='room', type=str, nargs='?', help=getMessage("room-argument"))
self._argparser.add_argument('-p', '--password', metavar='password', type=str, nargs='?', help=getMessage("password-argument"))
self._argparser.add_argument('--player-path', metavar='path', type=str, help=getMessage("player-path-argument"))
self._argparser.add_argument('--language', metavar='language', type=str, help=getMessage("language-argument"))
self._argparser.add_argument('file', metavar='file', type=lambda s: unicode(s, 'utf8'), nargs='?', help=getMessage("file-argument"))
self._argparser.add_argument('--clear-gui-data', action='store_true', help=getMessage("clear-gui-data-argument"))
self._argparser.add_argument('-v', '--version', action='store_true', help=getMessage("version-argument"))
self._argparser.add_argument('_args', metavar='options', type=str, nargs='*', help=getMessage("args-argument"))
args = self._argparser.parse_args()
if args.version:
print getMessage("version-message").format(version, milestone)
sys.exit()
self._overrideConfigWithArgs(args)
if not self._config['noGui']:
try:
from PySide import QtGui # @UnresolvedImport
from PySide.QtCore import QCoreApplication
from syncplay.vendor import qt4reactor
if QCoreApplication.instance() is None:
self.app = QtGui.QApplication(sys.argv)
qt4reactor.install()
except ImportError:
print getMessage("unable-import-gui-error")
self._config['noGui'] = True
if self._config['file'] and self._config['file'][:2] == "--":
self._config['playerArgs'].insert(0, self._config['file'])
self._config['file'] = None
# Arguments not validated yet - booleans are still text values
if self._config['language']:
setLanguage(self._config['language'])
if (self._config['forceGuiPrompt'] == "True" or not self._config['file']) and not self._config['noGui']:
self._forceGuiPrompt()
self._checkConfig()
self._saveConfig(iniPath)
if self._config['file']:
self._config['loadedRelativePaths'] = self._loadRelativeConfiguration()
if self._config['language']:
setLanguage(self._config['language'])
return self._config
def showFrameioDialog(self):
"""Shows the dialog"""
self.frameioMainViewController.show()
if not self.frameioSession.sessionHasValidCredentials:
self.frameioMainViewController.showLoginView()
else:
self.frameioMainViewController.showUploadFilesView()
self.frameioMainViewController.move(QCoreApplication.instance().desktop().screen().rect().center() - self.frameioMainViewController.rect().center())
def testBlockingSignal(self):
app = QCoreApplication.instance() or QCoreApplication([])
eventloop = QEventLoop()
emitter = Emitter()
receiver = Receiver(eventloop)
emitter.connect(emitter, SIGNAL("signal(int)"),
receiver.receive, Qt.BlockingQueuedConnection)
emitter.start()
retval = eventloop.exec_()
emitter.wait()
self.assertEqual(retval, 0)
def __init__(self, cmd, img):
"""Initialize executor.
Args:
cmd -- command to execute (str)
img -- path to resulting image (the renderer output) (str)
"""
super().__init__(QCoreApplication.instance())
self.thread = QThread()
self.worker = Worker(cmd, img)
self.thread.setObjectName("fcd-renderexec")
def __init__(self):
super(PySideEventLoop, self).__init__()
qapp = QCoreApplication.instance()
if qapp is None:
qapp = QCoreApplication(sys.argv)
self._qapp = qapp
self._stop = False
self._timers = set()
self._readers = {}
self._writers = {}
self._processor = EventProcessor(qapp, self)
def showFrameioWidgetWithSelection(self, selection):
"""Saves the Username to the uistate.ini"""
print "showUploadViewController : %s" % str(selection)
self.frameioMainViewController.show(selection)
if not self.frameioSession.sessionAuthenticated:
self.frameioMainViewController.showLoginView()
else:
self.frameioMainViewController.showUploadView()
self.frameioMainViewController.move(QCoreApplication.instance().desktop().screen().rect().center() - self.frameioMainViewController.rect().center())
def testBlockingSignal(self):
app = QCoreApplication.instance() or QCoreApplication([])
eventloop = QEventLoop()
emitter = Emitter()
receiver = Receiver(eventloop)
emitter.connect(emitter, SIGNAL("signal(int)"), receiver.receive,
Qt.BlockingQueuedConnection)
emitter.start()
retval = eventloop.exec_()
emitter.wait()
self.assertEqual(retval, 0)
def thread(cls): # -> OnlineThread not None
if not cls._thread:
t = cls._thread = OnlineThread()
t.start()
from PySide.QtCore import QCoreApplication
qApp = QCoreApplication.instance()
qApp.aboutToQuit.connect(t.destroy)
growl.msg(my.tr("Load {0} for TTS").format("Windows Media Player"))
return cls._thread
def solver(self):
from clipconv import YouTubeSolver
ret = YouTubeSolver(self.q)
ret.setWebView(self.window.webView())
# This could crash?
#ret.setParentWidget(self.window)
ret.urlSolved.connect(self._save)
ret.aborted.connect(self._retry)
qApp = QCoreApplication.instance()
qApp.aboutToQuit.connect(ret.stop)
return ret
def process_console(self):
try:
while True:
cmd, data = self.input_queue.get_nowait()
if cmd == 'console':
for line in data:
self.status_list.addItem(line)
self.log.write(line + '\r\n')
self.status_list.scrollToBottom()
elif cmd == 'result':
self.done = True
if data:
self.close()
QCoreApplication.instance().quit()
return
QMessageBox.critical(self, 'Build failed',
'Build failed. Please check the '
'build log.')
pass
except Queue.Empty:
return
def showFrameioDialogWithSelection(self, selection):
"""Shows the dialog from the Bin View"""
# We're not using the Export dialog, so use the normal flow
self.frameioMainViewController.usingExportDialog = False
self.frameioMainViewController.show()
if not self.frameioSession.sessionAuthenticated:
self.frameioMainViewController.showLoginView()
else:
self.frameioMainViewController.showUploadView()
self.frameioMainViewController.move(QCoreApplication.instance().desktop().screen().rect().center() - self.frameioMainViewController.rect().center())
def showFrameioDialog(self):
"""Shows the dialog"""
self.frameioMainViewController.show()
if not self.frameioSession.sessionHasValidCredentials:
self.frameioMainViewController.showLoginView()
else:
self.frameioMainViewController.showUploadFilesView()
self.frameioMainViewController.move(
QCoreApplication.instance().desktop().screen().rect().center() -
self.frameioMainViewController.rect().center())
def _setuser(self):
# FIXME - gripe should read from the session, which qt.app.SweatTrails
# should manage
user = QCoreApplication.instance().user
if user != self.user:
self.user = user
userdir = gripe.user_dir(user.uid())
self.inbox = os.path.join(userdir, "inbox")
gripe.mkdir(self.inbox)
self.queue = os.path.join(userdir, "queue")
gripe.mkdir(self.queue)
done = os.path.join(userdir, "done")
gripe.mkdir(done)
def showFrameioDialogWithSelection(self, selection):
"""Shows the dialog from the Bin View"""
# We're not using the Export dialog, so use the normal flow
self.frameioMainViewController.usingExportDialog = False
self.frameioMainViewController.show()
if not self.frameioSession.sessionAuthenticated:
self.frameioMainViewController.showLoginView()
else:
self.frameioMainViewController.showUploadView()
self.frameioMainViewController.move(
QCoreApplication.instance().desktop().screen().rect().center() -
self.frameioMainViewController.rect().center())
def __init__(self):
_assert(in_main_thread())
self._reads = {}
self._writes = {}
self._notifiers = {}
self._timer = QTimer()
self._timer.setSingleShot(True)
QObject.connect(self._timer, SIGNAL("timeout()"), self.iterate)
self.qApp = QCoreApplication.instance()
self._ownApp=False
if self.qApp is None:
self.qApp=QCoreApplication([])
self._ownApp=True
self._blockApp = None
posixbase.PosixReactorBase.__init__(self)
def appdata():
"""
Return the path that application data should be stored in. This acts a bit
special on Windows machines as Qt doesn't return the right path itself.
"""
if os.name == 'nt':
path = os.getenv('APPDATA')
app = QCoreApplication.instance()
if app:
if app.organizationName():
path = os.path.join(path, app.organizationName())
if app.applicationName():
path = os.path.join(path, app.applicationName())
return path
return QDesktopServices.storageLocation(QDesktopServices.DataLocation)
def get_data_path():
"""
Returns the path that application data should be stored in. This acts a bit
special on Windows machines, using the APPDATA environment variable to
ensure things go to AppData\Roaming and not AppData\Local.
"""
if os.name == 'nt':
qapp = QCoreApplication.instance()
path = os.getenv('APPDATA')
if qapp.organizationName():
path = os.path.join(path, qapp.organizationName())
if qapp.applicationName():
path = os.path.join(path, qapp.applicationName())
return path
return QDesktopServices.storageLocation(QDesktopServices.DataLocation)
def getConfiguration(self):
iniPath = self._getConfigurationFilePath()
self._parseConfigFile(iniPath)
args = self._argparser.parse_args()
self._overrideConfigWithArgs(args)
#Arguments not validated yet - booleans are still text values
if (self._config['forceGuiPrompt'] == "True"
or not self._config['file']):
self._forceGuiPrompt()
self._checkConfig()
self._saveConfig(iniPath)
if (self._config['file']):
self._loadRelativeConfiguration()
if (not self._config['noGui']):
from syncplay.vendor import qt4reactor
if QCoreApplication.instance() is None:
self.app = QtGui.QApplication(sys.argv)
qt4reactor.install()
return self._config
def __init__(self, q):
ss = settings.global_()
self._rubyEnabled = ss.isRubyEnabled()
self._ttsEnabled = ss.isTtsEnabled() # cached
self._fullTranslationEnabled = ss.isFullTranslationEnabled() # cached
self._translationTipEnabled = ss.isTranslationTipEnabled() # cached
self.loadProgress = 100 # int [0,100]
self.visitedUrls = [] # [str url]
self.closedUrls = [] # [str url]
import jlpman, trman, ttsman
self._jlpAvailable = jlpman.manager().isAvailable() # bool
self._ttsAvailable = ttsman.manager().isAvailable() # bool
self._translatorAvailable = trman.manager().isAvailable() # bool
#layout = QtWidgets.QVBoxLayout()
#layout.addWidget(self.addressWidget)
#layout.addWidget(self.tabWidget)
#w = QtWidgets.QWidget()
#w.setLayout(layout)
#layout.setContentsMargins(0, 0, 0, 0)
#q.setCentralWidget(w)
q.setCentralWidget(self.tabWidget)
dock = SkTitlelessDockWidget(self.addressWidget)
dock.setFeatures(QtWidgets.QDockWidget.NoDockWidgetFeatures)
dock.setAllowedAreas(Qt.TopDockWidgetArea)
q.addDockWidget(Qt.TopDockWidgetArea, dock)
self._createShortcuts(q)
self._createGestures()
from PySide.QtCore import QCoreApplication
qApp = QCoreApplication.instance()
qApp.aboutToQuit.connect(self._onQuit)
#self.newTabAfterCurrentWithBlankPage()
self.loadVisitedUrls()
self.loadClosedUrls()
def capture_pixmap(x, y, width, height, hwnd=None):
"""
@param x int
@param y int
@param width int
@param height int
@param hwnd int
@return QPixmap
"""
if width < OCR_MIN_WIDTH or height < OCR_MIN_HEIGHT:
dwarn("skip image that is too small: %sx%s" % (width, height))
return
if hwnd:
from sakurakit import skwidgets
return QPixmap.grabWindow(skwidgets.to_wid(hwnd), x, y, width, height)
else:
from PySide.QtCore import QCoreApplication
qApp = QCoreApplication.instance()
wid = qApp.desktop().winId()
return QPixmap.grabWindow(wid, x, y, width, height)
def thread(self): # -> QThread
if not self._thread:
t = self._thread = SpeechRecognitionThread()
t.setOnline(self.online)
t.setLanguage(self.language)
t.setDeviceIndex(self.deviceIndex)
t.setDetectsQuiet(self.detectsQuiet)
t.setSingleShot(self.singleShot)
q = self.q
t.textRecognized.connect(q.textRecognized, Qt.QueuedConnection)
t.recognitionFinished.connect(self.onRecognitionFinished,
Qt.QueuedConnection)
from PySide.QtCore import QCoreApplication
qApp = QCoreApplication.instance()
qApp.aboutToQuit.connect(t.destroy)
t.start()
dprint("create thread")
return self._thread
