def __init__(self, qml):
app = QGuiApplication(sys.argv)
model = QmlModel()
model.register()
qmlUrl = QUrl(qml)
assert qmlUrl.isValid()
print(qmlUrl.path())
# assert qmlUrl.isLocalFile()
"""
Create an engine a reference to the window?
window = QuickWindowFactory().create(qmlUrl=qmlUrl)
window.show() # visible
"""
engine = QQmlApplicationEngine()
"""
Need this if no stdio, i.e. Android, OSX, iOS.
OW, qWarnings to stdio.
engine.warnings.connect(self.errors)
"""
engine.load(qmlUrl)
engine.quit.connect(app.quit)
app.exec_() # !!! C exec => Python exec_
print("Application returned")
def start():
app = QGuiApplication(sys.argv)
ui = DefaultUI()
ui.gamesList.gameChanged.connect(test2)
ui.platformSelector.platformChanged.connect(test)
ui.show()
sys.exit(app.exec_())
def main():
print("start")
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
engine.load(QUrl("main.qml"))
engine.rootObjects()[0].show()
sys.exit(app.exec_())
def main(): # Set up correct Ctrl-C behavior. signal.signal(signal.SIGINT, signal.SIG_DFL) app = QGuiApplication( sys.argv ) engine = QQmlEngine() engine.addImportPath( path.join( path.dirname( __file__ ), 'ui', 'qml' ) ) core.register_types() component = QQmlComponent( engine ) component.loadUrl( QUrl( '/home/feoh3/.config/nube/hud.qml' ) ) if component.isError(): print( "\n".join( error.toString() for error in component.errors() ) ) else: window = component.create() app.exec_()
def main():
app = QGuiApplication(sys.argv)
qmlRegisterType(MainController, 'MainController', 1, 0, 'MainController')
qmlRegisterType(ProfileViewModel, 'ProfileViewModel', 1, 0, 'ProfileViewModel')
engine = QQmlApplicationEngine()
main_controller = MainController()
main_controller.profile_selection_changed(0)
engine.rootContext().setContextProperty('mainController', main_controller)
engine.load(QUrl.fromLocalFile(pkg_resources.resource_filename('yarg.resource', 'main.qml')))
sys.exit(app.exec_())
def execute_app(config_dict):
# On systems running X11, possibly due to a bug, Qt fires the qWarning
# "QXcbClipboard::setMimeData: Cannot set X11 selection owner" while
# setting clipboard data when copy/selection events are encountered in
# rapid succession, resulting in clipboard data not being set. This env
# variable acts as a fail-safe which aborts the application if this
# happens more than once. Similar situation arises when another clipboard
# management app (like GPaste) is running alongside chaos.
os.environ["QT_FATAL_WARNINGS"] = "1"
signal.signal(signal.SIGTERM, qt_quit)
signal.signal(signal.SIGINT, qt_quit)
signal.signal(signal.SIGTSTP, qt_quit)
signal.signal(signal.SIGHUP, qt_quit)
app = QGuiApplication(sys.argv)
timer(100, lambda: None)
cb = Clipboard(config_dict)
sys.exit(app.exec_())
def run_app():
app = QGuiApplication(sys.argv)
app.setApplicationName("Worship Prototype")
view = QQuickView()
view.setResizeMode(QQuickView.SizeRootObjectToView)
view.setSource(QUrl.fromLocalFile(os.path.join(os.path.dirname(__file__), 'main.qml')))
view.show()
root = view.rootObject()
preview = DefaultScreen()
preview.wire_to_gui(root, 'previewScreen')
preview.show_background(VideoBackground(os.path.join(os.path.dirname(__file__), '../echo.mp4')))
# preview_live = DefaultScreen()
# live = DefaultScreen()
modules = [
LyricsModule(SongsList(), root, preview),
]
sys.exit(app.exec_())
def main():
app = QGuiApplication(sys.argv)
app.setApplicationName('InfiniteCopy')
openDataBase()
view = QQuickView()
clipboardItemModel = ClipboardItemModel()
clipboardItemModel.create()
filterProxyModel = QSortFilterProxyModel()
filterProxyModel.setSourceModel(clipboardItemModel)
clipboard = Clipboard()
clipboard.setFormats([
mimeText,
mimeHtml,
mimePng,
mimeSvg
])
clipboard.changed.connect(clipboardItemModel.addItem)
engine = view.engine()
imageProvider = ClipboardItemModelImageProvider(clipboardItemModel)
engine.addImageProvider("items", imageProvider)
context = view.rootContext()
context.setContextProperty('clipboardItemModel', clipboardItemModel)
context.setContextProperty('clipboardItemModelFilterProxy', filterProxyModel)
context.setContextProperty('clipboard', clipboard)
view.setSource(QUrl.fromLocalFile('qml/MainWindow.qml'))
view.setGeometry(100, 100, 400, 240)
view.show()
engine.quit.connect(QGuiApplication.quit)
return app.exec_()
def run():
signal.signal(signal.SIGINT, signal.SIG_DFL)
app = QGuiApplication(sys.argv)
view = QQuickView()
view.setTitle('Hot reloading demo')
qml_engine = view.rootContext().engine()
qml_engine.addImportPath(lib_dir_path)
notifier = HotReloadNotifier(demo_dir_path, qml_engine, parent=app)
view.rootContext().setContextProperty('hotReloadNotifier', notifier)
qml_url = QUrl.fromLocalFile(os.path.join(demo_dir_path, 'Demo.qml'))
view.setSource(qml_url)
view.show()
exit_code = app.exec_()
# notifier.stop() # seems like this is not needed
sys.exit(exit_code)
def run(self):
engine = NetEaseEngine()
if self.qtype == "artist":
url = engine.searchCoverByArtistName(self.name)
elif self.qtype == "album":
url = engine.searchCoverByAlbumName(self.name)
coverWorker.receiveCover.emit(self.qtype, self.name, url)
if __name__ == "__main__":
app = QGuiApplication(sys.argv)
artists = []
for artist in db.get_cursor().execute("Select name from artist").fetchall():
artists.append(artist)
albums = []
for album in db.get_cursor().execute("Select name from album").fetchall():
albums.append(album)
for artist in artists:
d = DRunnable(artist, qtype="artist")
QThreadPool.globalInstance().start(d)
for album in albums:
d = DRunnable(album, qtype="album")
QThreadPool.globalInstance().start(d)
exitCode = app.exec_()
sys.exit(exitCode)
lc = lcm.LCM()
subscription = lc.subscribe("SIMULATOR", my_handler)
class WorkThread(QThread):
# 定义一个信号
trigger = pyqtSignal(str)
def __int__(self):
# 初始化函数，默认
super(WorkThread, self).__init__()
def run(self):
# 等待5秒后，给触发信号，并传递test
self.trigger.emit("ok")
HandleWork.lc.handle()
if __name__ == "__main__":
path = 'main.qml'
app = QGuiApplication([])
viewer = QQuickView()
con = MainPanel()
context = viewer.rootContext()
context.setContextProperty("con", con)
viewer.engine().quit.connect(app.quit)
viewer.setSource(QUrl(path))
rootObject = viewer.rootObject()
viewer.show()
app.exec_()
#!/usr/bin/env python
#-*-coding:utf-8-*-
import sys
import os
from PyQt5.QtCore import QUrl, Qt, QTimer, QMetaObject, QObject
from PyQt5.QtGui import QGuiApplication
from PyQt5.QtQml import QQmlApplicationEngine
from dataProc import GraphRefresh
from tools import Tools
if __name__ == '__main__':
myApp = QGuiApplication(sys.argv)
appLabel = QQmlApplicationEngine()
appLabel.addImportPath('.')
appLabel.addImportPath('./qml')
appLabel.load('splash.qml')
root = appLabel.rootObjects()
context = appLabel.rootContext()
g = GraphRefresh("COM1", 115200, 1, root, context)
tools = Tools(root, context, g)
context.setContextProperty('pyRoot', tools)
myApp.exec_()
sys.exit()
#!/usr/bin/python
# -*- coding: utf-8 -*-
from PyQt5.QtCore import QUrl, QObject, pyqtSlot
from PyQt5.QtGui import QGuiApplication
from PyQt5.QtQuick import QQuickView
class MyClass(QObject):
@pyqtSlot(int, result=str) # 声明为槽，输入参数为int类型，返回值为str类型
def returnValue(self, value):
"""
功能: 创建一个槽
参数: 整数value
返回值: 字符串
"""
return str(value+10)
if __name__ == '__main__':
path = 'demo.qml' # 加载的QML文件
app = QGuiApplication([])
view = QQuickView()
con = MyClass()
context = view.rootContext()
context.setContextProperty("con", con)
view.engine().quit.connect(app.quit)
view.setSource(QUrl(path))
view.show()
app.exec_()
for idx, ingr in enumerate(channelList):
dispensingModel.items[idx] = {
'channelId': idx,
'channelName': ingredients[ingr][0],
'channelColor': "grey",
'indicatorColor': "lightgrey"
}
view.rootContext().setContextProperty("dispensingModel", dispensingModel)
qml_file = os.path.join(os.path.dirname(__file__), "UI/main.qml")
view.setSource(QUrl.fromLocalFile(os.path.abspath(qml_file)))
screenMgr.title = "Main Menu"
screenMgr.status = "ready."
screenMgr.gaugeValue = 0
screenMgr.buttonMenuVisible = True
screenMgr.dispensingVisible = False
screenMgr.alertVisible = False
# print(view.findChild(QObject, "label4"))
if view.status() == QQuickView.Error:
sys.exit(-1)
view.show()
ret = app.exec_()
del view
hector.cleanAndExit()
sys.exit(ret)
if __name__ == '__main__':
import sys
from Curves import BezierCurve
from Generators import JsonGenerator
app = QGuiApplication(sys.argv)
qmlRegisterType(ConsoleOutput, 'PyConsole', 1, 0, 'PyConsole')
qmlRegisterType(BezierCurve, 'Curves', 1, 0, 'BezierCurve')
qmlRegisterType(JsonGenerator, 'Generators', 1, 0, 'JsonGenerator')
view = QQuickView()
context = view.rootContext()
view.engine().quit.connect(app.quit)
view.setResizeMode(QQuickView.SizeRootObjectToView)
view.setSource(
QUrl.fromLocalFile('../view/visionai.qml')
)
view.show()
for error in view.errors():
print(error.toString())
status = app.exec_()
for error in view.errors():
print(error.toString())
sys.exit(status)
class View(object):
shapes = ["rectangle", "ellipse", "image"]
edgetypes = ["line", "curve"]
def __init__(self):
self._controller = Controller(self)
self._gui = QGuiApplication(sys.argv)
self._qml_dir = os.path.dirname(os.path.realpath(__file__))
self._main = QQuickView()
self._main.setResizeMode(QQuickView.SizeRootObjectToView)
self._main.setSource(QUrl(self._qml_dir + '/main.qml'))
self._main.rootObject().create_node.connect(
self._controller.create_node)
self._main.rootObject().mouse_position.connect(
self._controller.mouse_position)
self._main.rootObject().save.connect(
self._controller.save)
self._main.rootObject().load.connect(
self._controller.load)
self._main.rootObject().lose_focus.connect(
self._controller.lose_focus)
self._main.rootObject().node_color_sel.connect(
self._controller.node_color_sel)
self._main.rootObject().edge_color_sel.connect(
self._controller.edge_color_sel)
self._main.rootObject().workspace_height_changed.connect(
self._controller.workspace_height_changed)
self._main.rootObject().workspace_width_changed.connect(
self._controller.workspace_width_changed)
self._main.rootObject().edge_type_sel.connect(
self._controller.edge_type_sel)
self._main.rootObject().node_shape_sel.connect(
self._controller.node_shape_sel)
self._main.rootObject().clear_workspace.connect(
self._controller.clear_workspace)
self._main.rootObject().node_width_changed.connect(
self._controller.node_width_changed)
self._main.rootObject().node_height_changed.connect(
self._controller.node_height_changed)
self._main.rootObject().node_text_color_sel.connect(
self._controller.node_text_color_sel)
self._main.rootObject().node_text_size_changed.connect(
self._controller.node_text_size_changed)
self._main.rootObject().edge_thickness_changed.connect(
self._controller.edge_thickness_changed)
self._main.rootObject().show_edge_controls.connect(
self._controller.show_edge_controls)
self._main.rootObject().hide_edge_controls.connect(
self._controller.hide_edge_controls)
self._main.rootObject().exporting.connect(
self._controller.exporting)
self._main.setProperty(
"width", self._controller.project.workspace_width)
self._main.setProperty(
"height", self._controller.project.workspace_height)
self._main.show()
def run(self):
return self._gui.exec_()
def create_node(self, node):
# Creates new node from source QML and puts it inside of main window
qml_node = QQuickView(QUrl(self._qml_dir + '/shapes/' +
self.shapes[node.shape] + '.qml'),
self._main)
workspace = self._main.rootObject().findChild(QQuickItem, "workspace")
# Sets all properties
qml_node.rootObject().setProperty("parent", workspace)
qml_node.rootObject().setProperty("objectId", str(node.id))
qml_node.rootObject().setProperty("background",
str(node.background))
qml_node.rootObject().setProperty("width", str(node.width))
qml_node.rootObject().setProperty("height", str(node.height))
qml_node.rootObject().setProperty("text", str(node.text.text))
qml_node.rootObject().setProperty("textFont", str(node.text.font))
qml_node.rootObject().setProperty("textSize", str(node.text.size))
qml_node.rootObject().setProperty("textColor", str(node.text.color))
# Sets drag boundaries
qml_node.rootObject().setProperty("workspaceWidth",
str(workspace.property("width")))
qml_node.rootObject().setProperty("workspaceHeight",
str(workspace.property("height")))
# Signal connection
qml_node.rootObject().node_delete.connect(
self._controller.node_delete)
qml_node.rootObject().node_text_changed.connect(
self._controller.node_text_changed)
qml_node.rootObject().node_position_changed.connect(
self._controller.node_position_changed)
qml_node.rootObject().node_connect.connect(
self._controller.node_connect)
qml_node.rootObject().node_focus.connect(
self._controller.node_focus)
if node.shape == 2:
qml_node.rootObject().node_image_loaded.connect(
self._controller.node_image_loaded)
# Position to mouse click
qml_node.rootObject().setX(node.x - node.width / 2)
qml_node.rootObject().setY(node.y - node.height / 2)
qml_node.rootObject().setZ(2)
return qml_node
def create_edge(self, edge, node1, node2):
qml_edge = QQuickView(QUrl(self._qml_dir + '/edges/' +
self.edgetypes[edge.type] + '.qml'),
self._main)
workspace = self._main.rootObject().findChild(QQuickItem, "workspace")
qml_edge.rootObject().setProperty("parent", workspace)
qml_edge.rootObject().setProperty("objectId", str(edge.id))
qml_edge.rootObject().setZ(1)
qml_edge.rootObject().setProperty(
"width", workspace.property("width"))
qml_edge.rootObject().setProperty(
"height", workspace.property("height"))
qml_edge.rootObject().setProperty("ctrlX", str(edge.x))
qml_edge.rootObject().setProperty("ctrlY", str(edge.y))
qml_edge.rootObject().setProperty("startX", str(node1.x))
qml_edge.rootObject().setProperty("startY", str(node1.y))
qml_edge.rootObject().setProperty("endX", str(node2.x))
qml_edge.rootObject().setProperty("endY", str(node2.y))
qml_edge.rootObject().setProperty("color", str(edge.color))
qml_edge.rootObject().setProperty("thickness", str(edge.thickness))
qml_edge.rootObject().setProperty("spiked", str(edge.spiked))
qml_edge.rootObject().setProperty("arrow", str(edge.arrow))
# Sets drag boundaries
qml_edge.rootObject().setProperty("workspaceWidth",
str(workspace.property("width")))
qml_edge.rootObject().setProperty("workspaceHeight",
str(workspace.property("height")))
# Signal connection
qml_edge.rootObject().edge_delete.connect(
self._controller.edge_delete)
qml_edge.rootObject().edge_position_changed.connect(
self._controller.edge_position_changed)
qml_edge.rootObject().edge_focus.connect(
self._controller.edge_focus)
return qml_edge
def node_update(self, node):
pass
import sys
from PersonModel import PersonModel
from PyQt5.QtCore import QUrl
from PyQt5.QtGui import QGuiApplication
from PyQt5.QtQml import QQmlApplicationEngine
from PyQt5.QtWidgets import QApplication
if __name__ == '__main__':
myApp = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
engine.load(QUrl.fromLocalFile("main.qml"))
if len(engine.rootObjects()) == 0:
sys.exit(-1)
sys.exit(myApp.exec_())
if DEBUG:
print('frozen', IS_FROZEN)
print('bundle dir is', BUNDLE_DIR)
print('sys.argv[0] is', sys.argv[0])
print('sys.executable is', sys.executable)
print('os.getcwd is', os.getcwd())
app = QGuiApplication(sys.argv)
MAINWINDOW_INSTANCE = PDFxGui()
# PdfDetailWindow("/tmp/some-test-funky.pdf", fake=True)
try:
status_code = app.exec_()
except:
# if this is packaged by PyInstaller, report crashes to sentry
if IS_FROZEN:
SENTRY.captureException()
raise
finally:
sys.exit(status_code)
# print(self.app)
# print(dir(self.app))
# self.app.setWindowIcon(QIcon("icon.ico"))
# self.app.setWindowTitle("Foo")
# self.app.setOrganizationName("Jeena")
# self.app.setOrganizationDomain("jeena.net")
# self.app.setApplicationName("FeedTheMonkey")
from PyQt5.QtGui import QGuiApplication
from PyQt5.QtQml import QQmlApplicationEngine
import sys
app = QGuiApplication(sys.argv)
# adding the engine to
engine = QQmlApplicationEngine()
engine.quit.connect(app.quit)
# just sending the signal to quit our app when close signal send from the qml engine
# loading the ui
engine.load("main.qml")
sys.exit(app.exec_())
from PyQt5.QtQml import QQmlApplicationEngine, qmlRegisterType
from PyQt5.QtGui import QGuiApplication, QIcon
from PyQt5.QtCore import QUrl, Qt
import resources
if __name__ == '__main__':
QGuiApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
engine.load(":/main.qml")
if not engine.rootObjects():
sys.exit(-1)
try:
exitCode = app.exec_()
del engine
sys.exit(exitCode)
except:
print("exiting")
## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
## LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################
import sys
import os.path
from PyQt5.QtCore import QUrl
from PyQt5.QtGui import QGuiApplication
from PyQt5.QtQuick import QQuickView
#animation 폴더의 animation_rc 와 shared 폴더의 shared_rc를 import해온다.
from shared_rc import *
from animation_rc import *
if len(sys.argv) is 2:# 실행 옵션으로 파이썬도움말 절대경로 제공시
os.chdir(sys.argv[1])
app = QGuiApplication(sys.argv)
view = QQuickView()
view.engine().quit.connect(app.quit)
view.setSource(QUrl('animation.qml'))
view.show()
sys.exit(app.exec_())
def main():
"""The main entry point when used as a regular app
It assumes a session is selected. When not, a dummy session None is used.
The status line will tell that a real session has to be created or selected from the menu.
"""
global app
# needed for making reports...
matplotlib.use('Agg')
app_Path = Path(__file__).parent.absolute() / '..'
be = app_Path / 'QtQuickBackend'
sys.path.append(str(be))
from backend_qtquick5 import FigureCanvasQTAggToolbar, MatplotlibIconProvider
gd.config = startup()
# always start without secondary session
gd.config['Session2'] = None
gd.globals = readGlobals()
# sys_argv = sys.argv
# sys_argv += ['--style', 'material']
app = QGuiApplication(sys.argv)
# app.aboutToQuit.connect(shutdown)
locale.setlocale(locale.LC_NUMERIC, "C");
# needed for filedialog
app.setOrganizationName(gd.orgname)
app.setOrganizationDomain(gd.orgdomain)
app.setApplicationName(gd.appname)
qmlRegisterType(FigureCanvasQTAggToolbar, "Backend", 1, 0, "FigureToolbar")
imgProvider = MatplotlibIconProvider()
# setup rootcontext to communicate with QML
engine = QQmlApplicationEngine()
engine.addImageProvider("mplIcons", imgProvider)
gd.context = engine.rootContext()
# Setup pieces
gd.data_model = DataSensorsModel()
gd.context.setContextProperty("sensorModel", gd.data_model)
gd.mainPieces = FormPieces(data=gd.data_model)
gd.context.setContextProperty("draw_mpl", gd.mainPieces)
# model to create pieces
gd.data_model2 = DataPiecesModel()
gd.context.setContextProperty("makePiecesModel", gd.data_model2)
# View piece
gd.data_model3 = DataSensorsModel()
gd.context.setContextProperty("sensorModel3", gd.data_model3)
# model for secondary session
gd.data_model4 = DataSensorsModel()
gd.context.setContextProperty("sensorModel4", gd.data_model4)
gd.mainView = FormView(data=gd.data_model3, data2=gd.data_model4)
gd.context.setContextProperty("piece_mpl", gd.mainView)
gd.data_model5 = DataPiecesModel()
gd.context.setContextProperty("viewPiecesModel", gd.data_model5)
# Boat
gd.boattablemodel = BoatTableModel()
gd.context.setContextProperty("boatTableModel", gd.boattablemodel)
gd.boatPlots = BoatForm()
gd.context.setContextProperty("boat_mpl", gd.boatPlots)
# Crew
gd.crewPlots = CrewForm()
gd.context.setContextProperty("crew_mpl", gd.crewPlots)
# Create rower tables and plots for potentially eight rowers
for i in range(8):
gd.rowertablemodel[i] = RowerTableModel(i)
gd.context.setContextProperty("rowerTableModel"+str(i), gd.rowertablemodel[i])
gd.rowerPlots[i] = RowerForm(i)
gd.context.setContextProperty("rower_mpl"+str(i), gd.rowerPlots[i])
# print(f'main: create the models rower {i} {gd.rowerPlots[i].update_figure}')
gd.stretcherPlots[i] = StretcherForm(i)
gd.context.setContextProperty("stretcher_mpl"+str(i), gd.stretcherPlots[i])
# Session info
gd.data_model6 = DataBoatsModel()
gd.context.setContextProperty("sInfoModel", gd.data_model6)
gd.data_model6.load_boatsInfo()
engine.load(str(app_Path / 'App' / 'qml' / 'main.qml'))
gd.win = engine.rootObjects()[0]
# set figures functions
gd.mainPieces.figure = gd.win.findChild(QObject, "pieces").getFigure()
gd.mainView.figure = gd.win.findChild(QObject, "viewpiece").getFigure()
gd.boatPlots.figure = gd.win.findChild(QObject, "viewboat").getFigure()
gd.crewPlots.figure = gd.win.findChild(QObject, "viewcrew").getFigure()
sys.exit(app.exec_())
