def main():
UNIQUE_MUTEX_NAME = 'Global\\UmnIsAlreadyRunning'
handle = win32event.CreateMutex(None, pywintypes.FALSE, UNIQUE_MUTEX_NAME)
if not handle or win32api.GetLastError() == winerror.ERROR_ALREADY_EXISTS:
print('既に別のプロセスが実行中です。')
win32api.MessageBox(0, u"既に常駐しています", u"uumail notification - エラー",
win32con.MB_OK | win32con.MB_ICONERROR)
sys.exit(-1)
app = QtWidgets.QApplication([])
systray = umn_systray.umn_systray()
try:
passcrypt.read_data()
except:
QtWidgets.QMessageBox.warning(None, \
"uumail notification - エラー", \
"アカウント情報を読み込めません。\nアカウント情報を設定してください", \
QtWidgets.QMessageBox.Ok)
systray.show_setting()
reg_notify = notification_daemon.Regularly_notify(systray)
reg_notify.start()
app.exec()
def main():
args = _parsed_args()
media_linker_name = otio_console.console_utils.media_linker_name(
args.media_linker)
try:
read_adapter_arg_map = otio_console.console_utils.arg_list_to_map(
args.adapter_arg, "adapter")
media_linker_argument_map = otio_console.console_utils.arg_list_to_map(
args.media_linker_arg, "media linker")
hook_function_argument_map = otio_console.console_utils.arg_list_to_map(
args.hook_function_arg, "hook function")
except ValueError as exc:
sys.stderr.write("\n" + str(exc) + "\n")
sys.exit(1)
application = QtWidgets.QApplication(sys.argv)
window = Main(read_adapter_arg_map, hook_function_argument_map,
media_linker_name, media_linker_argument_map)
if args.input is not None:
window.load(args.input)
window.center()
window.show()
window.raise_()
application.exec_()
def run(args):
locale.setlocale(locale.LC_ALL, "") # use system's default locale
QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling,
True)
data_dir = args.custom_network_storage
if data_dir is None:
from randovania.interface_common import persistence
data_dir = persistence.local_data_dir()
is_preview = args.preview
start_logger(data_dir, is_preview)
app = QtWidgets.QApplication(sys.argv)
def main_done(done: asyncio.Task):
e: typing.Optional[Exception] = done.exception()
if e is not None:
display_exception(e)
app.exit(1)
loop = create_loop(app)
with loop:
loop.create_task(qt_main(app, data_dir,
args)).add_done_callback(main_done)
loop.run_forever()
def do_gui():
dimensions = parse_dimensions()
app = QtWidgets.QApplication([])
widget = menu.MenuWidget()
with open(settings.GUI_STYLESHEET_FILE, "r") as f:
_style = formats.format_stylesheet(f.read())
app.setStyleSheet(_style)
logger.debug(f'Initializing GUI with style sheet: {_style}')
if not dimensions['full_screen']:
widget.resize(dimensions['width'], dimensions['height'])
center = QtGui.QScreen.availableGeometry(
QtWidgets.QApplication.primaryScreen()).center()
geo = widget.frameGeometry()
geo.moveCenter(center)
widget.move(geo.topLeft())
widget.show()
else:
widget.showFullScreen()
sys.exit(app.exec_())
def start_main_window():
app = QtWidgets.QApplication(sys.argv)
# signin_dialog = signin_window.SignInDialog()
# #
# if signin_dialog.exec_() != 1:
# return
#-----------------------------------------
from app._lib.server import api
from app.models.user.user import User
server = api.Api(TITOD_HOST, TITOD_PORT)
server.get_credentials('AndrIi', '123')
user = User.init_user(server)
user.set_current_project()
#
# # user.update_user_data()
# create_users(server)
w = MainAppWindow(user)
#-----------------------------------------
# w = MainAppWindow(signin_dialog.user)
w.show()
sys.exit(app.exec_())
def main():
add = "rtsp://*****:*****@192.168.1.12:8080/h264_ulaw.sdp"
app = QtWidgets.QApplication(["Vision Alarm"])
dashboard = Dashboard(add)
dashboard.show()
app.exec_()
def start():
qt = QtWidgets.QApplication()
app = App(Tello())
app.setMinimumWidth(300)
app.show()
Thread(target=app.connect_tello).start()
qt.exec_()
def run_main_window(sleep_time):
"""Runs the main window, kills everything that is in the main window when closed"""
app = QtWidgets.QApplication(sys.argv)
window = MainWindow(sleep_time)
window.show()
sys.exit(app.exec())
def main() -> None:
"""Creates and launches the app."""
app = QtWidgets.QApplication(sys.argv)
my_main_window = MyMainWindow.create_my_main_window()
apply_stylesheet(app, theme="dark_cyan.xml")
my_main_window.setWindowState(QtCore.Qt.WindowMaximized)
my_main_window.show()
sys.exit(app.exec_())
def main():
app = QtWidgets.QApplication(sys.argv)
app.setStyle(QtWidgets.QStyleFactory.create('Cleanlooks'))
app.setWindowIcon(
QtGui.QIcon(resource_filename(__name__, 'data/icons/weechat.png')))
main_win = MainWindow()
main_win.show()
sys.exit(app.exec_())
def main():
'''Codes for running GUI'''
# todo search
app = QtWidgets.QApplication([])
widget = PokeDex()
widget.show()
sys.exit(app.exec_())
def main():
# check if the user is running the program in batch mode
batchmode = '-no-gui' in sys.argv
# run PyAero in batch mode
if batchmode:
app = QtCore.QCoreApplication(sys.argv)
# FIXME
# FIXME check for proper batch control file
# FIXME
if sys.argv[-1] == '-no-gui':
print('No batch control file specified.')
sys.exit()
# prepare logger
Logger.log('file_only')
batch_controlfile = sys.argv[-1]
batchmode = BatchMode.Batch(app, batch_controlfile, __version__)
batchmode.run_batch()
return
# main application (contains the main event loop)
# run PyAero in GUI mode
app = QtWidgets.QApplication(sys.argv)
# set icon for the application ( upper left window icon and taskbar icon)
# and add specialization icons per size
# (needed depending on the operating system)
app_icon = QtGui.QIcon(os.path.join(ICONS, 'app_image.png'))
app_icon.addFile(os.path.join(ICONS, 'app_image_16x16.png'),
QtCore.QSize(16, 16))
app_icon.addFile(os.path.join(ICONS, 'app_image_24x24.png'),
QtCore.QSize(24, 24))
app_icon.addFile(os.path.join(ICONS, 'app_image_32x32.png'),
QtCore.QSize(32, 32))
app_icon.addFile(os.path.join(ICONS, 'app_image_48x48.png'),
QtCore.QSize(48, 48))
app_icon.addFile(os.path.join(ICONS, 'app_image_256x256.png'),
QtCore.QSize(256, 256))
app.setWindowIcon(app_icon)
if LOCALE == 'C':
# set default locale to C, so that decimal separator is a
# dot in spin boxes, etc.
QtCore.QLocale.setDefault(QtCore.QLocale.c())
# window style set in Settings.py
window = MainWindow(app, STYLE)
window.show()
sys.exit(app.exec())
def main():
app = QtWidgets.QApplication(["Vision-Alarm-System"])
pardic = {
"cams": ["rtsp://*****:*****@192.168.1.12:8080/h264_ulaw.sdp"],
"live_affinity": -1,
"dec affinity start": -1,
"dec affinity stop": -1
}
mg = MyGui(pardic)
mg.show()
app.exec_()
def run_calibration(filepath: str = None):
if access.application is None:
_app = QtWidgets.QApplication.instance()
if _app is None:
_app = QtWidgets.QApplication([])
access.application = _app
if access.window is None:
access.window = CalibrationWindow(filepath)
access.window.setup_ui()
access.application.exec()
def __init__(self, **kwargs):
vxprocess.AbstractProcess.__init__(self, **kwargs)
# Create application
self.app = QtWidgets.QApplication.instance()
if self.app is None:
self.app = QtWidgets.QApplication(sys.argv)
self.window = Window()
self.window.show()
# Run event loop
self.run(interval=1 / 30)
def main():
# Check whether there is already a running QApplication (e.g., if running
# from an IDE).
qapp = QtWidgets.QApplication.instance()
if not qapp:
qapp = QtWidgets.QApplication(sys.argv)
app = ApplicationWindow()
app.show()
app.activateWindow()
app.raise_()
qapp.exec_()
def copy_to_clipboard():
"""Initialize a wrapper around qt clipboard.
Necesessary to avoid some wired results on Wayland, where text sometimes get
copied, and sometimes not.
"""
from PySide6 import QtWidgets # pylint: disable=all
app = QtWidgets.QApplication.instance() or QtWidgets.QApplication()
def copy_qt(text):
logger.debug("Copy to clipboard:\n%s", text)
cb = app.clipboard()
cb.setText(text)
return copy_qt
def setup_app():
QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_DisableHighDpiScaling)
app = QtWidgets.QApplication(sys.argv)
pixmap = QtGui.QPixmap(os.path.join(QGRAIN_ROOT_PATH, "assets",
"icon.png"))
create_necessary_folders()
app.setWindowIcon(QtGui.QIcon(pixmap))
app.setApplicationVersion(QGRAIN_VERSION)
from qt_material import apply_stylesheet
apply_stylesheet(app,
theme=os.path.join(QGRAIN_ROOT_PATH, "assets",
"default_theme.xml"),
invert_secondary=True,
extra=EXTRA)
setup_matplotlib()
setup_language(app, "en")
return app
def __init__(self, style="fusion"):
"""
Info:
Class Constructor
Args:
Style: String
-> name of the application style to use
Returns: None
Errors: None
"""
self.app = QtWidgets.QApplication(sys.argv)
self.app.setStyle(style)
self.UI = ApolloMain()
self.UI.Theme.LoadTheme(app=self.app)
self.UI.show()
def start_viewer(pull_data_work:typing.Callable[[QtCore.Signal], None]):
# Check whether there is already a running QApplication (e.g., if running
# from an IDE).
qapp = QtWidgets.QApplication.instance()
if not qapp:
qapp = QtWidgets.QApplication(sys.argv)
app = ApplicationWindow()
#canvas=app.canvas
app.show()
app.activateWindow()
app.start_handle_data_flow(pull_data_work)
app.raise_()
qapp.exec_()
def run():
case_dtos = MongoDaoFactory().get_dao(MongoFoamCaseDAO).get_all()
cases = list(map(Mapper.map_foam_case_dto, case_dtos))
app = QtW.QApplication(sys.argv)
window = QtW.QMainWindow()
m_widget = MainWidget([case.name for case in cases], **handlers)
SharedState.m_widget = m_widget
SharedState.case_list = cases
layout = QtW.QGridLayout()
central_widget = QtW.QWidget()
central_widget.setLayout(layout)
layout.addWidget(m_widget)
window.setCentralWidget(central_widget)
window.setWindowTitle(WINDOW_TITLE)
window.setGeometry(WINDOW_X, WINDOW_Y, WINDOW_W, WINDOW_H)
window.show()
sys.exit(app.exec_())
def main():
"""Start main application logic."""
logger = logging.getLogger("normcap")
sys.excepthook = utils.hook_exceptions
# Allow closing QT app with CTRL+C in terminal
signal.signal(signal.SIGINT, signal.SIG_DFL)
args = create_argparser().parse_args()
logger.setLevel(args.verbosity.upper())
logger.info("Start NormCap v%s", __version__)
if system_info.display_manager_is_wayland():
# QT has 32 as default cursor size on wayland, while it should be 24
if "XCURSOR_SIZE" not in os.environ:
logger.debug("Set XCURSOR_SIZE=24")
os.environ["XCURSOR_SIZE"] = "24"
# Select wayland extension for better rendering
if "QT_QPA_PLATFORM" not in os.environ:
logger.debug("Set QT_QPA_PLATFORM=wayland")
os.environ["QT_QPA_PLATFORM"] = "wayland"
# Wrap QT logging output
QtCore.qInstallMessageHandler(utils.qt_log_wrapper)
if system_info.is_briefcase_package():
utils.copy_tessdata_files_to_config_dir()
app = QtWidgets.QApplication(sys.argv)
app.setQuitOnLastWindowClosed(False)
logger.debug("System info:\n%s", system_info.to_dict())
tray = SystemTray(app, vars(args))
tray.setVisible(True)
sys.exit(app.exec_())
def create_qapp(app_name: str = "VeighNa Trader") -> QtWidgets.QApplication:
"""
Create Qt Application.
"""
# Set up dark stylesheet
qapp: QtWidgets.QApplication = QtWidgets.QApplication(sys.argv)
qapp.setStyleSheet(qdarkstyle.load_stylesheet(qt_api="pyside6"))
# Set up font
font: QtGui.QFont = QtGui.QFont(SETTINGS["font.family"],
SETTINGS["font.size"])
qapp.setFont(font)
# Set up icon
icon: QtGui.QIcon = QtGui.QIcon(get_icon_path(__file__, "vnpy.ico"))
qapp.setWindowIcon(icon)
# Set up windows process ID
if "Windows" in platform.uname():
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_name)
# Hide help button for all dialogs
# qapp.setAttribute(QtCore.Qt.AA_DisableWindowContextHelpButton)
# Exception Handling
exception_widget: ExceptionWidget = ExceptionWidget()
def excepthook(exctype: type, value: Exception,
tb: types.TracebackType) -> None:
"""Show exception detail with QMessageBox."""
sys.__excepthook__(exctype, value, tb)
msg: str = "".join(traceback.format_exception(exctype, value, tb))
exception_widget.signal.emit(msg)
sys.excepthook = excepthook
return qapp
def run():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument(
"-m",
dest="module",
default="pynodegl_utils.examples",
help="set the module name containing the scene functions",
)
parser.add_argument(
"--hooks-script",
dest="hooks_scripts",
default=[op.join(op.dirname(__file__), "hooks", "desktop.py")],
action="append",
help="set the script containing event hooks",
)
pargs = parser.parse_args(sys.argv[1:])
app = QtWidgets.QApplication(sys.argv)
window = MainWindow(pargs.module, pargs.hooks_scripts)
window.show()
app.exec_()
def main():
"""Creates game instance; runs main loop if connection found"
Run main.py -h for info on arguments
"""
parser = ArgParser()
args = parser.parse_args()
main_game = Clueless(args.verbose)
host_found = main_game.test_connection()
if host_found:
app = QtWidgets.QApplication(sys.argv)
gui = MainWindow(main_game)
gui.window_title = 'Clue-less'
gui.geometry = QtCore.QRect(0, 0, app.primary_screen.size.width(),
app.primary_screen.size.height())
if gui.show():
gui.show_suspect_select_menu()
app.exec_()
gui.socket.end_connection()
print('Exiting...')
class MyWidget(QtWidgets.QWidget):
def __init__(self):
super().__init__()
self.hello = ["Hallo Welt", "Hei maailma", "Hola Mundo", "Привет мир"]
self.button = QtWidgets.QPushButton("Click me!")
self.text = QtWidgets.QLabel("Hello World",
alignment=QtCore.Qt.AlignCenter)
self.layout = QtWidgets.QVBoxLayout()
self.layout.addWidget(self.text)
self.layout.addWidget(self.button)
self.setLayout(self.layout)
self.button.clicked.connect(self.magic)
@QtCore.Slot()
def magic(self):
self.text.setText(random.choice(self.hello))
if __name__ == "__main__":
app = QtWidgets.QApplication([])
widget = MyWidget()
widget.resize(800, 600)
widget.show()
sys.exit(app.exec_())
def __init__(self, _configuration_path):
# Set up manager
ipc.Manager = mp.Manager()
# Set up logging
logger.setup_log_queue(ipc.Manager.Queue())
logger.setup_log_history(ipc.Manager.list())
logger.setup_log_to_file(f'{time.strftime("%Y-%m-%d-%H-%M-%S")}.log')
# Manually set up pipe for controller
ipc.Pipes[self.name] = mp.Pipe()
# Set up modules proxies (TODO: get rid of IPC.State)
_proxies = {
PROCESS_CONTROLLER: process.ProcessProxy(PROCESS_CONTROLLER),
PROCESS_CAMERA: process.ProcessProxy(PROCESS_CAMERA),
PROCESS_DISPLAY: process.ProcessProxy(PROCESS_DISPLAY),
PROCESS_GUI: process.ProcessProxy(PROCESS_GUI),
PROCESS_IO: process.ProcessProxy(PROCESS_IO),
}
# Set up STATES
ipc.State.Controller = ipc.Manager.Value(ctypes.c_int8, definitions.State.NA)
ipc.State.Camera = ipc.Manager.Value(ctypes.c_int8, definitions.State.NA)
ipc.State.Display = ipc.Manager.Value(ctypes.c_int8, definitions.State.NA)
ipc.State.Gui = ipc.Manager.Value(ctypes.c_int8, definitions.State.NA)
ipc.State.Io = ipc.Manager.Value(ctypes.c_int8, definitions.State.NA)
ipc.State.Worker = ipc.Manager.Value(ctypes.c_int8, definitions.State.NA)
# Initialize process
process.AbstractProcess.__init__(self, _program_start_time=time.time(), _configuration_path=_configuration_path)
# Generate and show splash screen
# TODO: Splashscreen blocks display of GUI under linux
if sys.platform == 'win32':
self.qt_app = QtWidgets.QApplication([])
pngpath = os.path.join(str(vxpy.__path__[0]), 'vxpy_icon.png')
# Optionally re-render splash
# self._render_splashscreen(pngpath)
self.splashscreen = QtWidgets.QSplashScreen(f=QtCore.Qt.WindowStaysOnTopHint,
screen=self.qt_app.screens()[config.CONF_GUI_SCREEN])
self.splashscreen.setPixmap(QtGui.QPixmap(pngpath))
self.splashscreen.show()
# Process events once
self.qt_app.processEvents()
# Set up processes
_routines_to_load = dict()
# Camera
if config.CONF_CAMERA_USE:
self._register_process(modules.Camera)
_routines_to_load[PROCESS_CAMERA] = config.CONF_CAMERA_ROUTINES
# Display
if config.CONF_DISPLAY_USE:
self._register_process(modules.Display)
_routines_to_load[PROCESS_DISPLAY] = config.CONF_DISPLAY_ROUTINES
# GUI
if config.CONF_GUI_USE:
self._register_process(modules.Gui)
# IO
if config.CONF_IO_USE:
self._register_process(modules.Io)
_routines_to_load[PROCESS_IO] = config.CONF_IO_ROUTINES
# Worker
if config.CONF_WORKER_USE:
self._register_process(modules.Worker)
_routines_to_load[PROCESS_WORKER] = config.CONF_WORKER_ROUTINES
# Select subset of registered processes which should implement
# the _run_protocol method
_active_process_list = [p[0].__name__ for p in self._registered_processes]
self._active_protocols = list(set(_active_process_list) & set(self._protocolized))
log.info(f'Protocolized processes: {self._active_protocols}')
# TODO: check if recording routines contains any entries
# for inactive processes or inactive routines on active processes
# print warning or just shut down completely in-case?
################################
# Set up CONTROLS
# General
ipc.Control.General = ipc.Manager.dict()
# Set avg. minimum sleep period
times = list()
for i in range(100):
t = time.perf_counter()
time.sleep(10 ** -10)
times.append(time.perf_counter() - t)
ipc.Control.General.update({definitions.GenCtrl.min_sleep_time: max(times)})
log.info(f'Minimum sleep period is {(1000 * max(times)):.3f}ms')
# Check time precision on system
dt = list()
t0 = time.time()
while len(dt) < 100:
t1 = time.time()
if t1 > t0:
dt.append(t1 - t0)
avg_dt = sum(dt) / len(dt)
msg = f'Timing precision on system {1000 * avg_dt:3f}ms'
if avg_dt > 0.001:
log.warning(msg)
else:
log.info(msg)
# Recording
ipc.Control.Recording = ipc.Manager.dict()
ipc.Control.Recording.update({
definitions.RecCtrl.enabled: True,
definitions.RecCtrl.active: False,
definitions.RecCtrl.folder: ''})
# Protocol
ipc.Control.Protocol = ipc.Manager.dict({definitions.ProtocolCtrl.name: None,
definitions.ProtocolCtrl.phase_id: None,
definitions.ProtocolCtrl.phase_start: None,
definitions.ProtocolCtrl.phase_stop: None})
# Load routine modules
self._routines = dict()
for process_name, routine_list in _routines_to_load.items():
self._routines[process_name] = dict()
for path in routine_list:
log.info(f'Load routine {path}')
# TODO: search different paths for package structure redo
# Load routine
parts = path.split('.')
module = importlib.import_module('.'.join(parts[:-1]))
routine_cls = getattr(module, parts[-1])
if routine_cls is None:
log.error(f'Routine "{path}" not found.')
continue
# Instantiate
self._routines[process_name][routine_cls.__name__]: routine.Routine = routine_cls()
# Set configured cameras
if config.CONF_CAMERA_USE:
for device_id in config.CONF_CAMERA_DEVICES:
register_camera_device(device_id)
# Set configured io devices
if config.CONF_IO_USE:
for device_id in config.CONF_IO_DEVICES:
register_io_device(device_id)
# Compare required vs registered devices
assert_device_requirements()
# Set up routines
for rs in self._routines.values():
for r in rs.values():
r.setup()
self._init_params = dict(
_program_start_time=self.program_start_time,
_configuration_path=_configuration_path,
_pipes=ipc.Pipes,
_states={k: v for k, v
in ipc.State.__dict__.items()
if not (k.startswith('_'))},
_proxies=_proxies,
_routines=self._routines,
_controls={k: v for k, v
in ipc.Control.__dict__.items()
if not (k.startswith('_'))},
_log_queue=logger._log_queue,
_log_history=logger.get_history(),
_attrs=Attribute.all
)
# Initialize all processes
for target, kwargs in self._registered_processes:
self.initialize_process(target, **kwargs)
# Set up initial recording states
self.manual_recording = False
self.set_compression_method(None)
self.set_compression_opts(None)
self.record_group_counter = 0
class MyWidget(QtWidgets.QWidget):
def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self, parent)
quit = QtWidgets.QPushButton("Quit")
quit.setFont(QtGui.QFont("Times", 18, QtGui.QFont.Bold))
lcd = QtWidgets.QLCDNumber(2)
slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
slider.setRange(0, 99)
slider.setValue(0)
self.connect(quit, QtCore.SIGNAL("clicked()"), qApp,
QtCore.SLOT("quit()"))
self.connect(slider, QtCore.SIGNAL("valueChanged(int)"), lcd,
QtCore.SLOT("display(int)"))
layout = QtWidgets.QVBoxLayout()
layout.addWidget(quit)
layout.addWidget(lcd)
layout.addWidget(slider)
self.setLayout(layout)
app = QtWidgets.QApplication(sys.argv)
widget = MyWidget()
widget.show()
sys.exit(app.exec_())
def run():
app = QtWidgets.QApplication([])
ex = Example()
app.exec_()
def main():
app = QtWidgets.QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
