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 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()
def __init__(self):
self.background = pyglet.graphics.Batch()
self.width = 1280
self.height = 960
with open('./level/levels.json', "r") as levels:
self.levels = json.load(levels)
print(self.levels)
self.resource_handler = ResourceHandler()
self.resource_handler.load_font()
self.cursor = Cursor(self.background)
self.pause_menu = Menu(self.width, self.height)
self.game_window = MainWindow(self.cursor,
self.levels['levels'],
self.pause_menu,
self.background,
self.width,
self.height,
'Shoot Em’ Up!',
resizable=True)
self.game_window.set_mouse_visible(False) # Hide the mouse cursor
pyglet.clock.schedule_interval(self.game_window.update, 1/120.0)
pyglet.app.run()
def setUp(self):
super().setUp()
panels.add("a")
panels.add("b")
panels.hide("b")
panels.add("c")
categories.add("cat1")
categories.add("cat2")
products.add("prod1_cat1", category_name="cat1")
products.add("prod2_cat1", category_name="cat1")
products.add("prod1_cat2", category_name="cat2")
products.add("prod2_cat2", category_name="cat2")
self.default_products_tree = [{
('cat1', ): [{
('prod1_cat1', ): []
}, {
('prod2_cat1', ): []
}]
}, {
('cat2', ): [{
('prod1_cat2', ): []
}, {
('prod2_cat2', ): []
}]
}]
self.main = MainWindow()
self.menu = MenuBar(self.main)
self.win = PanelsManagementWindow(self.menu)
def launch_gui():
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, GdkPixbuf, GObject, GLib
from gui.main_window import MainWindow
main_window = MainWindow()
Gtk.main()
def start(self):
self._manager = Manager()
settings.load()
downloads_file.load()
self._main_window = MainWindow(self._manager)
self._main_window.start()
downloads_file.save()
settings.save()
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_())
def main():
'''Main loop which initialises embedder application'''
app = QtGui.QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec_())
def bootstrap():
'''Launches the GUI'''
global main_window
if (main_window != None):
return
from gui.main_window import MainWindow
main_window = MainWindow()
main_window.mainloop()
def __init__(self):
self.root = tk.Tk()
self.size = tk.StringVar()
self.num_mines = tk.StringVar()
self.size.set(6)
self.num_mines.set(3)
self.model = Game(int(self.size.get()), int(self.num_mines.get()))
self.view = MainWindow(self.root, self.model, self.reveal_field, self.reset_game, self.size, self.num_mines)
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 __init__(self, parent=None):
super().__init__(parent)
self.stacked_widget = QtWidgets.QStackedWidget()
self.setCentralWidget(self.stacked_widget)
self.m_pages = {}
ten_o_pitches_window = TenOPitchesWindow()
self.register(ten_o_pitches_window.instruction_window,
"ten_o_pitches_instruction_page")
self.register(ten_o_pitches_window.main_window, "ten_o_pitches_page")
self.register(ten_o_pitches_window.generator_window,
"ten_o_pitches_generator_page")
self.register(ten_o_pitches_window.setting_window,
"ten_o_pitches_settings_page")
intervals_window = IntervalsWindow()
self.register(intervals_window.instruction_window,
"intervals_instruction_page")
self.register(intervals_window.main_window, "intervals_page")
self.register(intervals_window.generator_window,
"intervals_generator_page")
self.register(intervals_window.setting_window,
"intervals_settings_page")
voices_window = VoicesWindow()
self.register(voices_window.instruction_window,
"voices_instruction_page")
self.register(voices_window.main_window, "voices_page")
self.register(voices_window.generator_window, "voices_generator_page")
self.register(voices_window.setting_window, "voices_settings_page")
microtones_window = MicrotonesWindow()
self.register(microtones_window.instruction_window,
"microtones_instruction_page")
self.register(microtones_window.main_window, "microtones_page")
self.register(microtones_window.generator_window,
"microtones_generator_page")
self.register(microtones_window.setting_window,
"microtones_settings_page")
detuning_window = DetuningWindow()
self.register(detuning_window.instruction_window,
"detuning_instruction_page")
self.register(detuning_window.main_window, "detuning_page")
self.register(detuning_window.generator_window,
"detuning_generator_page")
self.register(detuning_window.setting_window, "detuning_settings_page")
self.register(MainWindow(voices_window=voices_window), "main_page")
self.goto("main_page")
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_())
def main(args, data_logger):
devices = []
try:
if args.devices is not None:
devices = files.read_device_list(args.devices)
except FileNotFoundError:
LOGGER.error(f'No such file: {args.devices}')
except ValueError:
LOGGER.error(f'Failed to parse device list')
win = MainWindow(devices, data_logger)
win.connect('destroy', Gtk.main_quit)
if args.profile is not None:
win.set_profile(args.profile, None)
win.show_all()
Gtk.main()
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent=parent)
self.ui = MainWindow()
self.ui.setup_ui(self)
# self.ui.mdiArea.subWindowActivated.connect(self.updateMenus)
self.ui.windowMapper.mapped[QWidget].connect(self.setActiveSubWindow)
self.ui.choice_interface.triggered.connect(self.newFile)
self.ui.exit_action.triggered.connect(qApp.quit)
self.threadpool = QThreadPool()
self.ui.open_act.triggered.connect(self.open)
self.ui.save_act.triggered.connect(self.save)
self.ui.save_as_act.triggered.connect(self.saveAs)
# self.ui.new_act.triggered.connect()
self.ui.cut_act.triggered.connect(self.cut)
self.ui.copy_act.triggered.connect(self.copy)
self.ui.paste_act.triggered.connect(self.paste)
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 __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()
def start(self):
settings.load_configuration()
settings.set_window_manager(self.window_manager)
self.window_manager.start()
self.audio_manager.start()
app = QApplication(sys.argv)
main_window = MainWindow()
if not QSystemTrayIcon.isSystemTrayAvailable():
QMessageBox.critical(None, self.APP_NAME,
"I couldn't detect any system tray on this system.")
sys.exit(1)
app.setQuitOnLastWindowClosed(False)
window = TrayWindow(main_window)
sys.exit(app.exec_())
def __init__(self, fslapp):
self.fslapp = fslapp
self.app = QApplication([])
self.main_window = MainWindow(self)
#!/usr/bin/env python3 import wx from gui.main_window import MainWindow app = wx.App() main_frame = MainWindow(None) main_frame.Show() app.MainLoop()
def __init__(self):
self._app = QApplication(sys.argv)
self._w = MainWindow()
self._w.setWindowIcon(QtGui.QIcon(resource_path("icons/icon.ico")))
import sys
from PyQt5.QtWidgets import QApplication
from gui.main_window import MainWindow
if __name__ == '__main__':
""" Inicializa a aplicação, criando a janela principal. """
app = QApplication(sys.argv)
w = MainWindow()
sys.exit(app.exec_())
from gui.main_window import MainWindow
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
import logging
logging.basicConfig(level=logging.DEBUG)
win = MainWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
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 main():
app = QtWidgets.QApplication(sys.argv)
window = MainWindow()
window.show()
app.exec()
def main():
app = QtGui.QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())
def main():
app = QApplication(sys.argv)
ex = MainWindow()
ex.show()
sys.exit(app.exec_())
#!/usr/bin/env python3 import sys from PySide2.QtWidgets import * from gui.main_window import MainWindow app = QApplication(sys.argv) main_window = MainWindow() sys.exit(app.exec_())
from form_alignment import align_form
from number_recognizer import CodeRecognizer
from gui.main_window import MainWindow
def main():
root = tk.Tk()
filename = filedialog.askopenfilename(initialdir = ".",title = "Select file",filetypes = (("jpeg files","*.jpg"),("all files","*.*")))
root.destroy()
print (filename)
image_np = cv2.imread(filename)
image_np = align_form(image_np)
code_recognizer = CodeRecognizer()
code = code_recognizer.recognize_code(image_np)
print(code)
target_X = 500
imgScale = target_X / image_np.shape[1]
newX,newY = image_np.shape[1]*imgScale, image_np.shape[0]*imgScale
image_np = cv2.resize(image_np,(int(newX),int(newY)))
cv2.imshow('image', image_np)
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.imwrite("result.jpg", image_np)
if __name__ == "__main__":
#main()
root = tk.Tk()
app = MainWindow(master=root)
app.mainloop()
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_())
