self.tabWidget.blockSignals(True) self.tabWidget.setCurrentWidget(self.langEdits[lang]) self.tabWidget.blockSignals(False) def unserialize(self, data: dict, errors: List[Dict]) -> None: self.setErrors(errors) if not data: return self.lineEdit.setText(str(data)) def serializeForPost(self) -> dict: text = self.lineEdit.text() if text: return self.lineEdit.text() return "" def serializeForDocument(self) -> dict: return self.serialize() def CheckForPasswordBone( moduleName: str, boneName: str, skelStucture: Dict[str, Any]) -> bool: return skelStucture[boneName]["type"] == "password" # Register this Bone in the global queue editBoneSelector.insert(2, CheckForPasswordBone, PasswordEditBone) viewDelegateSelector.insert(2, CheckForPasswordBone, PasswordViewBoneDelegate)
self.entry.setText("")
class FileBoneSelector(TreeBoneSelector):
displaySourceWidget = FileWidget
displaySelectionWidget = SelectedFilesWidget
def keyPressEvent(self, e: QtGui.QKeyEvent) -> None:
"""Handle multiple selection via return or enter key press"""
if self.multiple and e.key() in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return):
self.selection.extend([item.entryData for item in self.list.selectedItems()])
else:
super(FileBoneSelector, self).keyPressEvent(e)
def prepareDeletion(self) -> None:
self.selection.prepareDeletion()
self.list.prepareDeletion()
def CheckForFileBone(
moduleName: str,
boneName: str,
skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"].startswith("relational.tree.leaf.file")
# Register this Bone in the global queue
editBoneSelector.insert(4, CheckForFileBone, FileItemBone)
# viewDelegateSelector.insert(4, CheckForFileBone, FileViewBoneDelegate) # Disable the fileViewDelegate
if str(data) in items:
self.comboBox.setCurrentIndex(
self.comboBox.findText(items[str(data)]))
else:
self.comboBox.setCurrentIndex(-1)
else: # except:
self.comboBox.setCurrentIndex(-1)
def serializeForPost(self) -> Dict[str, Any]:
currentValue = str(self.comboBox.currentText())
for key, value in self.values:
if str(value) == currentValue:
return str(key)
return None
def CheckForSelectOneBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
isSelect = skelStucture[boneName]["type"] == "select" or skelStucture[
boneName]["type"].startswith("select.")
return isSelect and not bool(skelStucture[boneName].get("multiple"))
# Register this Bone in the global queue
editBoneSelector.insert(2, CheckForSelectOneBone, SelectOneEditBone)
viewDelegateSelector.insert(2, CheckForSelectOneBone,
SelectOneViewBoneDelegate)
extendedSearchWidgetSelector.insert(
1, ExtendedSelectOneFilterPlugin.canHandleExtension,
ExtendedSelectOneFilterPlugin)
widgetGen = lambda: ListMultiContainer(preMultiWidgetGen)
if myStruct.get("languages"):
preLangWidgetGen = widgetGen
widgetGen = lambda: LanguageContainer(myStruct["languages"],
preLangWidgetGen)
return widgetGen()
def unserialize(self, data: Dict[str, Any], errors: List[Dict]) -> None:
self.setErrors(errors)
if not data:
return
try:
lat, lng = data
except:
lat = lng = 0
self.lat.setValue(lat)
self.lng.setValue(lng)
def serializeForPost(self) -> Dict[str, Any]:
return {"lat": str(self.lat.value()), "lng": str(self.lng.value())}
def CheckForSpatialBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
return (skelStucture[boneName]["type"] == "spatial")
# Register this Bone in the global queue
editBoneSelector.insert(2, CheckForSpatialBone, SpatialEditBone)
viewDelegateSelector.insert(2, CheckForSpatialBone, SpatialViewBoneDelegate)
required,
multiple=False,
languages=None,
**kwargs)
if myStruct.get("multiple"):
preMultiWidgetGen = widgetGen
widgetGen = lambda: ListMultiContainer(preMultiWidgetGen)
if myStruct.get("languages"):
preLangWidgetGen = widgetGen
widgetGen = lambda: LanguageContainer(myStruct["languages"], preLangWidgetGen)
return widgetGen()
def unserialize(self, data: Dict[str, Any], errors: List[Dict]) -> None:
self.setErrors(errors)
if not data:
return
self.lineEdit.setText(unescapeHtml(str(data)))
def serializeForPost(self) -> Dict[str, Any]:
return self.lineEdit.text()
def CheckForStringBone(moduleName: str, boneName: str, skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"] == "str" or skelStucture[boneName]["type"].startswith("str.")
# Register this Bone in the global queue
editBoneSelector.insert(2, CheckForStringBone, StringEditBone)
viewDelegateSelector.insert(2, CheckForStringBone, StringViewBoneDelegate)
extendedSearchWidgetSelector.insert(1, ExtendedStringFilterPlugin.canHandleExtension, ExtendedStringFilterPlugin)
displaySelectionWidget = TreeSelectedEntities
def onSourceItemDoubleClicked(self,
item: QtWidgets.QListWidgetItem) -> None:
"""
An item has been doubleClicked in our listWidget.
Read its properties and add them to our selection.
"""
return
def onSourceItemClicked(self, item: QtWidgets.QListWidgetItem) -> None:
if not isinstance(item, self.list.getNodeItemClass()):
return
data = item.entryData
selection = self.selection.get()
if data in selection:
self.selection.set([])
else:
self.selection.set([data])
def CheckForTreeDirBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"].startswith("treedir.")
# Register this Bone in the global queue
editBoneSelector.insert(2, CheckForTreeDirBone, TreeDirBone)
viewDelegateSelector.insert(2, CheckForTreeDirBone, TreeDirViewBoneDelegate)
def showDialog(self) -> None:
acolor = QtWidgets.QColorDialog.getColor(
QtGui.QColor(self.lineEdit.displayText()), self.lineEdit,
self.skelStructure[self.boneName]["descr"])
if acolor.isValid():
self.lineEdit.setText(acolor.name())
self.refreshColor()
def refreshColor(self) -> None:
self.colordisplay.setStyleSheet("QWidget { background-color: %s }" %
str(self.lineEdit.displayText()))
def unserialize(self, data: dict, errors: List[Dict]) -> None:
self.setErrors(errors)
data = str(data) if data else ""
self.lineEdit.setText(data)
self.colordisplay.setStyleSheet("QWidget { background-color: %s }" %
data)
def serializeForPost(self) -> dict:
return str(self.lineEdit.displayText())
def CheckForColorBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
res = skelStucture[boneName]["type"] == "color"
return res
editBoneSelector.insert(2, CheckForColorBone, ColorEditBone)
self.ui.setupUi(self)
self.setTitle(extension["name"])
self.ui.values.addItem("", None)
for userData, text in extension["values"].items():
self.ui.values.addItem(text, userData)
@staticmethod
def canHandleExtension(extension: Dict[str, Any]) -> bool:
return (isinstance(extension, dict) and "type" in extension
and (((extension["type"] == "select"
or extension["type"].startswith("select."))
and extension.get("multiple", True)) or
(extension["type"] == "selectmulti"
or extension["type"].startswith("selectmulti."))))
def CheckForSelectMultiBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
isSelect = skelStucture[boneName]["type"] == "select" or skelStucture[
boneName]["type"].startswith("select.")
return isSelect and bool(skelStucture[boneName].get("multiple"))
# Register this Bone in the global queue
editBoneSelector.insert(2, CheckForSelectMultiBone, SelectMultiEditBone)
viewDelegateSelector.insert(2, CheckForSelectMultiBone,
SelectMultiViewBoneDelegate)
extendedSearchWidgetSelector.insert(
1, ExtendedSelectMultiFilterPlugin.canHandleExtension,
ExtendedSelectMultiFilterPlugin)
return widgetGen()
def unserialize(self, data: Dict[str, Any], errors: List[Dict]) -> None:
self.setErrors(errors)
return self.internalEdit.unserialize(
data or {}, errors) # New, non-multipe record-bones may be none
def serializeForPost(self) -> dict:
return self.internalEdit.serializeForPost()
def setErrors(self, errorList): # Just forward to internalEdit
self.internalEdit.setErrors(errorList)
def getEffectiveMaximumBoneError(
self,
inOptionalContainer: bool = False
) -> int: # Just forward to internalEdit
return self.internalEdit.getEffectiveMaximumBoneError(
inOptionalContainer or not self.required)
def CheckForRecordBoneBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"] == "record" or skelStucture[
boneName]["type"].startswith("record.")
# Register this Bone in the global queue
editBoneSelector.insert(2, CheckForRecordBoneBone, RecordEditBone)
viewDelegateSelector.insert(2, CheckForRecordBoneBone, RecordViewBoneDelegate)
self.lineEdit.setDateTime(
QtCore.QDateTime(
QtCore.QDate(self.dt.year, self.dt.month, self.dt.day),
QtCore.QTime(self.dt.hour, self.dt.minute, self.dt.second)))
elif self.date: # date only
self.lineEdit.setDate(QtCore.QDate(self.dt.year, self.dt.month, self.dt.day))
else:
self.lineEdit.setTime(QtCore.QTime(self.dt.hour, self.dt.minute, self.dt.second))
def serializeForPost(self) -> dict:
# FIXME: what's about deleted or not set date / times?
if self.time and self.date: # date AND time
arg = self.lineEdit.dateTime().toString(QtCore.Qt.ISODate)
elif self.date: # date only
arg = self.lineEdit.date().toString("dd.MM.yyyy")
else: # time only
arg = self.lineEdit.time().toString("hh:mm:ss")
return arg
def serializeForDocument(self) -> dict:
return self.serialize()
def CheckForDateBone(moduleName: str, boneName: str, skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"] == "date"
editBoneSelector.insert(2, CheckForDateBone, DateEditBone)
extendedSearchWidgetSelector.insert(1, DateRangeFilterPlugin.canHandleExtension, DateRangeFilterPlugin)
except AttributeError:
pass
self.selectionChanged.emit(self.selection.get())
event.emit("popWidget", self)
def onBtnCancelReleased(self, *args: Any, **kwargs: Any) -> None:
logger.debug("onBtnCancelReleased")
try:
self.selection.prepareDeletion()
except AttributeError:
pass
event.emit("popWidget", self)
def getFilter(self) -> Dict[str, Any]:
return self.list.getFilter()
def setFilter(self, queryFilter: Dict[str, Any]) -> None:
return self.list.setFilter(queryFilter)
def getModul(self) -> str:
return self.list.getModul()
def CheckForRelationalicBone(moduleName: str, boneName: str, skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"].startswith("relational.")
# Register this Bone in the global queue
editBoneSelector.insert(2, CheckForRelationalicBone, RelationalEditBone)
viewDelegateSelector.insert(2, CheckForRelationalicBone, RelationalViewBoneDelegate)
widgetGen = lambda: ListMultiContainer(preMultiWidgetGen)
if myStruct.get("languages"):
preLangWidgetGen = widgetGen
widgetGen = lambda: LanguageContainer(myStruct["languages"],
preLangWidgetGen)
return widgetGen()
def unserialize(self, data: dict, errors: List[Dict]) -> None:
self.setErrors(errors)
if data:
self.checkBox.setChecked(True)
def serializeForPost(self) -> dict:
return "1" if self.checkBox.isChecked() else "0"
def serializeForDocument(self) -> dict:
return self.serialize()
def CheckForBooleanBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"] == "bool"
# Register this Bone in the global queue
editBoneSelector.insert(2, CheckForBooleanBone, BooleanEditBone)
viewDelegateSelector.insert(2, CheckForBooleanBone, BooleanViewBoneDelegate)
extendedSearchWidgetSelector.insert(
1, ExtendedBooleanFilterPlugin.canHandleExtension,
ExtendedBooleanFilterPlugin)
"""
if not self.multiple:
self.entry.setReadOnly(True)
class HierarchyBoneSelector(RelationalBoneSelector):
displaySourceWidget = HierarchyWidget
def onSourceItemDoubleClicked(self,
item: QtWidgets.QListWidgetItem) -> None:
"""
An item has been doubleClicked in our listWidget.
Read its properties and add them to our selection.
"""
data = item.entryData
if self.multiple:
self.selection.extend([data])
else:
self.selectionChanged.emit([data])
event.emit("popWidget", self)
def CheckForHierarchyItemBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"].startswith("hierarchy.")
viewDelegateSelector.insert(1, CheckForHierarchyItemBone,
HierarchyItemViewBoneDelegate)
editBoneSelector.insert(1, CheckForHierarchyItemBone, HierarchyItemBone)
for module in self.modules:
self.checkmodulesbox(module)
def serializeForPost(self) -> Dict[str, Any]:
ret = []
for name in self.flags:
if self.checkboxes[name].isChecked():
ret.append(name)
for module in self.modules:
for state in self.states:
if self.modules[module][state][0].isChecked():
ret.append("%s-%s" % (module, state))
return {self.boneName: ret}
def serializeForDocument(self) -> Dict[str, Any]:
return self.serialize()
def CheckForAccessSelectMultiBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"] in ("select.access",
"selectmulti.access")
# Register this Bone in the global queue
editBoneSelector.insert(4, CheckForAccessSelectMultiBone,
AccessSelectMultiEditBone)
skelType = "leaf"
class TreeBoneSelector(RelationalBoneSelector):
displaySourceWidget = TreeWidget
displaySelectionWidget = TreeSelectedEntities
def onSourceItemDoubleClicked(self,
item: QtWidgets.QListWidgetItem) -> None:
"""
An item has been doubleClicked in our listWidget.
Read its properties and add them to our selection.
"""
if not isinstance(item, self.list.getLeafItemClass()):
return
data = item.entryData
if self.multiple:
self.selection.extend([data])
else:
self.selectionChanged.emit([data])
event.emit("popWidget", self)
def CheckForTreeItemBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"].startswith("relational.treeitem.")
editBoneSelector.insert(2, CheckForTreeItemBone, TreeItemBone)
viewDelegateSelector.insert(2, CheckForTreeItemBone, TreeItemViewBoneDelegate)
else:
self.webView.setHtml(text)
def unserialize(self, data: dict, errors: List[Dict]) -> None:
self.setErrors(errors)
self.html = str(data).replace("target=\"_blank\" href=\"",
"href=\"!") if (data) else ""
if isPyodide:
self.webView.setText(self.html)
else:
self.webView.setHtml(self.html)
def serializeForPost(self) -> Dict[str, Any]:
return self.html.replace("href=\"!", "target=\"_blank\" href=\"")
def serializeForDocument(self) -> dict:
return self.serialize()
def remove(self) -> None:
pass
def CheckForTextBone(moduleName: str, boneName: str,
skelStucture: Dict[str, Any]) -> bool:
return skelStucture[boneName]["type"] == "text"
# Register this Bone in the global queue
editBoneSelector.insert(2, CheckForTextBone, TextEditBone)
viewDelegateSelector.insert(2, CheckForTextBone, TextViewBoneDelegate)
self.setParams()
self.lineEdit.show()
def setParams(self) -> None:
self.setEnabled(not self.readOnly)
@staticmethod
def fromSkelStructure(moduleName: str, boneName: str, skelStructure: dict,
**kwargs: Any) -> Any:
readOnly = "readonly" in skelStructure[boneName] and skelStructure[
boneName]["readonly"]
required = "required" in skelStructure[boneName] and skelStructure[
boneName]["required"]
return BaseEditBone(moduleName, boneName, readOnly, required, **kwargs)
def unserialize(self, data: dict, errors: List[Dict]) -> None:
self.setErrors(errors)
self.lineEdit.setText(str(data) if data else "")
def serializeForPost(self) -> dict:
return self.lineEdit.displayText()
def serializeForDocument(self) -> dict:
return self.serialize()
# Register this Bone in the global queue
editBoneSelector.insert(0, lambda *args, **kwargs: True, BaseEditBone)
viewDelegateSelector.insert(0, lambda *args, **kwargs: True,
BaseViewBoneDelegate)