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
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()
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()
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"]
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_())
##
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_())
##
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()
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))
def write_property(self, name:str, v):
self._check_view()
return QQmlProperty.write(self.root, name, QVariant(v), self.engine)
