def main():
window = MainWindow()
window.setStyleSheet(appStyle)
setattr(FWindow, 'window', window)
window.show()
# window.showMaximized()
sys.exit(app.exec_())
def main():
app = QApplication(sys.argv)
window = MainWindow(config)
window.show()
ret = app.exec_()
sys.exit(ret)
def main():
from PyQt5.QtWidgets import QApplication
# from PyQt5.QtWidgets import QSplashScreen
# from PyQt5.QtGui import QPixmap
# from PyQt5.QtCore import Qt
app=QApplication.instance()
if not app:
app=QApplication(sys.argv)
# splash_pix = QPixmap('://rc/pic/Aesop.png')
# splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
# splash.setMask(splash_pix.mask())
# splash.show()
# splash.showMessage("Loaded modules")
# app.processEvents()
# Simulate something that takes time
# time.sleep(3)
# splash.hide()
# splash.close()
arith=Arith()
if arith.checkDeadDateTime()==False:
print("License out of date. Quit now")
return
mainwindow = MainWindow()
mainwindow.setArith(arith)
mainwindow.show()
# mainwindow.actionQuit.triggered.connect(self.quit())
# mainwindow.close.
# splash.finish(mainwindow)
sys.exit(app.exec_())
def main(argv=None):
if argv is None:
argv = sys.argv
app = QApplication(argv)
app.setApplicationName('CANopenGUI')
window = MainWindow()
window.show()
return app.exec_()
def main():
""" """
setup()
app = QtGui.QApplication(sys.argv)
window = MainWindow()
window.show()
# window.showMaximized()
sys.exit(app.exec_())
def main():
gettext_windows.setup_env()
locale.setlocale(locale.LC_ALL, '')
gettext.install('soulou', localedir='locale', unicode=True)
app = QtGui.QApplication(sys.argv)
window = MainWindow()
setattr(F_Window, 'window', window)
window.show()
#~ window.showMaximized()
sys.exit(app.exec_())
def main():
""" """
gettext_windows.setup_env()
locale.setlocale(locale.LC_ALL, "")
# gettext.install('mmain', localedir='locale', unicode=True)
gettext.install("bmain.py", localedir="locale")
window = MainWindow()
window.setStyleSheet(CSS.appStyle)
setattr(FWindow, "window", window)
window.show()
# window.showMaximized()
sys.exit(app.exec_())
def launch_data_downloader(path):
app = QApplication(sys.argv)
splash_pix = QPixmap('icons/xigmanas_conf_backup_icon.svg')
splash = QSplashScreen(splash_pix)
splash.setMask(splash_pix.mask())
splash.show()
config_dict = configparser.ConfigParser()
if not os.path.exists(os.path.join(path, 'xigmanas_backup.ini')):
config_dict['LOG'] = {'level': 'INFO', 'path': ''}
config_dict['OPTIONS'] = {
'language': 'english',
'check_update': 'False'
}
config_dict['CREDENTIALS'] = {
'password': '',
'username': '',
'folder': '',
'target': '',
'target_port': '22'
}
with open(os.path.join(path, 'xigmanas_backup.ini'),
'w') as configfile:
config_dict.write(configfile)
config_dict.read(os.path.join(path, 'xigmanas_backup.ini'))
path_exist = True
if not config_dict.get('LOG', 'path'):
log_filename = os.path.join(path, 'xigmanas_backup_log.out')
else:
path_exist = os.path.isdir(config_dict.get('LOG', 'path'))
if path_exist:
log_filename = os.path.join(config_dict.get('LOG', 'path'),
'xigmanas_backup_log.out')
else:
log_filename = os.path.join(path, 'xigmanas_backup_log.out')
logging.getLogger('').handlers = []
logging.basicConfig(filename=log_filename,
level=getattr(logging, config_dict.get('LOG',
'level')),
filemode='w',
format='%(asctime)s : %(levelname)s : %(message)s')
formatter = logging.Formatter('%(levelname)s : %(message)s')
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
logging.info('*****************************************')
logging.info('XigmaNAS Conf Backup ' + _backup_version +
' is starting ...')
logging.info('*****************************************')
ui = MainWindow(path, config_dict)
ui.show()
splash.finish(ui)
sys.exit(app.exec_())
class MainWindowController():
def __init__(self):
self.store = Gtk.TreeStore(str)
self.store.append(None, ["foobar"])
self.store.append(None, ["barfoo"])
self.ui = MainWindow(self.store)
self.ui.connect("delete-event", Gtk.main_quit)
def show(self):
self.ui.show_all()
class MainApp():
def __init__(self):
self.settings = Settings("./config.json")
self.machine = Machine(self.settings)
self.window = MainWindow(self.settings, self.machine)
def __del__(self):
self.machine.disable()
self.window.disable()
def runUI(self):
self.window.mainloop()
def main():
try:
app.check_and_update_data()
except Exception:
pass
qapp = QtWidgets.QApplication(sys.argv)
mw = MainWindow()
mw.showMaximized()
ret = qapp.exec_()
mw.user_data.save()
sys.exit(ret)
def main():
app = QtWidgets.QApplication(sys.argv)
with open("ui/style.qss") as f:
try:
app.setStyleSheet("\n".join(f.readlines()))
except Exception as e:
logging.error(e)
else:
logging.info("Stylesheets are included")
window = MainWindow()
window.show()
logging.info("Show main window, starting main thread")
main_thread = threading.Thread(target=app.exec_)
main_thread.run()
def main():
#gettext_windows.setup_env()
locale.setlocale(locale.LC_ALL, '')
gettext.install('rede', localedir='locale', unicode=True)
app = QtGui.QApplication(sys.argv)
window = MainWindow()
setattr(REDEWindow, 'window', window)
window.show()
#window.showMaximized()
#window.showNormal()
#window.showFullScreen()
sys.exit(app.exec_())
def __init__(self):
self.store = Gtk.TreeStore(str)
self.store.append(None, ["foobar"])
self.store.append(None, ["barfoo"])
self.ui = MainWindow(self.store)
self.ui.connect("delete-event", Gtk.main_quit)
def main():
app = QApplication(sys.argv)
app.setOrganizationName("University of Oldenburg")
app.setOrganizationDomain("www.uni-oldenburg.de")
app.setApplicationName("OptiSim")
app.setWindowIcon(QIcon(":/OS_logo.png"))
# Create and display the splash screen
#splash_pix = QPixmap(":/OS_logo.png")
#splash = QSplashScreen(splash_pix, QtCore.Qt.WindowStaysOnTopHint)
#splash.setMask(splash_pix.mask())
#splash.show()
#app.processEvents()
wnd = MainWindow()
wnd.show()
#splash.finish(wnd)
sys.exit(app.exec_())
def launch_egads_gui(path):
app = QtWidgets.QApplication(sys.argv)
splash_pix = QtGui.QPixmap('icons/egads_gui_splashscreen.png')
splash = QtWidgets.QSplashScreen(splash_pix,
QtCore.Qt.WindowStaysOnTopHint)
splash.setMask(splash_pix.mask())
splash.show()
config_dict = ConfigParser.ConfigParser()
if not os.path.exists(os.path.join(path, 'egads_gui.ini')):
ini_file = open(os.path.join(path, 'egads_gui.ini'), 'w')
config_dict.add_section('LOG')
config_dict.add_section('OPTIONS')
config_dict.set('LOG', 'level', 'DEBUG')
config_dict.set('LOG', 'path', '')
config_dict.set('OPTIONS', 'check_update', 'False')
config_dict.write(ini_file)
ini_file.close()
config_dict.read(os.path.join(path, 'egads_gui.ini'))
log_filename = os.path.join(config_dict.get('LOG', 'path'),
'egads_gui.log')
logging.getLogger('').handlers = []
logging.basicConfig(filename=log_filename,
level=getattr(logging, config_dict.get('LOG',
'level')),
filemode='w',
format='%(asctime)s : %(levelname)s : %(message)s')
formatter = logging.Formatter('%(levelname)s : %(message)s')
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
logging.info('**********************************')
logging.info('EGADS GUI ' + _gui_version + ' is starting ...')
logging.info('**********************************')
logging.info('gui - operating system: ' + str(sys.platform))
python_version = str(sys.version_info[0]) + '.' + str(
sys.version_info[1]) + '.' + str(sys.version_info[2])
logging.info('gui - python version: ' + python_version)
logging.info('gui - egads version: ' + egads_version)
ui = MainWindow(path, config_dict)
ui.show()
splash.finish(ui)
sys.exit(app.exec_())
def launch_prosim_updater(path):
app = QApplication(sys.argv)
splash_pix = QPixmap('icons\splash_screen.svg')
splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
splash.setMask(splash_pix.mask())
splash.show()
config_dict = configparser.ConfigParser()
if not os.path.exists(os.path.join(path, 'prosim_updater.ini')):
config_dict['LOG'] = {'level': 'DEBUG',
'path': ''}
config_dict['OPTIONS'] = {'language':'english',
'check_update':'False',
'terminate_processes':'False',
'relaunch_processes':'False'}
with open(os.path.join(path, 'prosim_updater.ini'), 'w') as configfile:
config_dict.write(configfile)
config_dict.read(os.path.join(path, 'prosim_updater.ini'))
if not config_dict['OPTIONS'].get('language'):
config_dict.set('OPTIONS', 'language', 'english')
with open(os.path.join(path, 'prosim_updater.ini'), 'w') as configfile:
config_dict.write(configfile)
if not config_dict.get('LOG', 'path'):
log_filename = os.path.join(path, 'prosim_creator_log.out')
else:
log_filename = os.path.join(config_dict.get('LOG', 'path'),'prosim_creator_log.out')
logging.getLogger('').handlers = []
logging.basicConfig(filename = log_filename,
level = getattr(logging, config_dict.get('LOG', 'level')),
filemode = 'w',
format = '%(asctime)s : %(levelname)s : %(message)s')
formatter = logging.Formatter('%(levelname)s : %(message)s')
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
logging.info('*****************************************')
logging.info('Prosim737 Updater ' + _updater_version + ' is starting ...')
logging.info('*****************************************')
translations = read_translations()
ui = MainWindow(path, config_dict, translations)
ui.show()
splash.finish(ui)
sys.exit(app.exec_())
def __init__(self, app, library):
self.app = app
self.library = library
self.player = None
self.ui = MainWindow(app, library.playlists)
self.context_id = self.ui.statusbar.get_context_id("mainwindow")
self.ui.set_tree_selection_callback(self.on_tree_selection_changed)
self.ui.set_ppbutton_callback(self.on_playpause_button)
def main(args):
halt_on_quit = False
fullscreen = False
if 'fullscreen' in args:
fullscreen = True
if 'halt_on_quit' in args:
halt_on_quit = True
locale.setlocale(locale.LC_ALL, '')
gettext.install('nut', localedir='locale', unicode=True)
app = QtGui.QApplication(sys.argv)
# translation file for Qt (QT's widgets)
loc = QtCore.QLocale.system()
trans = QtCore.QTranslator(app)
sLocName = "qt_" + loc.name()
sLocPath = QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.TranslationsPath)
if trans.load(sLocName, sLocPath):
app.installTranslator(trans)
window = MainWindow(app)
setattr(NUTWindow, 'window', window)
setattr(NUTWindow, 'halt_on_quit', halt_on_quit)
if fullscreen:
window.showFullScreen()
else:
window.show()
ret = app.exec_()
if halt_on_quit:
import subprocess
subprocess.call(' '.join(['/usr/bin/sudo', '/sbin/halt']), shell=True)
sys.exit(ret)
def main():
window = MainWindow()
window.setStyleSheet(appStyle)
setattr(FWindow, 'window', window)
window.show()
# window.showMaximized()
sys.exit(app.exec_())
def start_main():
app = QApplication(sys.argv)
icon = QIcon(':/icons/application.png')
app.setWindowIcon(icon)
# If compiled as a one-file PyInstaller package look for Qt4 Plugins in the TEMP folder.
try:
extra_path = [os.path.join(sys._MEIPASS, 'qt4_plugins')]
app.setLibraryPaths(app.libraryPaths() + extra_path)
app.utils_path = os.path.join(sys._MEIPASS, 'utils')
except AttributeError:
app.utils_path = os.path.join(os.getcwd(), 'utils')
# Error handling stuff.
if hasattr(sys, 'frozen'):
sys.excepthook = except_hook
app.setApplicationName('ABBYY Automator')
app.setApplicationVersion(VERSION)
app.setOrganizationName('Pearl Scan Solutions')
print 'AppName: %s' % app.applicationName()
print 'AppVersion: %s' % app.applicationVersion()
print 'Company Name: %s' % app.organizationName()
app.setStyle(QStyleFactory.create('Cleanlooks'))
app.setPalette(QApplication.style().standardPalette())
if not instance_check(app):
message_box_error('Program already running.',
'You can only have one copy of ABBYY Automator running at once.')
sys.exit()
mainwindow = MainWindow()
mainwindow.show()
app.exec_()
app.closeAllWindows()
app.quit()
def _main():
logging.basicConfig(level=logging.WARN, format=_LOG_MSG_FORMAT)
@QtCore.pyqtSlot()
def atExit():
faceRecognizer.save(_FACE_RECOGNIZER_STATE_PATH)
app = QtGui.QApplication(sys.argv)
splashLogo = QtGui.QPixmap(_SPLASH_LOGO_PATH)
splash = QtGui.QSplashScreen(splashLogo)
splash.setMask(splashLogo.mask())
splash.show()
app.processEvents()
try:
faceRecognizer = FaceRecognizer.load(_FACE_RECOGNIZER_STATE_PATH)
except:
faceRecognizer = FaceRecognizer(_PLUGINS_PATH)
try:
mainWindow = MainWindow(faceRecognizer)
except Exception as e:
QtGui.QMessageBox.critical(None, "Load error",
"Error during load:\n\n%s" % e.message)
return 1
splash.finish(mainWindow)
mainWindow.show()
app.aboutToQuit.connect(atExit)
appRet = app.exec_()
# ugly workaround to force the release of cameraDevice =S
import sip
sip.delete(mainWindow)
return appRet
def startmain():
"""
Initialise the application and display the main window.
"""
args = parse_arguments()
app = QApplication(sys.argv)
app.cleanup_files = []
if not args.native_style:
app.setStyle(QStyleFactory.create('Fusion'))
app.setPalette(QApplication.style().standardPalette())
app_icon = QIcon(':/icons/ui/ot_icon.svg')
print(app_icon.isNull(), app_icon.pixmap(200, 200).isNull())
app.setApplicationName(APP_NAME)
app.setApplicationVersion(VERSION_STRING)
app.setOrganizationName(ORG_NAME)
app.setWindowIcon(app_icon)
print('AppName: {0:s}'.format(app.applicationName()))
print('AppVersion: {0:s}'.format(app.applicationVersion()))
print('Company Name: {0:s}'.format(app.organizationName()))
QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedKingdom))
# Add passed arguments to app.
app.args = args
print('Args:', app.args)
# Check to see if application already running.
existing_pid = instance_check(app)
if existing_pid:
print(existing_pid)
if app.args.quit_existing:
# Command line argument passed to close existing program. Do that, then quit.
if platform.system() == "Windows":
subprocess.Popen("taskkill /F /T /PID %i" % existing_pid, shell=True)
else:
os.killpg(existing_pid, signal.SIGKILL)
else:
message_box_error('Program already running.',
'You can only have one copy of the Bing Wallpaper Changer running at once.')
sys.exit()
mainwindow = MainWindow()
# mainwindow.show()
sys.exit(app.exec_())
def startmain():
"""
Initialise the application and display the main window.
"""
app = QtGui.QApplication(sys.argv)
icon = QIcon(QPixmap(':/icons/ssh_tunnel.svg'))
app.setWindowIcon(icon)
# If compiled as a one-file PyInstaller package look for Qt4 Plugins in the TEMP folder.
try:
extra_path = [os.path.join(sys._MEIPASS, 'qt4_plugins')]
app.setLibraryPaths(app.libraryPaths() + extra_path)
except AttributeError:
pass
# Error handling stuff.
if hasattr(sys, 'frozen'):
sys.excepthook = except_hook
QtGui.QApplication.setStyle(QtGui.QStyleFactory.create('CleanLooks'))
QtGui.QApplication.setPalette(QtGui.QApplication.style().standardPalette())
QtGui.QApplication.setApplicationName('SSH Tunnel')
QtGui.QApplication.setApplicationVersion(VERSION)
QtGui.QApplication.setOrganizationName('Pearl Scan Software')
print 'AppName: %s' % QtGui.QApplication.applicationName()
print 'AppVersion: %s' % QtGui.QApplication.applicationVersion()
print 'Company Name: %s' % QtGui.QApplication.organizationName()
QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedKingdom))
mainwindow = MainWindow()
mainwindow.show()
sys.exit(app.exec_())
def __init__(self):
super(Window, self).__init__()
self.ui: MainWindow = MainWindow()
self.ui.setupUi(self)
# self.ui.verticalLayout.addWidget(Lab_1(self.ui.centralwidget))
self.ui.tabWidget.addTab(Lab_1(self.ui.tabWidget), 'Лабораторная 1')
self.ui.tabWidget.addTab(Lab_2(self.ui.tabWidget), 'Лабораторная 2')
self.ui.tabWidget.addTab(Lab_3(self.ui.tabWidget), 'Лабораторная 3')
self.ui.tabWidget.addTab(Lab_4(self.ui.tabWidget), 'Лабораторная 4')
self.ui.tabWidget.addTab(Lab_5(self.ui.tabWidget), 'Лабораторная 5')
self.ui.tabWidget.addTab(Lab_6(self.ui.tabWidget), 'Лабораторная 6')
self.ui.tabWidget.setCurrentIndex(6-1)
self.ui.tabWidget.setCurrentIndex(1-1)
self.setGeometry(QtCore.QRect(0, 0, 0, 0))
self.ui.tabWidget.currentChanged.connect(
lambda: self.resize(self.minimumSize())
)
def new_instance(self, args=None, show=True):
"""Creates a new instances.
Arguments:
args: List of filenames to open in new instance (default: None).
show: If True, instance.show() is called here (default: True).
Returns:
The new instance.
"""
create_editor = not args
instance = MainWindow(self, create_editor=create_editor)
if args is None:
args = []
for arg in args:
instance.editor_create(arg)
self._instances.append(instance)
instance.connect("destroy", self.on_instance_destroyed)
if show:
instance.show()
self.cb.emit("instance-created", instance)
return instance
def __init__(self):
self.app = QApplication(sys.argv)
self.settings = QSettings("shampoo", "shampoo")
self.window = MainWindow(self)
args = self._parse_args()
if args.level == 0:
level = logging.ERROR
elif args.level == 1:
level = logging.INFO
else:
level = logging.DEBUG
logging.basicConfig(format="%(levelname)s: %(message)s", level=level)
self.case = Case()
if args.load:
self.case.load(args.load)
self.window.set_case(self.case)
def new_instance(self, args=None, show=True):
"""Creates a new instances.
Arguments:
args: List of filenames to open in new instance (default: None).
show: If True, instance.show() is called here (default: True).
Returns:
The new instance.
"""
create_editor = not args
instance = MainWindow(self, create_editor=create_editor)
if args is None:
args = []
for arg in args:
instance.editor_create(arg)
self._instances.append(instance)
instance.connect("destroy", self.on_instance_destroyed)
if show:
instance.show()
self.cb.emit("instance-created", instance)
return instance
def main():
app = QtWidgets.QApplication([])
window = MainWindow()
sys.exit(app.exec_())
'''
'''
import sys
from PyQt5 import QtWidgets
from ui.mainwindow import MainWindow
import yappi
if __name__ == '__main__':
yappi.start()
app = QtWidgets.QApplication(sys.argv)
app.setOrganizationDomain('kasan.ws')
app.setOrganizationName('K.A.S.A.N.')
app.setApplicationName('GoldmineViewer')
wnd = MainWindow()
wnd.show()
app.exec_()
yappi.get_func_stats().print_all()
#!/usr/bin/env python # -*- coding: utf-8 -*- __author__ = 'ipetrash' # TODO: добавить батник сборки ехе через pyinstaller import sys from PyQt5.QtWidgets import QApplication from ui.mainwindow import MainWindow app = QApplication(sys.argv) font = app.font() font.setPointSize(font.pointSize() + 8) app.setFont(font) mw = MainWindow(r'C:\Users\ipetrash\Music\Эпоха – Ценой великих жертв.mp3') mw.show() sys.exit(app.exec_())
splash = SplashScreen()
splash.show()
app.exec_()
if DEBUG:
QMessageBox.warning(None, app.tr("HoruCNC"), app.tr(fp.name),
QMessageBox.Close)
# check that the resources has been extracted. Otherwise we
# are running direct from the "*.dmg" image -which is not supported-
#
if not os.access("resources/config/configuration.ini", os.W_OK | os.R_OK):
QMessageBox.warning(None, app.tr("HoruCNC"),
app.tr("Running from DMG Image is not supported.\n" + \
"Copy HoruCNC to your application folder"),
QMessageBox.Close)
else:
main = MainWindow()
main.show()
if len(sys.argv) > 1:
main.loadPipelinePyFile(sys.argv[1])
else:
main.loadPipelineByIndex(0)
print("--------------------")
print(sys.version)
print(QtCore.qVersion())
print("--------------------")
exit_code = app.exec_()
sys.exit(exit_code)
def main():
app = QtWidgets.QApplication(sys.argv)
QLocale.setDefault(QLocale(QLocale.English))
ui = MainWindow()
ui.show()
sys.exit(app.exec_())
def launch_prosim_updater(path):
app = QApplication(sys.argv)
splash_pix = QPixmap('icons\downloader_update_off_icon.svg')
splash = QSplashScreen(splash_pix)
splash.setMask(splash_pix.mask())
splash.show()
config_dict = configparser.ConfigParser()
if not os.path.exists(os.path.join(path, 'ecmwf_downloader.ini')):
config_dict['LOG'] = {'level': 'DEBUG', 'path': ''}
config_dict['OPTIONS'] = {
'language': 'english',
'check_update': 'True',
'display_api_info': 'True'
}
config_dict['CREDENTIALS'] = {
'url': 'https://api.ecmwf.int/v1',
'key': '',
'email': '',
'folder': ''
}
with open(os.path.join(path, 'ecmwf_downloader.ini'),
'w') as configfile:
config_dict.write(configfile)
config_dict.read(os.path.join(path, 'ecmwf_downloader.ini'))
if not config_dict['OPTIONS'].get('language'):
config_dict.set('OPTIONS', 'language', 'english')
with open(os.path.join(path, 'ecmwf_downloader.ini'),
'w') as configfile:
config_dict.write(configfile)
if not config_dict['CREDENTIALS'].get('folder'):
config_dict.set('CREDENTIALS', 'folder', '')
with open(os.path.join(path, 'ecmwf_downloader.ini'),
'w') as configfile:
config_dict.write(configfile)
path_exist = True
if not config_dict.get('LOG', 'path'):
log_filename = os.path.join(path, 'ecmwf_downloader_log.out')
else:
path_exist = os.path.isdir(config_dict.get('LOG', 'path'))
if path_exist:
log_filename = os.path.join(config_dict.get('LOG', 'path'),
'ecmwf_downloader_log.out')
else:
log_filename = os.path.join(path, 'ecmwf_downloader_log.out')
logging.getLogger('').handlers = []
logging.basicConfig(filename=log_filename,
level=getattr(logging, config_dict.get('LOG',
'level')),
filemode='w',
format='%(asctime)s : %(levelname)s : %(message)s')
formatter = logging.Formatter('%(levelname)s : %(message)s')
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
logging.info('*****************************************')
logging.info('ECMWF Data Downloader ' + _downloader_version +
' is starting ...')
logging.info('*****************************************')
if not path_exist:
logging.exception(
'ecmwf_data_downloader.py - exception occured when EDD tried to write log file in a non-default folder. Please check '
+
'that the folder exists. The path option in the config file is going to be modified to the default folder.'
)
config_dict.set('LOG', 'path', '')
with open(os.path.join(path, 'ecmwf_downloader.ini'),
'w') as configfile:
config_dict.write(configfile)
ui = MainWindow(path, config_dict)
ui.show()
splash.finish(ui)
sys.exit(app.exec_())
import settings
def stream_stdout( stream):
"""
Acts as callback for messages from stream.
Routes messages from pycurl stream to the UI
"""
ui.update_textBrowser( stream )
if __name__ == "__main__":
import sys
#start window
app = QtGui.QApplication(sys.argv)
ui = MainWindow()
#start stream as new thread
flow = flowdockClient.flowdock_py()
flow.DEBUG = 1
flow.API_TOKEN = settings.API_TOKEN
flow.USER = settings.USER #this is the user email address (user for logging in)
flow.USER_NAME = settings.USER_NAME #the display name for the user
flow.PASS = settings.PASS
th = thread.start_new_thread(flow.stream, (stream_stdout, ))
ui.load_flow(flow)
flow.get_users()
#show window
ui.show()
sys.exit(app.exec_())
def main_curses(self, screen):
# tell the terminal to not send us SIGINTs when Ctrl+C is pressed
tty_attributes = termios.tcgetattr(sys.stdin)
tty_attributes[3] &= ~termios.ISIG
termios.tcsetattr(sys.stdin, termios.TCSANOW, tty_attributes)
self.screen = screen
curses.use_default_colors()
curses.curs_set(0)
self.status_bar = StatusBar(self)
self.main_window = MainWindow(self)
curses.doupdate()
# this window stack kind of duplicates the one kept by
# curses.panel — perhaps we should just use that directly?
self.window_stack = [self.status_bar, self.main_window]
self.should_quit = False
while True:
key = screen.get_wch() # blocks indefinitely
if key == curses.KEY_RESIZE:
# this could be either a legitimate SIGWINCH, notifying us that
# the terminal was resized,
# or a fake SIGWINCH, generated by the zgram_handler
# (see __init__) notifying us that we have new zephyrgrams
# to take from the queue
while not self.zgram_queue.empty():
zgram = Zephyrgram.from_zpipe(self.zgram_queue.get())
self.db.append_message(zgram)
# if this is in class 'ununclass', and we aren't yet
# subscribed to 'unununclass', do so
undepth, class_stripped = take_unprefix(zgram.class_)
new_unclass = 'un' + zgram.class_
for instance, recipient in self.db.update_undepth(
class_stripped, undepth + 1):
self.zpipe.subscribe(new_unclass, instance, recipient)
for window in self.window_stack:
window.update_size()
else:
self.status_bar.clear_status()
self.should_quit = False
events = self.window_stack[-1].handle_keypress(key)
self.handle_events(events)
if self.should_quit:
break
if not self.error_queue.empty():
error = self.error_queue.get()
self.status_bar.set_status('Error in {}: {}'.format(
error.operation, error.message))
curses.doupdate()
from core.filecompare import DiffTwoSides
from core.foldercompare import FolderComparator
import logging
from ui.mainwindow import MainWindow
if __name__ == "__main__":
# For testing
logging.basicConfig(level=logging.INFO)
comparator = FolderComparator('..\\tests\\leftdir', '..\\tests\\rightdir')
comparator.rescan(False)
comparator.print_result()
# Compare files
left_text = open('..\\tests\\file_compare\\left.txt').read()
right_text = open('..\\tests\\file_compare\\right.txt').read()
lines = DiffTwoSides(left_text.splitlines(0), right_text.splitlines(0))
w = MainWindow()
w.set_text(lines)
w.mainloop()
class Shampoo:
def __init__(self):
self.app = QApplication(sys.argv)
self.settings = QSettings("shampoo", "shampoo")
self.window = MainWindow(self)
args = self._parse_args()
if args.level == 0:
level = logging.ERROR
elif args.level == 1:
level = logging.INFO
else:
level = logging.DEBUG
logging.basicConfig(format="%(levelname)s: %(message)s", level=level)
self.case = Case()
if args.load:
self.case.load(args.load)
self.window.set_case(self.case)
def open(self):
dirname = QFileDialog.getExistingDirectory(
self.window, "Load OpenFOAM case", ".")
if not dirname:
return
self.case = Case()
self.case.load(dirname)
self.window.set_case(self.case)
def save(self):
self.case.path = "/home/spirali/tmp/svtest"
if self.case.path:
self.case.save()
else:
self.save_as()
def save_as(self):
dirname = QFileDialog.getSaveFileName(
self.window, "Save OpenFOAM case", ".")
if not dirname:
return
self.case.path = dirname
self.case.save()
self.window.update_title()
def main(self):
self.window.show()
return self.app.exec_()
def _parse_args(self):
parser = argparse.ArgumentParser(
description="Shampoo -- OpenFoam configuration tool")
parser.add_argument("--load",
metavar="DIRECTORY",
type=str,
help="Load OpenFoam case")
parser.add_argument("--level",
metavar="LEVEL",
type=int,
default=1,
help="Verbose level, default: 1")
return parser.parse_args()
def run(self):
if not self.settings.value("openfoam/path"):
self.window.console.write_error("Path to OpenFOAM is not set")
return
if not self.case.path:
self.window.console.write_error("Shampoo project is not saved")
return
self.case.save()
path = os.path.join(self.settings.value("openfoam/path"), "etc/bashrc")
commands = "source {0}\n{1}\n".format(
path,
"blockMesh")
program_name = "/bin/bash"
logging.info("Running %s", "blockMesh")
process = QProcess()
self.window.console.set_process(process)
process.setWorkingDirectory(self.case.path)
process.start(program_name)
process.write(commands)
process.closeWriteChannel()
def configure(self):
dialog = ConfigDialog(self.window, self.settings)
if dialog.exec_():
self.settings.sync()
config = Config()
config.load()
# Create some directories if they don't exist
for dir in ['tmp', 'cache', 'cache' + os.sep + 'data']:
if not os.path.exists(os.path.join(os.getcwd(), dir)):
os.mkdir(os.path.join(os.getcwd(), dir))
os.chmod(os.path.join(os.getcwd(), dir), 0777)
# The app
if __name__ == '__main__':
# Create app
app = QApplication(sys.argv)
app.setApplicationName('LMMS Theme Installer')
# Configuration wizard
if config.get('Wizard', 'firstrun') == 'True':
from ui.firstrunwizard import FirstRunWizardWindow
wizard = FirstRunWizardWindow()
wizard.show()
# Show window
window = MainWindow()
window.show()
# Closed connection
app.lastWindowClosed.connect(app.quit)
# Run it
sys.exit(app.exec_())
from PyQt5 import QtWidgets
from PyQt5 import sip
import sys
sys.path.append(".")
from ui.mainwindow import MainWindow
if __name__ == "__main__":
import sys
import os
max_dept = sys.getrecursionlimit()
path = os.path.dirname(os.path.realpath(__file__))
print("path:" + path)
print("stack size:" + str(max_dept))
os.chdir(path)
app = QtWidgets.QApplication(sys.argv)
MainWindows = MainWindow()
MainWindows.show()
sys.exit(app.exec_())
def main():
app = QApplication([])
app.setApplicationName("Clinician Scheduler")
window = MainWindow()
app.exec_()
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
from PyQt5 import QtWidgets, QtCore
from ui.mainwindow import MainWindow
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
translator = QtCore.QTranslator()
# get system locale
systemLocale = QtCore.QLocale.system().name()
translationFile = "i18n/{}".format(systemLocale)
# load translation file and install translator
translator.load(translationFile)
app.installTranslator(translator)
# fire up main ui
ui = MainWindow()
ui.showMaximized()
sys.exit(app.exec_())
#!usr/bin/env python
"""
Minerva - An artwork manager for the XBMC Media Center
Launches the Qt interface
"""
import sys
from PySide import QtGui
from ui.mainwindow import MainWindow
if __name__ == '__main__':
app = QtGui.QApplication(sys.argv)
frame = MainWindow()
frame.show()
app.exec_()
import logging, logging.config
logging.config.fileConfig("logging.conf")
logger = logging.getLogger("wallLogger")
logger.info("logger stated")
from ui.mainwindow import MainWindow
main_window = MainWindow()
# APPSLIST
from mtmenu.ui.appslist import AppsList
from utils import get_all_applications
apps_list = AppsList(get_all_applications())
# TOPBAR
from ui.topbar import TopBar
top_bar = TopBar()
# CATEGORIES LIST
from ui.categorylist import CategoryList
from utils import get_all_categories
categories_list = CategoryList(get_all_categories())
# PROXY
from proxy import Proxy
proxy = Proxy()
# BACKGROUND
from ui.backgroundimage import BackgroundImage
background_image = BackgroundImage(filename='images/wallpaper.png')
def main():
window = MainWindow()
window.show()
sys.exit(app.exec_())
from PyQt4 import QtCore, QtGui
from ui.mainwindow import MainWindow
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
ui = MainWindow()
ui.show()
sys.exit(app.exec_())
def threadcount(self):
"""Returns the amount of observed threads."""
return len(self._observers)
def thread(self, num):
"""Gets the num'th thread
@param num Number of the thread. Must be 0 <= num < threadcount().
@return Instance of FourChanThread
"""
if not 0 <= num < self.threadcount():
raise ValueError("num out of bounds")
return self._observers[num].thread()
threadobserved = Signal(FourChanThread)
"""Signal that is emitted, when a new thread is observed."""
threadobservationcancelled = Signal(FourChanThread)
"""Signal that is emitted, when observation of a thread has been cancelled.
"""
################################################################################
if __name__ == "__main__":
from PySide.QtGui import QApplication
from ui.mainwindow import MainWindow
import sys
app = QApplication(sys.argv)
main = MainWindow()
main.showMaximized()
app.exec_()
def launch_asmm_creator(path):
app = QApplication(sys.argv)
ui = MainWindow(path)
ui.show()
sys.exit(app.exec_())
LOG_FORMATTER = \
logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
LOGGER_FH.setFormatter(LOG_FORMATTER)
LOGGER_CH.setFormatter(LOG_FORMATTER)
# add the handlers to the logger
LOGGER.addHandler(LOGGER_FH)
LOGGER.addHandler(LOGGER_CH)
if __name__ == '__main__':
LOGGER.debug('Start program')
# Read LOC_LANG from settings file
SETTINGS = QtCore.QSettings('settings.ini', QtCore.QSettings.IniFormat)
SETTINGS.beginGroup('UserSettings')
LOC_LANG = SETTINGS.value('Language')
SETTINGS.endGroup()
APP = QtWidgets.QApplication(sys.argv)
PARENT_PATH = os.path.join(__file__, os.path.pardir)
DIR_PATH = os.path.abspath(PARENT_PATH)
FILE_PATH = os.path.join(DIR_PATH, 'i18n', LOC_LANG + '.qm')
if Path(FILE_PATH).exists():
TRANSLATOR = QtCore.QTranslator()
TRANSLATOR.load(FILE_PATH)
APP.installTranslator(TRANSLATOR)
UI = MainWindow()
UI.show()
sys.exit(APP.exec_())
LOGGER.debug('Exit program')
import sys
def generateSTL(inputfilename, outputfilename, precision):
with open(inputfilename, 'r') as f:
input = f.read()
from evaluator import evaluator
result = evaluator.safeEvaluate(input, sys.stdout)
if result:
import cadmium
if isinstance(result, cadmium.solid.Solid):
result.toSTL(filename = outputfilename, deflection=precision)
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(description='Python script based CAD')
parser.add_argument('inputfile', nargs='?', default='')
parser.add_argument('-x', '--export', nargs=1, help='export STL to file')
parser.add_argument('-p', '--precision', nargs=1, help='smallest error', default=[0.01])
args = parser.parse_args()
if args.export:
generateSTL(args.inputfile, args.export[0], float(args.precision[0] ) )
exit()
app = QtGui.QApplication(sys.argv)
ui = MainWindow()
ui.show()
ui.glWidget.InitDriver()
ui.setup(args.inputfile)
sys.exit(app.exec_())
# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
from ui.mainwindow import MainWindow
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
a = MainWindow(sys.argv)
a.show()
sys.exit(app.exec_())
from PyQt4.QtCore import * from PyQt4.QtGui import * from OpenGL.GLUT import glutInit from ui.mainwindow import MainWindow import sys app = QApplication(sys.argv) form = MainWindow() glutInit(sys.argv) form.show() app.exec_()
import sys
from PySide6.QtWidgets import QApplication
from ui.mainwindow import MainWindow
if __name__ == '__main__':
app = QApplication()
window = MainWindow()
window.show()
sys.exit(app.exec_())
# This Python file uses the following encoding: utf-8
import sys
from PySide2 import QtGui, QtCore, QtWidgets
from PySide2.QtWidgets import QApplication
from ui.mainwindow import MainWindow
from conf import Conf
if __name__ == "__main__":
app = QApplication(sys.argv)
win = MainWindow()
win.show()
sys.exit(app.exec_())
#!/usr/bin/env python # # === PYDAQCONFIG === # # This work is licensed under the Creative Commons Attribution-NonCommercial- # ShareAlike 4.0 International License. To view a copy of this license, visit # http://creativecommons.org/licenses/by-nc-sa/4.0/ or send a letter to Creative # Commons, PO Box 1866, Mountain View, CA 94042, USA. import sys from ui.mainwindow import MainWindow from PyQt4 import QtGui qApp = QtGui.QApplication(sys.argv) window = MainWindow() window.show() window.raise_() qApp.exec_()
class MainWindowController():
def __init__(self, app, library):
self.app = app
self.library = library
self.player = None
self.ui = MainWindow(app, library.playlists)
self.context_id = self.ui.statusbar.get_context_id("mainwindow")
self.ui.set_tree_selection_callback(self.on_tree_selection_changed)
self.ui.set_ppbutton_callback(self.on_playpause_button)
def on_tree_selection_changed(self, selection):
model, treeiter = selection.get_selected()
if treeiter is not None and model[treeiter][0] is not None:
vc = PlaylistViewController(model[treeiter][0])
vc.set_click_listener(self.on_track_clicked)
self.ui.setright(vc.ui)
def status_msg(self, message):
self.ui.statusbar.push(self.context_id, message)
def fetch_albumart_thread(self, url):
response = urllib2.urlopen(url)
input_stream = Gio.MemoryInputStream.new_from_data(response.read(), None)
pixbuf = GdkPixbuf.Pixbuf.new_from_stream(input_stream, None)
if pixbuf is not None:
self.ui.set_albumart(pixbuf.scale_simple(32, 32, GdkPixbuf.InterpType.BILINEAR))
def on_track_clicked(self, track):
self.ui.set_trackinfo(track.title, track.artist)
self.player.playsong(track.id)
if track.albumarturl is not None:
thread = threading.Thread(target=self.fetch_albumart_thread, args=[track.albumarturl])
thread.start()
def show(self):
self.ui.show_all()
def setplayer(self, player):
self.player = player
player.add_messagelistener(self.on_playerstate)
player.statusbar_func = self.status_msg
def on_playerstate(self, state, param):
if state == "playing":
self.ui.set_ppbutton_play(True)
elif state == "paused":
self.ui.set_ppbutton_play(False)
def on_playpause_button(self, widget):
if self.player is not None:
if self.player.isplaying():
print("Pausing")
self.player.pause()
else:
print("Playing")
self.player.play()
def stream_stdout(stream):
"""
Acts as callback for messages from stream.
Routes messages from pycurl stream to the UI
"""
ui.update_textBrowser(stream)
if __name__ == "__main__":
import sys
#start window
app = QtGui.QApplication(sys.argv)
ui = MainWindow()
#start stream as new thread
flow = flowdockClient.flowdock_py()
flow.DEBUG = 1
flow.API_TOKEN = settings.API_TOKEN
flow.USER = settings.USER #this is the user email address (user for logging in)
flow.USER_NAME = settings.USER_NAME #the display name for the user
flow.PASS = settings.PASS
th = thread.start_new_thread(flow.stream, (stream_stdout, ))
ui.load_flow(flow)
flow.get_users()
#show window
ui.show()
sys.exit(app.exec_())
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys, os
from PyQt4 import QtGui
from ui.mainwindow import MainWindow
from util import logger
from util.common import *
from ui.notrootdialog import NotrootDialog
log = logger.Log.getInst()
log.info("init main program")
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
mw= MainWindow()
#检查是否root
if not is_root():
nd = NotrootDialog(mw)
nd.show()
#log.info(mw.focusProxy())
#mw.setFocusProxy(nd)
log.info("Not root,click to close!")
else:
mw.show()
sys.exit(app.exec_())
