Пример #1
0
    def __getattribute__(self, name):
        if name in QmlWrapper._qml_wrapper_attribs:
            value = super().__getattribute__(name)
        else:
            qobject = super().__getattribute__("qobject")
            if hasattr(qobject, name):
                value = getattr(qobject, name)
                QmlWrapper.warn_name_clash(qobject, name)
            else:
                value = QQmlProperty.read(qobject, name)

        if isinstance(value, QJSValue):
            return value.toVariant()

        if isinstance(value, BoundSignal):
            # Workaround for a pqt5 bug where the qmlengine may wait for the first read to property named "name"
            # to make the auto-generated signal e.g. "nameChanged" active, we thus ensure property named "name"
            # is read at least once
            match = re.match(r"\d*(\D+)Changed", name)
            if match:
                QQmlProperty.read(qobject, match.group(1))

        if isinstance(value, QObject):
            if name == "qobject":
                return super().__getattribute__("qobject")

            wrappers = super().__getattribute__("wrappers")
            if name not in wrappers:
                wrappers[name] = QmlWrapper(value)
            return wrappers[name]

        return value
Пример #2
0
    def __init__(self, parent=None):
        super(HappyBirthdaySong, self).__init__(parent)

        self._line = -1
        self._lyrics = []
        self._target = QQmlProperty()
        self._name = ''

        timer = QTimer(self)
        timer.timeout.connect(self.advance)
        timer.start(1000)
Пример #3
0
    def __read_qml_properties(self):
        controls = self.window.controls

        self.cursor                = int(QQmlProperty.read(self.window.qobject, "cursor"))
        self.synchronized_cursor   = int(self.window.synchronizedCursor)
        self.player_cursor         = int(self.window.playerCursor)

        self.show_actor            =        controls.showActor
        self.show_bbox_2d          =        controls.showBBox2D
        self.show_seg_2d           =        controls.showSeg2D
        self.show_bbox_3d          =        controls.showBBox3D
        self.show_seg_3d           =        controls.showSeg3D
        self.show_lanes            =        controls.showLanes
        self.conf_threshold        = int(   controls.confThreshold)/100.0
        self.undistort             = bool(  controls.undistort)
        self.undistortimage        = bool(  controls.undistortimage)
        self.has_referential       =        controls.hasReferential
        self.point_size            = int(   controls.pointSize)
        self.use_colors            = bool(  controls.useColors)
        self.use_box_colors        = bool(  controls.useBoxColors)
        self.box_labels_size       = int(   controls.boxLabelsSize)
        self.ds_colors             =        controls.dsColors
        self.box_2d_colors         =        controls.box2DColors
        self.box_3d_colors         =        controls.box3DColors
        self.log_scale             = bool(  controls.logScale)
        self.is_recording          = bool(  controls.video)
        self.category_filter       = str(   controls.categoryFilter)
        self.aspect_ratio          = float( controls.aspectRatio)
        self.crops                 =       [controls.cropLeft, 
                                            controls.cropRight, 
                                            controls.cropTop, 
                                            controls.cropBottom]
