def main():
print(f'PySide6=={PySideVer} Qt=={QtVer}')
parser = ArgumentParser(
description='cappuccino: Simple image viewer with download')
parser.add_argument('download_keyword',
nargs='?',
default='',
help='image keyword to download')
args = parser.parse_args()
download_keyword = args.download_keyword
if not download_keyword and not exist_images():
download_keyword = DEFAULT_KEYWORD
initialize_qt()
app = QGuiApplication(sys.argv)
app.setWindowIcon(QIcon(resource_path('cappuccino.ico')))
is_download = download_keyword != ''
mmodel = MainModel(is_download, IMAGES_DIR_NAME)
dmodel = DownloaderModel(download_keyword, IMAGES_DIR_NAME)
imodel = ImageViewerModel(IMAGES_DIR_NAME)
dmodel.download_completed.connect(mmodel.on_download_completed)
engine = QQmlApplicationEngine()
engine.rootContext().setContextProperty('mmodel', mmodel)
engine.rootContext().setContextProperty('dmodel', dmodel)
engine.rootContext().setContextProperty('imodel', imodel)
engine.load(f'file:///{resource_path("qml/Main.qml")}')
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec())
def start(self):
qt_app = QGuiApplication([])
qt_app.aboutToQuit.connect(self._app.stop)
qml_engine = QQmlApplicationEngine(qt_app)
for plugin in self._app._plugin_registry.plugins.values():
if not hasattr(plugin, "after_qml_engine_created"):
continue
plugin.after_qml_engine_created(qml_engine)
controller = Controller(qml_engine, self._app)
qml_engine.rootContext().setContextProperty("controller", controller)
qml_engine.load(str(self._app.base_directory / "ui/qml/main.qml"))
qt_app.exec_()
def main_app(base_path, file, file_config):
"""Run the GUI of xBan
The function initiates and resize the application
"""
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")))
xBanApp = xBanWindow(base_path, file, file_config)
xBanApp.setStyleSheet(style)
# resize and move screen to center
primary_screen = QGuiApplication.primaryScreen()
if primary_screen:
screen_size = primary_screen.availableSize()
xBanApp.resize(screen_size.width() / 3, screen_size.height() / 2)
xBanApp.move(
(screen_size.width() - xBanApp.width()) / 2,
(screen_size.height() - xBanApp.height()) / 2,
)
app.setStyle("Fusion")
sys.exit(app.exec_())
else:
main_logger.error("Primary screen not found")
def main():
app = QGuiApplication(sys.argv)
app.setApplicationName(metadata.get("Name"))
# QQuickStyle.setStyle("Material")
QmlEncryptedJSONStorage6.DICTIONARY = {"$apphome": home}
engine = Paper()
encryptedStorage = QmlEncryptedJSONStorage6()
encryptedStorage._key = 26
engine.rootContext().setContextProperty("encryptedStorage",
encryptedStorage)
engine.init_ui()
sys.exit(app.exec_())
def screen_info(widget):
"""Format information on the screens"""
policy = QGuiApplication.highDpiScaleFactorRoundingPolicy()
policy_string = str(policy).split('.')[-1]
result = "<p>High DPI scale factor rounding policy: {}</p><ol>".format(
policy_string)
for screen in QGuiApplication.screens():
current = screen == widget.screen()
result += "<li>"
if current:
result += "<i>"
result += '"{}" {} {}DPI, DPR={}'.format(
screen.name(), format_geometry(screen.geometry()),
int(screen.logicalDotsPerInchX()), screen.devicePixelRatio())
if current:
result += "</i>"
result += "</li>"
result += "</ol>"
return result
def initUI(self):
# setup UI
self.setWindowTitle("Taplist - Let's Beer Brewpub")
# get screen width and height
self.screen = QGuiApplication.primaryScreen().geometry()
self.width = self.screen.width()
self.height = self.screen.height()
# set screen size
self.resize(1920, 1080)
# self.setMinimumWidth(800)
self.layout = QGridLayout()
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle('Qt DataVisualization 3D Bars')
self.bars = Q3DBars()
self.columnAxis = QCategory3DAxis()
self.columnAxis.setTitle('Columns')
self.columnAxis.setTitleVisible(True)
self.columnAxis.setLabels(['Column1', 'Column2'])
self.columnAxis.setLabelAutoRotation(30)
self.rowAxis = QCategory3DAxis()
self.rowAxis.setTitle('Rows')
self.rowAxis.setTitleVisible(True)
self.rowAxis.setLabels(['Row1', 'Row2'])
self.rowAxis.setLabelAutoRotation(30)
self.valueAxis = QValue3DAxis()
self.valueAxis.setTitle('Values')
self.valueAxis.setTitleVisible(True)
self.valueAxis.setRange(0, 5)
self.bars.setRowAxis(self.rowAxis)
self.bars.setColumnAxis(self.columnAxis)
self.bars.setValueAxis(self.valueAxis)
self.series = QBar3DSeries()
self.arrayData = [[1, 2], [3, 4]]
self.series.dataProxy().addRows(dataToBarDataArray(self.arrayData))
self.bars.setPrimarySeries(self.series)
self.container = QWidget.createWindowContainer(self.bars)
if not self.bars.hasContext():
print("Couldn't initialize the OpenGL context.")
sys.exit(-1)
camera = self.bars.scene().activeCamera()
camera.setYRotation(22.5)
geometry = QGuiApplication.primaryScreen().geometry()
size = geometry.height() * 3 / 4
self.container.setMinimumSize(size, size)
self.container.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.container.setFocusPolicy(Qt.StrongFocus)
self.setCentralWidget(self.container)
def initialize(self):
screen = QGuiApplication.primaryScreen().size()
size = screen.height() * 0.7
self.window = QMainWindow()
self.window.setAutoFillBackground(True)
self.window.setWindowFlag(
PySide6.QtCore.Qt.WindowType.WindowMaximizeButtonHint, False)
self.window.setWindowTitle('Chess')
self.window.resize(size, size)
self.window.move((screen.width() - self.window.width()) // 2,
(screen.height() - self.window.height()) // 2)
self.window.show()
self.margin = 10
self.button_size = (size - 2 * self.margin) // 8
def main(self):
init()
# Welcome users, and load configurations.
try:
_, self._noupdate, self._config = canvas_grab.get_options.get_options(
)
except TypeError:
# User canceled the configuration process
return
app = QGuiApplication(sys.argv)
app.setQuitOnLastWindowClosed(True)
app.aboutToQuit.connect(self._exit_handler)
engine = QQmlApplicationEngine()
engine.rootContext().setContextProperty('py_sync_model', self._model)
engine.load(os.path.join(os.path.dirname(__file__), "ui/main.qml"))
if not engine.rootObjects():
sys.exit(-1)
thread = threading.Thread(target=self._canvas_grab_run)
thread.start()
sys.exit(app.exec_())
def main(argv: List[str]):
config = Config(Path(argv[1]))
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
# Instance of the Python object
backend = Backend(CoreApp(iter_files(Path('.'), config.exceptions), config.root_folder, config.root_category))
# Expose the Python object to QML
context = engine.rootContext()
context.setContextProperty('backend', backend)
#qmlRegisterType(Test, 'TestTypes', 1, 0, 'Test')
# Get the path of the current directory, and then add the name
# of the QML file, to load it.
qmlFile = join(dirname(__file__), 'qml', 'main.qml')
engine.load(abspath(qmlFile))
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec_())
def update(self):
grid_unit = QFontMetrics(
QGuiApplication.font()).boundingRect('M').height()
if grid_unit % 2 != 0:
grid_unit += 1
if grid_unit != self._grid_unit:
self._grid_unit = grid_unit
self._changed_grid_unit.emit(self._grid_unit)
if grid_unit != self._large_spacing:
self._small_spacing = max(2, int(
grid_unit / 4)) # 1 / 4 of grid_unit, at least 2
self._large_spacing = self._small_spacing * 2
self._changed_spacing.emit()
def update_device_pixel_ratio(self):
# Using QGuiApplication::devicePixelRatio() gives too coarse values,
# i.e.it directly jumps from 1.0 to 2.0. We want tighter control on
# sizing, so we compute the exact ratio and use that.
# TODO: make it possible to adapt to the dpi for the current screen dpi
# instead of assuming that all of them use the same dpi which applies for
# X11 but not for other systems.
primary = QGuiApplication.primaryScreen()
if primary:
return
dpi = primary.logicalDotsPerInchX()
# Usual "default" is 96 dpi
# that magic ratio follows the definition of "device independent pixel" by Microsoft
self._device_pixel_patio = dpi / 96
self._changed_spacing.emit()
def __init__(self):
QtWidgets.QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.userInfo = None
self.setupUi(self)
self.setWindowTitle("Waifu2x-Gui")
self.msgForm = QtBubbleLabel(self)
self.settingForm = QtSetting(self)
self.settingForm.hide()
self.settingForm.LoadSetting()
self.aboutForm = QtAbout(self)
self.img = QtImg()
self.stackedWidget.addWidget(self.img)
# self.resize(1000, 1000)
self.menuabout.triggered.connect(self.OpenAbout)
desktop = QGuiApplication.primaryScreen().geometry()
def __init__(self):
super(Ruler, self).__init__()
self.old_position = None # is used for dragging of the window
self.setMinimumWidth(50)
self.setMinimumHeight(50)
# load the options
self.data = Data()
# main widget
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.constructContextMenu)
self.setWindowTitle('Screen Ruler')
self.resize(self.data.get('ruler_width'),
self.data.get('ruler_height'))
self.setMouseTracking(True)
self.setAttribute(Qt.WA_TranslucentBackground, True)
self.setGeometry(
QStyle.alignedRect(
Qt.LeftToRight, Qt.AlignCenter, self.size(),
QGuiApplication.primaryScreen().availableGeometry()))
windowFlags = Qt.CustomizeWindowHint | Qt.FramelessWindowHint
leftResize = SizeGrip(self, True)
rightResize = SizeGrip(self, False)
self.left_resize = leftResize
self.right_resize = rightResize
if self.data.get('always_above'):
windowFlags = windowFlags | Qt.WindowStaysOnTopHint
self.setWindowFlags(
windowFlags) # Turns off the default window title hints
# initialize the secondary windows
self.about_window = AboutWindow()
self.options_window = OptionsWindow(self)
if self.data.get('options_opened'):
self.openOptions()
def create_app_engine(argv, qml_file):
# We only support EGL but Qt still uses the legacy GLX by default
os.environ["QT_XCB_GL_INTEGRATION"] = "xcb_egl"
# We do not support Opengl 2.1 contexts (the default on macOS), so we
# force OpenGL 4.1 (Core Profile)
if platform.system() == "Darwin":
surface_format = QSurfaceFormat()
surface_format.setRenderableType(QSurfaceFormat.OpenGL)
major_version, minor_version = (4, 1)
surface_format.setVersion(major_version, minor_version)
surface_format.setProfile(QSurfaceFormat.CoreProfile)
surface_format.setDepthBufferSize(24)
surface_format.setStencilBufferSize(8)
surface_format.setAlphaBufferSize(8)
QSurfaceFormat.setDefaultFormat(surface_format)
app = QGuiApplication(argv)
QQuickWindow.setGraphicsApi(QSGRendererInterface.OpenGL)
engine = QQmlApplicationEngine(qml_file)
engine.quit.connect(app.quit)
return app, engine
def __init__(self, parent, history):
super().__init__(parent=parent)
self.setWindowTitle("History")
layout = QVBoxLayout()
text = QPlainTextEdit()
font = QFont()
font.setFamily("monospace")
font.setStyleHint(QFont.Monospace)
text.setFont(font)
highlighter = PythonHighlighter(text.document()) # noqa: F841
text.setReadOnly(True)
text.setPlainText(history)
layout.addWidget(text)
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok)
clipboardbutton = QPushButton("Copy to clipboard")
buttonbox.addButton(clipboardbutton, QDialogButtonBox.ActionRole)
clipboard = QGuiApplication.clipboard()
clipboardbutton.clicked.connect(
lambda: clipboard.setText(history + "\n"))
layout.addWidget(buttonbox)
self.setLayout(layout)
buttonbox.accepted.connect(self.accept)
self.resize(700, 500)
events = i.event_gen(yield_nones=False, timeout_s=1)
reload = False
for event in list(events):
(_, type_names, path, filename) = event
if filename[-3:] == 'qml' and 'IN_MODIFY' in type_names:
reload = True
break
if reload:
self.requestReload.emit()
if __name__ == "__main__":
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
workerThread = QThread()
workerThread.start()
worker = Worker()
worker.moveToThread(workerThread)
master = Master()
master.command.connect(worker.run)
worker.requestReload.connect(master.reload)
master.command.emit()
# Stop application gracefully:
signal.signal(signal.SIGINT, signal.SIG_DFL)
status = app.exec_()
self.load_from_json(filename)
def load_from_json(self,filename):
"""Load list of cities from given file"""
with open(filename,encoding="utf-8") as f:
self.city_list = json.load(f)
def rowCount(self, parent:QtCore.QModelIndex=...) -> int:
""" Return number of cities in the list"""
return len(self.city_list)
def data(self, index:QtCore.QModelIndex, role:int=...) -> typing.Any:
""" For given index and DisplayRole return name of the selected city"""
# Return None if the index is not valid
if not index.isValid():
return None
# If the role is the DisplayRole, return name of the city
if role == QtCore.Qt.DisplayRole:
return self.city_list[index.row()]["muniLabel"]
app = QGuiApplication(sys.argv)
view = QQuickView()
url = QUrl(VIEW_URL)
citylist_model = CityListModel(CITY_LIST_FILE)
ctxt = view.rootContext()
ctxt.setContextProperty('cityListModel',citylist_model)
view.setSource(url)
view.show()
app.exec_()
def copy(self):
QGuiApplication.clipboard().setText(self.fileNameLabel.text())
self._name = value
colorChanged = Signal()
color = Property(QColor, getColor, setColor, notify=colorChanged)
name = Property(str, getName, setName)
chartCleared = Signal()
@Slot() # This should be something like @Invokable
def clearChart(self):
self.setColor(Qt.transparent)
self.update()
self.chartCleared.emit()
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
qmlRegisterType(PieChart, 'Charts', 1, 0, 'PieChart')
view = QQuickView()
view.setResizeMode(QQuickView.SizeRootObjectToView)
qmlFile = os.path.join(os.path.dirname(__file__), 'app.qml')
view.setSource(QUrl.fromLocalFile(os.path.abspath(qmlFile)))
if view.status() == QQuickView.Error:
sys.exit(-1)
view.show()
res = app.exec_()
# Deleting the view before it goes out of scope is required to make sure all child QML instances
# are destroyed in the correct order.
del view
sys.exit(res)
if (self.staticUser.lower() == getUser.lower()
and self.staticPass == getPass):
# Send User And Pass
self.signalUser.emit("Username: "******"Password: "******"Login passed!")
else:
self.signalLogin.emit(False)
print("Login error!")
# INSTACE CLASS
if __name__ == "__main__":
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
# Get Context
main = MainWindow()
engine.rootContext().setContextProperty("backend", main)
# Load QML File
engine.load(os.path.join(os.path.dirname(__file__), "qml/main.qml"))
# Check Exit App
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec_())
def center(self):
qr = self.frameGeometry()
cp = QGuiApplication.primaryScreen().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
import sys
from PySide6.QtGui import QGuiApplication, QIcon
from PySide6.QtQml import QQmlApplicationEngine
from backend import BackEnd
import resources_rc
app = QGuiApplication(sys.argv)
app.setWindowIcon(QIcon(r"icons\icon.ico"))
backend = BackEnd(app)
engine = QQmlApplicationEngine()
engine.quit.connect(app.quit)
engine.load('main.qml')
engine.rootContext().setContextProperty('backend', backend)
sys.exit(app.exec())
def initialize_qt():
sys.argv += ['--style', 'Material']
QGuiApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)
QCoreApplication.setAttribute(Qt.AA_UseOpenGLES)
import os
from PySide6.QtQml import qmlRegisterType #, qmlRegisterUncreatableType
from PySide6.QtQuick import QQuickView
import re, sys
from PySide6.QtGui import QGuiApplication, QCursor
from PySide6.QtQml import QQmlApplicationEngine
from PySide6.QtCore import Qt
from fileio import FileIO
from Rem import Re
from syntaxhighlighter import syntaxhighlighter
if __name__ == '__main__':
app = QGuiApplication()
os.environ['XCURSOR_SIZE'] = '64'
# app.setOverrideCursor(QCursor("/home/minhinc/tmp/example/imageviewer/mycursor.png"))
qmlfile = sys.argv[1] if len(
sys.argv) > 1 else re.sub(r'^(.*)[.]py$', r'\1', sys.argv[0]) + '.qml'
qmlRegisterType(FileIO, "FileIOPlugin", 1, 0, "FileIO")
qmlRegisterType(syntaxhighlighter, "SyntaxHighlighter", 1, 0,
"SyntaxHighlighter")
reinstance = Re()
# if re.search(r'(?:\w+)?Window\s*{',open(qmlfile).read()):
if re.search(r'^(?<!//)\s*(?:\w+)?Window\s*{\s*$',
open(qmlfile).read(),
flags=re.MULTILINE) and (
not re.search(r'/[*](?![*]/)*?\n\s*(?:\w+)?Window\s*{',
open(qmlfile).read(),
flags=re.DOTALL)
or re.search(r'[*]/(?!/[*])*?\n\s*(?:\w+)?Window\s*{',
#!/usr/bin/python
# This Python file uses the following encoding: utf-8
import sys
import os
from PySide6.QtGui import QGuiApplication
from PySide6.QtQml import QQmlApplicationEngine
from PySide6 import QtCore, QtWidgets
# created from /usr/lib/qt6/rcc -g python qml.qrc -o resources.py
# converts the resources to bytes and can be called from qrc:/some/file.jpg
import resources
if __name__ == "__main__":
QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_ShareOpenGLContexts)
app = QGuiApplication(sys.argv)
app.setApplicationName("WeatherWidget")
app.setOrganizationName("AllspiceInc")
app.setOrganizationDomain("AllspiceInc")
engine = QQmlApplicationEngine()
engine.load(QtCore.QUrl("main.qml"))
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec())
and explains in which circumstances it is handy to use this control.
"""
import os
import sys
import platform
from PySide6.QtGui import QGuiApplication, QIcon
from PySide6.QtCore import QSettings, QUrl
from PySide6.QtQml import QQmlApplicationEngine, QQmlContext
from PySide6.QtQuickControls2 import QQuickStyle
import rc_gallery
if __name__ == "__main__":
QGuiApplication.setApplicationName("Gallery")
QGuiApplication.setOrganizationName("QtProject")
app = QGuiApplication()
QIcon.setThemeName("gallery")
settings = QSettings()
if not os.environ.get("QT_QUICK_CONTROLS_STYLE"):
QQuickStyle.setStyle(settings.value("style", str))
engine = QQmlApplicationEngine()
built_in_styles = ["Basic", "Fusion", "Imagine", "Material", "Universal"]
if platform.system() == "Darwin":
built_in_styles.append("macOS")
elif platform.system() == "Windows":
