class PointInSpace:
def __init__(self):
self.main_window = MainWindow()
def run(self):
if self.main_window:
self.main_window.show()
def main():
print 'Starting Central Access Reader...'
import sys
import os
from PyQt4.QtGui import QApplication, QPixmap, QSplashScreen
app = QApplication(sys.argv)
# Create a splash screen
from forms import resource_rc
pixmap = QPixmap(':/icons/icons/CAR Splash.png')
splash = QSplashScreen(pixmap)
splash.show()
app.processEvents()
# Check to see if my folders in my paths exist. If they don't, make them
from misc import program_path, app_data_path, temp_path
if not os.path.exists(os.path.dirname(program_path('test.txt'))):
os.makedirs(os.path.dirname(program_path('test.txt')))
if not os.path.exists(os.path.dirname(app_data_path('test.txt'))):
os.makedirs(os.path.dirname(app_data_path('test.txt')))
if not os.path.exists(os.path.dirname(temp_path('test.txt'))):
os.makedirs(os.path.dirname(temp_path('test.txt')))
from gui.main_window import MainWindow
window = MainWindow(app)
window.show()
splash.finish(window)
sys.exit(app.exec_())
def main():
'''Main loop which initialises embedder application'''
app = QtGui.QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec_())
def _main():
# Must assign an instance of QApplication to a variable otherwise a Segmentation Fault will occur.
app = QApplication(sys.argv)
# Must assign an instance of MainWindow to a variable otherwise the main window won't display.
main_window = MainWindow(sys.argv[1])
main_window.show()
# Keep the program running.
sys.exit(app.exec_())
class SEASideApp:
def __init__(self):
self._app = QApplication(sys.argv)
self._w = MainWindow()
self._w.setWindowIcon(QtGui.QIcon(resource_path("icons/icon.ico")))
def run(self):
self._w.show()
self._app.exec_()
class GUI:
def __init__(self, fslapp):
self.fslapp = fslapp
self.app = QApplication([])
self.main_window = MainWindow(self)
def start(self):
""" BLOCKING """
self.main_window.show()
self.app.exec_()
def main():
sys._excepthook = sys.excepthook
def my_exception_hook(exctype, value, traceback):
print(exctype, value, traceback)
sys._excepthook(exctype, value, traceback)
sys.exit(1)
sys.excepthook = my_exception_hook
app = QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec_())
class SplashScreen(QtWidgets.QMainWindow):
def __init__(self, ctx):
super(SplashScreen, self).__init__()
self.ctx = ctx
self.main_window = None
uic.loadUi(ctx.get_resource("ui/splash_screen.ui"), self)
self.setWindowIcon(QtGui.QIcon(ctx.get_resource("Icon.ico")))
self.create_new_project_button.clicked.connect(self.create_new_project)
self.open_existing_project_button.clicked.connect(
self.open_existing_project)
self.exit_button.clicked.connect(self.exit)
def create_new_project(self):
# TODO create a new file?
project = {"path": "tmp.eproj"}
self.main_window = MainWindow(self.ctx, project)
self.main_window.show()
self.close()
# move code to project service?
def open_project(self):
project_file = QtWidgets.QFileDialog.getOpenFileName(
self, "Projektdatei auswählen.", "C:\\",
"Edaid Project Files (*.eproj)")
if project_file:
if project_file[0]:
# TODO open the project. Check if there are settings inside.
return {"path": project_file[0]}
else:
raise UserCancelledError("User pressed the cancel button.")
raise FileNotFoundError
def open_existing_project(self):
try:
project = self.open_project()
self.main_window = MainWindow(self.ctx, project)
self.main_window.show()
self.close()
except UserCancelledError:
return
except Exception as e:
show_error(e)
def exit(self):
self.close()
def __init__(self):
'''
Constructor
'''
main_window = MainWindow()
self.dialog_new_game = QDialog()
self.ui = Ui_DialogNewGame()
self.ui.setupUi(self.dialog_new_game)
self.user_input = UserInput(main_window, self)
self.board = None
self.over = False
self.ai_player = None
self.new_game()
main_window.show()
class CinemolApp(object):
def __init__(self):
pass
def launch(self):
self.app = QApplication(sys.argv)
self.app.setOrganizationName("rotatingpenguin.com")
self.app.setApplicationName("Cinemol")
self.mainWin = MainWindow()
self.renderer = CinemolRenderer()
# self.renderer.actors.append(Sphere2TestScene())
self.renderer.actors.append(FiveBallScene())
# self.renderer.actors.append(TeapotActor())
self.mainWin.ui.glCanvas.set_gl_renderer(self.renderer)
console_context.cm._set_app(self)
self.mainWin.show()
sys.exit(self.app.exec_())
class ToneBoxApp(QApplication):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.settings_model = SettingsModel()
self.manager_model = manager_model.Model(
self.settings_model.get("DatabasePath"))
self.queue_manager = queue_manager.QueueManager(self.manager_model)
self.player_object = QMediaPlayer()
self.player_object.setPlaylist(self.queue_manager)
self.queue_manager.player_object = self.player_object
self.main_window = MainWindow(self.settings_model, self.manager_model,
self.queue_manager)
self.queue_manager.player_widget = self.main_window.playerWidget
self.main_window.playerWidget.queue_manager = self.queue_manager
self.queue_manager.queue_widget = self.main_window.queueWidget
self.main_window.queueWidget.queue_manager = self.queue_manager
self.queue_manager.setup_signals()
self.main_window.show()
def run(args):
#if img_symlink_dir:
#print 'creating image symlinks...'
#if not os.path.isdir(img_symlink_dir):
#os.mkdir(img_symlink_dir)
#for i in xrange(len(pdc.images)):
#img = pdc.images[i]
#imgId = img.index
#imgFiles = img.imageFiles
#for name,path in imgFiles:
#symlink_name = '%04d_%s.tif' % (imgId, name)
#symlink_path = os.path.join(img_symlink_dir, symlink_name)
#os.symlink(path, symlink_path)
#print 'finished creating image symlinks'
TRY_OPENGL = args.opengl
project_file = args.project_file
start_pipeline = args.run_filtering
app = QApplication(sys.argv)
#mainwindow = MainWindow(simple_ui)
mainwindow = MainWindow()
mainwindow.show()
if project_file:
mainwindow.load_project_file(project_file)
if start_pipeline:
mainwindow.on_start_cancel()
app.exec_()
mainwindow.close()
"""importer = mainwindow.importer
from PyQt4 import QtGui from gui.main_window import MainWindow import sys from gui.direct_view_window import DirectViewWindow, DirectViewer ''' Later configure from here in some code lines: GUI On GUI off, want to have view x and view y maybe a api for gui ? ''' q_app = QtGui.QApplication(sys.argv) gui = MainWindow() # a = NewSimulationWindow(gui) gui.show() # sys.exit(q_app.exec_())
#! /bin/python
from PyQt5.QtWidgets import *
from gui.frist_dialog import FirstDialog
from gui.main_window import MainWindow
if __name__ == '__main__':
import sys
app = QApplication(sys.argv)
dialog = FirstDialog()
dialog.setModal(True)
if dialog.exec() == QDialog.Accepted:
main_window = MainWindow(file=dialog.get_log_path())
main_window.show()
else:
sys.exit(0)
sys.exit(app.exec_())
from plugin_framework.plugin_service import PluginService
import sys
from PySide2 import QtWidgets, QtGui
from gui.main_window import MainWindow
if __name__ == "__main__":
# instanciramo plugin servis
plugin_service = PluginService()
# ucitamo sve plugin-ove sa putanje plugins/
plugin_service.load_plugins()
# kreiramo Qt aplikaciju
app = QtWidgets.QApplication(sys.argv)
# napravimo glavni prozor
main_window = MainWindow(plugin_service)
# prikazemo glavni prozor
main_window.show()
# izvrsimo Qt aplikaciju. Nakon sto se zavrsi Qt aplikacija, zavrsava se i rad interpretera
sys.exit(app.exec_())
def main():
app = QApplication(sys.argv)
ex = MainWindow()
ex.show()
sys.exit(app.exec_())
def main():
app = QtGui.QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())
import sys
import pandas as pd
from PyQt5.QtWidgets import QApplication
from tensorflow.keras import optimizers
from gui.main_window import MainWindow
from models.model_handler import ModelHandler
if __name__ == '__main__':
if sys.argv[-1] == 'gui':
app = QApplication(sys.argv)
ui = MainWindow()
ui.show()
sys.exit(app.exec_())
else:
configs = [
{
"layers": [{
"size": 256,
"activation": 'relu'
}],
"optimizer": optimizers.Adam()
},
{
"layers": [{
"size": 256,
"activation": 'relu'
}, {
"size": 64,
"activation": 'relu'
def initialise_gui(obj, data):
app = QtGui.QApplication(sys.argv)
window = MainWindow(data, obj)
window.show()
app.exec_()
def main():
app = QApplication(sys.argv)
mw = MainWindow()
mw.show()
app.exec()
def main():
app = QtGui.QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())
def login(self):
account, autoconnect = LoginManager().do_login()
if account:
player = Player(account['uid'], account['auth'])
main_window = MainWindow(player, account['name'], autoconnect)
main_window.show()
def main():
app = QtWidgets.QApplication(sys.argv)
window = MainWindow()
window.show()
app.exec()
from PyQt4 import QtGui
from gui.main_window import MainWindow
import sys
from gui.direct_view_window import DirectViewWindow, DirectViewer
'''
Later configure from here in some code lines: GUI On GUI off, want to have view x and view y
maybe a api for gui ?
'''
q_app = QtGui.QApplication(sys.argv)
gui = MainWindow()
# a = NewSimulationWindow(gui)
gui.show()
# sys.exit(q_app.exec_())
def main():
app = QApplication(sys.argv)
mainWindow = MainWindow(getConfig())
mainWindow.show()
app.exec_()
from gui.main_window import MainWindow
import resources.resources_rcc
if __name__ == '__main__':
import sys
from PyQt5.QtWidgets import QApplication
app = QApplication(sys.argv)
app.setOrganizationName("Sonance")
app.setApplicationName("Sonance")
player = MainWindow()
player.show()
sys.exit(app.exec_())
app.setWindowIcon(QtGui.QIcon('icons/copper_icon.png'))
# Create and display the splash screen
splash_pix = QtGui.QPixmap('media/splash_screen.png')
splash = QtGui.QSplashScreen(splash_pix, QtCore.Qt.WindowStaysOnTopHint)
splash.show()
app.processEvents()
# Create main window
from gui.main_window import MainWindow
window = MainWindow()
window.load_style()
# Move main window to desktop center
desktop = QtGui.QApplication.desktop()
screenWidth = desktop.width()
screenHeight = desktop.height()
x = (screenWidth - window.width()) / 2
y = (screenHeight - window.height()) / 2
window.move(x, y)
# Show main window
window.show()
splash.finish(window)
window.raise_()
window.activateWindow()
window.open_project(make_test_project=True)
sys.exit(app.exec_())
from gui.main_window import MainWindow g_MainWindow = MainWindow() g_MainWindow.show()