Пример #4
0
    def get_intervals(self):
        cursors = QQmlProperty.read(self.leddar_vp.root, "cursors").toVariant()
        intervals = []
        for i in range(len(cursors) // 2):
            intervals.append((int(cursors[i * 2]), int(cursors[i * 2 + 1])))

        return intervals
Пример #5
0
    def _setup_properties(self, window):
        self.read_properties = \
            { 'cursor': lambda: int(QQmlProperty.read(window, "cursor"))
            , 'recording': lambda: bool(QQmlProperty.read(window, "recording"))
            , 'cursors': lambda: QQmlProperty.read(window, "cursors").toVariant()
            , 'datasetPath': lambda: QQmlProperty.read(window, "datasetPath")
            }

        self.write_properties = \
            {
                'cursors': lambda value: QQmlProperty.write(window, "cursors", value)
            }

        #TODO: Investigate, for some reason signals won't trigger if we don't read properties beforehand.
        for _, property in self.read_properties.items():
            property()
Пример #6
0
 def __setitem__(self, property_name, value):
     ''' Useful to force using QQmlProperty.write() in the case of a name clash '''
     rv = QQmlProperty.write(self.qobject, property_name, QVariant(value))
     if not rv:
         warnings.warn(
             f"QQmlProperty.write() on object {self.qobject} at {property_name} failed!"
         )
     return value
Пример #7
0
class HappyBirthdaySong(QObject, QQmlPropertyValueSource):
    def __init__(self, parent=None):
        super(HappyBirthdaySong, self).__init__(parent)

        self._line = -1
        self._lyrics = []
        self._target = QQmlProperty()
        self._name = ""

        timer = QTimer(self)
        timer.timeout.connect(self.advance)
        timer.start(1000)

    nameChanged = pyqtSignal()

    @pyqtProperty(str, notify=nameChanged)
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        if self._name != name:
            self._name = name

            self._lyrics = [
                "",
                "Happy birthday to you,",
                "Happy birthday to you,",
                "Happy birthday dear %s," % self._name,
                "Happy birthday to you!",
            ]

            self.nameChanged.emit()

    def setTarget(self, target):
        self._target = target

    @pyqtSlot()
    def advance(self):
        self._line += 1

        if self._line < len(self._lyrics):
            self._target.write(self._lyrics[self._line])
        else:
            QCoreApplication.instance().quit()
Пример #8
0
class HappyBirthdaySong(QObject, QQmlPropertyValueSource):
    def __init__(self, parent=None):
        super(HappyBirthdaySong, self).__init__(parent)

        self._line = -1
        self._lyrics = []
        self._target = QQmlProperty()
        self._name = ''

        timer = QTimer(self)
        timer.timeout.connect(self.advance)
        timer.start(1000)

    nameChanged = pyqtSignal()

    @pyqtProperty(str, notify=nameChanged)
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        if self._name != name:
            self._name = name

            self._lyrics = [
                "",
                "Happy birthday to you,",
                "Happy birthday to you,",
                "Happy birthday dear %s," % self._name,
                "Happy birthday to you!"
            ]

            self.nameChanged.emit()

    def setTarget(self, target):
        self._target = target

    @pyqtSlot()
    def advance(self):
        self._line += 1

        if self._line < len(self._lyrics):
            self._target.write(self._lyrics[self._line])
        else:
            QCoreApplication.instance().quit()
Пример #9
0
    def _connect_traces_windows(self):

        self.traces_windows = QQmlProperty.read(self.leddar_vp.root,
                                                "tracesWindows").toVariant()
        self._traces_windows = []
        for ds_name, window in self.traces_windows.items():
            self._traces_windows.append(
                TracesWindow(utils.QmlWrapper(window), self.pf,
                             self.synchronized, ds_name))
    def setupUi(self, Notification):

        msgv = QQuickView()

        msgv.setSource(QUrl('message.qml'))
        rootObj = msgv.rootObject()
        total_width = int(QQmlProperty.read(rootObj, "width"))
        total_height = int(QQmlProperty.read(rootObj, "height"))

        self.twidth = total_width
        self.theight = total_height

        qmlengine = msgv.engine()
        qmlengine.addImageProvider("bicimage", BicImageProvider())

        rootObj.findChild(QObject, "img").setProperty(
            "source", "image://bicimage/" + Notification.mssg["icon"])
        rootObj.findChild(QObject, "textprocess").setProperty(
            "text", Notification.mssg["process"])
        rootObj.findChild(QObject,
                          "filename").setProperty("text",
                                                  Notification.mssg["file"])
        rootObj.findChild(QObject, "textaction").setProperty(
            "text", Notification.mssg["action"])
        rootObj.findChild(QObject,
                          "textaction").setProperty("color",
                                                    Notification.mssg["color"])
        rootObj.findChild(QObject,
                          "timestr").setProperty("text",
                                                 Notification.mssg["time"])

        Notification.setObjectName(_fromUtf8("Notification"))
        Notification.setMinimumSize(QtCore.QSize(total_width, total_height))
        Notification.setMaximumSize(QtCore.QSize(total_width, total_height))

        # Notification.setWindowOpacity(1.0)
        # Notification.setAutoFillBackground(False)
        # Notification.setToolButtonStyle(QtCore.Qt.ToolButtonIconOnly)

        centralwidget = QWidget.createWindowContainer(msgv)
        centralwidget.setObjectName(_fromUtf8("centralwidget"))

        Notification.setCentralWidget(centralwidget)
Пример #11
0
    def __init__(self, parent=None):
        super(HappyBirthdaySong, self).__init__(parent)

        self._line = -1
        self._lyrics = []
        self._target = QQmlProperty()
        self._name = ''

        timer = QTimer(self)
        timer.timeout.connect(self.advance)
        timer.start(1000)
Пример #12
0
    def _generateJson(self, node: QQuickItem, offset: int) -> str:
        s = (' ' * (offset) * 4) + '{\n'
        s += (' ' * (offset + 1) * 4) + self['_generate' + QQmlProperty.read(node, 'actualName')](node)

        s += (' ' * (offset + 1) * 4) + "'x': " + str(node.x()) + ',\n'
        s += (' ' * (offset + 1) * 4) + "'y': " + str(node.y()) + ',\n'

        s += (' ' * (offset + 1) * 4) + "'children': [\n"
        rightPoint = QQmlProperty.read(node, '_rightPoint')
        if rightPoint is not None:
            try:
                arrows = QQmlProperty.read(rightPoint, 'arrows')
                if arrows.isArray():
                    for i in range(0, arrows.property('length').toInt()):
                        arrow = arrows.property(i).toQObject()
                        leftPoint = QQmlProperty.read(arrow, 'leftPoint')
                        s += self._generateJson(leftPoint.parent(), offset + 2) + ',\n'
            except Exception as e:
                print(e)
        s += (' ' * (offset + 1) * 4) + '],\n'
        s += (' ' * (offset) * 4) + '}'
        return s
Пример #13
0
    def showTime(self):
        time = QTime.currentTime()
        text = time.toString('hh:mm')
        date = QDate.currentDate()
        dateFinal = date.toString("dddd, d MMMM yyyy")
        #print('date is ',dateFinal)
        #if (time.second() % 2) == 0:
        #text = text[:2] + ':' + text[3:]

        QQmlProperty.write(self.digitalClock, "clockTime", str(text))
        QQmlProperty.write(self.digitalClock, "dateInfoQTime", str(dateFinal))


#if __name__ == '__main__':

#import sys

#app = QApplication(sys.argv)
#clock = DigitalClock()
#clock.show()
#sys.exit(app.exec_())
##
Пример #14
0
 def dumpQMLComponents(self, root):
     children = root.findChildren(QObject)
     for item in children:
         # Note the QML id property is NOT the objectName
         print(item, "name is:", item.objectName())
         try:
             '''
     Apparently you can't just access item's properties: item.id
     Also, the id property apparently is not accessible via QQmlProperty.
     '''
             foo = QQmlProperty.read(item, "shoeSize")
             print("shoeSize property:", foo)
         except AttributeError:
             pass
Пример #15
0
 def dumpQMLComponents(self, root):
     children = root.findChildren(QObject)
     for item in children:
         # Note the QML id property is NOT the objectName
         print(item, "name is:", item.objectName())
         try:
             """
     Apparently you can't just access item's properties: item.id
     Also, the id property apparently is not accessible via QQmlProperty.
     """
             foo = QQmlProperty.read(item, "shoeSize")
             print("shoeSize property:", foo)
         except AttributeError:
             pass
Пример #16
0
    def showTime(self):
        time = QTime.currentTime()
        text = time.toString('hh:mm')
        date = QDate.currentDate()
        dateFinal = date.toString("dddd, d MMMM yyyy")
        #print('date is ',dateFinal)
        #if (time.second() % 2) == 0:
            #text = text[:2] + ':' + text[3:]


        QQmlProperty.write(self.digitalClock, "clockTime",str(text) )
        QQmlProperty.write(self.digitalClock, "dateInfoQTime",str(dateFinal) )


#if __name__ == '__main__':

    #import sys

    #app = QApplication(sys.argv)
    #clock = DigitalClock()
    #clock.show()
    #sys.exit(app.exec_())
##
Пример #17
0
    def set_custom_viewports(self, ds_names, callbacks):

        QQmlProperty.write(self.leddar_vp.root, "customViewports", ds_names)

        self.custom_viewport_windows = {}

        while not all(k in self.custom_viewport_windows for k in ds_names):
            QApplication.processEvents()
            self.custom_viewport_windows = QQmlProperty.read(
                self.leddar_vp.root, "customViewportWindows").toVariant()

        self.custom_datasources = {}

        for i, ds in enumerate(ds_names):
            w = self.custom_viewport_windows[ds]
            cb = DasCallback(w, self.pf, ds)
            cb.vp = QQmlProperty.read(w, "viewport")
            cb.cursor_callback = callbacks[i]

            def update(context):
                cursor = int(QQmlProperty.read(context.window, "cursor"))
                context.cursor_callback(cursor, context)

            cb.wrap_callback(update)
            cb.callback()
            cb.connect_to(w.cursorChanged)
            cb.connect_to(w.visibleChanged)
            self.callbacks["custom_viewport_windows"][ds] = cb

            sensor_type, position, datasource = platform_utils.parse_datasource_name(
                ds)

            self.custom_datasources[ds] = {
                'sensor_name': f"{sensor_type}_{position}",
                'ds_name': datasource,
                'full_ds_name': ds,
                'size': len(self.synchronized)
            }

        QQmlProperty.write(self.leddar_vp.root, "customDatasources",
                           self.custom_datasources)

        return self.callbacks["custom_viewport_windows"]
Пример #18
0
 def __getitem__(self, property_name):
     ''' Useful to force using QQmlProperty.read() in the case of a name clash '''
     return QQmlProperty.read(self.qobject, property_name)
Пример #19
0
 def write_property(self, name:str, v):
     self._check_view()
     return QQmlProperty.write(self.root, name, QVariant(v), self.engine)
Пример #20
0
 def read_property(self, name:str):
     self._check_view()
     return QQmlProperty.read(self.root, name, self.engine)
Пример #21
0
    def _create_vp(self):

        self.populate_datasources()

        if self.pf.is_live():
            self.record = True

        self.leddar_vp = interactive.multi_windows_vp(
            'root_das.qml', [backend_qtquick5.QMLDIR, QMLDIR],
            [("mplIcons", backend_qtquick5.MatplotlibIconProvider())],
            rgb=sorted(self.pf.expand_wildcards(['*_img*', '*_flimg*'])),
            bboxes2D=sorted(self.pf.expand_wildcards(['*_box2d*'])),
            seg2D=sorted(
                self.pf.expand_wildcards(
                    ['*_poly2d-*', '*_seg2d-*', '*_seg2dimg-*'])),
            bboxes3D=sorted(self.pf.expand_wildcards(['*_box3d*'])),
            seg3D=sorted(self.pf.expand_wildcards(['*_seg3d-*'])),
            lanes=sorted(self.pf.expand_wildcards(['*_lane-*'])),
            viewports=sorted(
                self.pf.expand_wildcards([
                    '*_ech*', '*_xyzit', '*xyzit-*', '*_xyzvcfar*', '*_xyzvi*'
                ])),
            scalars=sorted(
                self.pf.expand_wildcards([
                    'sbgekinox_*',
                    'peakcan_*',
                    'encoder_*',
                    'mti_*',
                    'carlagps_*',
                    'carlaimu_*',
                    'imu_*',
                    'gps_*',
                    'bench_*',
                ])),
            traces=sorted(
                self.pf.expand_wildcards(['*_trr*', '*_trf*', '*_ftrr*'])),
            sensors=self.sensors,
            datasources=self.datasources,
            synchDatasources=self.synchronized.keys(),
            nIndices=len(self.synchronized),
            isLive=self.record)

        root = self.leddar_vp.root_wrapper()

        self.callbacks = {
            "scalars_windows": {},
            "traces_windows": {},
            "viewport_windows": {},
            "custom_viewport_windows": {}
        }

        self.all_windows = {}

        self._connect_scalars_windows()
        self._connect_traces_windows()
        self._connect_viewport_windows()
        self._connect_imager_windows()
        self.custom_viewport_windows = {}

        self.metadata_window = MetadataWindow(
            self.leddar_vp.root_wrapper().metadataWindow, self.synchronized)

        self.player_window = PlayerWindow(self.leddar_vp.root, self.pf,
                                          self._all_windows(),
                                          self.synchronized, self)

        self.calib_window = CalibWindow(
            self.leddar_vp.root_wrapper().calibWindow, self.pf)

        QQmlProperty.write(self.leddar_vp.root, "title",
                           os.path.abspath(self.pf.dataset))
Пример #22
0
 def warn_name_clash(qobject, name):
     if QQmlProperty(qobject, name).isValid():
         warnings.warn(
             f"Name clash detected on object {qobject} for property '{name}', property name exists for both QML and QObject API."
         )
Пример #23
0
 def update(context):
     cursor = int(QQmlProperty.read(context.window, "cursor"))
     context.cursor_callback(cursor, context)