def main(): app = QApplication(sys.argv) window = MainWindow() window.show() app.exec_()
def main(): app = QApplication([]) QtWebEngine.initialize() engine = QQmlApplicationEngine() qml_file_path = os.path.join(os.path.dirname(__file__), 'browser.qml') qml_url = QUrl.fromLocalFile(os.path.abspath(qml_file_path)) engine.load(qml_url) app.exec_()
def testIt(self): app = QApplication([]) self.box = MySpinBox() self.box.show() QTimer.singleShot(0, self.sendKbdEvent) QTimer.singleShot(100, app.quit) app.exec_() self.assertEqual(self.box.text(), '0')
def main(): global dbus parser = ArgumentParser() parser.add_argument("-v", "--verbose", help="increase output verbosity", action="store_true") args = parser.parse_args() QtQml.qmlRegisterType(QmlPage, "djpdf", 1, 0, "DjpdfPage") app = QApplication([]) engine = QQmlApplicationEngine() thumbnail_image_provider = ThumbnailImageProvider() engine.addImageProvider("thumbnails", thumbnail_image_provider) ctx = engine.rootContext() pages_model = QmlPagesModel(verbose=args.verbose) if os.environ.get("DJPDF_PLATFORM_INTEGRATION", "") == "flatpak": import dbus import dbus.mainloop.glib dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) bus = dbus.SessionBus() platform_integration = QmlFlatpakPlatformIntegration(bus) else: platform_integration = QmlPlatformIntegration() ctx.setContextProperty("pagesModel", pages_model) ctx.setContextProperty("platformIntegration", platform_integration) engine.load(QUrl.fromLocalFile( os.path.join(QML_DIR, "main.qml"))) if os.environ.get("DJPDF_PLATFORM_INTEGRATION", "") == "flatpak": platform_integration.win_id = engine.rootObjects()[0].winId() exit(app.exec_())
def run_main(): import sys from PySide2.QtWidgets import QApplication app = QApplication(sys.argv) mw = AddressWidget() mw.show() sys.exit(app.exec_())
def main(): # load options from cmdline parser = create_parser() args = parser.parse_args() # set debug levels LEVELS = { 'notset': logging.NOTSET, 'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR, 'critical': logging.CRITICAL, } level_name = 'info' if args.debug: level_name = args.debug level = LEVELS.get(level_name, logging.INFO) # now get the logger used in the common module and set its level to what # we get from sys.argv commonlogger.setLevel(level) logger.setLevel(level) formatter = logging.Formatter('[%(levelname)s] %(name)s %(message)s') handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(formatter) handler.setLevel(logging.DEBUG) logger.addHandler(handler) commonlogger.addHandler(handler) app = QApplication(sys.argv) frame = MainWindow() # args is defined at the top of this module if not args.hidden: # Need to fix showing wrong window frame.show() sys.exit(app.exec_())
def main(): app = QApplication(sys.argv) root = coin.SoSeparator() vert = coin.SoVertexShader() vert.sourceProgram = "vertex.glsl" frag = coin.SoFragmentShader() frag.sourceProgram = "frag.glsl" shaders = [vert,frag] pro = coin.SoShaderProgram() pro.shaderObject.setValues(0,len(shaders),shaders) mat = coin.SoMaterial() mat.diffuseColor.setValue(coin.SbColor(0.8, 0.8, 0.8)) mat.specularColor.setValue(coin.SbColor(1, 1, 1)) mat.shininess.setValue(1.0) mat.transparency.setValue(0.5) sphere = coin.SoSphere() sphere.radius = 1.2 root.addChild(pro) root.addChild(sphere) root.addChild(mat) root.addChild(coin.SoCube()) viewer = quarter.QuarterWidget() viewer.setSceneGraph(root) viewer.setWindowTitle("minimal") viewer.show() sys.exit(app.exec_())
class TilePad(object): Instance = None @staticmethod def Run(): TilePad.Instance = TilePad() return TilePad.Instance.run() def __init__(self): QCoreApplication.setOrganizationName('DynArt') QCoreApplication.setApplicationName('TilePad') QCoreApplication.setApplicationVersion('0.4.0') if getattr(sys, 'frozen', False): self.dir = os.path.dirname(sys.executable) else: self.dir = os.path.dirname(__file__) self.dir = self.dir.replace('\\', '/') self.qApp = QApplication(sys.argv) self.mainWindow = MainWindow(self) def run(self): self.mainWindow.show() return self.qApp.exec_()
def main(): logic = Logic() # Serial to Arduino # serial_reader = SerialReader() serial_reader = SerialReader() while not serial_reader.isOpen: serial_reader.try_open() # TCP Server to rPi tcp_server = TCP_Server() tcp_server.catch_client() QCoreApplication.setAttribute(Qt.AA_ShareOpenGLContexts) app = QApplication([]) window = TseMainWindow() # logika serial_reader.signals.message.connect(window.parse_incoming_message) serial_reader.signals.message.connect(logic.update) # przyciski HOME window.ui.btn_homing.clicked.connect(window.prepare_message_homing) window.ui.btn_homing_ack.clicked.connect( lambda x: serial_reader.write("9")) window.signals.sendSerial.connect(serial_reader.write) # from GUI dx dy to cal logic window.signals.sliderPosOrient.connect(logic.slider_pos_orient) # from logic to update sliders with wanted pos logic.signals.setUserSliderValues.connect(window.update_user_sliders) # apexes from logic to gui update logic.signals.setCurrentPosOrient.connect(window.update_current_posorient) logic.signals.setWantedPosOrient.connect(window.update_wanted_posorient) # task sending window.ui.btn_task.clicked.connect(window.prepare_message_task) # tcp camera message -> gui update tcp_server.signals.message_camera.connect(window.update_camera_target_info) # tcp imu message -> gui update tcp_server.signals.message_imu.connect(window.update_imu_label) # logic to dx dy ... predictions tcp_server.signals.message_camera.connect( logic.get_dposorient_to_follow_target) logic.signals.setFollowedUserSliders.connect( window.update_target_follow_derivatives) # timers interruptions, send task to TSE when enable window.send_task_timer.timeout.connect(window.prepare_message_task) # handle test pos button and set slider to zero button window.ui.btn_autosend.clicked.connect(window.send_task_timer_callback) window.ui.btn_test_pos.clicked.connect(window.set_sliders_to_test) window.ui.btn_zero.clicked.connect(window.set_d_sliders_to_zero) # loop button callback window.ui.btn_loop.clicked.connect(window.loop_button_callback) # log to file button callback window.ui.btn_log_to_file.clicked.connect(window.log_to_file_callback) # stabilize button enabled # window.ui.btn_stabilize.clicked.connect(window.stabilize_callback) #threading Serial and TCP thread = threading.Thread(target=serial_reader.loop, daemon=True) thread.start() thread2 = threading.Thread(target=tcp_server.loop, daemon=True) thread2.start() app.aboutToQuit.connect(lambda: serial_reader.stop()) app.aboutToQuit.connect(lambda: tcp_server.stop()) app.exec_()
def test(): app = QApplication(sys.argv) app.setStyle('Fusion') win = ApplicationWindow() win.showMaximized() sys.exit(app.exec_())
class MyMainWindow(QFrame): def __init__(self, parent=None): QFrame.__init__(self, parent) palette = QPalette() pixmap = QPixmap("sec_shield.png") brush = QBrush(pixmap) frame_layout = QVBoxLayout() self.setFixedSize(300, 300) self.setFrameStyle(QFrame.Box) self.setWindowTitle("QFrame Set Background Image Example") #set QFrame Border Width 4 pixels self.setLineWidth(4) self.setLayout(frame_layout) btn1 = QPushButton(self) btn1.setText("Button 1") frame_layout.addWidget(btn1) palette.setBrush(QPalette.Background, brush) self.setPalette(palette) if __name__ == '__main__': app = QApplication(sys.argv) w = MyMainWindow() w.show() app.exec_()
self.pixmap = QPixmap.fromImage(image) self.pixmapOffset = QPoint() self.lastDragPosition = QPoint() self.pixmapScale = scaleFactor self.update() def zoom(self, zoomFactor): self.curScale *= zoomFactor self.update() self.thread.render(self.centerX, self.centerY, self.curScale, self.size()) def scroll(self, deltaX, deltaY): self.centerX += deltaX * self.curScale self.centerY += deltaY * self.curScale self.update() self.thread.render(self.centerX, self.centerY, self.curScale, self.size()) if __name__ == '__main__': import sys app = QApplication(sys.argv) widget = MandelbrotWidget() widget.show() r = app.exec_() widget.thread.stop() sys.exit(r)
customPlot.xAxis.setTickLabelFont(QFont(QFont().family(), 8)) customPlot.yAxis.setTickLabelFont(QFont(QFont().family(), 8)) # set axis labels: customPlot.xAxis.setLabel("Date") customPlot.yAxis.setLabel("Random wobbly lines value") # make top and right axes visible but without ticks and labels: customPlot.xAxis2.setVisible(True) customPlot.yAxis2.setVisible(True) customPlot.xAxis2.setTicks(False) customPlot.yAxis2.setTicks(False) customPlot.xAxis2.setTickLabels(False) customPlot.yAxis2.setTickLabels(False) # set axis ranges to show all data: customPlot.xAxis.setRange(now, now + 24 * 3600 * 249) customPlot.yAxis.setRange(0, 60) # show legend with slightly transparent background brush: customPlot.legend.setVisible(True) customPlot.legend.setBrush(QColor(255, 255, 255, 150)) customPlot.rescaleAxes() customPlot.show() # Create and show the form # Run the main Qt loop res = app.exec_() customPlot = None sys.exit(res)
class QtFrontend(ViewSBFrontend): """ Qt Frontend that consumes packets for display. """ UI_NAME = 'qt' UI_DESCRIPTION = 'proof-of-concept, unstable GUI in Qt' @staticmethod def reason_to_be_disabled(): # If we weren't able to import pyside2, disable the library. if 'QWidget' not in globals(): return "pyside2 (qt library) not available" return None def __init__(self): """ Sets up the Qt UI. """ QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_ShareOpenGLContexts) self.app = QApplication([]) self.ui_file = QtCore.QFile(os.path.dirname(os.path.realpath(__file__)) + '/qt.ui') self.loader = QUiLoader() self.window: QtWidgets.QMainWindow = self.loader.load(self.ui_file) # The default column size of 100 is too small for the summary column. self.window.usb_tree_widget.setColumnWidth(1, 400) self.window.update_timer = QtCore.QTimer() self.window.update_timer.timeout.connect(self.update) self.window.usb_tree_widget.currentItemChanged.connect(self.tree_current_item_changed) self.window.usb_tree_widget: QtWidgets.QTreeWidget = self.window.usb_tree_widget self.window.usb_tree_widget.sortByColumn(0) self.window.showMaximized() def update(self): """ Called by the QTimer `update_timer`, collects packets waiting the queue and adds them to the tree view. Note: Since this is called via a QTimer signal, this method runs in the UI thread. """ packet_list = [] try: # Get as many packets as we can as quick as we can. while(True): packet = self.data_queue.get_nowait() packet_list.append(packet) # But the instant it's empty, don't wait for any more; just send them to be processed. except multiprocessing.queues.Empty: pass finally: # In case the queue was empty in the first place and didn't have anything ready. if len(packet_list) > 0: self.add_packets(packet_list) def add_packets(self, viewsb_packets: []): """ Adds a list of top-level ViewSB packets to the tree. We're in the UI thread; every bit of overhead counts, so let's batch as much as possible. """ for viewsb_packet in viewsb_packets: top_level_item = QtWidgets.QTreeWidgetItem(get_packet_string_array(viewsb_packet)) top_level_item.setData(0, QtCore.Qt.UserRole, viewsb_packet) list_of_children = [] recursive_packet_walk(viewsb_packet, list_of_children) top_level_item.addChildren(list_of_children) self.window.usb_tree_widget.addTopLevelItem(top_level_item) def tree_current_item_changed(self, current_item, previous_item): """ Use the side panel to show a detailed view of the current item. """ # Clear the details widget. self.window.usb_details_tree_widget.clear() self.window.usb_details_tree_widget.setColumnCount(2) current_packet: ViewSBPacket = current_item.data(0, QtCore.Qt.UserRole) # A list of 2-tuples: first element is a table title, and the second is usually a string: string dict detail_fields = current_packet.get_detail_fields() # Each table will have a root item in the details view. root_items = [] for table in detail_fields: title: str = table[0] root = QtWidgets.QTreeWidgetItem([title]) children = [] fields = table[1] # The usual case: a str: str dict. if type(fields) == type({}): for key, value in fields.items(): children.append(QtWidgets.QTreeWidgetItem(stringify_list([key, value]))) # Sometimes a descriptor will just be a 1-column list. elif type(fields) == type([]): for item in fields: children.append(QtWidgets.QTreeWidgetItem([str(item)])) # Sometimes it'll just be a string, or, if it's an unknown descriptor, a `bytes` instance. else: children.append(QtWidgets.QTreeWidgetItem([str(fields)])) root.addChildren(children) # Add an empty "item" between each table root_items += [root, QtWidgets.QTreeWidgetItem([])] self.window.usb_details_tree_widget.addTopLevelItems(root_items) self.window.usb_details_tree_widget.expandAll() self.window.usb_details_tree_widget.resizeColumnToContents(0) self.window.usb_details_tree_widget.resizeColumnToContents(1) def run(self): """ Overrides `ViewSBFrontend.run()` """ # TODO: is there a better value than 100 ms? Should it be configurable by the Analyzer? self.window.update_timer.start(100) self.app.exec_() self.stop() def stop(self): self.app.closeAllWindows() self.termination_event.set()
class Application: def __init__(self, argv): self.plumbing_bridge = PlumbingBridge() self.daq_bridge = DAQBridge(self.plumbing_bridge) self.controls_bridge = ControlsBridge(self.plumbing_bridge) self.procedures_bridge = ProceduresBridge(self.plumbing_bridge, self.controls_bridge) self.app = QApplication(argv) # ALL custom built QQuickItems have to be registered as QML objects in this way: qmlRegisterType(QMLVisualizationArea, 'VisualizationArea', 1, 0, 'VisualizationArea') self.app.setWindowIcon(QIcon(find_resource('icon.ico'))) self.app.setOrganizationName('Waterloo Rocketry') self.app.setOrganizationDomain('waterloorocketry.com') self.app.setApplicationName('Topside') self.qml_engine = QQmlEngine() context = self.qml_engine.rootContext() context.setContextProperty('plumbingBridge', self.plumbing_bridge) context.setContextProperty('controlsBridge', self.controls_bridge) context.setContextProperty('proceduresBridge', self.procedures_bridge) self.main_window = self._make_main_window() # TODO(jacob): Currently we load these example files at startup # to make testing turnaround a bit faster. Figure out how to # make the application remember the last file opened, and open # that instead. self.plumbing_bridge.load_from_files([find_resource('example.pdl')]) self.procedures_bridge.load_from_file(find_resource('example.proc')) self.controls_bridge.refresh() def _make_main_window(self): # TODO(jacob): Should we move this code somewhere else (maybe # into a separate MainWindow class)? window = QMainWindow() vert_splitter = QSplitter(Qt.Vertical) vert_splitter.setChildrenCollapsible(False) horiz_splitter = QSplitter(Qt.Horizontal) horiz_splitter.setChildrenCollapsible(False) daq_widget = make_daq_widget(self.daq_bridge, self.plumbing_bridge) horiz_splitter.addWidget(daq_widget) plumb_widget = make_qml_widget(self.qml_engine, 'PlumbingPane.qml') plumb_widget.setMinimumWidth(600) plumb_widget.setMinimumHeight(600) horiz_splitter.addWidget(plumb_widget) proc_widget = make_qml_widget(self.qml_engine, 'ProceduresPane.qml') proc_widget.setMinimumWidth(400) proc_widget.setMinimumHeight(600) horiz_splitter.addWidget(proc_widget) vert_splitter.addWidget(horiz_splitter) controls_widget = make_qml_widget(self.qml_engine, 'ControlsPane.qml') controls_widget.setMinimumHeight(200) vert_splitter.addWidget(controls_widget) window.setCentralWidget(vert_splitter) file_menu = QMenu('&File') open_proc_action = QAction('Open Procedure Suite', window) open_proc_action.setShortcut(QKeySequence('Ctrl+O')) open_proc_action.triggered.connect( self.procedures_bridge.loadFromDialog) file_menu.addAction(open_proc_action) open_plumb_action = QAction('Open Plumbing Engine', window) open_plumb_action.setShortcut(QKeySequence('Ctrl+Shift+O')) open_plumb_action.triggered.connect( self.plumbing_bridge.loadFromDialog) file_menu.addAction(open_plumb_action) exit_action = QAction('Exit', window) exit_action.setShortcut(QKeySequence.Quit) exit_action.triggered.connect(window.close) file_menu.addAction(exit_action) window.menuBar().addMenu(file_menu) tools_menu = QMenu('&Tools') pdl_editor_action = QAction('PDL Editor', window) pdl_editor_action.setShortcut(QKeySequence('Ctrl+Shift+E')) pdl_editor_action.triggered.connect(self.launchPDLEditor) tools_menu.addAction(pdl_editor_action) window.menuBar().addMenu(tools_menu) return window @Slot() def launchPDLEditor(self): w = make_pdl_editor(self.main_window) w.show() def run(self): self.app.aboutToQuit.connect(self.shutdown) self.main_window.showMaximized() app_return_code = self.app.exec_() return app_return_code def shutdown(self): # NOTE(jacob): We explicitly `del` this to suppress a TypeError # that arises from the bridges getting destroyed before the QML # engine, causing QML references to go invalid. We attach this # cleanup to the aboutToQuit signal because app.exec_ is not # guaranteed to return, and therefore placing it immediately # after the app.exec_ call would not guarantee that this cleanup # routine runs. # For reference: https://bugreports.qt.io/browse/QTBUG-81247 del self.qml_engine
""" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if __name__ == "__main__": application = QApplication(sys.argv) db = QSqlDatabase.addDatabase("QSQLITE") print("set database driver") db.setDatabaseName("test.db") print("select test database") model = Model() print("create model") model.setTable("units") print("select units table") model.select() print("select table data") view = View() table = MainTable() table.setModel(model) view.setCentralWidget(table) view.show() print("show view") sys.exit(application.exec_())
def volleyball_button_handler(self): kwargs = dict() if self.ui.home_text.text() != '': kwargs['home'] = self.ui.home_text.text() if self.ui.visitor_text.text() != '': kwargs['visitor'] = self.ui.visitor_text.text() if self.ui.server_ip.text() != '': kwargs['serverIP'] = self.ui.server_ip.text() volleyball = VolleyballGUI(**kwargs) self.close() volleyball.show() volleyball.exec() if __name__ == '__main__': QApplication.setAttribute(Qt.ApplicationAttribute.AA_EnableHighDpiScaling, True) APP = QApplication(sys.argv) WINDOW = ScoresnakeGUI() WINDOW.show() sys.exit(APP.exec_())
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import sys from PySide2.QtWidgets import QApplication, QWidget class MyWidget(QWidget): def __init__(self): super().__init__() self.setGeometry(0, 0, 800, 600) # 坐标0 0 大小800 600 self.setWindowTitle('myapp') if __name__ == '__main__': myapp = QApplication(sys.argv) mywidget = MyWidget() mywidget.show() sys.exit(myapp.exec_())
def main(): app = QApplication(sys.argv) ex = UI_Window() ex.show() sys.exit(app.exec_())
class Main(object): """主程序""" def __init__(self): self.loadIni() # 加载配置文件 self.app = QApplication(sys.argv) self.loadUi() # 加载ui self.attribute() # 属性 self.connect() # 槽连接 self.window.show() sys.exit(self.app.exec_()) def loadIni(self): """获取配置文件""" with open(RESOURCES_ROOT + "/setting.ini", "r") as file: text = file.read() thread_num = int(findall(r"thread_num = (\d+);", text)[0]) Spider.thread_num = thread_num def attribute(self): """属性""" # 图标 self.window.setWindowIcon(QIcon(RESOURCES_ROOT + "/magnet.ico")) # 磁力爬虫 self.spider = Spider() self.spider_thread = None # 爬虫线程锁 self.lock = Lock() # 右键菜单 self.rightMenu = QMenu(self.window.search_out) # 剪切板 self.clipboard = QApplication.clipboard() def loadUi(self): """加载ui文件""" # 主ui ui = QFile(UI_ROOT + "/main.ui") ui.open(QFile.ReadOnly) ui.close() self.window = QUiLoader().load(ui) def connect(self): """槽连接""" # 搜索框和按钮 self.window.search_button.clicked.connect(self.search) self.window.input_box.returnPressed.connect(self.search) # 磁力搜索线程 self.spider.status_change.connect(self.searchStatusChange) self.spider.result_add.connect(self.outputBoxAdd) # 右键菜单 action = self.rightMenu.addAction("复制") action.triggered.connect(self.rightCopy) self.window.search_out.setContextMenuPolicy(Qt.CustomContextMenu) self.window.search_out.customContextMenuRequested.connect( lambda: self.rightMenu.exec_(QCursor.pos())) def searchStatusChange(self): """爬虫运行状态改变""" status = self.spider.getStatus() if status: # 如果爬虫运行中 self.window.search_status.setText("运行中") self.window.search_button.setText("停止") else: self.window.search_status.setText("未运行") self.window.search_button.setText("搜索") @Slot(Magnet) def outputBoxAdd(self, result: Magnet): """磁力增加到GUI""" self.lock.acquire() # 计数以及表格行数变更 count = self.window.search_out.rowCount() result.id_num = count + 1 self.window.search_out.setRowCount(count + 1) # 设置值 self.window.search_out.setItem(count, 0, QTableWidgetItem(result.domain)) self.window.search_out.setItem(count, 1, QTableWidgetItem(result.title)) self.window.search_out.setItem(count, 2, QTableWidgetItem(result.size)) self.window.search_out.setItem(count, 3, QTableWidgetItem(result.download)) self.window.search_out.setItem(count, 4, QTableWidgetItem(result.create_time)) self.lock.release() def search(self): """搜索""" bt_text = self.window.search_button.text() if bt_text == "搜索": # 删除原有的 Magnet.all.clear() self.window.search_out.setRowCount(0) self.window.search_out.clearContents() # 搜索 content = self.window.input_box.text() if content: self.spider.setContent(content) self.spider_thread = Thread(target=self.spider.runMagnet) self.spider_thread.start() else: # 停止 self.spider.stop() def rightCopy(self): """右键菜单:复制""" try: select_item = self.window.search_out.selectedItems()[0] row = select_item.row() for magnet in Magnet.all: if magnet.id_num == row + 1: if magnet.hash: self.clipboard.setText(magnet.hash) elif magnet.magnet_content: self.clipboard.setText(magnet.magnet_content) else: self.clipboard.setText(magnet.torrent) break except: pass
def main(): app = QApplication(sys.argv) w = MainWindow() w.show() QMessageBox.information(None, "Info", "Just drag and drop the items.") sys.exit(app.exec_())
def _test_pipedimagerpq(): # vertices of a pentagon (roughly) centered in a 1000 x 1000 square pentagonpts = ( (504.5, 100.0), (100.0, 393.9), (254.5, 869.4), (754.5, 869.4), (909.0, 393.9), ) linepts = ((350, 50), (200, 150), (400, 250), (300, 350), (150, 250), (100, 450)) # start PyQt testapp = QApplication(["PipedImagerPQ"]) # create the list of commands to submit drawcmnds = [] drawcmnds.append({"action": "setTitle", "title": "Tester"}) drawcmnds.append({"action": "show"}) drawcmnds.append({"action": "clear", "color": "black"}) drawcmnds.append({"action": "screenInfo"}) # create the image to be displayed testimage = QImage(500, 500, QImage.Format_ARGB32_Premultiplied) # initialize a black background testimage.fill(0xFF000000) # draw some things in the image testpainter = QPainter(testimage) testpainter.setBrush(QBrush(QColor(0, 255, 0, 128), Qt.SolidPattern)) testpainter.setPen( QPen(QBrush(QColor(255, 0, 0, 255), Qt.SolidPattern), 5.0, Qt.SolidLine, Qt.SquareCap, Qt.MiterJoin)) testpainter.drawRect(QRectF(5.0, 255.0, 240.0, 240.0)) testpainter.setBrush(QBrush(QColor(0, 0, 255, 255), Qt.SolidPattern)) testpainter.setPen( QPen(QBrush(QColor(0, 0, 0, 255), Qt.SolidPattern), 5.0, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin)) testpainter.drawPolygon( QPolygonF([ QPointF(.25 * ptx, .25 * pty + 250) for (ptx, pty) in pentagonpts ])) testpainter.setBrush(Qt.NoBrush) testpainter.setPen( QPen(QBrush(QColor(255, 255, 255, 255), Qt.SolidPattern), 3.0, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin)) testpainter.drawPolyline( QPolygonF([QPointF(pts, pty) for (pts, pty) in linepts])) testpainter.end() # add the image command testimgwidth = testimage.width() testimgheight = testimage.height() testimgstride = testimage.bytesPerLine() # not a good way to get the pixel data testimgdata = bytearray(testimgheight * testimgstride) k = 0 for pty in range(testimgheight): for ptx in range(testimgwidth): pixval = testimage.pixel(ptx, pty) (aval, rgbval) = divmod(pixval, 256 * 256 * 256) (rval, gbval) = divmod(rgbval, 256 * 256) (gval, bval) = divmod(gbval, 256) testimgdata[k] = bval k += 1 testimgdata[k] = gval k += 1 testimgdata[k] = rval k += 1 testimgdata[k] = aval k += 1 testblocksize = 4000 testnumblocks = (testimgheight * testimgstride + testblocksize - 1) // testblocksize drawcmnds.append({ "action": "newImage", "width": testimgwidth, "height": testimgheight, "stride": testimgstride }) for k in range(testnumblocks): if k < (testnumblocks - 1): blkdata = testimgdata[k * testblocksize:(k + 1) * testblocksize] else: blkdata = testimgdata[k * testblocksize:] drawcmnds.append({ "action": "newImage", "blocknum": k + 1, "numblocks": testnumblocks, "startindex": k * testblocksize, "blockdata": blkdata }) # finish the command list drawcmnds.append({"action": "show"}) drawcmnds.append({"action": "exit"}) # create a PipedImagerPQ in this process (cmndrecvpipe, cmndsendpipe) = multiprocessing.Pipe(False) (rspdrecvpipe, rspdsendpipe) = multiprocessing.Pipe(False) testviewer = PipedImagerPQ(cmndrecvpipe, rspdsendpipe) # create a command submitter dialog tester = _CommandSubmitterPQ(testviewer, cmndsendpipe, rspdrecvpipe, drawcmnds) tester.show() # let it all run testresult = testapp.exec_() if testresult != 0: sys.exit(testresult)
def run_application(): """Start application.""" qt_app = QApplication(sys.argv) window = MainWindow() window.show() sys.exit(qt_app.exec_())
if __name__ == '__main__': app = QApplication([]) # 初始化应用 # # 检查是否需要验证产品密钥 # login_dial = LoginDialog() if login_dial.check() or login_dial.exec_(): # # 显示界面 # main_window = MainWindow() # 创建主窗口 # main_window.ui.show() # 按实际大小显示窗口 main_window.ui.showMaximized() # 全屏显示窗口,必须要用,不然不显示界面 # # 子线程启动 # serial_worker = SerialWorker(main_window) serial_worker.start() check_worker = CheckWorker(main_window) check_worker.start() # # 关闭界面了,强制关闭子线程 # if app.exec_() == 0: serial_worker.terminate() check_worker.terminate()
def main(): app = QApplication(sys.argv) ex = Example() sys.exit(app.exec_())
self.view.scene.camera = camera #self.repaint() self.view.start_rendering() self.view.update() if __name__ == "__main__": parser = argparse.ArgumentParser( description="Provide a chemical input file") parser.add_argument( "-i", "--input", type=str, help="an input file, accepted types: mol2, pdb, xyz, gsd") parser.add_argument( "-t", "--frame", type=int, default="-1", help= "if trajectory file is given, which frame to diffract (default -1 or last frame)" ) args = parser.parse_args() qapp = QApplication([]) app = ApplicationWindow(args.input, args.frame) app.show() qapp.exec_()
def main(): """main function """ # Adds Ctrl+C support to kill app signal.signal(signal.SIGINT, signal.SIG_DFL) QCoreApplication.setAttribute(Qt.AA_ShareOpenGLContexts) app = QApplication(sys.argv) app.setOrganizationName("djieffx") app.setApplicationName("vspleeter") loader = QUiLoader() mw = loader.load( os.path.join(os.path.dirname(__file__), "vspleeter_mainWindow.ui")) mw.setWindowIcon(QIcon(":/icons/vspleeter_icon.png")) def getBinaries(): """Create a generator that yield the proper command name if the checkbox is checked. :return: generator with command name :rtype: generator """ if mw.cpuCheckBox.checkState(): yield 'spleeter' if mw.gpuCheckBox.checkState(): yield 'spleeter-gpu' def getStemsAmount(): """Create a generator that yield the stems amount if the checkbox is checked. :return: generator with stem count :rtype: generator """ if mw.stems2CheckBox.checkState(): yield '2' if mw.stems4CheckBox.checkState(): yield '4' if mw.stems5CheckBox.checkState(): yield '5' def createOutputDir(cmdSpecs): """Create the output directory from defined output specifications :param cmdSpecs: context based variables to execute spleeter command :type cmdSpecs: dict :return: the output directory :rtype: str """ outputDir = OUTPUT_PATH_SUFFIX.format(**cmdSpecs) if not os.path.exists(outputDir): os.makedirs(outputDir, mode=0o777) print('Created the {0} directory'.format(outputDir)) return outputDir def generateCommandsPerElements(binaryGenerator, inputFilePath, stemsCPUGenerator, stemsGPUGenerator, rootOutputDir): """Generate all the commands necessary, per what is selected in the UI, looping on the process type :param binaryGenerator: generator with all the binary selections :param str inputFilePath: The file to be spleeted :param stemsCPUGenerator: generator with the CPU processes flag :param stemsGPUGenerator: generator with the GPU processes flag :param str rootOutputDir: The output directory :return: generator with all command line to spleet the file """ for binaryName in binaryGenerator: cmdSpecs = { 'rootOutputDir': rootOutputDir, 'basename': os.path.basename(os.path.splitext(inputFilePath)[0]), 'binaryType': 'CPU', 'binaryName': binaryName, 'inputFilePath': inputFilePath, 'stemsGenerator': stemsCPUGenerator } if 'gpu' in binaryName: cmdSpecs['binaryType'] = 'GPU' cmdSpecs['stemsGenerator'] = stemsGPUGenerator yield from generateCmdPerStem(cmdSpecs) else: yield from generateCmdPerStem(cmdSpecs) def generateCmdPerStem(cmdSpecs): """Generate the command from the stem count :param dict cmdSpecs: a dictionary containing all necessary data to generate the command :return: a command to execute :rtype: list """ stemsGenerator = cmdSpecs['stemsGenerator'] for stemNum in stemsGenerator: cmdSpecs['stemNum'] = stemNum outputDir = createOutputDir(cmdSpecs) if os.name == 'nt': cmd = [ "python", "-m", "{}".format(cmdSpecs['binaryName']), "separate", "-i", "{}".format(cmdSpecs['inputFilePath']), "-p", "spleeter:{}stems".format(cmdSpecs['stemNum']), "-o", "{}".format(outputDir) ] else: cmd = [ "{}".format(cmdSpecs['binaryName']), "separate", "-i", "{}".format(cmdSpecs['inputFilePath']), "-p", "spleeter:{}stems".format(cmdSpecs['stemNum']), "-o", "{}".format(outputDir) ] yield cmd def browseForInputFile(_): """Opens a file browser, and set the input file :param _: unused """ inputFile = QFileDialog.getOpenFileName()[0] mw.inputFileLineEdit.setText(inputFile) checkToEnableProcess() def browseForOutputDir(_): """Opens a file browser, and set the input file :param _: unused """ outputDir = QFileDialog.getExistingDirectory() mw.outputDirLineEdit.setText(outputDir) checkToEnableProcess() def checkToEnableProcess(): """If all the necessary params are set, enable the process button""" mw.processPushButton.setEnabled(False) inputFileCheck = bool(mw.inputFileLineEdit.text()) procCheck = any([ mw.cpuCheckBox.checkState(), mw.gpuCheckBox.checkState(), ]) stemsCheck = any([ mw.stems2CheckBox.checkState(), mw.stems4CheckBox.checkState(), mw.stems5CheckBox.checkState(), ]) outputFileCheck = bool(mw.outputDirLineEdit.text()) if all([ inputFileCheck, procCheck, stemsCheck, outputFileCheck, ]): mw.processPushButton.setEnabled(True) def processBatchElements(_): """Process all the data from the UI, and execute all the commands generated :param _: unused input """ binaryGenerator = getBinaries() inputFilePath = mw.inputFileLineEdit.text() stemsCPUGenerator = getStemsAmount() stemsCPUGenerator, stemsGPUGenerator = itertools.tee(stemsCPUGenerator) rootOutputDir = mw.outputDirLineEdit.text() generatedCmds = generateCommandsPerElements(binaryGenerator, inputFilePath, stemsCPUGenerator, stemsGPUGenerator, rootOutputDir) generatedCmds, generatedCmdsForLength = itertools.tee(generatedCmds) amountOfCommands = 0 for _ in generatedCmdsForLength: amountOfCommands += 1 mw.progressBar.setRange(0, amountOfCommands) mw.progressBar.setValue(0) mw.resultTextEdit.setText('') mw.resultTextEdit.append('Source File: %s' % inputFilePath) for cmd in generatedCmds: currentJobCount = mw.progressBar.value() subprocess.run(cmd) mw.progressBar.setValue(currentJobCount + 1) mw.resultTextEdit.append('Output %s:' % cmd[5].split(':')[1]) outputFiles = glob.glob(os.path.join(cmd[7], '*', '*')) for outputFile in outputFiles: mw.resultTextEdit.append(outputFile) mw.resultTextEdit.append('') checkToEnableProcess() mw.inputFilePushButton.clicked.connect(browseForInputFile) mw.outputDirPushButton.clicked.connect(browseForOutputDir) mw.cpuCheckBox.stateChanged.connect(checkToEnableProcess) mw.gpuCheckBox.stateChanged.connect(checkToEnableProcess) mw.stems2CheckBox.stateChanged.connect(checkToEnableProcess) mw.stems4CheckBox.stateChanged.connect(checkToEnableProcess) mw.stems5CheckBox.stateChanged.connect(checkToEnableProcess) mw.processPushButton.clicked.connect(processBatchElements) mw.actionexit.triggered.connect(app.quit) mw.show() sys.exit(app.exec_())
def createSlider(self): hbox = QHBoxLayout() self.slider = QSlider() self.slider.setOrientation(Qt.Horizontal) self.slider.setTickPosition(QSlider.TicksBelow) self.slider.setTickInterval(10) self.slider.setMinimum(0) self.slider.setMaximum(100) self.slider.valueChanged.connect(self.changeValue) self.label = QLabel("0") self.setFont(QtGui.QFont("Sanserif", 15)) hbox.addWidget(self.slider) hbox.addWidget(self.label) self.setLayout(hbox) def changeValue(self): size = self.slider.value() self.label.setText(str(size)) myApp = QApplication(sys.argv) window = Window() window.show() myApp.exec_() sys.exit(0)
self.setIcon() self.setButton() def setIcon(self): appIcon = QIcon("icon.png") self.setWindowIcon(appIcon) def setButton(self): btn1 = QPushButton("Quit", self) btn1.move(50, 100) btn1.clicked.connect(self.quiteApp) def quiteApp(self): userInfo = QMessageBox.question(self, "Confirmation", "Do You Want To Quit The Application", QMessageBox.Yes | QMessageBox.No) if userInfo == QMessageBox.Yes: myapp.quit() elif userInfo == QMessageBox.No: print('Quit cancelled') if __name__ == "__main__": myapp = QApplication(sys.argv) window = Window() window.show() myapp.exec_() sys.exit()
self.mainUI.logBoxActionCopy.triggered.connect( self.mainUI.logText.copy) self.mainUI.logBoxActionClear.triggered.connect( self.mainUI.logText.clear) self.mainUI.logBoxActionDebug.triggered.connect(self._onClickDebug) self.mainUI.logBoxMenu.popup(QCursor.pos()) def _onClickDebug(self): self.isDebug = bool(1 - self.isDebug) def onSettings(self): self.subUI.show() def onAbout(self): webbrowser.open('https://github.com/Matrixchung/EDAutopilot', new=1) def onExit(self): # release resources if self.thread_script is not None: self.thread_script.terminate() self.thread_io.terminate() self.thread_image.terminate() self.logger.info("Resource cleared, program will exit.") self.thread_log.terminate() QApplication.instance().quit() if __name__ == '__main__': app = QApplication([]) main = Main() main.mainUI.show() sys.exit(app.exec_())
self.setXRotation(self.xRot + 8 * dy) self.setYRotation(self.yRot + 8 * dx) elif event.buttons() & Qt.RightButton: self.setXRotation(self.xRot + 8 * dy) self.setZRotation(self.zRot + 8 * dx) self.lastPos = QPoint(event.pos()) if __name__ == '__main__': app = QApplication(sys.argv) fmt = QSurfaceFormat() fmt.setDepthBufferSize(24) if "--multisample" in QCoreApplication.arguments(): fmt.setSamples(4) if "--coreprofile" in QCoreApplication.arguments(): fmt.setVersion(3, 2) fmt.setProfile(QSurfaceFormat.CoreProfile) QSurfaceFormat.setDefaultFormat(fmt) mainWindow = Window() if "--transparent" in QCoreApplication.arguments(): mainWindow.setAttribute(Qt.WA_TranslucentBackground) mainWindow.setAttribute(Qt.WA_NoSystemBackground, False) mainWindow.resize(mainWindow.sizeHint()) mainWindow.show() res = app.exec_() sys.exit(res)
def syncMenu(self): self.actionPort_Config_Panel.setChecked(not self.dockWidget_PortConfig.isHidden()) self.actionQuick_Send_Panel.setChecked(not self.dockWidget_QuickSend.isHidden()) self.actionSend_Hex_Panel.setChecked(not self.dockWidget_SendHex.isHidden()) def onViewChanged(self): checked = self._viewGroup.checkedAction() if checked is None: self.actionHEX_UPPERCASE.setChecked(True) self.receiver_thread.setViewMode(VIEWMODE_HEX_UPPERCASE) else: if 'Ascii' in checked.text(): self.receiver_thread.setViewMode(VIEWMODE_ASCII) elif 'lowercase' in checked.text(): self.receiver_thread.setViewMode(VIEWMODE_HEX_LOWERCASE) elif 'UPPERCASE' in checked.text(): self.receiver_thread.setViewMode(VIEWMODE_HEX_UPPERCASE) def is_hex(s): try: int(s, 16) return True except ValueError: return False if __name__ == '__main__': app = QApplication(sys.argv) frame = MainWindow() frame.show() app.exec_()
def main(): logging.info('main') app = QApplication(sys.argv) app.setQuitOnLastWindowClosed(False) appctxt = AppContext(app) sentry_sdk.init( "https://[email protected]/5210435", shutdown_timeout=5, default_integrations=False, # Either pyqt or pyinstaller do weird things with sentry, # need to explicitely specify these else sentry fails integrations=[ LoggingIntegration(), StdlibIntegration(), ExcepthookIntegration(), DedupeIntegration(), AtexitIntegration(), ModulesIntegration(), ArgvIntegration(), ThreadingIntegration(), ]) instance = SingleInstance() print('instance', instance) logger = get_logging(appctxt.build_settings['debug']) build_msg = "Production" if appctxt.is_frozen else "Development" logger.info( f"PWUploader, version: {appctxt.build_settings['version']}, {build_msg} build" ) logging.debug(f'config {CONFIG.as_dict()}') signal.signal(signal.SIGINT, signal.SIG_DFL) logo_path = appctxt.get_resource('logo.png') logging.debug(f'logo_path: {logo_path}') icon = QIcon(logo_path) tray = QSystemTrayIcon() tray.setIcon(icon) logging.debug('tray: %s', tray) tray.show() menu = QMenu() # left-click should just open the menu too def on_systray_activated(reason): if reason == 3: menu.popup(QCursor.pos()) tray.activated.connect(on_systray_activated) action0 = QAction(f"Version: v{appctxt.build_settings['version']}") menu.addAction(action0) action2 = QAction('settings') action2.triggered.connect(on_settings(appctxt)) menu.addAction(action2) action3 = QAction('resync files') def connect_missing_files(): upload_missing_files(appctxt, remote_config) action3.triggered.connect(connect_missing_files) menu.addAction(action3) action4 = QAction('open log dir') action4.triggered.connect(on_open_logdir) menu.addAction(action4) def toggle_always_running(state): if state: CONFIG.set('always_running', True) start_guardian_detached() else: CONFIG.set('always_running', False) kill_guardian() with open(CONFIG_FILE, 'w') as f: f.write(json.dumps(CONFIG.as_dict(), indent=2)) logging.info('config saved') action5 = QAction('always running', checkable=True) if CONFIG.get('always_running'): action5.setChecked(True) action5.triggered.connect(toggle_always_running) menu.addAction(action5) action1 = QAction("quit") action1.triggered.connect(on_quit) menu.addAction(action1) tray.setContextMenu(menu) # FIXME get this after app display if possible for i in range(10): api = PWAPI(appctxt, appctxt.build_settings['api_url'], CONFIG.get('api_token'), CONFIG.get('account_id')) remote_config = api.get_config() if 'detail' in remote_config: logging.error('Invalid remote config %s', remote_config) message = 'Unable to reach Pathology Watch API for authentication, are your API Token & Lab ID correct? Click ok to open settings.' response = QtWidgets.QMessageBox.question( None, 'API Error', message, QtWidgets.QMessageBox.Ok, QtWidgets.QMessageBox.Cancel) if response == QtWidgets.QMessageBox.Cancel: sys.exit(0) settings_dialog = SettingsDialog(appctxt, CONFIG, CONFIG_FILE) settings_dialog.ui.setWindowModality(QtCore.Qt.ApplicationModal) settings_dialog.ui.exec_() else: break time.sleep(1) if remote_config is not None: clean_remote_config = { k: v for k, v in remote_config.items() if 'secret' not in k } logging.debug(f'remote_config {clean_remote_config}') # TODO verify remote_config if it's not set, check api token or pw connectivity else: logging.error( 'Uploader settings invalid or server isn\'t configured, contact [email protected]' ) sys.exit(1) # FIXME need to validate remote_config, config logging.info('Starting upload watcher') watcher_thread = WatcherThread(CONFIG.get('watch_dir'), trigger_upload) watcher_thread.finished.connect(app.exit) watcher_thread.start() logging.info('Starting heartbeat thread') heartbeat_thread = HeartbeatThread(appctxt, remote_config, CONFIG, upload_missing_files) heartbeat_thread.finished.connect(app.exit) heartbeat_thread.start() worker_threads = [] for i in range(appctxt.build_settings['n_upload_worker_threads']): logging.info(f'Starting worker {i}') worker_thread = WorkerThread(appctxt, remote_config, CONFIG, UPLOAD_QUEUE) worker_thread.finished.connect(app.exit) worker_thread.start() worker_threads.append(worker_thread) #def excepthook(exc_type, exc_value, exc_tb): # import traceback # tb = "".join(traceback.format_exception(exc_type, exc_value, exc_tb)) # logging.error("error caught: %s", str(tb)) # capture_exception(exc_type) #sys.excepthook = excepthook exit_code = -1 delay = 2 for i in range(5): logging.info('Starting') exit_code = app.exec_() if exit_code == 0: break logging.info(f'Exit loop {exit_code}, sleeping {delay}') time.sleep(delay) delay = delay**2 logging.info(f'Exited: {exit_code}') sys.exit(exit_code)
self.statusBar().addWidget(download_widget) def _remove_download_requested(self): download_widget = self.sender() self.statusBar().removeWidget(download_widget) del download_widget def _show_find(self): if self._find_tool_bar is None: self._find_tool_bar = FindToolBar() self._find_tool_bar.find.connect(self._tab_widget.find) self.addToolBar(Qt.BottomToolBarArea, self._find_tool_bar) else: self._find_tool_bar.show() self._find_tool_bar.focus_find() def write_bookmarks(self): self._bookmark_widget.write_bookmarks() if __name__ == '__main__': app = QApplication(sys.argv) main_win = create_main_window() initial_urls = sys.argv[1:] if not initial_urls: initial_urls.append('http://qt.io') for url in initial_urls: main_win.load_url_in_new_tab(QUrl.fromUserInput(url)) exit_code = app.exec_() main_win.write_bookmarks() sys.exit(exit_code)
def test(): app = QApplication() # data = XAnlageV_Zeile_Data( 1, "Name", "Kendel", "Name des Steuerpflichtigen" ) # z = AnlageV_ZeileView( data ) # z.show() app.exec_()
def main(): app = QApplication([]) rig = Rigctl() rig.show() app.exec_()
def main(): app = QApplication(sys.argv) window = GuiClass() window.show() app.exec_()
def main(): app = QApplication(sys.argv) memory_test_controller = MemoryTestController() memory_test_controller.ui.show() sys.exit(app.exec_())
self.setGeometry(150, 150, 350, 350) self.UI() def UI(self): self.widgets() self.layouts() def widgets(self): self.button = QPushButton("Button") self.checkbox = QCheckBox() def layouts(self): self.main_layout = QHBoxLayout() self.main_layout.addWidget(self.button) self.main_layout.addWidget(self.checkbox) self.setLayout(self.main_layout) if __name__ == "__main__": MainEventThread = QApplication([]) MainApplication = Main() MainApplication.show() sysExit(MainEventThread.exec_())
def test2(): app = QApplication() v = TestView() v.setWindowTitle("Test") v.show() app.exec_()
def test(): app = QApplication() v = IccTableEditorView() v.setWindowTitle("Test zum Testen") v.show() app.exec_()
def collapse(self, full_rows: list): for row in reversed(sorted(full_rows)): for column in range(self.num_columns): self[row, column].collapse() def shift(self, full_rows: list): for row in reversed(range(min(full_rows))): for column in range(self.num_columns): if self[row, column] is not None: self[row, column].shift(len(full_rows)) def restart(self): for tile in filter(lambda tl: tl is not None, self): tile.disappear() self.clear() self.update({(row, column): None for row in range(self.num_rows) for column in range(self.num_columns)}) self.score = 0 self.delegate.scored(self.score) self.spawn() if __name__ == '__main__': from PySide2.QtWidgets import QApplication import sys import ui application = QApplication(sys.argv) qTetris = ui.QTetris() sys.exit(application.exec_())
Batch.signals.batch_inactive.connect(mwi.setFullWindow) for Thread in Thread_List: mwi.signals.windowClosing.connect(Thread.close) ########################## ## --- Thread start --- ## ########################## ## Start threads Cam_Capturestream.start(QThread.HighPriority) Image_Processor.start(QThread.HighPriority) ######################## ## --- Exit stuff --- ## ######################## ret = app.exec_() print("Main function thread: " + str(QThread.currentThread())) ## Make sure positioning is stopped for Thread in Thread_List: if Thread is not None: Thread.wait_ms(1000) print("waiting for Thread: " + str(Thread) + " to exit.") ## stops the motors and disconnects from pseudo serial link /tmp/printer at exit steppers.PrintHAT_serial.disconnect() sys.exit(ret)
#get all ip adresses in the lan host_list = get_neighbors() print(host_list) col_getter = [ {"Name": "Dev", "Getter": lambda aHostItem: aHostItem["dev"]}, {"Name": "Ip", "Getter": lambda aHostItem: aHostItem["ip"]}, {"Name": "Mac", "Getter": lambda aHostItem: aHostItem["mac"]}, ] host_table = QTableView() host_model = HostModel(host_list, col_getter, host_table) host_table.setModel(host_model) host_table.show() # Run the main Qt loop sys.exit(app.exec_())
def main(): if parser.lang: sys_locale = parser.lang[0] else: sys_locale = QtCore.QLocale.system().name() translator = QtCore.QTranslator() #load intern dialogs translations qtTranslator = QtCore.QTranslator() qtTranslator.load("qt_" + sys_locale, QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.TranslationsPath)) #load translations files translations_path = os.path.join(os.getenv("PINGUINO_LIB"), "multilanguage") trasnlations = os.path.exists(translations_path) if trasnlations and (os.getenv("PINGUINO_MODE") == "NORMAL"): translations_file = "pinguino_" + sys_locale if translations_file + ".qm" in os.listdir(translations_path): translator.load(os.path.join(os.getenv("PINGUINO_LIB"), "multilanguage", "pinguino_{}.qm".format(sys_locale))) elif "_" in sys_locale: sys_locale = sys_locale[:sys_locale.find("_")] translations_file = "pinguino_" + sys_locale if translations_file + ".qm" in os.listdir(translations_path): translator.load(os.path.join(os.getenv("PINGUINO_LIB"), "multilanguage", "pinguino_{}.qm".format(sys_locale))) app = QApplication(sys.argv) #Splash (pinguino\qtgui\resources\art) #pixmap = QPixmap(":/logo/art/splash.png") pixmap = QPixmap("pinguino/qtgui/resources/art/splash.png") #pixmap = QPixmap("pinguino/qtgui/resources/art/pinguino_logo_background_blue-256x256.png") #pixmap = QPixmap(760, 256) #pixmap.fill(QtGui.QColor("#4d4d4d")) # keep the splash screen above all the other windows on the desktop splash = QSplashScreen(pixmap, QtCore.Qt.WindowStaysOnTopHint) splash.show() splash.setStyleSheet(""" font-family: inherit; font-weight: normal; font-size: 11pt; """) # update the splash screen with messages def splash_write(msg): if not splash is None: splash.showMessage("\t" + msg, color=QtGui.QColor("#4d4d4d"), alignment=QtCore.Qt.AlignBottom) splash_write(NAME + " " + MAJOR) app.processEvents() app.installTranslator(qtTranslator) if trasnlations: app.installTranslator(translator) frame = PinguinoIDE(splash_write=splash_write) frame.show() if not splash is None: splash.finish(frame) app.exec_()