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_())
