class AbstractStoreWidget(QWidget):
"""
@brief Ein einfaches Widget, um das Inventar des Charakters zu füllen.
"""
itemBought = Signal(str, str)
itemSold = Signal(str, str)
def __init__(self, template, character, parent=None):
super(AbstractStoreWidget, self).__init__(parent)
self.ui = Ui_AbstractStoreWidget()
self.ui.setupUi(self)
self.__character = character
self.__storage = template
self.__modelInventory = QStandardItemModel()
self.ui.view_inventory.setModel(self.__modelInventory)
self.__modelStore = QStandardItemModel()
self.ui.view_store.setModel(self.__modelStore)
## Resources
self.ui.traitDots_resources.valueChanged.connect(
self.__character.traits["Merit"]["Social"]["Resources"].setValue)
self.__character.traits["Merit"]["Social"][
"Resources"].valueChanged.connect(
self.ui.traitDots_resources.setValue)
self.ui.traitDots_enhancedItem.valueChanged.connect(
self.__character.traits["Merit"]["Item"]["Enhanced Item"].setValue)
self.__character.traits["Merit"]["Item"][
"Enhanced Item"].valueChanged.connect(
self.ui.traitDots_enhancedItem.setValue)
## Items
self.ui.traitDots_token.maximum = 10
self.ui.traitDots_imbuedItem.maximum = 10
self.ui.traitDots_artifact.maximum = 10
self.ui.traitDots_cursedItem.valueChanged.connect(
self.__character.traits["Merit"]["Item"]["Cursed Item"].setValue)
self.ui.traitDots_fetish.valueChanged.connect(
self.__character.traits["Merit"]["Item"]["Fetish"].setValue)
self.ui.traitDots_token.valueChanged.connect(
self.__character.traits["Merit"]["Item"]["Token"].setValue)
self.ui.traitDots_imbuedItem.valueChanged.connect(
self.__character.traits["Merit"]["Item"]["Imbued Item"].setValue)
self.ui.traitDots_artifact.valueChanged.connect(
self.__character.traits["Merit"]["Item"]["Artifact"].setValue)
self.__character.traits["Merit"]["Item"][
"Cursed Item"].valueChanged.connect(
self.ui.traitDots_cursedItem.setValue)
self.__character.traits["Merit"]["Item"][
"Fetish"].valueChanged.connect(self.ui.traitDots_fetish.setValue)
self.__character.traits["Merit"]["Item"]["Token"].valueChanged.connect(
self.ui.traitDots_token.setValue)
self.__character.traits["Merit"]["Item"][
"Imbued Item"].valueChanged.connect(
self.ui.traitDots_imbuedItem.setValue)
self.__character.traits["Merit"]["Item"][
"Artifact"].valueChanged.connect(
self.ui.traitDots_artifact.setValue)
self.ui.pushButton_add.setIcon(
QIcon(":/icons/images/actions/1leftarrow.png"))
self.ui.pushButton_remove.setIcon(
QIcon(":/icons/images/actions/1rightarrow.png"))
self.__modelInventory.rowsInserted.connect(self.checkButtonState)
self.__modelInventory.rowsRemoved.connect(self.checkButtonState)
self.__modelStore.rowsInserted.connect(self.checkButtonState)
self.__modelStore.rowsRemoved.connect(self.checkButtonState)
self.ui.pushButton_add.clicked.connect(self.buyItem)
self.ui.view_store.doubleClicked.connect(self.buyItem)
self.ui.pushButton_remove.clicked.connect(self.sellItem)
self.ui.view_inventory.doubleClicked.connect(self.sellItem)
self.ui.lineEdit_custom.textChanged.connect(
self.changeCustomButtonState)
self.ui.pushButton_addCustom.clicked.connect(self.buyCustomItem)
def setEnhancedItemTraitsVisible(self, sw=True):
self.ui.label_enhancedItem.setVisible(sw)
self.ui.traitDots_enhancedItem.setVisible(sw)
def setMagicalItemTraitsVisible(self, sw=True):
self.ui.label_cursedItem.setVisible(sw)
self.ui.traitDots_cursedItem.setVisible(sw)
self.ui.label_fetish.setVisible(sw)
self.ui.traitDots_fetish.setVisible(sw)
self.ui.label_token.setVisible(sw)
self.ui.traitDots_token.setVisible(sw)
self.ui.label_artifact.setVisible(sw)
self.ui.traitDots_artifact.setVisible(sw)
self.ui.label_imbuedItem.setVisible(sw)
self.ui.traitDots_imbuedItem.setVisible(sw)
def setAddCustomVisible(self, sw=True):
self.ui.widget_custom.setVisible(sw)
def addItemToStore(self, name, category=None, icon=None):
newItem = QStandardItem(name)
if icon:
newItem.setIcon(icon)
if category:
newItem.setData(category)
self.__modelStore.appendRow(newItem)
def buyItem(self):
"""
Der besagte Gegenstand wird vom Laden in das Inventar übernommen.
"""
listOfItems = self.__modelStore.takeRow(
self.ui.view_store.currentIndex().row())
self.__modelInventory.appendRow(listOfItems)
self.itemBought.emit(listOfItems[0].text(), listOfItems[0].data())
def __customItem(self, name):
"""
Erzeugt einen vom Benutzer benannten Gegenstand.
"""
if name:
existingItemInventory = self.__modelInventory.findItems(name)
if not existingItemInventory:
existingItem = self.__modelStore.findItems(name)
if existingItem:
listOfItems = self.__modelStore.takeRow(
existingItem[0].index().row())
self.__modelInventory.appendRow(listOfItems)
self.itemBought.emit(listOfItems[0].text(),
listOfItems[0].data())
else:
newItem = QStandardItem(name)
self.__modelInventory.appendRow(newItem)
self.itemBought.emit(newItem.text(), newItem.data())
def buyCustomItem(self):
"""
Fügt dem Inventar des Charakters einen Gegenstand hinzu.
\todo Nach dem Drücken des Hinzufügen.Knopfes, sollte der Fokus wieder auf das LineEdit gehen.
"""
newName = self.ui.lineEdit_custom.text()
if newName:
self.__customItem(newName)
## Textzeile löschen
self.ui.lineEdit_custom.setText("")
def sellItem(self):
"""
Der besagte Gegenstand wird vom Inventar zurück in den Laden befördert.
"""
listOfItems = self.__modelInventory.takeRow(
self.ui.view_inventory.currentIndex().row())
self.__modelStore.appendRow(listOfItems)
#for item in listOfItems:
#Debug.debug(item.data())
self.itemSold.emit(listOfItems[0].text(), listOfItems[0].data())
def moveItemToInventory(self, name, category=None):
"""
Der besagte Gegenstand wird aus dem Laden ins Inventar bewegt. Gibt es keinen Gegenstand dieses Namens im Laden, wird er direkt im Inventar erzeugt.
"""
foundItems = self.__modelStore.findItems(name)
if foundItems:
for item in foundItems:
if item.data() == category:
listOfItems = self.__modelStore.takeRow(item.index().row())
self.__modelInventory.appendRow(listOfItems)
else:
self.__customItem(name)
def moveItemToStore(self, name, category=None):
"""
Der besagte Gegenstand wird aus dem Inventar in den Laden bewegt.
"""
foundItems = self.__modelInventory.findItems(name)
for item in foundItems:
if item.data() == category:
listOfItems = self.__modelInventory.takeRow(item.index().row())
self.__modelStore.appendRow(listOfItems)
def checkButtonState(self):
"""
Aktiviert/Deaktiviert die Knöpfe für das Übertragen von Gegenständen.
"""
if self.__modelInventory.rowCount() > 0:
self.ui.pushButton_remove.setEnabled(True)
else:
self.ui.pushButton_remove.setEnabled(False)
if self.__modelStore.rowCount() > 0:
self.ui.pushButton_add.setEnabled(True)
else:
self.ui.pushButton_add.setEnabled(False)
def changeCustomButtonState(self):
"""
Aktiviert den Knopf zum Hinzufügen eines zusätzlichen Gegenstandes nur, wenn es etwas zum Hinzufügen gibt. Die zeile also nicht leer und der Gegnstand noch nicht vorhanden ist.
"""
self.ui.pushButton_addCustom.setEnabled(False)
if self.ui.lineEdit_custom.text(
) and not self.__modelInventory.findItems(
self.ui.lineEdit_custom.text()):
self.ui.pushButton_addCustom.setEnabled(True)
class SelectionSetsWidget(QFrame):
"""
Widget for managing multiple stored item selections
"""
selectionModified = Signal(bool)
def __init__(self, parent):
QFrame.__init__(self, parent)
self.setContentsMargins(0, 0, 0, 0)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(1)
self._setNameLineEdit = QLineEdit(self)
layout.addWidget(self._setNameLineEdit)
self._setListView = QListView(self)
self._listModel = QStandardItemModel(self)
self._proxyModel = QSortFilterProxyModel(self)
self._proxyModel.setSourceModel(self._listModel)
self._setListView.setModel(self._proxyModel)
self._setListView.setItemDelegate(ListItemDelegate(self))
self._setNameLineEdit.textChanged.connect(
self._proxyModel.setFilterFixedString)
self._completer = QCompleter(self._listModel, self)
self._setNameLineEdit.setCompleter(self._completer)
self._listModel.itemChanged.connect(self._onSetNameChange)
layout.addWidget(self._setListView)
buttonLayout = QHBoxLayout()
self._addAction = QAction(
"+", self, toolTip="Add a new sort key")
self._updateAction = QAction(
"Update", self, toolTip="Update/save current selection")
self._removeAction = QAction(
"\u2212", self, toolTip="Remove selected sort key.")
self._addToolButton = QToolButton(self)
self._updateToolButton = QToolButton(self)
self._removeToolButton = QToolButton(self)
self._updateToolButton.setSizePolicy(
QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
self._addToolButton.setDefaultAction(self._addAction)
self._updateToolButton.setDefaultAction(self._updateAction)
self._removeToolButton.setDefaultAction(self._removeAction)
buttonLayout.addWidget(self._addToolButton)
buttonLayout.addWidget(self._updateToolButton)
buttonLayout.addWidget(self._removeToolButton)
layout.addLayout(buttonLayout)
self.setLayout(layout)
self._addAction.triggered.connect(self.addCurrentSelection)
self._updateAction.triggered.connect(self.updateSelectedSelection)
self._removeAction.triggered.connect(self.removeSelectedSelection)
self._setListView.selectionModel().selectionChanged.connect(
self._onListViewSelectionChanged)
self.selectionModel = None
self._selections = []
def sizeHint(self):
size = QFrame.sizeHint(self)
return QSize(size.width(), 200)
def _onSelectionChanged(self, selected, deselected):
self.setSelectionModified(True)
def _onListViewSelectionChanged(self, selected, deselected):
try:
index = self._setListView.selectedIndexes()[0]
except IndexError:
return
self.commitSelection(self._proxyModel.mapToSource(index).row())
def _onSetNameChange(self, item):
self.selections[item.row()].name = str(item.text())
def _setButtonStates(self, val):
self._updateToolButton.setEnabled(val)
def setSelectionModel(self, selectionModel):
if self.selectionModel:
self.selectionModel.selectionChanged.disconnect(
self._onSelectionChanged)
self.selectionModel = selectionModel
self.selectionModel.selectionChanged.connect(self._onSelectionChanged)
def addCurrentSelection(self):
item = self.addSelection(
SelectionByKey(self.selectionModel.selection(),
name="New selection",
key=(1, 2, 3, 10)))
index = self._proxyModel.mapFromSource(item.index())
self._setListView.setCurrentIndex(index)
self._setListView.edit(index)
self.setSelectionModified(False)
def removeSelectedSelection(self):
i = self._proxyModel.mapToSource(self._setListView.currentIndex()).row()
self._listModel.takeRow(i)
del self.selections[i]
def updateCurentSelection(self):
i = self._proxyModel.mapToSource(self._setListView.selectedIndex()).row()
self.selections[i].setSelection(self.selectionModel.selection())
self.setSelectionModified(False)
def addSelection(self, selection, name=""):
self._selections.append(selection)
item = QStandardItem(selection.name)
item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled)
self._listModel.appendRow(item)
self.setSelectionModified(False)
return item
def updateSelectedSelection(self):
i = self._proxyModel.mapToSource(self._setListView.currentIndex()).row()
self.selections[i].setSelection(self.selectionModel.selection())
self.setSelectionModified(False)
def setSelectionModified(self, val):
self._selectionModified = val
self._setButtonStates(val)
self.selectionModified.emit(bool(val))
def commitSelection(self, index):
selection = self.selections[index]
selection.select(self.selectionModel)
def setSelections(self, selections):
self._listModel.clear()
for selection in selections:
self.addSelection(selection)
def selections(self):
return self._selections
selections = property(selections, setSelections)
class InputDialog(GenericDialog):
TBL_HEADER_LABEL=["Input Mesh", "Output group name"]
def __init__(self, parent=None, name="InputDialog", modal=0):
"""
This initializes a dialog windows to define the input data of
the plugin function. The input data consist in a list of
meshes characterizes each by a name, a pointer to the smesh
servant object, a type and a group name (see data model in the
inputdata.py).
"""
GenericDialog.__init__(self, parent, name, modal)
# Set up the user interface from Designer.
self.__ui = Ui_InputFrame()
# BE CAREFULL HERE, the ui form is NOT drawn in the global
# dialog (already containing some generic widgets) but in the
# center panel created in the GenericDialog as a void
# container for the form. The InputFrame form is supposed
# here to create only the widgets to be placed in the center
# panel. Then, the setupUi function of this form draws itself
# in the specified panel, i.e. the panel returned by
# self.getPanel().
self.__ui.setupUi(self.getPanel())
self.setWindowTitle("Specification of input files")
# The icon are supposed to be located in the plugin folder,
# i.e. in the same folder than this python module file
iconfolder=os.path.dirname(os.path.abspath(__file__))
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"select.png"))
self.__ui.btnSmeshObject.setIcon(icon)
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"addinput.png"))
self.__ui.btnAddInput.setIcon(icon)
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"deleteinput.png"))
self.__ui.btnDeleteInput.setIcon(icon)
# We specify here the items in the combo box (even if already
# defined in the designer) so that we can be sure of the item
# indexation.
self.MESHTYPE_ICONS = {}
meshTypeIndex = InputData.MESHTYPES.CONCRETE
self.__ui.cmbMeshType.setItemText(meshTypeIndex, "Béton")
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"concrete.png"))
self.__ui.cmbMeshType.setItemIcon(meshTypeIndex, icon)
self.MESHTYPE_ICONS[meshTypeIndex] = icon
meshTypeIndex = InputData.MESHTYPES.STEELBAR
self.__ui.cmbMeshType.setItemText(meshTypeIndex, "Acier")
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"steelbar.png"))
self.__ui.cmbMeshType.setItemIcon(meshTypeIndex, icon)
self.MESHTYPE_ICONS[meshTypeIndex] = icon
# The click on btnSmeshObject (signal clicked() emitted by the
# button btnSmeshObject) is connected to the slot
# onSelectSmeshObject, etc ...
self.connect(self.__ui.btnSmeshObject, SIGNAL('clicked()'), self.onSelectSmeshObject )
self.connect(self.__ui.btnAddInput, SIGNAL('clicked()'), self.onAddInput )
self.connect(self.__ui.btnDeleteInput, SIGNAL('clicked()'), self.onDeleteInput )
# Set up the model of the Qt table list
self.__inputModel = QStandardItemModel(0,2)
self.__inputModel.setHorizontalHeaderLabels(InputDialog.TBL_HEADER_LABEL)
self.__ui.tblListInput.setModel(self.__inputModel)
self.__ui.tblListInput.verticalHeader().hide()
self.__ui.tblListInput.horizontalHeader().setStretchLastSection(True)
# Note that the type is not display explicitly in the Qt table
# because it is specified using an icon on the text of the
# name item.
# Note that PADDER does not support group name longer than 8
# characters. We apply then this limit in the gui field.
self.__ui.txtGroupName.setMaxLength(GROUPNAME_MAXLENGTH)
self.clear()
self.smeshStudyTool = SMeshStudyTools()
def clear(self):
"""
This function clears the data gui area and associated values.
"""
self.__ui.txtSmeshObject.setText("")
self.__ui.txtGroupName.setText("")
self.__inputModel.clear()
self.__inputModel.setHorizontalHeaderLabels(InputDialog.TBL_HEADER_LABEL)
if not DEBUG_MODE:
self.__ui.txtSmeshObject.setEnabled(False)
self.__ui.btnAddInput.setEnabled(False)
self.__selectedMesh = None
self.__dictInputData = {}
self.__nbConcreteMesh = 0
self.__nbSteelbarMesh = 0
def accept(self):
"""
This function is the slot connected to the button OK
"""
# The dialog is raised in a non modal mode to get
# interactivity with the parents windows. Then we have to emit
# a signal to warn the parent observer that the dialog has
# been validated so that it can process the event
GenericDialog.accept(self)
if self.wasOk():
self.emit(SIGNAL('inputValidated()'))
def onSelectSmeshObject(self):
'''
This function is the slot connected on the mesh selection
button. It memorizes the selected mesh and put its name in the
text field of the dialog box.
'''
mySObject, myEntry = guihelper.getSObjectSelected()
if CORBA.is_nil(mySObject):
self.__ui.txtSmeshObject.setText("You must choose a mesh")
self.__ui.txtGroupName.setText("")
self.__ui.txtSmeshObject.setEnabled(False)
self.__ui.btnAddInput.setEnabled(False)
self.__selectedMesh = None
return
self.smeshStudyTool.updateStudy(studyedit.getActiveStudyId())
self.__selectedMesh = self.smeshStudyTool.getMeshObjectFromSObject(mySObject)
if CORBA.is_nil(self.__selectedMesh):
self.__ui.txtSmeshObject.setText("The selected object is not a mesh")
self.__ui.txtGroupName.setText("")
self.__ui.txtSmeshObject.setEnabled(False)
self.__ui.btnAddInput.setEnabled(False)
self.__selectedMesh = None
return
myName = mySObject.GetName()
self.__ui.txtSmeshObject.setText(myName)
self.__ui.txtSmeshObject.setEnabled(True)
self.__ui.btnAddInput.setEnabled(True)
# We can suggest a default group name from the mesh name
self.__ui.txtGroupName.setText(myName)
def onAddInput(self):
"""
This function is the slot connected to the Add button. It
creates a new entry in the list of input data, or updates this
entry if it already exists.
"""
meshName = str(self.__ui.txtSmeshObject.text().trimmed())
meshObject = self.__selectedMesh
meshType = self.__ui.cmbMeshType.currentIndex()
groupName = str(self.__ui.txtGroupName.text().trimmed())
self.__addInputInGui(meshName, meshObject, meshType, groupName)
self.__addInputInMap(meshName, meshObject, meshType, groupName)
def __addInputInGui(self, meshName, meshObject, meshType, groupName):
"""
This function adds an entry with the specified data int the
GUI table (for data visualization purpose).
"""
# The mesh name is used as the key index in the model. We have
# to check first if this item already exists in the list.
tblItems = self.__inputModel.findItems(meshName)
row = self.__inputModel.rowCount()
if not tblItems:
tblItems = []
tblItems.append(QStandardItem()) # input mesh name
tblItems.append(QStandardItem()) # output group name
else:
row = tblItems[0].index().row()
tblItems.append(self.__inputModel.item(row,1))
tblItems[0].setText(meshName)
tblItems[0].setIcon(self.MESHTYPE_ICONS[meshType])
tblItems[1].setText(groupName)
self.__inputModel.setItem(row,0,tblItems[0])
self.__inputModel.setItem(row,1,tblItems[1])
self.__ui.tblListInput.setCurrentIndex(tblItems[0].index())
def __addInputInMap(self, meshName, meshObject, meshType, groupName):
"""
This function adds an entry with the specified data in the
internal map (for data management purpose).
"""
# if the entry already exists, we remove it to replace by a
# new one
if self.__dictInputData.has_key(meshName):
self.__delInputFromMap(meshName)
inputData = InputData()
inputData.meshName = meshName
inputData.meshObject = meshObject
inputData.meshType = meshType
inputData.groupName = groupName
# The key of the map is the mesh name
self.__dictInputData[meshName] = inputData
if inputData.meshType == InputData.MESHTYPES.CONCRETE:
self.__nbConcreteMesh += 1
else:
self.__nbSteelbarMesh += 1
print inputData
print "meshType = ",inputData.meshType
print "nb concrete mesh ",self.__nbConcreteMesh
print "nb steelbar mesh ",self.__nbSteelbarMesh
def onDeleteInput(self):
"""
This function is the slot connected to the Delete button. It
remove from the data list the entry selected in the Qt table.
"""
selectedIdx = self.__ui.tblListInput.selectedIndexes()
if selectedIdx:
row = selectedIdx[0].row()
tblItem = self.__inputModel.item(row,0)
meshName = str(tblItem.text())
self.__inputModel.takeRow(row)
# Don't forget to remove this entry from the mesh object
# internal dictionnary
self.__delInputFromMap(meshName)
def __delInputFromMap(self, meshName):
"""
This function removes the specified entry from the internal
map (for data management purpose)
"""
inputData = self.__dictInputData.pop(meshName)
if inputData.meshType == InputData.MESHTYPES.CONCRETE:
self.__nbConcreteMesh -= 1
else:
self.__nbSteelbarMesh -= 1
print inputData
print "nb concrete mesh ",self.__nbConcreteMesh
print "nb steelbar mesh ",self.__nbSteelbarMesh
def setData(self, listInputData=[]):
"""
This function fills the dialog widgets with values provided by
the specified data list.
"""
self.clear()
for inputData in listInputData:
meshName = inputData.meshName
meshObject = inputData.meshObject
meshType = inputData.meshType
groupName = inputData.groupName
self.__addInputInGui(meshName, meshObject, meshType, groupName)
self.__addInputInMap(meshName, meshObject, meshType, groupName)
if not DEBUG_MODE:
self.onSelectSmeshObject()
def getData(self):
"""
This function returns a list of InputData that corresponds to
the data in the dialog widgets of the current dialog.
"""
# Note that the values() function returns a copy of the list
# of values.
return self.__dictInputData.values()
def checkData(self):
"""
This function checks if the data are valid, from the dialog
window point of view.
"""
if self.__nbConcreteMesh == 0 and self.__nbSteelbarMesh == 0:
self.checkDataMessage = "You must define at least one mesh (CONCRETE or STEELBAR)"
return False
if self.__nbConcreteMesh > 1:
self.checkDataMessage = "You define multiple CONCRETE meshes."
self.checkDataMessage += "You should verify first that your version of PADDER support this configuration."
# just warn the user, but don't block
QMessageBox.information(self, "Info", self.checkDataMessage)
return True
return True
class SelectionSetsWidget(QFrame):
"""
Widget for managing multiple stored item selections
"""
selectionModified = Signal(bool)
def __init__(self, parent):
QFrame.__init__(self, parent)
self.setContentsMargins(0, 0, 0, 0)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(1)
self._setNameLineEdit = QLineEdit(self)
layout.addWidget(self._setNameLineEdit)
self._setListView = QListView(self)
self._listModel = QStandardItemModel(self)
self._proxyModel = QSortFilterProxyModel(self)
self._proxyModel.setSourceModel(self._listModel)
self._setListView.setModel(self._proxyModel)
self._setListView.setItemDelegate(ListItemDelegate(self))
self._setNameLineEdit.textChanged.connect(
self._proxyModel.setFilterFixedString)
self._completer = QCompleter(self._listModel, self)
self._setNameLineEdit.setCompleter(self._completer)
self._listModel.itemChanged.connect(self._onSetNameChange)
layout.addWidget(self._setListView)
buttonLayout = QHBoxLayout()
self._addAction = QAction("+", self, toolTip="Add a new sort key")
self._updateAction = QAction("Update",
self,
toolTip="Update/save current selection")
self._removeAction = QAction("\u2212",
self,
toolTip="Remove selected sort key.")
self._addToolButton = QToolButton(self)
self._updateToolButton = QToolButton(self)
self._removeToolButton = QToolButton(self)
self._updateToolButton.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum)
self._addToolButton.setDefaultAction(self._addAction)
self._updateToolButton.setDefaultAction(self._updateAction)
self._removeToolButton.setDefaultAction(self._removeAction)
buttonLayout.addWidget(self._addToolButton)
buttonLayout.addWidget(self._updateToolButton)
buttonLayout.addWidget(self._removeToolButton)
layout.addLayout(buttonLayout)
self.setLayout(layout)
self._addAction.triggered.connect(self.addCurrentSelection)
self._updateAction.triggered.connect(self.updateSelectedSelection)
self._removeAction.triggered.connect(self.removeSelectedSelection)
self._setListView.selectionModel().selectionChanged.connect(
self._onListViewSelectionChanged)
self.selectionModel = None
self._selections = []
def sizeHint(self):
size = QFrame.sizeHint(self)
return QSize(size.width(), 150)
def _onSelectionChanged(self, selected, deselected):
self.setSelectionModified(True)
def _onListViewSelectionChanged(self, selected, deselected):
try:
index = self._setListView.selectedIndexes()[0]
except IndexError:
return
self.commitSelection(self._proxyModel.mapToSource(index).row())
def _onSetNameChange(self, item):
self.selections[item.row()].name = str(item.text())
def _setButtonStates(self, val):
self._updateToolButton.setEnabled(val)
def setSelectionModel(self, selectionModel):
if self.selectionModel:
self.selectionModel.selectionChanged.disconnect(
self._onSelectionChanged)
self.selectionModel = selectionModel
self.selectionModel.selectionChanged.connect(self._onSelectionChanged)
def addCurrentSelection(self):
item = self.addSelection(
SelectionByKey(self.selectionModel.selection(),
name="New selection",
key=(1, 2, 3, 10)))
index = self._proxyModel.mapFromSource(item.index())
self._setListView.setCurrentIndex(index)
self._setListView.edit(index)
self.setSelectionModified(False)
def removeSelectedSelection(self):
i = self._proxyModel.mapToSource(
self._setListView.currentIndex()).row()
self._listModel.takeRow(i)
del self.selections[i]
def updateCurentSelection(self):
i = self._proxyModel.mapToSource(
self._setListView.selectedIndex()).row()
self.selections[i].setSelection(self.selectionModel.selection())
self.setSelectionModified(False)
def addSelection(self, selection, name=""):
self._selections.append(selection)
item = QStandardItem(selection.name)
item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled)
self._listModel.appendRow(item)
self.setSelectionModified(False)
return item
def updateSelectedSelection(self):
i = self._proxyModel.mapToSource(
self._setListView.currentIndex()).row()
self.selections[i].setSelection(self.selectionModel.selection())
self.setSelectionModified(False)
def setSelectionModified(self, val):
self._selectionModified = val
self._setButtonStates(val)
self.selectionModified.emit(bool(val))
def commitSelection(self, index):
selection = self.selections[index]
selection.select(self.selectionModel)
def setSelections(self, selections):
self._listModel.clear()
for selection in selections:
self.addSelection(selection)
def selections(self):
return self._selections
selections = property(selections, setSelections)
class AbstractStoreWidget(QWidget):
"""
@brief Ein einfaches Widget, um das Inventar des Charakters zu füllen.
"""
itemBought = Signal(str, str)
itemSold = Signal(str, str)
def __init__(self, template, character, parent=None):
super(AbstractStoreWidget, self).__init__(parent)
self.ui = Ui_AbstractStoreWidget()
self.ui.setupUi(self)
self.__character = character
self.__storage = template
self.__modelInventory = QStandardItemModel()
self.ui.view_inventory.setModel(self.__modelInventory)
self.__modelStore = QStandardItemModel()
self.ui.view_store.setModel(self.__modelStore)
## Resources
self.ui.traitDots_resources.valueChanged.connect(self.__character.traits["Merit"]["Social"]["Resources"].setValue)
self.__character.traits["Merit"]["Social"]["Resources"].valueChanged.connect(self.ui.traitDots_resources.setValue)
self.ui.traitDots_enhancedItem.valueChanged.connect(self.__character.traits["Merit"]["Item"]["Enhanced Item"].setValue)
self.__character.traits["Merit"]["Item"]["Enhanced Item"].valueChanged.connect(self.ui.traitDots_enhancedItem.setValue)
## Items
self.ui.traitDots_token.maximum = 10
self.ui.traitDots_imbuedItem.maximum = 10
self.ui.traitDots_artifact.maximum = 10
self.ui.traitDots_cursedItem.valueChanged.connect(self.__character.traits["Merit"]["Item"]["Cursed Item"].setValue)
self.ui.traitDots_fetish.valueChanged.connect(self.__character.traits["Merit"]["Item"]["Fetish"].setValue)
self.ui.traitDots_token.valueChanged.connect(self.__character.traits["Merit"]["Item"]["Token"].setValue)
self.ui.traitDots_imbuedItem.valueChanged.connect(self.__character.traits["Merit"]["Item"]["Imbued Item"].setValue)
self.ui.traitDots_artifact.valueChanged.connect(self.__character.traits["Merit"]["Item"]["Artifact"].setValue)
self.__character.traits["Merit"]["Item"]["Cursed Item"].valueChanged.connect(self.ui.traitDots_cursedItem.setValue)
self.__character.traits["Merit"]["Item"]["Fetish"].valueChanged.connect(self.ui.traitDots_fetish.setValue)
self.__character.traits["Merit"]["Item"]["Token"].valueChanged.connect(self.ui.traitDots_token.setValue)
self.__character.traits["Merit"]["Item"]["Imbued Item"].valueChanged.connect(self.ui.traitDots_imbuedItem.setValue)
self.__character.traits["Merit"]["Item"]["Artifact"].valueChanged.connect(self.ui.traitDots_artifact.setValue)
self.ui.pushButton_add.setIcon(QIcon(":/icons/images/actions/1leftarrow.png"))
self.ui.pushButton_remove.setIcon(QIcon(":/icons/images/actions/1rightarrow.png"))
self.__modelInventory.rowsInserted.connect(self.checkButtonState)
self.__modelInventory.rowsRemoved.connect(self.checkButtonState)
self.__modelStore.rowsInserted.connect(self.checkButtonState)
self.__modelStore.rowsRemoved.connect(self.checkButtonState)
self.ui.pushButton_add.clicked.connect(self.buyItem)
self.ui.view_store.doubleClicked.connect(self.buyItem)
self.ui.pushButton_remove.clicked.connect(self.sellItem)
self.ui.view_inventory.doubleClicked.connect(self.sellItem)
self.ui.lineEdit_custom.textChanged.connect(self.changeCustomButtonState)
self.ui.pushButton_addCustom.clicked.connect(self.buyCustomItem)
def setEnhancedItemTraitsVisible(self, sw=True):
self.ui.label_enhancedItem.setVisible(sw)
self.ui.traitDots_enhancedItem.setVisible(sw)
def setMagicalItemTraitsVisible(self, sw=True):
self.ui.label_cursedItem.setVisible(sw)
self.ui.traitDots_cursedItem.setVisible(sw)
self.ui.label_fetish.setVisible(sw)
self.ui.traitDots_fetish.setVisible(sw)
self.ui.label_token.setVisible(sw)
self.ui.traitDots_token.setVisible(sw)
self.ui.label_artifact.setVisible(sw)
self.ui.traitDots_artifact.setVisible(sw)
self.ui.label_imbuedItem.setVisible(sw)
self.ui.traitDots_imbuedItem.setVisible(sw)
def setAddCustomVisible(self, sw=True):
self.ui.widget_custom.setVisible(sw)
def addItemToStore(self, name, category=None, icon=None):
newItem = QStandardItem(name)
if icon:
newItem.setIcon(icon)
if category:
newItem.setData(category)
self.__modelStore.appendRow(newItem)
def buyItem(self):
"""
Der besagte Gegenstand wird vom Laden in das Inventar übernommen.
"""
listOfItems = self.__modelStore.takeRow(self.ui.view_store.currentIndex().row())
self.__modelInventory.appendRow(listOfItems)
self.itemBought.emit(listOfItems[0].text(), listOfItems[0].data())
def __customItem(self, name):
"""
Erzeugt einen vom Benutzer benannten Gegenstand.
"""
if name:
existingItemInventory = self.__modelInventory.findItems(name)
if not existingItemInventory:
existingItem = self.__modelStore.findItems(name)
if existingItem:
listOfItems = self.__modelStore.takeRow(existingItem[0].index().row())
self.__modelInventory.appendRow(listOfItems)
self.itemBought.emit(listOfItems[0].text(), listOfItems[0].data())
else:
newItem = QStandardItem(name)
self.__modelInventory.appendRow(newItem)
self.itemBought.emit(newItem.text(), newItem.data())
def buyCustomItem(self):
"""
Fügt dem Inventar des Charakters einen Gegenstand hinzu.
\todo Nach dem Drücken des Hinzufügen.Knopfes, sollte der Fokus wieder auf das LineEdit gehen.
"""
newName = self.ui.lineEdit_custom.text()
if newName:
self.__customItem(newName)
## Textzeile löschen
self.ui.lineEdit_custom.setText("")
def sellItem(self):
"""
Der besagte Gegenstand wird vom Inventar zurück in den Laden befördert.
"""
listOfItems = self.__modelInventory.takeRow(self.ui.view_inventory.currentIndex().row())
self.__modelStore.appendRow(listOfItems)
#for item in listOfItems:
#Debug.debug(item.data())
self.itemSold.emit(listOfItems[0].text(), listOfItems[0].data())
def moveItemToInventory(self, name, category=None):
"""
Der besagte Gegenstand wird aus dem Laden ins Inventar bewegt. Gibt es keinen Gegenstand dieses Namens im Laden, wird er direkt im Inventar erzeugt.
"""
foundItems = self.__modelStore.findItems(name)
if foundItems:
for item in foundItems:
if item.data() == category:
listOfItems = self.__modelStore.takeRow(item.index().row())
self.__modelInventory.appendRow(listOfItems)
else:
self.__customItem(name)
def moveItemToStore(self, name, category=None):
"""
Der besagte Gegenstand wird aus dem Inventar in den Laden bewegt.
"""
foundItems = self.__modelInventory.findItems(name)
for item in foundItems:
if item.data() == category:
listOfItems = self.__modelInventory.takeRow(item.index().row())
self.__modelStore.appendRow(listOfItems)
def checkButtonState(self):
"""
Aktiviert/Deaktiviert die Knöpfe für das Übertragen von Gegenständen.
"""
if self.__modelInventory.rowCount() > 0:
self.ui.pushButton_remove.setEnabled(True)
else:
self.ui.pushButton_remove.setEnabled(False)
if self.__modelStore.rowCount() > 0:
self.ui.pushButton_add.setEnabled(True)
else:
self.ui.pushButton_add.setEnabled(False)
def changeCustomButtonState(self):
"""
Aktiviert den Knopf zum Hinzufügen eines zusätzlichen Gegenstandes nur, wenn es etwas zum Hinzufügen gibt. Die zeile also nicht leer und der Gegnstand noch nicht vorhanden ist.
"""
self.ui.pushButton_addCustom.setEnabled(False)
if self.ui.lineEdit_custom.text() and not self.__modelInventory.findItems(self.ui.lineEdit_custom.text()):
self.ui.pushButton_addCustom.setEnabled(True)
class QgsAttributeTableDialog(QDialog):
'''
classdocs
'''
def __init__(self, parent, vectorlayer):
QDialog.__init__(self, parent)
# self.w = QDialog(self)
self.baseLayer = vectorlayer
self.canChangeAttributes = self.validate(
QgsVectorDataProvider.ChangeAttributeValues)
self.canDeleteFeatures = self.validate(
QgsVectorDataProvider.DeleteFeatures)
self.canAddAttributes = self.validate(
QgsVectorDataProvider.AddAttributes)
self.canDeleteAttributes = self.validate(
QgsVectorDataProvider.DeleteAttributes)
self.canAddFeatures = self.validate(QgsVectorDataProvider.AddFeatures)
gridLayout = QGridLayout(self)
self.setLayout(gridLayout)
self.setWindowTitle("Attribute Table")
self.setFixedSize(QSize(800, 600))
editorToolbar = QToolBar()
editorToolbar.setFixedSize(QSize(768, 48))
self.actionToggleEditing = QAction(QIcon("Resource\\edit.png"),
"ToggleEditing", self)
self.actionToggleEditing.triggered.connect(self.toggleEditing)
if (self.canChangeAttributes or self.canDeleteFeatures
or self.canAddAttributes or self.canDeleteAttributes
or self.canAddFeatures) and (not self.baseLayer.isReadOnly()):
self.actionToggleEditing.setEnabled(True)
else:
self.actionToggleEditing.setEnabled(False)
self.actionToggleEditing.setCheckable(True)
editorToolbar.addAction(self.actionToggleEditing)
self.actionSave = QAction(QIcon("Resource\\filesave.png"),
"Save Edits", self)
self.actionSave.triggered.connect(self.saveEditing)
self.actionSave.setCheckable(False)
self.actionSave.setEnabled(False)
editorToolbar.addAction(self.actionSave)
self.actiondeleteRows = QAction(
QIcon("Resource\\mActionDeleteSelected.png"),
"Delete selected features", self)
self.actiondeleteRows.triggered.connect(self.deleteRows)
self.actiondeleteRows.setCheckable(False)
self.actiondeleteRows.setEnabled(False)
editorToolbar.addAction(self.actiondeleteRows)
self.actionUnselectAll = QAction(
QIcon("Resource\\mActionDeselectAll.png"), "Unselect All", self)
self.actionUnselectAll.triggered.connect(self.unselectAll)
self.actionUnselectAll.setCheckable(False)
self.actionUnselectAll.setEnabled(True)
editorToolbar.addAction(self.actionUnselectAll)
self.actionSelectedToZoom = QAction(
QIcon("Resource\\mActionZoomToSelected.png"),
"Zoom map to the selected rows", self)
self.actionSelectedToZoom.triggered.connect(self.selectedToZoom)
self.actionSelectedToZoom.setCheckable(False)
self.actionSelectedToZoom.setEnabled(True)
editorToolbar.addAction(self.actionSelectedToZoom)
gridLayout.addWidget(editorToolbar, 0, 0, 1, 1)
self.model = QStandardItemModel()
# self.model.itemChanged.connect(self.attributeChanged)
self.attributeTable = QTableView(self)
self.attributeTable.setModel(self.model)
self.attributeTable.setColumnWidth(0, 200)
self.attributeTable.setColumnWidth(1, 160)
self.attributeTable.clicked.connect(self.tableSelectionChanged)
self.attributeTable.setSortingEnabled(True)
self.changeItemList = []
self.selectRows = []
self.isSave = True
self.initTable()
gridLayout.addWidget(self.attributeTable, 1, 0, 1, 1)
# self.attributeTable.selectionChanged.connect(self.selectFeature)
def tableSelectionChanged(self):
idxList = self.attributeTable.selectedIndexes()
if idxList != None and len(idxList) > 0:
self.baseLayer.removeSelection()
fidList = []
for idx in idxList:
fid = int(self.model.item(idx.row()).text())
fidList.append(fid)
self.baseLayer.setSelectedFeatures(fidList)
def toggleEditing(self):
if self.baseLayer != None:
if not self.actionToggleEditing.isChecked():
if self.isSave:
self.baseLayer.commitChanges()
self.actionSave.setEnabled(False)
self.actiondeleteRows.setEnabled(False)
self.model.itemChanged.disconnect(self.attributeChanged)
self.toggleEditingTable(False)
else:
button = QMessageBox.warning(
self, "Stop Editing",
"Do you want to save the changes to layer?",
QMessageBox.Save | QMessageBox.Discard
| QMessageBox.Cancel)
if (button == QMessageBox.Cancel):
self.actionToggleEditing.setChecked(True)
elif button == QMessageBox.Save:
self.saveEditing()
self.baseLayer.commitChanges()
self.actionSave.setEnabled(False)
self.actiondeleteRows.setEnabled(False)
self.model.itemChanged.disconnect(
self.attributeChanged)
self.toggleEditingTable(False)
else:
self.initTable()
self.baseLayer.commitChanges()
self.actionSave.setEnabled(False)
self.actiondeleteRows.setEnabled(False)
self.model.itemChanged.disconnect(
self.attributeChanged)
self.toggleEditingTable(False)
# self.isEditable = False
else:
self.actionSave.setEnabled(True)
self.actiondeleteRows.setEnabled(True)
self.baseLayer.startEditing()
self.toggleEditingTable(True)
self.model.itemChanged.connect(self.attributeChanged)
# self.isEditable = True
def toggleEditingTable(self, isEditable):
columnCount = self.model.columnCount()
rowCount = self.model.rowCount()
col = 0
while col < columnCount:
row = 0
while row < rowCount:
self.model.item(row, col).setEditable(isEditable)
row += 1
col += 1
def attributeChanged(self, standardItem):
self.isSave = False
# if not self.isDelete:
self.changeItemList.append(standardItem)
# featureId = standardItem.row()
# self.baseLayer.changeAttributeValue(featureId,
# standardItem.column(), standardItem.text())
def saveEditing(self):
self.isSave = True
if len(self.changeItemList) > 0:
for standardItem in self.changeItemList:
featureId = standardItem.row()
self.baseLayer.changeAttributeValue(featureId,
standardItem.column(),
standardItem.text())
self.changeItemList = []
if len(self.selectRows) > 0:
for id in self.selectRows:
self.baseLayer.deleteFeature(id)
self.selectRows = []
def initTable(self):
self.model.clear()
# header = QHeaderView(Qt.Horizontal)
# headerModel = QStandardItemModel()
layer = self.baseLayer
fields = layer.pendingFields()
headersList = ["fid"]
for field in fields:
headersList.append(field.name())
self.model.setHorizontalHeaderLabels(headersList)
# headerModel.setHorizontalHeaderLabels(headersList)
# header.setModel(headerModel)
# self.attributeTable.setHorizontalHeader(header)
if len(layer.selectedFeatures()) > 0:
features = layer.selectedFeatures()
else:
features = layer.getFeatures()
for feature in features:
record = [QStandardItem(str(feature.id()))]
for field in feature.fields():
name = field.name()
attribute = feature.attribute(name).toString()
stdItemValue = QStandardItem(attribute)
stdItemValue.setEditable(False)
record.append(stdItemValue)
self.model.appendRow(record)
def deleteRows(self):
if len(self.attributeTable.selectedIndexes()) > 0:
self.isSave = False
selectedIndexs = self.attributeTable.selectedIndexes()
k = -1
self.selectRows = []
for index in selectedIndexs:
if k != index.row():
k = index.row()
self.selectRows.append(k)
for row in self.selectRows:
self.model.takeRow(row)
def unselectAll(self):
if len(self.attributeTable.selectedIndexes()) > 0:
self.attributeTable.clearSelection()
def selectedToZoom(self):
if len(self.attributeTable.selectedIndexes()) > 0:
self.baseLayer.removeSelection()
selectedIndexs = self.attributeTable.selectedIndexes()
k = -1
self.selectRows = []
for index in selectedIndexs:
if k != index.row():
k = index.row()
self.selectRows.append(k)
self.baseLayer.setSelectedFeatures(self.selectRows)
# for row in self.selectRows:
# self.model.takeRow(row)
define._canvas.zoomToSelected(self.baseLayer)
def validate(self, condition):
if self.baseLayer.dataProvider().capabilities() & condition:
return True
else:
return False
class route:
def __init__(self, name='', desc='', survey_date=None, run_no=''):
self.name = name
self.desc = desc
self.survey_date = survey_date
self.run_no = run_no
self.model = QStandardItemModel()
#self.model=route_model.route_model()
self.model.setColumnCount(len(cols))
[self.model.setHeaderData(cols[c], Qt.Horizontal, c) for c in cols]
#def add_section(self,label,snode,rev,length,rbt,ch,desc,wkt,row=0):
# #self.model.insertRow(row,[make_cell(label),make_cell(rev,True),make_cell(desc,True),make_cell(ch),make_cell(snode),make_cell(length),make_cell(rbt),make_cell(wkt)])
def add_section(self,
label,
rev,
desc,
ch,
snode,
length,
rbt,
wkt,
row=0):
self.model.insertRow(row, [
make_cell(label),
make_cell(rev, True),
make_cell(desc, True),
make_cell(ch),
make_cell(snode),
make_cell(length),
make_cell(rbt),
make_cell(wkt)
])
#converts to qgis features
def to_features(self, layer):
return [
self.to_feat(i, layer) for i in range(0, self.model.rowCount())
]
def remove_rows(self, rows):
# removing changes following row numbers.Start with highest row number.
for r in reversed(sorted(rows)):
self.model.takeRow(r)
#key like [route_att:feature_att]
def add_feat(self, f, transform, row, rev, key):
geom = f.geometry()
geom.transform(transform)
snode = f[key['snode']]
if rev:
geom = reversed_geom(geom)
snode = f[key['enode']]
#chainage will be recalculated so irrelevant
self.add_section(f[key['section_label']], rev,
f[key['section_description']], 0, snode,
f[key['section_length']], f[key['roundabout']],
geom.exportToWkt(), row)
# g.geometry().asWkt()))) for qgis 3
#make qgis feature from row of model
def to_feat(self, row, layer):
feat = QgsFeature(layer.fields())
for c in cols:
if c != 'wkt':
feat.setAttribute(c, self.get_val(row, cols[c]))
feat.setAttribute('route', self.name)
feat.setAttribute('route_description', self.desc)
feat.setAttribute('survey_date', self.desc)
feat.setAttribute('run_no', self.run_no)
if self.get_val(row, cols['reversed']):
geom = reversed_geom(
QgsGeometry.fromWkt(self.get_val(row, cols['wkt'])))
else:
geom = QgsGeometry.fromWkt(self.get_val(row, cols['wkt']))
feat.setGeometry(geom)
return feat
def get_val(self, row, col):
return self.model.item(row, col).data(Qt.EditRole)
def __eq__(self, other):
return self.name == other.name and self.desc == other.desc and self.run_no == other.run_no #and self.survey_date=other.survey_date
#def __add__(self,other):
# if self==other:
# r=route(self.name,self.desc,self.survey_date,self.run_no)
# else:
# raise ValueError('conflicting route data')
def consume_other(self, other):
if self == other:
for i in other.model.rowCount():
self.model.appendRow(other.model.takeRow(i))
else:
raise ValueError('conflicting route data')
