class MarkdownDocument(QObject):
def __init__(self):
QObject.__init__(self)
self.textVal = str()
def readText(self):
return self.textVal
def setText(self, val):
self.textVal = val
self.textChanged.emit(val)
textChanged = Signal(str)
text = Property(str, readText, setText, notify=textChanged)
class GameManager(QObject):
@abc.abstractmethod
def get_instances(self) -> List[GameInstance]:
"""Return a list of active game instance. The instances returned should be stable (same instance for all invocation)"""
...
instance_added = Signal()
instance_removed = Signal()
instance_changed = Signal()
instances = Property(list, get_instances, notify=instance_changed)
def stop(self):
"""Stop the GameManager and any GameInstances"""
pass
class MyObjectWithNotifyProperty(QObject):
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.p = 0
def readP(self):
return self.p
def writeP(self, v):
self.p = v
self.notifyP.emit()
notifyP = Signal()
myProperty = Property(int, readP, fset=writeP, notify=notifyP)
class PolyEncoder(QObject):
# name, min, max, value
def __init__(self, starteffect="", startparameter=""):
QObject.__init__(self)
self.effectval = starteffect
self.parameterval = startparameter
self.speed = 1
self.value = 1
def readEffect(self):
return self.effectval
def setEffect(self, val):
self.effectval = val
self.effect_changed.emit()
@Signal
def effect_changed(self):
pass
effect = Property(str, readEffect, setEffect, notify=effect_changed)
def readParameter(self):
return self.parameterval
def setParameter(self, val):
self.parameterval = val
self.parameter_changed.emit()
@Signal
def parameter_changed(self):
pass
parameter = Property(str,
readParameter,
setParameter,
notify=parameter_changed)
class PieChart (QQuickPaintedItem):
def __init__(self, parent = None):
QQuickPaintedItem.__init__(self, parent)
self._name = u''
self._color = QColor()
def paint(self, painter):
pen = QPen(self._color, 2)
painter.setPen(pen);
painter.setRenderHints(QPainter.Antialiasing, True);
painter.drawPie(self.boundingRect(), 90 * 16, 290 * 16);
def getColor(self):
return self._color
def setColor(self, value):
if value != self._color:
self._color = value
self.update()
self.colorChanged.emit()
def getName(self):
return self._name
def setName(self, value):
self._name = value
colorChanged = Signal()
color = Property(QColor, getColor, setColor, notify=colorChanged)
name = Property(text_type, getName, setName)
chartCleared = Signal()
@Slot() # This should be something like @Invokable
def clearChart(self):
self.setColor(Qt.transparent)
self.update()
self.chartCleared.emit()
class PieSlice(QQuickPaintedItem):
def __init__(self, parent=None):
QQuickPaintedItem.__init__(self, parent)
self._color = QColor()
self._fromAngle = 0
self._angleSpan = 0
def getColor(self):
return self._color
def setColor(self, value):
self._color = value
def getFromAngle(self):
return self._angle
def setFromAngle(self, value):
self._fromAngle = value
def getAngleSpan(self):
return self._angleSpan
def setAngleSpan(self, value):
self._angleSpan = value
color = Property(QColor, getColor, setColor)
fromAngle = Property(int, getFromAngle, setFromAngle)
angleSpan = Property(int, getAngleSpan, setAngleSpan)
def paint(self, painter):
global paintCalled
pen = QPen(self._color, 2)
painter.setPen(pen)
painter.setRenderHints(QPainter.Antialiasing, True)
painter.drawPie(self.boundingRect(), self._fromAngle * 16,
self._angleSpan * 16)
paintCalled = True
class BenchmarkWrapper(QObject):
def __init__(self, benchmark):
super().__init__()
self._benchmark = benchmark
def _name(self):
return self._benchmark['name']
name_changed = Signal()
name = Property("QString", _name, notify=name_changed)
def _path(self):
return basename(self._benchmark['path'])
path_changed = Signal()
path = Property("QString", _path, notify=path_changed)
def _isPlaced(self):
return self._benchmark['isPlaced']
isPlaced_changed = Signal()
isPlaced = Property("bool", _isPlaced, notify=isPlaced_changed)
def _isOther(self):
return self._benchmark.get('isOther', False)
isOther_changed = Signal()
isOther = Property("bool", _isOther, notify=isOther_changed)
class CsvColumn(QObject):
"""Store content of a CSV column."""
def __init__(self, title="", parent=None):
"""Initialize the object with optional column title parameter."""
super(CsvColumn, self).__init__(parent=parent)
self._title = title
self._content = []
def appendValue(self, value):
self._content.append(value)
@Slot(result=str)
def getFirst(self):
if not self._content:
return ""
return self._content[0]
@Slot(result=str)
def getLast(self):
if not self._content:
return ""
return self._content[-1]
@Slot(QtCharts.QXYSeries)
def fillChartSerie(self, serie):
"""Fill XYSerie used for displaying QML Chart."""
if not serie:
return
serie.clear()
for index, value in enumerate(self._content):
serie.append(float(index), float(value))
title = Property(str, lambda self: self._title, constant=True)
content = Property("QStringList",
lambda self: self._content,
constant=True)
class Box(Component):
def __init__(self):
super(Box, self).__init__()
self._type = ComponentType.Box
self._width = 1
self._height = 1
self._depth = 1
def width(self):
return self._width
def setWidth(self, value):
self._width = value
def height(self):
return self._height
def setHeight(self, value):
self._height = value
def depth(self):
return self._depth
def setDepth(self, value):
self._depth = value
widthProperty = Property(float, width, setHeight)
heightProperty = Property(float, height, setHeight)
depthProperty = Property(float, depth, setDepth)
def createPropertyMap(self):
return [
ComponentProperty('Width', 'width', float),
ComponentProperty('Height', 'height', float),
ComponentProperty('Depth', 'depth', float)
]
class UndoStack(QUndoStack):
def __init__(self, parent=None):
super(UndoStack, self).__init__(parent)
# connect QUndoStack signal to UndoStack's ones
self.cleanChanged.connect(self._cleanChanged)
self.canUndoChanged.connect(self._canUndoChanged)
self.canRedoChanged.connect(self._canRedoChanged)
self.undoTextChanged.connect(self._undoTextChanged)
self.redoTextChanged.connect(self._redoTextChanged)
def tryAndPush(self, command):
# type: (UndoCommand) -> bool
try:
res = command.redoImpl()
except Exception as e:
logging.error("Error while trying command '{}': \n{}".format(
command.text(), traceback.format_exc()))
res = False
if res is not False:
command.setEnabled(False)
self.push(command) # takes ownership
command.setEnabled(True)
return res
# Redeclare QUndoStack signal since original ones can not be used for properties notifying
_cleanChanged = Signal()
_canUndoChanged = Signal()
_canRedoChanged = Signal()
_undoTextChanged = Signal()
_redoTextChanged = Signal()
clean = Property(bool, QUndoStack.isClean, notify=_cleanChanged)
canUndo = Property(bool, QUndoStack.canUndo, notify=_canRedoChanged)
canRedo = Property(bool, QUndoStack.canRedo, notify=_canUndoChanged)
undoText = Property(str, QUndoStack.undoText, notify=_undoTextChanged)
redoText = Property(str, QUndoStack.redoText, notify=_redoTextChanged)
def __deepcopy__(self, memo):
cls = self.__class__
result = cls.__new__(cls)
super(Dipole, result).__init__()
memo[id(self)] = result
for k, v in self.__dict__.items():
if (k not in ("quaternion", "quaternionChanged")):
setattr(result, k, deepcopy(v, memo))
elif (k == "quaternion"):
result.quaternionChanged = Signal()
result.quaternion = Property(QQuaternion,
result.getQuaternion,
result.setQuaternion,
notify=result.quaternionChanged)
return result
class Connector(QObject):
def __init__(self):
super(Connector, self).__init__()
self._text = "default"
self.setObjectName("ConnectorObject")
def setText(self, value):
print("setText : " + value)
self._text = value
self.textChanged.emit()
def getText(self):
return self._text
textChanged = Signal()
text = Property(str, getText, setText, notify=textChanged)
class Num(QObject):
def __init__(self):
super(Num, self).__init__()
self._number = "10"
self.setObjectName("NumObject")
def setNumber(self, number):
print("setNumber : " + number)
self._number = number
self.numberChanged.emit()
def getNumber(self):
return self._number
numberChanged = Signal()
number = Property(str, getNumber, setNumber, notify=numberChanged)
class SingleParam(ParamBase):
"""A direct mapping to a single parameter within a
:class:`~jvconnected.device.ParameterGroup`
"""
_param_group_attr = None
_n_value = Signal()
def __init__(self, *args):
assert self._param_group_attr is not None
self._prop_attr_map = {self._param_group_attr:'value'}
self._value = None
super().__init__(*args)
def _g_value(self) -> str: return str(self._value)
def _s_value(self, value: str): self._generic_setter('_value', value)
value: str = Property(str, _g_value, _s_value, notify=_n_value)
"""The parameter value"""
class MyClass(QObject):
def __init__(self):
super(MyClass, self).__init__()
self.__url = QUrl()
def getUrl(self):
return self.__url
def setUrl(self, value):
newUrl = QUrl(value)
if (newUrl != self.__url):
self.__url = newUrl
self.urlChanged.emit()
urlChanged = Signal()
urla = Property(QUrl, getUrl, setUrl, notify=urlChanged)
class DeviceInfoList(GenericQObject):
_n_devices = Signal()
update_devices = Signal()
def __init__(self, *args):
self._devices = {}
self._devices_by_index = {}
self._devices_by_serial = {}
super().__init__(*args)
self.update_devices.connect(self._on_update_devices)
def _g_devices(self):
d = self._devices
return [d[key] for key in sorted(d.keys())]
def _s_devices(self, value):
changed = False
for i, val in enumerate(value):
if self._devices.get(i) != val:
changed = True
self._devices[i] = val
if changed:
self._n_devices.emit()
devices = Property('QVariantList',
_g_devices,
_s_devices,
notify=_n_devices)
def _on_update_devices(self):
device_serials = RtlSdr.get_device_serial_addresses()
logger.debug(f'found sdr serial numbers: {device_serials}')
for i, device_serial in enumerate(device_serials):
if i in self._devices:
continue
device = self.add_device(i, device_serial)
def add_device(self, device_index, device_serial):
assert device_index not in self._devices
device = DeviceInfo()
device.device_index = device_index
device.device_serial = device_serial
self._devices_by_index[device_index] = device
device.get_info_from_device_index(device_index)
self._devices[device_index] = device
self._n_devices.emit()
return device
class StringField(Field):
def __init__(self, property):
super(StringField, self).__init__(property)
self._widget = QLineEdit()
self._widget.textChanged.connect(self.emitChanged)
def value(self):
return self._widget.text()
def setValue(self, value):
self._widget.setText(value)
def setReadOnly(self, value):
self._widget.setReadOnly(value)
valueProperty = Property(
str, value, Field.setValueBlocked) # C++: should be in parent class
class KrajeListModel(QAbstractListModel):
def __init__(self, filename=None):
QAbstractListModel.__init__(self)
self.kraje_list = []
self.ktery_kraj = None
if filename:
self.load_from_json(filename)
# nacteni jsonu kraju
def load_from_json(self, filename):
with open(filename, encoding="utf-8") as f:
self.kraje_list = json.load(f)
# zjisteni poctu kraju
def rowCount(self, parent: QtCore.QModelIndex = ...) -> int:
return len(self.kraje_list['polozky'])
# nacteni nazvu kraju
def data(self, index: QtCore.QModelIndex, role: int = ...) -> typing.Any:
if not index.isValid():
return None
if role == QtCore.Qt.DisplayRole:
return self.kraje_list['polozky'][index.row()]['nazev']
# poslani id vybraneho kraje do tridy okresu po vybrani kraje uzivatelem
@Slot()
def zmena(self):
print(self.ktery_kraj)
ajdicko = 0
for i in range(len(self.kraje_list['polozky']) - 1, -1, -1):
if self.kraje_list['polozky'][i]['nazev'] == self.ktery_kraj:
ajdicko = self.kraje_list['polozky'][i]['id']
okresylist_model.setkraj(ajdicko)
# tvorba property pro ziskani nazvu kraje z qml
def get_ktery(self):
return self.ktery_kraj
def set_ktery(self, new_val):
if self.ktery_kraj != new_val:
self.ktery_kraj = new_val
self.counter_changed3.emit()
counter_changed3 = Signal()
krajus = Property(str, get_ktery, set_ktery, notify=counter_changed3)
class RssFeedReader(QObject):
"""
Loads the RSS feed from the network async, every complete
download is announced as the emit of the signal
"""
rssFeedLoadedFromSource = Signal()
rssFeedComplete = Signal()
def __init__(self, parent=None):
super().__init__(parent)
self._rss = []
@Slot()
def refreshRssFeed(self):
"""
Refresh the RSS data from the servers
"""
logging.info("Worker thread starting")
self._thread = QThread()
self.worker = Worker()
# connect the signals with slots or re-emit the signals
self._thread.started.connect(self.worker.do_work)
self._thread.finished.connect(self._thread.deleteLater)
self.worker.rssSourceLoaded.connect(self.rssFeedLoadedFromSource.emit)
self.worker.rssDownloadComplete.connect(self.downloadComplete)
# move the worker to its own thread
self.worker.moveToThread(self._thread)
self._thread.start()
logging.info("Worker thread started via QThread")
@Slot()
def downloadComplete(self):
logging.info("Download complete, stopping thread")
self._rss = self.worker.get_list()
self._thread.quit()
self.rssFeedComplete.emit()
def get_list(self):
return self._rss
rssList = Property('QVariantList', get_list)
class Number(QObject):
__val = 0
@Signal
def numberChanged(self):
pass
@Slot(int)
def set_number(self, val):
print("setter func")
self.__val = val
self.numberChanged.emit()
def get_number(self):
print("getter func")
return self.__val
ValueNumber = Property(int, get_number, set_number, notify=numberChanged)
class PolyBool(QObject):
# name, min, max, value
def __init__(self, startval=False):
QObject.__init__(self)
self.valueval = startval
def readValue(self):
return self.valueval
def setValue(self, val):
self.valueval = val
self.value_changed.emit()
@Signal
def value_changed(self):
pass
value = Property(bool, readValue, setValue, notify=value_changed)
class MyObject(QObject):
def __init__(self, parent=None):
QObject.__init__(self, parent)
self._p = 100
def setX(self, value):
self._p = value
def getX(self):
return self._p
def resetX(self):
self._p = 100
def delX(self):
self._p = 0
x = Property(int, getX, setX, resetX, delX)
def __init_subclass__(cls, *args, **kwargs):
super().__init_subclass__(**kwargs)
# transform AutoProp instances into Qt properties
for attr in dir(cls):
try:
prop = getdeepr(cls, attr)
except AttributeError:
continue
if not isinstance(prop, AutoProp):
continue
prop_kwargs = {'notify': getdeepr(cls, prop.signal_name)}
if prop.fget:
prop_kwargs['fget'] = prop.fget
if prop.writable:
prop_kwargs['fset'] = prop.fset
setattr(
cls, attr, Property(prop.type_signature, **prop_kwargs)
)
class PieSlice (QQuickPaintedItem):
def __init__(self, parent = None):
QQuickPaintedItem.__init__(self, parent)
self._color = QColor()
def getColor(self):
return self._color
def setColor(self, value):
self._color = value
color = Property(QColor, getColor, setColor)
def paint(self, painter):
pen = QPen(self._color, 2)
painter.setPen(pen);
painter.setRenderHints(QPainter.Antialiasing, True);
painter.drawPie(self.boundingRect(), 90 * 16, 290 * 16);
class CurrencyComboBox(QComboBox):
changed = Signal(int)
def __init__(self, parent):
QComboBox.__init__(self, parent)
self.p_selected_id = 0
self.model = None
self.table_name = 'currencies'
self.field_name = 'name'
self.activated.connect(self.OnUserSelection)
self.model = QSqlTableModel(db=db_connection())
self.model.setTable(self.table_name)
self.model.select()
self.setModel(self.model)
self.setModelColumn(self.model.fieldIndex(self.field_name))
def isCustom(self):
return True
def getId(self):
return self.p_selected_id
def setId(self, new_id):
if self.p_selected_id == new_id:
return
self.p_selected_id = new_id
name = get_field_by_id_from_table(self.table_name, self.field_name,
self.p_selected_id)
if self.currentIndex() == self.findText(name):
return
self.setCurrentIndex(self.findText(name))
selected_id = Property(int, getId, setId, notify=changed, user=True)
def setIndex(self, index):
if index is not None:
self.selected_id = index
self.changed.emit(self.selected_id)
@Slot()
def OnUserSelection(self, _selected_index):
self.selected_id = self.model.record(self.currentIndex()).value("id")
self.changed.emit(self.selected_id)
class Container(QObject):
def __init__(self, name, data, parent=None):
super().__init__(parent)
self.setObjectName(name)
self._content = data
self.destroyed.connect(self._slot_container_is_going_to_be_destroyed)
@Slot(QObject)
def _slot_container_is_going_to_be_destroyed(self, obj: QObject):
logger().info(f'{type(obj)}: {obj.objectName()} (id:{id(obj)}) is going to be destroyed')
self.terminal_clean_up()
def terminal_clean_up(self):
try:
self._content.terminal_clean_up()
except AttributeError:
pass
self._content = None
def get_content(self):
return self._content
def _get_content_property(self):
return self.get_content()
content = Property(str, _get_content_property, constant=True)
def data(self, column: str, role: int):
if role in [Qt.DisplayRole, Qt.EditRole]:
if column == 'name':
return self.objectName()
return None
def set_data(self, column: str, role: int, data):
return False
# def editable(self, column: str):
# return False
def flags(self, column: str, flags):
return flags
def values_choice(self, column='value'):
return None, None
class Squircle(QQuickItem):
def __init__(self, t=0.0, parent=None):
super().__init__(parent)
# self._renderer = None
self._t = t
self._renderer = None
self.windowChanged.connect(self.onWindowChanged)
@Slot(QQuickWindow)
def onWindowChanged(self, window):
self.window().beforeSynchronizing.connect(self.sync,
type=Qt.DirectConnection)
self.window().setClearBeforeRendering(False)
@Slot()
def sync(self):
print("sync({})".format(self._t))
if self._renderer is None:
self._renderer = SquircleRenderer()
self.window().beforeRendering.connect(self._renderer.paint,
type=Qt.DirectConnection)
self._renderer.set_viewport_size(self.window().size() *
self.window().devicePixelRatio())
self._renderer.set_t(self._t)
self._renderer.set_window(self.window())
def getT(self):
return self._t
def setT(self, t):
if t == self._t:
return
self._t = t
#print("setT({})".format(t))
if self.window():
self.window().update()
@Signal
def t_changed(self):
pass
t = Property(float, getT, setT, notify=t_changed)
class PieChart(QQuickPaintedItem):
def __init__(self, parent=None):
QQuickPaintedItem.__init__(self, parent)
self._name = u''
self._slices = []
def getName(self):
return self._name
def setName(self, value):
self._name = value
name = Property(text_type, getName, setName)
def appendSlice(self, _slice):
_slice.setParentItem(self)
self._slices.append(_slice)
slices = ListProperty(PieSlice, appendSlice)
class Notif(NotifP):
def __init__(self, val=None):
self._val = val
super().__init__()
@Signal
def changed(self):
pass
def read(self):
return self._val
def write(self, val):
if self._val != val:
self._val = val
self.changed.emit()
py.update()
val = Property(type_, read, write, notify=changed)
class Person(QObject):
def __init__(self):
super().__init__()
self.current_mood = "Happy"
def getMood(self):
return self.current_mood
def setMood(self, mood):
if mood != self.current_mood and mood != "":
self.current_mood = mood
# Call the notifying signal. We are not passing data here so don't need to emit anything in particular.
self.moodChanged.emit()
# Notifying signal - to be used in qml as "onMoodChanged"
moodChanged = Signal()
# Mood property to be accessed to and from QML and Python.
mood = Property(str, getMood, setMood, notify=moodChanged)
