def registerTypes(self, uri): sys.stderr.write( 'exampleqmlitemplugin.py debug: ExampleQmlItemPlugin.registerTypes(): uri - {!r}\n' .format(uri)) sys.stderr.flush() try: QtQml.qmlRegisterType( pyqt5_plugins.examples.exampleqmlitem.ExampleQmlItem, 'examples', 1, 0, 'ExampleQmlItem', ) except Exception as e: sys.stderr.write( 'exampleqmlitemplugin.py debug: ExampleQmlItemPlugin.registerTypes(): exception - {!r}\n' .format(e)) sys.stderr.flush() traceback.print_exc(file=sys.stderr) sys.stderr.flush() raise sys.stderr.write( 'exampleqmlitemplugin.py debug: ExampleQmlItemPlugin.registerTypes(): about to return None\n' ) sys.stderr.flush() return None
def registerTypes(self, uri): QtQml.qmlRegisterType( pyqt5_tools.examples.exampleqmlitem.ExampleQmlItem, 'examples', 1, 0, 'ExampleQmlItem', )
def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) # QtQml.qmlRegisterType(ViewConfig, 'ViewConfig', 1, 0, 'ViewConfig') self.view = QtQuickWidgets.QQuickWidget(self) rootCtx = self.view.rootContext() self.cfg = ViewConfig(self) self.msgStack = MessageStack(self) rootCtx.setContextProperty('viewConfig', self.cfg) QtQml.qmlRegisterType(MessageItem, 'Message', 1, 0, 'Message') QtQml.qmlRegisterType(MessageStack, 'Message', 1, 0, 'Store') rootCtx.setContextProperty('msgStack', self.msgStack) self.view.setSource(QtCore.QUrl("qrc:///qml/message-view.qml")) # self.view.show() self.timer = QtCore.QTimer() self.timer.timeout.connect(self.repaint) self.timer.start(50)
def main(qml_file="millerLauncher.qml", path=""): # _root = os.path.abspath(path) # List._root = os.path.abspath(path) # Show QML Window full_directory = os.path.dirname(os.path.abspath(__file__)) app = pigui.pyqt5.widget.QApplication(sys.argv) # app = QtWidgets.QApplication(sys.argv) QtQml.qmlRegisterType(Controller, 'Controller', 1, 0, 'Controller') engine = QtQml.QQmlApplicationEngine() qml_file = os.path.join(full_directory, qml_file) engine.load(str(qml_file)) window = engine.rootObjects()[0] window.show() sys.exit(app.exec_())
super(Filesystem, self).__init__(parent) @QtCore.pyqtSlot(str, result="QStringList") def listdir(self, path): """Exposed function to QML Note input parameter specified in decorator, along with output format """ return os.listdir(path) app = QtWidgets.QApplication(sys.argv) QtQml.qmlRegisterType(Filesystem, 'Os', 1, 0, 'Filesystem') engine = QtQml.QQmlApplicationEngine() def finish_load(obj, url): if obj is not None: obj.show() app.exec_() else: sys.exit() engine.objectCreated.connect(finish_load) engine.load(QtCore.QUrl.fromLocalFile("app.qml"))
self.player.start() else: if self.player.isRunning(): self.player.terminate() @QtCore.pyqtSlot(float) def scrub(self, where): if self.isPlaying: self.isPlaying = False self.progress = where self.isPlaying = True else: self.progress = where filename_changed, filename = autoProperty(str, 'filename') isPlaying_changed, isPlaying = autoProperty(bool, 'isPlaying') progress_changed, progress = autoProperty(float, 'progress') waveform_changed, waveform = autoProperty(QtCore.QVariant, 'waveform', readonly=True) length_changed, length = autoProperty(float, 'length', readonly=True) if __name__ == "__main__": if not QtGui.QGuiApplication.instance(): app = QtGui.QGuiApplication(sys.argv) QtQml.qmlRegisterType(Player, 'Player', 1, 0, 'Player') engine = QtQml.QQmlApplicationEngine('main.qml') if len(engine.rootObjects()) > 0: mainWindow = engine.rootObjects()[0] mainWindow.setVisible(True) app.exec()
Whenever the property named `prop` is changed, each dataset's `prop` property is set accordingly. Additionally, when adding a dataset, its `prop` property is initialized with the current value. Parameters ---------- prop Name of the property whose value should be passed on to datasets """ self._propagated.append(prop) sig = getNotifySignal(self, prop) sig.connect(lambda: self._propagatedPropertyChanged(prop)) def _propagatedPropertyChanged(self, prop: str): """Slot called when a property marked for propagation changes This does the actual setting of the datasets' properties. Parameters ---------- prop Property name """ newVal = getattr(self, prop) for i in range(self.rowCount()): setattr(self.get(i, "dataset"), prop, newVal) QtQml.qmlRegisterType(Dataset, "SdtGui", 0, 1, "Dataset") QtQml.qmlRegisterType(DatasetCollection, "SdtGui", 0, 1, "DatasetCollection")
import os import sys from PyQt5 import QtCore, QtQml, QtWidgets from mymodel import MyModel, MyItem osname = os.name.lower() sysplatform = sys.platform.lower() windows = os.name.lower() == "nt" and sysplatform.startswith("win") # PyQt class name, QML URI, major version, minor version, QML type name QtQml.qmlRegisterType(MyModel, 'MyModel', 1, 0, 'MyModel') QtQml.qmlRegisterType(MyItem, 'MyItem', 1, 0, 'MyItem') app = QtWidgets.QApplication(sys.argv) # Create the QML engine engine = QtQml.QQmlEngine(app) engine.quit.connect(app.quit) # Load the main.qml file and create the toplevel component component = QtQml.QQmlComponent(engine) currentFilePath = os.path.dirname(os.path.abspath(__file__)) mainFilepath = os.path.join(currentFilePath, "main.qml") if windows: mainFilepath = mainFilepath.replace('\\', '/') qmlFile = QtCore.QUrl("file:///" + mainFilepath) component.loadUrl(qmlFile) if component.status() != QtQml.QQmlComponent.Ready: for error in component.errors(): print(error.toString())
def main(): app = QtGui.QGuiApplication(sys.argv) QtQml.qmlRegisterType(LoginManager, 'LoginManager', 1, 0, 'LoginManager') engine = QtQml.QQmlApplicationEngine(os.path.join(THIS_DIR, "Main.qml")) app.exec_()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import sys, signal from PyQt5 import QtCore, QtGui, QtQml from zmq_client import ZmqClient from camera_item import CameraItem if __name__ == "__main__": app = QtGui.QGuiApplication(sys.argv) app.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling) app.setOverrideCursor(QtCore.Qt.BlankCursor) QtQml.qmlRegisterType(CameraItem, "goldo", 1, 0, "CameraItem") engine = QtQml.QQmlApplicationEngine() zmq_client = ZmqClient() engine.rootContext().setContextProperty("zmqClient", zmq_client) engine.load('qml/main.qml') signal.signal(signal.SIGINT, signal.SIG_DFL) sys.exit(app.exec_())
def main(): app = QtGui.QGuiApplication(sys.argv) QtQml.qmlRegisterType(JSManager, 'JSManager', 1, 0, 'JSManager') engine = QtQml.QQmlApplicationEngine(os.path.join(THIS_DIR, "main.qml")) app.exec_()
@image.setter def image(self, image: Union[np.ndarray, None]): if self._image is image: return self._image = image self._imageMinVal = image.min() if image is not None else 0.0 self._imageMaxVal = image.max() if image is not None else 0.0 self._imageMinChanged.emit(self._imageMin) self._imageMaxChanged.emit(self._imageMax) self.imageChanged.emit(image) _imageMinChanged = QtCore.pyqtSignal(float) @QtCore.pyqtProperty(float, notify=_imageMinChanged) def _imageMin(self) -> float: """Minimum value in input image. Used for QML property binding.""" return self._imageMinVal _imageMaxChanged = QtCore.pyqtSignal(float) @QtCore.pyqtProperty(float, notify=_imageMaxChanged) def _imageMax(self): """Maximum value in input image. Used for QML property binding.""" return self._imageMaxVal error = SimpleQtProperty(str) """Error message to be displayed""" QtQml.qmlRegisterType(ImageDisplay, "SdtGui.Templates", 0, 1, "ImageDisplay")
#! /usr/bin/env python # -*- coding: utf-8 -*- # Copyright (C) 2011 ~ 2014 Deepin, Inc. # 2011 ~ 2014 Hou ShaoHui # # Author: Hou ShaoHui <*****@*****.**> # Maintainer: Hou ShaoHui <*****@*****.**> # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from PyQt5 import QtQml from dtalk.gui.plugins.message import DMessage from dtalk.gui.plugins.popup import PopupItem QtQml.qmlRegisterType(DMessage, "DTalk", 1, 0, "DMessage") QtQml.qmlRegisterType(PopupItem, "DTalk", 1, 0, "PopupItem")
""" if self._locData is None or not self._locData.size: self._circles = [] else: vals = np.empty((len(self._locData), 4)) for i, axis in enumerate(["x", "y"]): sz_col = f"size_{axis}" sizes = self._locData[sz_col if sz_col in self._locData.columns else "size"] sizes = sizes.to_numpy() * self.scaleFactor coords = self._locData[axis] * self.scaleFactor - sizes vals[:, i] = coords vals[:, i + 2] = 2 * sizes self._circles = [QtCore.QRectF(*v) for v in vals] self.update() def paint(self, painter: QtGui.QPainter): # Implement QQuickItem.paint pen = painter.pen() pen.setColor(self.color) pen.setWidthF(2.5) pen.setCosmetic(True) painter.setPen(pen) painter.setRenderHint(QtGui.QPainter.Antialiasing, True) for c in self._circles: painter.drawEllipse(c) QtQml.qmlRegisterType(LocDisplay, "SdtGui", 0, 1, "LocDisplay")
if self.player.isRunning(): self.player.terminate() @QtCore.pyqtSlot(float) def scrub(self, where): if self.isPlaying: self.isPlaying = False self.progress = where self.isPlaying = True else: self.progress = where filename_changed, filename = autoProperty(str, 'filename') isPlaying_changed, isPlaying = autoProperty(bool, 'isPlaying') progress_changed, progress = autoProperty(float, 'progress') waveform_changed, waveform = autoProperty(QtCore.QVariant, 'waveform', readonly=True) length_changed, length = autoProperty(float, 'length', readonly=True) if __name__ == "__main__": if not QtGui.QGuiApplication.instance(): app = QtGui.QGuiApplication(sys.argv) QtQml.qmlRegisterType(Player, 'Player', 1, 0, 'Player') engine = QtQml.QQmlApplicationEngine('main.qml') if len(engine.rootObjects()) > 0: mainWindow = engine.rootObjects()[0] mainWindow.setVisible(True) app.exec()
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA) frame = QtGui.QImage(frame, frame.shape[1], frame.shape[0], 17) self.cam_frame = frame.copy() self.update() def get_frames(app): cap = cv2.VideoCapture(0) num = 0 imgw = ImageWriter() while True: while num != 30: _, bgframe = cap.read() num += 1 ret, frame = cap.read() if ret: imgw.update_frame(frame) #print("get frames") app.processEvents() if __name__ == '__main__': app = QtGui.QGuiApplication(sys.argv) QtQml.qmlRegisterType(ImageWriter, "imageWriter", 1, 0, "ImageWriter") view = QtQuick.QQuickView() view.setSource(QtCore.QUrl('test.qml')) rootObject = view.rootObject() view.show() get_frames(app) sys.exit(app.exec_())
@staticmethod def workerFunc(image: np.ndarray, algorithm: str, options: Mapping[str, Any]) -> pd.DataFrame: """Run localization algorithm This is executed in the worker process. Paramters --------- image Image to find localizations in. algorithm Name of the algorithm, i.e., name of the submodule in :py:mod:`sdt.loc`. options Arguments passed to the ``locate`` function of the submodule specified by `algorithm` Returns ------- Localization data """ if image is None: return None algo_mod = getattr(loc, algorithm) result = algo_mod.locate(image, **options) return result QtQml.qmlRegisterType(LocOptions, "SdtGui.Templates", 0, 1, "LocOptions")
Parameters ---------- index Index of currently selected frame """ if self._curImage is None: self._image = None else: try: self._image = self._curImage[index] except Exception as ex: self._image = None err = str(ex) if self._error != err: self._error = err self.errorChanged.emit() self._image = None else: if self._error: self._error = "" self.errorChanged.emit() self.imageChanged.emit() currentIndex = QmlDefinedProperty() """Index w.r.t :py:attr:`dataset` of currently selected image sequence""" currentFrame = QmlDefinedProperty() """Currently selected frame number""" QtQml.qmlRegisterType(ImageSelector, "SdtGui.Templates", 0, 1, "ImageSelector")
super(Species, self).__init__(parent=parent, identifier=identifier) self.name = None self.cost = None self.baseLE = None self.baseSK = None self.baseZ = None self.baseGS = None self.talentBoniList = None self.cultureList = None self.perkList = None self.quirkList = None self.unusualPerkList = None self.unusualQuirkList = None self.hairColorList = None self.eyeColorList = None self.heightLimits = None self.weightLimits = None def select(self, c): c.species = self def deselect(self, c): pass QtQml.qmlRegisterType(Species, 'dsa5', 1, 0, 'species') QtQml.qmlRegisterType(Trait, 'dsa5', 1, 0, 'trait') QtQml.qmlRegisterType(Perk, 'dsa5', 1, 0, 'perk') QtQml.qmlRegisterType(Quirk, 'dsa5', 1, 0, 'quirk') # QtQml.qmlRegisterType(Id, 'dsa5', 1, 0, 'id')
import os import sys from PyQt5 import QtCore, QtQml, QtWidgets from regatta import QRegatta, QEvent, QSailingClub, QPerson # Fixme: I have no idea why I can't put it in a method # def main(): osname = os.name.lower() sysplatform = sys.platform.lower() windows = os.name.lower() == "nt" and sysplatform.startswith("win") # PyQt class name, QML URI, major version, minor version, QML type name QtQml.qmlRegisterType(QRegatta, 'QRegatta', 1, 0, 'QRegatta') QtQml.qmlRegisterType(QEvent, 'QEvent', 1, 0, 'QEvent') QtQml.qmlRegisterType(QSailingClub, 'QSailingClub', 1, 0, 'QSailingClub') QtQml.qmlRegisterType(QPerson, 'QPerson', 1, 0, 'QPerson') app = QtWidgets.QApplication(sys.argv) # Create the QML engine engine = QtQml.QQmlEngine(app) engine.quit.connect(app.quit) # Load the main.qml file and create the toplevel component component = QtQml.QQmlComponent(engine) currentFilePath = os.path.dirname(os.path.abspath(__file__)) mainFilepath = os.path.join(currentFilePath, "regatta/main.qml") if windows:
class MaxRGBFilter(PyCVQML.CVAbstractFilter): def process_image(self, src): return max_rgb_filter(src) class GrayFilter(PyCVQML.CVAbstractFilter): def process_image(self, src): return rgb_to_gray(src) if __name__ == '__main__': import os import sys app = QtGui.QGuiApplication(sys.argv) PyCVQML.registerTypes() QtQml.qmlRegisterType(MaxRGBFilter, "Filters", 1, 0, "MaxRGBFilter") QtQml.qmlRegisterType(GrayFilter, "Filters", 1, 0, "GrayFilter") view = QtQuick.QQuickView() view.setTitle("PyCVQML Example") dir_path = os.path.dirname(os.path.realpath(__file__)) view.setSource( QtCore.QUrl.fromLocalFile( QtCore.QDir(dir_path).absoluteFilePath("main.qml"))) view.show() sys.exit(app.exec_())
#! /usr/bin/env python # -*- coding: utf-8 -*- from PyQt5 import QtQml from gui.popup import PopupItem QtQml.qmlRegisterType(PopupItem, "DGui", 1, 0, "PopupItem")
"""Resize all ROIs to `model`'s size This is a callback invoked when a ROI (whose name is given by the `model` argument) changes. Parameters ---------- model Name of the channel to get the ROI size from image Image defining the ROI boundaries """ allRois = self.channels modelRoi = allRois[model]["roi"] sz = modelRoi.size for n, v in allRois.items(): r = v.get("roi", None) if n == model or r is None: continue if image is not None: # Resize to right/bottom only as long as image boundaries are # not exceeded tl = (min(r.top_left[0], image.shape[1] - sz[0]), min(r.top_left[1], image.shape[0] - sz[1])) else: tl = r.top_left self._setROI(v.get("source_id", 0), n, sdt_roi.ROI(tl, size=sz)) QtQml.qmlRegisterType(ChannelConfig, "SdtGui.Templates", 0, 1, "ChannelConfig")
def registerTypes(uri="PyCVQML"): QtQml.qmlRegisterType(CVCapture, uri, 1, 0, "CVCapture") QtQml.qmlRegisterType(CVItem, uri, 1, 0, "CVItem")
"""Convert QUrl to local file name string Parameters ---------- u URL to convert Returns ------- File name """ return u.toLocalFile() @QtCore.pyqtSlot(QtCore.QUrl, result=QtCore.QUrl) def parentUrl(self, u: QtCore.QUrl) -> QtCore.QUrl: """Get URL of directory containing `u` Parameters ---------- u URL to get parent directory for Returns ------- URL to `u`'s parent """ return QtCore.QUrl.fromLocalFile(str(Path(u.toLocalFile()).parent)) QtQml.qmlRegisterType(Sdt, "SdtGui.Templates", 0, 1, "Sdt")
@QtCore.pyqtSlot() def GetServerNames(self): def go(): serverNames = ["one", "two", "three"] self.serverNames.emit(serverNames) threading.Thread(target=go).start() @QtCore.pyqtSlot() def GetLastLogin(self): def go(): login = "******" self.lastLogin.emit(login) threading.Thread(target=go).start() @QtCore.pyqtSlot() def GetLastServerName(self): def go(): serverName = "three" self.lastServer.emit(serverName) threading.Thread(target=go).start() app = QtGui.QGuiApplication(sys.argv) QtQml.qmlRegisterType(LoginManager, 'LoginManager', 1, 0, 'LoginManager') engine = QtQml.QQmlApplicationEngine("Main.qml") app.exec_()
# -*- coding: utf-8 -*- import sys from PyQt5 import QtCore, QtWidgets, QtQuick, QtQml import text_balloon if __name__ == '__main__': app = QtWidgets.QApplication(sys.argv) view = QtQuick.QQuickView() QtQml.qmlRegisterType(text_balloon.TextBalloon, "Custom", 1, 0, "TextBalloon") view.setSource(QtCore.QUrl("main.qml")) view.show() sys.exit(app.exec_())
return reg @QtCore.pyqtSlot() def abortCalculation(self): """Abort processing""" if self._worker is None: return self._worker.enabled = False self._worker = None def _workerFinished(self, retval: multicolor.Registrator): """Worker has finished Store the result in :py:attr:`registrator` Parameters ---------- retval Result of calculation """ self.registrator = retval self.abortCalculation() def _workerError(self, exc: Exception): # TODO: error handling print("worker exc", exc) self.abortCalculation() QtQml.qmlRegisterType(Registrator, "SdtGui.Templates", 0, 1, "Registrator")
QtGui.QImage.Format_Grayscale8) self.update() def paint(self, painter: QtGui.QPainter): if self._qImage is None: return # Maybe use self._qImage.scaled(), which would allow to specifiy # whether to do interpolation or not? painter.drawImage( QtCore.QRect(0, 0, self.width(), self.height()), self._qImage, QtCore.QRect(0, 0, self.sourceWidth, self.sourceHeight)) sourceWidthChanged = QtCore.pyqtSignal(int) """Width of the image changed.""" @QtCore.pyqtProperty(int, notify=sourceWidthChanged) def sourceWidth(self) -> int: """Width of the image.""" return self._source.shape[1] if self._source is not None else 0 sourceHeightChanged = QtCore.pyqtSignal(int) """Height of the image changed.""" @QtCore.pyqtProperty(int, notify=sourceHeightChanged) def sourceHeight(self) -> int: """Height of the image.""" return self._source.shape[0] if self._source is not None else 0 QtQml.qmlRegisterType(PyImage, "SdtGui", 0, 1, "PyImage")
# -*- coding: utf-8 -*- # Copyright (C) 2011 ~ 2014 Deepin, Inc. # 2011 ~ 2014 Hou ShaoHui # # Author: Hou ShaoHui <*****@*****.**> # Maintainer: Hou ShaoHui <*****@*****.**> # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from PyQt5 import QtQml from dtalk.gui.plugins.message import DMessage from dtalk.gui.plugins.popup import PopupItem QtQml.qmlRegisterType(DMessage, "DTalk", 1, 0, "DMessage") QtQml.qmlRegisterType(PopupItem, "DTalk", 1, 0, "PopupItem")
def qmlRegister(): QtQml.qmlRegisterType(WheelArea, "QuickMamba", 1, 0, "WheelAreaImpl") QtQml.qmlRegisterType(ExternDropArea, "QuickMamba", 1, 0, "ExternDropAreaImpl") QtQml.qmlRegisterType(ColorExtended, "QuickMamba", 1, 0, "ColorExtended") QtQml.qmlRegisterType(ColorPicker, "QuickMamba", 1, 0, "ColorPicker")
# -*- coding: utf-8 -*- import sys from PyQt5 import QtCore, QtGui, QtQuick, QtQml import squircle if __name__ == '__main__': app = QtGui.QGuiApplication(sys.argv) QtQml.qmlRegisterType(squircle.Squircle, "OpenGLUnderQML", 1, 0, "Squircle") view = QtQuick.QQuickView() # Rendering in a thread introduces a slightly more complicated cleanup # so we ensure that no cleanup of graphics resources happen until the # application is shutting down. view.setPersistentOpenGLContext(True) view.setPersistentSceneGraph(True) view.setResizeMode(QtQuick.QQuickView.SizeRootObjectToView) view.setSource(QtCore.QUrl("main.qml")) view.show() execReturn = app.exec() # As the render threads make use of our QGuiApplication object # to clean up gracefully, wait for them to finish before # QGuiApp is taken off the heap. for t in squircle.Squircle.threads: t.wait()
Parameters ---------- locData Localization data for tracking searchRange `search_range` parameter to :py:func:`trackpy.link` memory `memory` parameter to :py:func:`trackpy.link` Returns ------- Tracked data """ if locData is None: return None if not locData.size: ret = locData.copy() ret["particle"] = [] return ret trackpy.quiet() return trackpy.link(locData, search_range=searchRange, memory=memory) @QtCore.pyqtSlot(result=QtCore.QVariant) def getTrackFunc(self) -> Callable[[pd.DataFrame], pd.DataFrame]: return functools.partial(self.workerFunc, searchRange=self.searchRange, memory=self.memory) QtQml.qmlRegisterType(TrackOptions, "SdtGui.Templates", 0, 1, "TrackOptions")
class DataCollector(QtQuick.QQuickItem): """QtQuick item which allows for defining a dataset and associated files This supports defining multiple files per dataset entry, which can appear, for instance, when using multiple cameras simultaneously; see the :py:attr:`sourceNames` property. """ sourceNames = QmlDefinedProperty() """Number of source files per dataset entry or list of source names""" dataset = QmlDefinedProperty() """:py:class:`Dataset` that is used by this item""" class MultiDataCollector(QtQuick.QQuickItem): """QtQuick item which allows for defining datasets and associated files This supports defining multiple datasets using :py:class:`DataCollector`. """ sourceNames = QmlDefinedProperty() """Number of source files per dataset entry or list of source names""" datasets = QmlDefinedProperty() """:py:class:`DatasetCollection` that is used by this item""" QtQml.qmlRegisterType(DataCollector, "SdtGui.Templates", 0, 1, "DataCollector") QtQml.qmlRegisterType(MultiDataCollector, "SdtGui.Templates", 0, 1, "MultiDataCollector")
def _makeLines(self): """Create lines marking the tracks This calls also :py:meth:`update` to trigger paint. """ self._lines = [] if self._curFrame < 0 or self._trc is None: self.locData = None else: self.locData = self._trc[self._trc["frame"] == self._curFrame] curTrc = self._trc.groupby("particle").filter(lambda x: (x[ "frame"].min() <= self._curFrame <= x["frame"].max())) # TODO: sort by frame for p, t in curTrc.groupby("particle"): xs = (t["x"].to_numpy() + 0.5) * self.scaleFactor ys = (t["y"].to_numpy() + 0.5) * self.scaleFactor poly = QtGui.QPolygonF( QtCore.QPointF(x, y) for x, y in zip(xs, ys)) self._lines.append(poly) self.update() def paint(self, painter: QtGui.QPainter): # Implement QQuickItem.paint super().paint(painter) for li in self._lines: painter.drawPolyline(li) QtQml.qmlRegisterType(TrackDisplay, "SdtGui", 0, 1, "TrackDisplay")
def _workerFinished(self, retval: Any): """Worker has finished Store the result in the dataset Parameters ---------- retval Return value of :py:attr:`func` call """ if self._resultRole: if self._resultRole not in self._curDset.roles: self._curDset.roles = self._curDset.roles + [self._resultRole] self._curDset.set(self._curIndex, self._resultRole, retval) self._progress += 1 self._curIndex += 1 self.progressChanged.emit() if self.progress < self._count: self._nextCall() else: self.abort() def _workerError(self, exc): # TODO: error handling tb = traceback.TracebackException.from_exception(exc) print("".join(tb.format())) self.abort() QtQml.qmlRegisterType(BatchWorker, "SdtGui.Templates", 0, 1, "BatchWorker")
import os import sys from PyQt5 import QtCore, QtQml, QtWidgets from sortfilterproxymodel import SortFilterProxyModel from mymodel import MyModel, MyItem osname = os.name.lower() sysplatform = sys.platform.lower() windows = os.name.lower() == "nt" and sysplatform.startswith("win") # PyQt class name, QML URI, major version, minor version, QML type name QtQml.qmlRegisterType(MyModel, 'MyModel', 1, 0, 'MyModel') QtQml.qmlRegisterType(MyItem, 'MyItem', 1, 0, 'MyItem') QtQml.qmlRegisterType(SortFilterProxyModel, 'SortFilterProxyModel', 1, 0, 'SortFilterProxyModel') app = QtWidgets.QApplication(sys.argv) # Create the QML engine engine = QtQml.QQmlEngine(app) engine.quit.connect(app.quit) # Load the main.qml file and create the toplevel component component = QtQml.QQmlComponent(engine) currentFilePath = os.path.dirname(os.path.abspath(__file__)) mainFilepath = os.path.join(currentFilePath, "main.qml") if windows: mainFilepath = mainFilepath.replace('\\', '/') qmlFile = QtCore.QUrl("file:///" + mainFilepath) component.loadUrl(qmlFile) if component.status() != QtQml.QQmlComponent.Ready: