async def show_main_window(app: QtWidgets.QApplication, options, is_preview: bool):
from randovania.interface_common.preset_manager import PresetManager
from randovania.interface_common.options import Options
options = typing.cast(Options, options)
preset_manager = PresetManager(options.presets_path)
logger.info("Loading user presets...")
await preset_manager.load_user_presets()
logger.info("Finished loading presets!")
from randovania.gui.lib.qt_network_client import QtNetworkClient
network_client: QtNetworkClient = app.network_client
async def attempt_login():
from randovania.network_client.network_client import UnableToConnect
from randovania.gui.lib import async_dialog
try:
from randovania.gui import main_online_interaction
if not await main_online_interaction.ensure_logged_in(None, network_client):
await async_dialog.warning(None, "Login required",
"Logging in is required to use dev builds.")
return False
except UnableToConnect as e:
s = e.reason.replace('\n', '<br />')
await async_dialog.warning(
None, "Connection Error",
f"<b>Unable to connect to the server:</b><br /><br />{s}<br /><br />"
f"Logging in is required to use dev builds.")
return False
return True
if randovania.is_frozen() and randovania.is_dev_version():
try:
logger.info("Disabling quit on last window closed")
app.setQuitOnLastWindowClosed(False)
if not await attempt_login():
app.quit()
return
finally:
def reset_last_window_quit():
logger.info("Re-enabling quit on last window closed")
app.setQuitOnLastWindowClosed(True)
QtCore.QTimer.singleShot(1000, reset_last_window_quit)
from randovania.gui.main_window import MainWindow
logger.info("Preparing main window...")
main_window = MainWindow(options, preset_manager, network_client, is_preview)
app.main_window = main_window
logger.info("Displaying main window")
main_window.show()
await main_window.request_new_data()
async def qt_main(app: QtWidgets.QApplication, data_dir: Path, args):
app.setQuitOnLastWindowClosed(False)
app.network_client = None
logging.info("Loading server client...")
from randovania.gui.lib.qt_network_client import QtNetworkClient
logging.info("Configuring server client...")
app.network_client = QtNetworkClient(data_dir)
logging.info("Server client ready.")
if args.login_as_guest:
logging.info("Logging as %s", args.login_as_guest)
await app.network_client.login_as_guest(args.login_as_guest)
options = await _load_options()
if options is None:
app.exit(1)
return
executor = create_memory_executor(args.debug_game_backend, options)
logging.info("Configuring game connection with the backend...")
from randovania.game_connection.game_connection import GameConnection
app.game_connection = GameConnection(executor)
logging.info("Configuring qasync...")
import qasync
@qasync.asyncClose
async def _on_last_window_closed():
if app.quitOnLastWindowClosed():
await app.network_client.disconnect_from_server()
await app.game_connection.stop()
logger.info("Last QT window closed")
else:
logger.warning(
"Last Qt window closed, but currently not doing anything")
app.setQuitOnLastWindowClosed(True)
app.lastWindowClosed.connect(_on_last_window_closed,
QtCore.Qt.QueuedConnection)
await asyncio.gather(app.game_connection.start(),
display_window_for(app, options, args.command, args))
def toggle(self):
if self.tabs.currentWidget().objectName() == 'udp':
self.udpFrame.toggle()
elif self.tabs.currentWidget().objectName() == 'webSocket':
self.webFrame.toggle()
def eventFilter(self, obj, event):
if event.type() == QtCore.QEvent.KeyPress:
if event.key() == QtCore.Qt.Key_R:
self.loop.create_task(self.messenger.connectSocket())
return super(MainWindow, self).eventFilter(obj, event)
def exitHandler(self):
self.webFrame.messenger.terminate()
if __name__ == '__main__':
import logging
app = QApplication()
app.setQuitOnLastWindowClosed(True)
window = MainWindow()
app.aboutToQuit.connect(window.exitHandler)
if SECOND_DISPLAY:
display = app.screens()[1]
window.setScreen(display)
window.move(display.geometry().x() + 200, display.geometry().y() + 200)
window.show()
sys.exit(app.exec_())
import sys
from PySide6.QtWidgets import QApplication, QMessageBox, QSystemTrayIcon
from window import Window
from libmanager import APP_NAME
if __name__ == "__main__":
app = QApplication()
if not QSystemTrayIcon.isSystemTrayAvailable():
QMessageBox.critical(None, APP_NAME, "Cannot detect any system tray on system")
sys.exit(1)
QApplication.setQuitOnLastWindowClosed(False)
window = Window()
window.show()
sys.exit(app.exec_())
if sys.platform == "win32":
try:
myappid = 'mercuryseven.ssd.zextrasdrivedesktop.1.0'
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
myappid)
except Exception as e:
print(e)
# Bisogna fare questo per poter usare QSettings
QCoreApplication.setOrganizationName("MercurySeven")
QCoreApplication.setApplicationName("SSD")
# start main application
app = QApplication(sys.argv)
# utile per avere l'icona di notifica
app.setQuitOnLastWindowClosed(False)
# initialize logging format
_format = "%(asctime)s:%(levelname)s:%(filename)s:%(name)s:%(message)s"
logging.basicConfig(level=logging.INFO, format=_format)
# rimuove i log spammosi di rete
logging.getLogger("gql.transport.aiohttp").setLevel(logging.WARNING)
logging.getLogger("gql.transport.requests").setLevel(logging.WARNING)
env_settings = QSettings()
# env_settings.setValue("sync_path", None)
# env_settings.setValue("Credentials/user", None)
# env_settings.setValue("Credentials/password", None)
# Controlliamo se l'utente ha già settato il PATH della cartella
check_path = env_settings.value("sync_path")
