def documentationWebViewWidget(documentationPath): """ Creates a PySide web view Widget :param str documentationPath: the absolute path to the html file to display :return: a PySide web view widget set up with the local documentation :rtype: PySide2.QtWebEngineWidgets.QWebEngineView """ webView = qWebview() webView.setWindowTitle('LayerAlchemy Documentation') qUrl = QUrl.fromLocalFile(documentationPath) webView.load(qUrl) screenGeo = QApplication.desktop().geometry() webView.setMinimumHeight(screenGeo.height() / 2) center = screenGeo.center() webView.move(center - webView.rect().center()) return webView
def launch_gui(filename=None): # check the requirements and import failed_requirements = [] try: from PySide2.QtWidgets import QApplication from PySide2.QtGui import QIcon except ModuleNotFoundError: failed_requirements.append('PySide2') try: from asyncqt import QEventLoop except ModuleNotFoundError: failed_requirements.append('asyncqt') if failed_requirements: for package in failed_requirements: print(_module_err_msg.format(package=package)) sys.exit() # if on Windows, change the taskbar icon try: from PySide2.QtWinExtras import QtWin myappid = f'andersonics.llc.patchbay.{__version__}' QtWin.setCurrentProcessExplicitAppUserModelID(myappid) except ImportError: pass from patchbay.qt.patchbay_ui import Patchbay # launch the GUI app = QApplication(sys.argv) app.setOrganizationName('Andersonics') app.setOrganizationDomain('andersonics.llc') app.setApplicationName('patchbay') app.setWindowIcon(QIcon(str(root_path / 'resources' / 'pb.svg'))) try: # use proper scaling for matplotlib figures in the UI plt.matplotlib.rcParams['figure.dpi'] = app.desktop().physicalDpiX() except NameError: pass asyncio.set_event_loop(QEventLoop(app)) patchbay_ui = Patchbay(filename=filename) return app.exec_()
def compute_font_size(): screen_rect = QApplication.desktop().availableGeometry() font_size = 14 while True: font = QApplication.font() font.setPixelSize(font_size) fm = QFontMetrics(font) byte_height = fm.boundingRect("0").height() byte_view_height = byte_height * 64 if byte_view_height < screen_rect.height(): return font_size else: font_size -= 1
def read_settings(self): settings = get_settings() # noinspection PyArgumentList screen = QApplication.desktop().screenGeometry() h = min(screen.height() * 5 / 6., 900) size = QSize(min(screen.width() * 5 / 6., 1200), h) pos = settings.value("pos", None) savesize = settings.value("size", size) if savesize.width() > screen.width(): savesize.setWidth(size.width()) if savesize.height() > screen.height(): savesize.setHeight(size.height()) self.resize(savesize) if ((pos is None or pos.x() + savesize.width() > screen.width() or pos.y() + savesize.height() > screen.height())): self.move(screen.center() - self.rect().center()) else: self.move(pos)
def readSettings(self): # restore window position settings = QSettings("settings.ini", QSettings.IniFormat) screen_rect = QApplication.desktop().screenGeometry() default_rect = QRect(screen_rect.width() // 6, screen_rect.height() // 4, screen_rect.width() * 2 // 3, screen_rect.height() // 2) geometry = settings.value("geometry", default_rect) self.setGeometry(geometry) maximized = settings.value("maximized", False) fullscreen = settings.value("fullscreen", False) wstate = self.windowState() if fullscreen == "true": self.setWindowState(wstate | Qt.WindowFullScreen) elif maximized: self.setWindowState(wstate | Qt.WindowMaximized)
def __init__(self, kind, component, parent=None): super().__init__() self.clipboard = parent.clipboard self.setWindowTitle("%s : %s" % (kind, component)) self.setGeometry(0, 0, 500, 500) # noinspection PyArgumentList self.move(QApplication.desktop().screenGeometry().center() - self.rect().center()) self.show() # Main layout self.layout = QVBoxLayout() self.setLayout(self.layout) self.display_tabs = QTabWidget() self.display = {} for k in ["yaml", "python", "bibliography"]: self.display[k] = QTextEdit() self.display[k].setLineWrapMode(QTextEdit.NoWrap) self.display[k].setFontFamily("mono") self.display[k].setCursorWidth(0) self.display[k].setReadOnly(True) self.display_tabs.addTab(self.display[k], k) self.layout.addWidget(self.display_tabs) # Fill text defaults_txt = get_default_info(component, kind, return_yaml=True) _indent = " " defaults_txt = (kind + ":\n" + _indent + component + ":\n" + 2 * _indent + ("\n" + 2 * _indent).join(defaults_txt.split("\n"))) from cobaya.yaml import yaml_load self.display["python"].setText(pformat(yaml_load(defaults_txt))) self.display["yaml"].setText(defaults_txt) self.display["bibliography"].setText(get_bib_component( component, kind)) # Buttons self.buttons = QHBoxLayout() self.close_button = QPushButton('Close', self) self.copy_button = QPushButton('Copy to clipboard', self) self.buttons.addWidget(self.close_button) self.buttons.addWidget(self.copy_button) self.close_button.released.connect(self.close) self.copy_button.released.connect(self.copy_clipb) self.layout.addLayout(self.buttons)
def _restore_preview_ui(self): """Restore UI state from previous session.""" if not self._preview_window_state: self._settings.beginGroup(self._SETTINGS_GROUP_NAME) window_size = self._settings.value("windowSize") window_pos = self._settings.value("windowPosition") n_screens = self._settings.value("n_screens", defaultValue=1) window_maximized = self._settings.value("windowMaximized", defaultValue='false') splitter_state = {} for splitter in self._import_preview.findChildren(QSplitter): splitter_state[splitter] = self._settings.value( splitter.objectName() + "_splitterState") self._settings.endGroup() original_size = self.size() if window_size: self.resize(window_size) else: self.setGeometry( QStyle.alignedRect( Qt.LeftToRight, Qt.AlignCenter, QSize(1000, 700), QApplication.desktop().availableGeometry(self))) if window_pos: self.move(window_pos) if len(QGuiApplication.screens()) < int(n_screens): # There are less screens available now than on previous application startup self.move( 0, 0) # Move this widget to primary screen position (0,0) ensure_window_is_on_screen(self, original_size) if window_maximized == 'true': self.setWindowState(Qt.WindowMaximized) for splitter, state in splitter_state.items(): if state: splitter.restoreState(state) else: self.resize(self._preview_window_state["size"]) self.move(self._preview_window_state["position"]) self.setWindowState(self._preview_window_state["maximized"]) for splitter in self._import_preview.findChildren(QSplitter): name = splitter.objectName() splitter.restoreState( self._preview_window_state["splitters"][name])
def __init__(self): QMainWindow.__init__(self) self.setWindowTitle("Earthquake Information") # Menu self.menu = self.menuBar() self.file_menu = self.menu.addMenu("File") # Exit QAction exit_action = QAction("Exit", self) exit_action.setShortcut(QKeySequence.Quit) exit_action.triggered.connect(self.close) self.file_menu.addAction(exit_action) # Status Bar self.status = self.statusBar() self.status.showMessage("Data loaded and plotted") # Window dimensions geometry = QApplication.desktop().availableGeometry(self) self.setFixedSize(geometry.width() * 0.8, geometry.height() * 0.7)
def main_app(base_path, file, file_config): """Run the GUI of xBan""" app = QApplication(sys.argv) if hasattr(QStyleFactory, "AA_UseHighDpiPixmaps"): app.setAttribute(Qt.AA_UseHighDpiPixmaps) with open(os.path.join(base_path, "xBanStyle.css"), "r") as style_sheet: style = style_sheet.read() app.setWindowIcon(QIcon(os.path.join(base_path, "xBanUI.png"))) xbanwindow = BanBoard(file, file_config) xbanwindow.setStyleSheet(style) # move screen to center screen = app.desktop().screenGeometry() xbanwindow.move( (screen.width() - xbanwindow.width()) / 2, (screen.height() - xbanwindow.height()) / 2, ) app.setStyle("Fusion") sys.exit(app.exec_())
def show(self): logger.debug("Opening collaboration settings dialog") screen_width = QApplication.desktop().width() parent_x = self._dialog.parent().x() parent_width = self._dialog.parent().width() width = self._dialog.width() offset = 16 if parent_x + parent_width / 2 > screen_width / 2: x = parent_x - width - offset if x < 0: x = 0 else: x = parent_x + parent_width + offset diff = x + width - screen_width if diff > 0: x -= diff self._dialog.move(x, self._dialog.parent().y()) # Execute dialog self._dialog.raise_() self.show_cursor_loading(True) self._dialog.exec_()
def __init__(self, parent=None): super().__init__(parent) # Default values. Updated if found in config.JSON self.use_qt_thread = False self.rhythm_algorithm = "multifeature" self.default_device_name = "" self.show_video_preview = True self.video_loop_bpm = 60 self.video_update_skip_ms = 100 self.limit_tempo_by_default = False self.tempo_lower_limit = 60.0 self.tempo_upper_limit = 120.0 self.screen = 0 self.spotify_track_id = "" self.read_config() self.setWindowTitle("Gandalf Enjoys Music") self.desktop = QApplication.desktop() self.audio = AudioDevice(self.default_device_name) self.input_devices = self.audio.get_input_device_names() self.audio_changed.connect(self.audio.change_audio_input) if self.use_qt_thread: self.bpm_extractor = BPMQt(self.update_bpm, algorithm=self.rhythm_algorithm) else: self.bpm_extractor = BPMmp(self.update_bpm, algorithm=self.rhythm_algorithm) self.audio.data_ready.connect(self.bpm_extractor.start_bpm_calculation) self.init_ui()
def show(self, on_finished): def finished(): self._dialog.finished.disconnect(finished) self._view.resizeRowsToContents() self._model.beginResetModel() on_finished() screen_width = QApplication.desktop().width() parent_x = self._dialog.parent().x() parent_width = self._dialog.parent().width() width = self._dialog.width() offset = 16 if parent_x + parent_width / 2 > screen_width / 2: x = parent_x - width - offset if x < 0: x = 0 else: x = parent_x + parent_width + offset diff = x + width - screen_width if diff > 0: x -= diff self._dialog.move(x, self._dialog.parent().y()) if width > screen_width - offset: self._dialog.resize(screen_width - offset, self._dialog.height()) self._view.setMouseTracking(True) self._old_mouse_move_event = self._view.mouseMoveEvent self._view.mouseMoveEvent = self._mouse_moved self._old_mouse_release_event = self._view.mouseMoveEvent self._view.mouseReleaseEvent = self._mouse_released logger.info("Opening device list dialog...") # Execute dialog self._dialog.finished.connect(finished) self._dialog.raise_() self._dialog.show()
def __init__(self, parent: QWidget): super(ObjectDropdown, self).__init__(parent) self.setEditable(True) self.setMaxVisibleItems(30) self.completer().setCompletionMode( QCompleter.CompletionMode.PopupCompletion) self.completer().setFilterMode(Qt.MatchContains) self.setInsertPolicy(QComboBox.NoInsert) self.currentIndexChanged.connect(self._on_object_selected) # guard against overly long item descriptions self.setMaximumWidth(QApplication.desktop().geometry().width() / 5) self.setWhatsThis( "<b>Object Dropdown</b><br/>" "Contains all objects and enemies/items, that can be placed in this type of level. Which are " "available depends on the object set, that is selected for this level.<br/>" "You can search, by typing in the name, or simply select it from the list. After selecting " "an object, you can place it by clicking the middle mouse button anywhere in the level." )
def showColorValue(self) -> None: if not self.pressed: return x: int = QCursor.pos().x() y: int = QCursor.pos().y() self.txtPoint.setText("x:%d y:%d" % (x, y)) screen: QScreen = QApplication.primaryScreen() pixmap: QPixmap = screen.grabWindow(QApplication.desktop().winId(), x, y, 2, 2) red: int = 0 green: int = 0 blue: int = 0 strDecimalValue: str = '' strHex: str = '' if not pixmap.isNull(): image: QImage = pixmap.toImage() if not image.isNull(): if image.valid(0, 0): color: QColor = QColor(image.pixel(0, 0)) red = color.red() green = color.green() blue = color.blue() strDecimalValue = "%d, %d, %d" % (red, green, blue) strHex = "#%02X%02X%02X" % (red, green, blue) # 根据背景色自动计算合适的前景色 color: QColor = QColor(red, green, blue) gray: float = (0.299 * color.red() + 0.587 * color.green() + 0.114 * color.blue()) / 255 textColor: QColor = QColor(Qt.black) if gray > 0.5 else QColor(Qt.white) value = "background:rgb(%s);color:%s" % (strDecimalValue, textColor.name()) self.labColor.setStyleSheet(value) self.txtRgb.setText(strDecimalValue) self.txtWeb.setText(strHex)
from PySide2.QtCore import Qt from utils.main_ui import MainWindow if __name__ == '__main__': qss = '' try: with open('utils/qdark.qss', 'r') as f: qss = f.read() except: print('警告!找不到QSS文件!请从github项目地址下载完整文件。') QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True) QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True) app = QApplication(sys.argv) app.setStyleSheet(qss) app.setFont(QFont('微软雅黑', 9)) desktop = app.desktop() splash = QSplashScreen(QPixmap(r'utils\splash.jpg')) splash.show() mainWindow = MainWindow() mainWindow.setWindowIcon(QIcon(r'utils\favicon.ico')) screen = app.primaryScreen().geometry() mainWindow.resize(screen.width() * 0.75, screen.height() * 0.75) size = mainWindow.geometry() mainWindow.move((screen.width() - size.width()) / 2, (screen.height() - size.height()) / 2) mainWindow.showMaximized() mainWindow.show() splash.finish(mainWindow) sys.exit(app.exec_())
""" Contains the main entry point to the application. """ import sys from PySide2.QtCore import Qt from PySide2.QtWidgets import QApplication, QStyle from gui import DataGingerWindow if __name__ == "__main__": APP = QApplication(sys.argv) GEOMETRY = APP.desktop().availableGeometry() MAIN_WINDOW = DataGingerWindow() MAIN_WINDOW.show() MAIN_WINDOW.setGeometry( QStyle.alignedRect(Qt.LeftToRight, Qt.AlignCenter, GEOMETRY.size() * 0.75, GEOMETRY)) sys.exit(APP.exec_())
result = pattern.format(n) if not os.path.exists(result): return result n = n + 1 return None def takePicture(self): self.currentPreview = QImage() self.camera.searchAndLock() self.imageCapture.capture(self.nextImageFileName()) self.camera.unlock() def imageCaptured(self, id, previewImage): self.currentPreview = previewImage def imageSaved(self, id, fileName): index = self.tabWidget.count() imageView = ImageView(self.currentPreview, fileName) self.tabWidget.addTab(imageView, "Capture #{}".format(index)) self.tabWidget.setCurrentIndex(index) if __name__ == '__main__': app = QApplication(sys.argv) mainWin = MainWindow() availableGeometry = app.desktop().availableGeometry(mainWin) mainWin.resize(availableGeometry.width() / 3, availableGeometry.height() / 2) mainWin.show() sys.exit(app.exec_())
def center(window): """Center window on the desktop""" qrect = window.frameGeometry() qpoint = QApplication.desktop().availableGeometry().center() qrect.moveCenter(qpoint) window.move(qrect.topLeft())
def processCommand(self, cmnd): ''' Examine the action of cmnd and call the appropriate method to deal with this command. Raises a KeyError if the "action" key is missing. ''' try: cmndact = cmnd["action"] except KeyError: raise ValueError("Unknown command '%s'" % str(cmnd)) if cmndact == "clear": try: bkgcolor = self.__helper.getColorFromCmnd(cmnd) except KeyError: bkgcolor = None self.clearScene(bkgcolor) elif cmndact == "exit": self.exitViewer() elif cmndact == "hide": self.showMinimized() elif cmndact == "screenInfo": scrnrect = QApplication.desktop().availableGeometry() info = (self.physicalDpiX(), self.physicalDpiY(), scrnrect.width(), scrnrect.height()) self.__rspdpipe.send(info) elif cmndact == "redraw": try: bkgcolor = self.__helper.getColorFromCmnd(cmnd) except KeyError: bkgcolor = None self.redrawScene(bkgcolor) elif cmndact == "rescale": self.scaleScene(float(cmnd["factor"]), True) elif cmndact == "resize": mysize = self.__helper.getSizeFromCmnd(cmnd) self.resizeScene(mysize.width(), mysize.height()) elif cmndact == "newImage": self.loadNewSceneImage(cmnd) elif cmndact == "save": filename = cmnd["filename"] fileformat = cmnd.get("fileformat", None) try: bkgcolor = self.__helper.getColorFromCmnd(cmnd) except KeyError: bkgcolor = None rastsize = self.__helper.getSizeFromCmnd(cmnd["rastsize"]) self.saveSceneToFile(filename, fileformat, bkgcolor, rastsize) elif cmndact == "setTitle": self.setWindowTitle(cmnd["title"]) elif cmndact == "imgname": myvalue = cmnd.get("name", None) if myvalue: self.__lastfilename = myvalue myvalue = cmnd.get("format", None) if myvalue: self.__lastformat = myvalue.lower() elif cmndact == "show": if not self.isVisible(): self.show() elif cmndact == "noalpha": # ignore any alpha channel values in colors self.__noalpha = True else: raise ValueError("Unknown command action %s" % str(cmndact))
hash_thread = threading.Thread(target=import_export.hash_audio_files, args=(self.queue, )) hash_thread.daemon = True hash_thread.start() self.timer.start() # Check if hashes have finished computing def hash_update(self): while not self.queue.empty(): data = self.queue.get() if data == "msgdone": self.timer.stop() self.ui.actionLoad_episode.setEnabled(True) self.ui.actionAdd_audio_path.setEnabled(True) else: self.console(data) if __name__ == "__main__": QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) app = QApplication(sys.argv) window = MainWindow() window.move( (QApplication.desktop().availableGeometry().width() - window.width()) / 2, (QApplication.desktop().availableGeometry().height() - window.height()) / 2, ) window.show() sys.exit(app.exec_())
def init_pos(self): screen_resolution = QApplication.desktop().screenGeometry() width, height = screen_resolution.width(), screen_resolution.height() self.move(width-650, 10)
def main(): app = QApplication(sys.argv) screen_resolution = app.desktop().screenGeometry() exce = PopupTranslatorWidget(screen_resolution) exce.show() sys.exit(app.exec_())
class App: killSignal = signal.SIGUSR1 def __init__(self): # Qt application creation. self.qApp = QApplication(sys.argv) # System tray icon menu creation. menu = QMenu() showMainWindowAction = menu.addAction(_('Show %s window') % (APP_NAME)) showMainWindowAction.triggered.connect(self.showMainWindow) menu.addSeparator() exitAction = menu.addAction(_('Exit')) exitAction.triggered.connect(self._quit) # System tray icon creation. self.tray = QSystemTrayIcon() self.tray.setIcon(QIcon(self.getResourceFile(APP_ICON))) self.tray.setContextMenu(menu) self.tray.show() self.tray.setToolTip(APP_NAME) self.tray.activated.connect(self._iconActivated) # QWebEngineView to handle external urls opening. self.wevExternalUrl = QWebEngineView() def _download(self, download): filename = QFileDialog.getSaveFileName(None, _('Save as'), download.path(), "") if (filename[0] == ''): download.cancel() else: download.setPath(filename[0]) download.accept() def _iconActivated(self, reason): if (reason == QSystemTrayIcon.Trigger): self.toggleVisible() def _kill(self): if (self.killSignal == signal.SIGUSR1): self.killSignal = signal.SIGTERM elif (self.killSignal == signal.SIGTERM): self.killSignal = signal.SIGKILL print('Killing...') os.killpg(0, self.killSignal) def _launchExternalUrl(self, url): self.wevExternalUrl.urlChanged.disconnect(self._launchExternalUrl) _EOU(url.toString()) def _quit(self, checked): # Sometimes QtWebEngineProcess hangs and next code is a work around. self.timer = QTimer() self.timer.timeout.connect(self._kill) self.timer.start(5000 * 10) # Two seconds for mercy. sys.exit() def getResourceFile(self, fileName): fileNameAux = fileName.lower() if (fileNameAux == APP_ICON): fileName = os.path.join(_PR2A('desktop'), 'Juasap.png') return fileName def hideMainWindow(self): self.mainWindow.hide() def run(self): self.mainWindow = MainWindow() availableGeometry = self.qApp.desktop().availableGeometry( self.mainWindow) self.mainWindow.resize(availableGeometry.width() * 0.40, availableGeometry.height() * 0.90) self.mainWindow.show() def showMainWindow(self): self.mainWindow.show() def toggleVisible(self): if self.mainWindow.isVisible(): self.hideMainWindow() else: self.showMainWindow()
self.webEngineView = QWebEngineView() self.setCentralWidget(self.webEngineView) initialUrl = 'http://qt.io' self.addressLineEdit.setText(initialUrl) self.webEngineView.load(QUrl(initialUrl)) self.webEngineView.page().titleChanged.connect(self.setWindowTitle) self.webEngineView.page().urlChanged.connect(self.urlChanged) def load(self): url = QUrl.fromUserInput(self.addressLineEdit.text()) if url.isValid(): self.webEngineView.load(url) def back(self): self.webEngineView.page().triggerAction(QWebEnginePage.Back) def forward(self): self.webEngineView.page().triggerAction(QWebEnginePage.Forward) def urlChanged(self, url): self.addressLineEdit.setText(url.toString()) if __name__ == '__main__': app = QApplication(sys.argv) mainWin = MainWindow() availableGeometry = app.desktop().availableGeometry(mainWin) mainWin.resize(availableGeometry.width() * 2 / 3, availableGeometry.height() * 2 / 3) mainWin.show() sys.exit(app.exec_())
self.resize(width / 2, height / 2) # Tamanho mínimo da janela. self.setMinimumSize(width / 2, height / 2) # Tamanho maximo da janela. self.setMaximumSize(width - 200, height - 200) self.create_widgets() def create_widgets(self): hbox = QHBoxLayout() self.setLayout(hbox) for n in range(1, 5): button = QPushButton(f'Button {n}') hbox.addWidget(button) if __name__ == "__main__": import sys app = QApplication([]) screen_size = app.desktop().geometry() # screen_size = app.primaryScreen().geometry() mainwindow = MainWindow(screen_size=screen_size) mainwindow.show() sys.exit(app.exec_())
def __init__(self): super().__init__() self.setWindowTitle("Trivial Purfuit Board") self.num_row_tiles = 9 self.num_col_tiles = 9 self.board_tile_width = 95 self.board_tile_height = self.board_tile_width self.board_width = self.num_row_tiles * self.board_tile_width self.board_height = self.num_col_tiles * self.board_tile_height monitor = QApplication.desktop().geometry() self.resize(monitor.width(), self.board_height) #default is event self.qtype1_tile_color = Qt.white #default is holidau self.qtype2_tile_color = Qt.green #default is location self.qtype3_tile_color = Qt.blue #default is people self.qtype4_tile_color = Qt.red self.roll_again_tile_color = Qt.darkGray self.players_initialized = False self.dice_initialized = False # Background music playlist self.playlist = QMediaPlaylist() self.playlist.addMedia( QUrl.fromLocalFile( definitions.ROOT_DIR + "/Trivial_Purfuit/resources/audio/sea_change.mp3")) self.playlist.addMedia( QUrl.fromLocalFile(definitions.ROOT_DIR + "/Trivial_Purfuit/resources/audio/feblu.mp3")) self.playlist.addMedia( QUrl.fromLocalFile( definitions.ROOT_DIR + "/Trivial_Purfuit/resources/audio/vals_de_rodrigues.mp3")) self.playlist.addMedia( QUrl.fromLocalFile( definitions.ROOT_DIR + "/Trivial_Purfuit/resources/audio/escaping_time.mp3")) self.playlist.setPlaybackMode(QMediaPlaylist.Loop) self.playlist_player = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.playlist_player.setPlaylist(self.playlist) self.number_of_players = 0 self.player_list = [] self.die = Die() self.board_menu = BoardMenu() self.qa_manager = QuestionManager( definitions.ROOT_DIR + "/Trivial_Purfuit/csvs/questions-and-answers.csv") self.question_categories = [ definitions.question_type1, definitions.question_type2, definitions.question_type3, definitions.question_type4 ] self.image_path = definitions.ROOT_DIR + "/Trivial_Purfuit/src/board/images/" self.restart_menu = RestartMenu()
font.setItalic(not font.italic()) legend.setFont(font) def font_size_changed(self): legend = self.chart.legend() font = legend.font() font_size = self.font_size.value() if font_size < 1: font_size = 1 font.setPointSizeF(font_size) legend.setFont(font) def update_legend_layout(self): legend = self.chart.legend() rect = QRectF(self.legend_posx.value(), self.legend_posy.value(), self.legend_width.value(), self.legend_height.value()) legend.setGeometry(rect) legend.update() if __name__ == "__main__": app = QApplication(sys.argv) w = MainWidget() available_geometry = app.desktop().availableGeometry(w) size = available_geometry.height() * 0.75 w.setFixedSize(size, size) w.show() sys.exit(app.exec_())
def initialize_game(self): """ Description ------------- - TODO: JGC """ monitor = QApplication.desktop().geometry() # Navigation Menu setup self.board_menu.resize(monitor.width(), monitor.height()) self.board_menu.ui.player_order_group_box.move( self.board_width, self.board_menu.ui.player_order_group_box.y()) self.board_menu.ui.navigation_group.move(self.board_width, monitor.height() / 3) temp_x = self.board_menu.ui.navigation_group.x() temp_y = self.board_menu.ui.navigation_group.y( ) + self.board_menu.ui.navigation_group.height() self.board_menu.ui.misc_group.move(temp_x, temp_y) self.board_menu.ui.audio_group.move( self.board_menu.ui.misc_group.x(), self.board_menu.ui.misc_group.y() + self.board_menu.ui.misc_group.height()) # Connect signals/slots for buttons on board menu self.connect(self.board_menu.ui.up_button, SIGNAL("clicked()"), partial(self.start_move, "UP")) self.connect(self.board_menu.ui.down_button, SIGNAL("clicked()"), partial(self.start_move, "DOWN")) self.connect(self.board_menu.ui.left_button, SIGNAL("clicked()"), partial(self.start_move, "LEFT")) self.connect(self.board_menu.ui.right_button, SIGNAL("clicked()"), partial(self.start_move, "RIGHT")) self.connect(self.board_menu.ui.reset_button, SIGNAL("clicked()"), self.cheat) self.connect(self.board_menu.ui.roll_die_button, SIGNAL("clicked()"), self.get_dice_value) # Connect signals/slots for audio slider widgets on board menu self.connect(self.board_menu.ui.music_volume_slider, SIGNAL("sliderReleased()"), self.update_music_volume) self.connect(self.board_menu.ui.sound_effects_volume, SIGNAL("sliderReleased()"), self.update_sound_effect_volume) self.board_menu.ui.sound_effects_volume.setValue(50) self.board_menu.ui.music_volume_slider.setValue(50) # Die Setup/initialization self.initialize_dice() # Game sounds self.win_noise = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.lose_noise = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.win_noise.setMedia( QUrl.fromLocalFile( definitions.ROOT_DIR + "/Trivial_Purfuit/resources/audio/win_bing.mp3")) self.lose_noise.setMedia( QUrl.fromLocalFile( definitions.ROOT_DIR + "/Trivial_Purfuit/resources/audio/lose_noise.mp3")) # Start the background music self.playlist_player.play() self.layout().addChildWidget(self.die) self.layout().addChildWidget(self.board_menu) self.player_list = self.set_round_order(self.player_list) self.current_player = self.player_list[0] self.current_player_list_index = 0 self.current_player.is_current_player = True self.board_menu.ui.current_player_field.insertPlainText( str(self.current_player.name))
def showEvent(self, event) -> None: if sys.platform in ['linux', 'darwin']: media_content = QMediaContent( QUrl.fromLocalFile( QFileInfo( './../example_data/sample.mp4').absoluteFilePath())) else: media_content = QMediaContent( QUrl.fromLocalFile( QFileInfo( './../example_data/pusheen.gif').absoluteFilePath())) self.media_player.setMedia(media_content) self.media_player.setVideoOutput(self.video_widget) self.video_widget.show() self.video_widget.update() self.media_player.setPosition(0) self.media_player.play() if __name__ == "__main__": app = QtModernRedux.QApplication(sys.argv) mw = QtModernRedux.wrap( MainWindow(), title_bar=True, transparent_window=False, window_buttons_position=QtModernRedux.WINDOW_BUTTONS_RIGHT) desktop = QApplication.desktop() mw.show() sys.exit(app.exec_())
actions.append(action) return actions ######################## # Add plugin path to library path : mandatory to enable # the loading of imageformat dlls for reading and writing QImage objects. ####################### plugin_path = os.path.join(os.path.dirname(QtCore.__file__), "plugins") QtCore.QCoreApplication.addLibraryPath(plugin_path) ###################### # Hide console for frozen app # Pass an argument to program to keep console showing ##################### if getattr(sys, 'frozen', False) and len(sys.argv) <= 1: hideConsole() ############ # launch app ############ app = QApplication(sys.argv) # get root widget for screen management rootWidget = app.desktop() ################# # init main form # the UI is not loaded yet window = Form1() #################
self.widget = None #self.widget = QWidget() #self.setCentralWidget(self.widget) print(f'---- yWin: stop to close ----') #---- kong ---- self.close() #---- #================================ # # if __name__ == '__main__': app = QApplication(sys.argv) win = app.desktop().screenGeometry() signal.signal(signal.SIGINT, lambda s, f: app.quit()) r = -1 with Win('2', 10) as w: t = QTimer() t.setSingleShot(True) t.timeout.connect(w.showFullScreen) t.start(1000) w.setGeometry(win) w.show() r = app.exec_() sys.exit(r)
series2 = QtCharts.QPieSeries() series2.setName("Renewables") series2.append("Wood fuels", 319663) series2.append("Hydro power", 45875) series2.append("Wind power", 1060) series3 = QtCharts.QPieSeries() series3.setName("Others") series3.append("Nuclear energy", 238789) series3.append("Import energy", 37802) series3.append("Other", 32441) donut_breakdown = DonutBreakdownChart() donut_breakdown.setAnimationOptions(QtCharts.QChart.AllAnimations) donut_breakdown.setTitle("Total consumption of energy in Finland 2010") donut_breakdown.legend().setAlignment(Qt.AlignRight) donut_breakdown.add_breakdown_series(series1, Qt.red) donut_breakdown.add_breakdown_series(series2, Qt.darkGreen) donut_breakdown.add_breakdown_series(series3, Qt.darkBlue) window = QMainWindow() chart_view = QtCharts.QChartView(donut_breakdown) chart_view.setRenderHint(QPainter.Antialiasing) window.setCentralWidget(chart_view) available_geometry = app.desktop().availableGeometry(window) size = available_geometry.height() * 0.75 window.resize(size, size * 0.8) window.show() sys.exit(app.exec_())