mirror of https://gitlab.com/pamhyr/pamhyr2
379 lines
10 KiB
Python
379 lines
10 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from tools import trace, timer
|
|
|
|
from View.ASubWindow import ASubMainWindow
|
|
from View.ListedSubWindow import ListedSubWindow
|
|
|
|
from PyQt5.QtGui import (
|
|
QKeySequence,
|
|
)
|
|
|
|
from PyQt5.QtCore import (
|
|
Qt, QVariant, QAbstractTableModel,
|
|
QCoreApplication, QModelIndex, pyqtSlot,
|
|
QRect,
|
|
)
|
|
|
|
from PyQt5.QtWidgets import (
|
|
QDialogButtonBox, QPushButton, QLineEdit,
|
|
QFileDialog, QTableView, QAbstractItemView,
|
|
QUndoStack, QShortcut, QAction, QItemDelegate,
|
|
QComboBox,
|
|
)
|
|
|
|
from View.BoundaryCondition.BCUndoCommand import (
|
|
SetNameCommand, SetNodeCommand, SetTypeCommand,
|
|
AddCommand, DelCommand, SortCommand,
|
|
MoveCommand, PasteCommand, DuplicateCommand,
|
|
)
|
|
|
|
from Model.BoundaryCondition.BoundaryConditionTypes import (
|
|
NotDefined, PonctualContribution,
|
|
TimeOverZ, TimeOverDebit, ZOverDebit
|
|
)
|
|
|
|
from View.BoundaryCondition.translate import long_types
|
|
from View.BoundaryCondition.Edit.Window import EditBoundaryConditionWindow
|
|
|
|
_translate = QCoreApplication.translate
|
|
|
|
table_headers = {
|
|
"name": _translate("BoundaryCondition", "Name"),
|
|
"type": _translate("BoundaryCondition", "Type"),
|
|
"node": _translate("BoundaryCondition", "Node")
|
|
}
|
|
|
|
BC_types = {
|
|
"ND": NotDefined,
|
|
"PC": PonctualContribution,
|
|
"TZ": TimeOverZ,
|
|
"TD": TimeOverDebit,
|
|
"ZD": ZOverDebit
|
|
}
|
|
|
|
|
|
class ComboBoxDelegate(QItemDelegate):
|
|
def __init__(self, data=None, mode="type", parent=None):
|
|
super(ComboBoxDelegate, self).__init__(parent)
|
|
|
|
self._data = data
|
|
self._mode = mode
|
|
|
|
def createEditor(self, parent, option, index):
|
|
self.editor = QComboBox(parent)
|
|
|
|
if self._mode == "type":
|
|
self.editor.addItems([long_types[k] for k in BC_types.keys()])
|
|
else:
|
|
self.editor.addItems(
|
|
[_translate("BoundaryCondition", "Not associate")] +
|
|
self._data.nodes_names()
|
|
)
|
|
|
|
self.editor.setCurrentText(index.data(Qt.DisplayRole))
|
|
return self.editor
|
|
|
|
def setEditorData(self, editor, index):
|
|
value = index.data(Qt.DisplayRole)
|
|
self.editor.currentTextChanged.connect(self.currentItemChanged)
|
|
|
|
def setModelData(self, editor, model, index):
|
|
text = str(editor.currentText())
|
|
model.setData(index, text)
|
|
editor.close()
|
|
editor.deleteLater()
|
|
|
|
def updateEditorGeometry(self, editor, option, index):
|
|
r = QRect(option.rect)
|
|
if self.editor.windowFlags() & Qt.Popup and editor.parent() is not None:
|
|
r.setTopLeft(self.editor.parent().mapToGlobal(r.topLeft()))
|
|
editor.setGeometry(r)
|
|
|
|
@pyqtSlot()
|
|
def currentItemChanged(self):
|
|
self.commitData.emit(self.sender())
|
|
|
|
|
|
class TableModel(QAbstractTableModel):
|
|
def __init__(self, data=None, undo=None):
|
|
super(QAbstractTableModel, self).__init__()
|
|
self._headers = list(table_headers.keys())
|
|
self._data = data
|
|
self._undo = undo
|
|
self._lst = self._data.boundary_condition
|
|
|
|
def flags(self, index):
|
|
options = Qt.ItemIsEnabled | Qt.ItemIsSelectable
|
|
options |= Qt.ItemIsEditable
|
|
|
|
return options
|
|
|
|
def rowCount(self, parent):
|
|
return len(self._lst)
|
|
|
|
def columnCount(self, parent):
|
|
return len(self._headers)
|
|
|
|
def data(self, index, role):
|
|
if role != Qt.ItemDataRole.DisplayRole:
|
|
return QVariant()
|
|
|
|
row = index.row()
|
|
column = index.column()
|
|
|
|
if self._headers[column] == "name":
|
|
return self._lst[row].name
|
|
elif self._headers[column] == "type":
|
|
t = self._lst[row].bctype
|
|
return long_types[t]
|
|
elif self._headers[column] == "node":
|
|
n = self._lst[row].node
|
|
if n is None:
|
|
return _translate("BoundaryCondition", "Not associate")
|
|
return n.name
|
|
|
|
return QVariant()
|
|
|
|
def headerData(self, section, orientation, role):
|
|
if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
|
|
return table_headers[self._headers[section]]
|
|
|
|
return QVariant()
|
|
|
|
def setData(self, index, value, role=Qt.EditRole):
|
|
if not index.isValid() or role != Qt.EditRole:
|
|
return False
|
|
|
|
row = index.row()
|
|
column = index.column()
|
|
|
|
if self._headers[column] == "name":
|
|
self._undo.push(
|
|
SetNameCommand(
|
|
self._lst, row, value
|
|
)
|
|
)
|
|
elif self._headers[column] == "type":
|
|
key = next(k for k, v in long_types.items() if v == value)
|
|
self._undo.push(
|
|
SetTypeCommand(
|
|
self._lst, row, BC_types[key]
|
|
)
|
|
)
|
|
elif self._headers[column] == "node":
|
|
self._undo.push(
|
|
SetNodeCommand(
|
|
self._lst, row, self._data.node(value)
|
|
)
|
|
)
|
|
|
|
self.dataChanged.emit(index, index)
|
|
return True
|
|
|
|
def add(self, row, parent=QModelIndex()):
|
|
self.beginInsertRows(parent, row, row - 1)
|
|
|
|
self._undo.push(
|
|
AddCommand(
|
|
self._lst, row
|
|
)
|
|
)
|
|
|
|
self.endInsertRows()
|
|
self.layoutChanged.emit()
|
|
|
|
def delete(self, rows, parent=QModelIndex()):
|
|
self.beginRemoveRows(parent, rows[0], rows[-1])
|
|
|
|
self._undo.push(
|
|
DelCommand(
|
|
self._lst, rows
|
|
)
|
|
)
|
|
|
|
self.endRemoveRows()
|
|
|
|
def sort(self, _reverse, parent=QModelIndex()):
|
|
self.layoutAboutToBeChanged.emit()
|
|
|
|
self._undo.push(
|
|
SortCommand(
|
|
self._lst, False
|
|
)
|
|
)
|
|
|
|
self.layoutAboutToBeChanged.emit()
|
|
self.layoutChanged.emit()
|
|
|
|
def move_up(self, row, parent=QModelIndex()):
|
|
if row <= 0:
|
|
return
|
|
|
|
target = row + 2
|
|
|
|
self.beginMoveRows(parent, row - 1, row - 1, parent, target)
|
|
|
|
self._undo_stack.push(
|
|
MoveCommand(
|
|
self._lst, "up", row
|
|
)
|
|
)
|
|
|
|
self.endMoveRows()
|
|
self.layoutChanged.emit()
|
|
|
|
def move_down(self, index, parent=QModelIndex()):
|
|
if row > len(self._lst):
|
|
return
|
|
|
|
target = row
|
|
|
|
self.beginMoveRows(parent, row + 1, row + 1, parent, target)
|
|
|
|
self._undo_stack.push(
|
|
MoveCommand(
|
|
self._lst, "down", row
|
|
)
|
|
)
|
|
|
|
self.endMoveRows()
|
|
self.layoutChanged.emit()
|
|
|
|
def undo(self):
|
|
self._undo.undo()
|
|
self.layoutChanged.emit()
|
|
|
|
def redo(self):
|
|
self._undo.redo()
|
|
self.layoutChanged.emit()
|
|
|
|
|
|
class BoundaryConditionWindow(ASubMainWindow, ListedSubWindow):
|
|
def __init__(self, title="BoundaryConditions", study=None, parent=None):
|
|
super(BoundaryConditionWindow, self).__init__(
|
|
name=title, ui="BoundaryConditions", parent=parent
|
|
)
|
|
|
|
self._study = study
|
|
self._lst = self._study.river.boundary_condition
|
|
|
|
self.setup_sc()
|
|
self.setup_table()
|
|
self.setup_connections()
|
|
|
|
self.ui.setWindowTitle(title)
|
|
|
|
def setup_sc(self):
|
|
self._undo_stack = QUndoStack()
|
|
|
|
self.undo_sc = QShortcut(QKeySequence.Undo, self)
|
|
self.redo_sc = QShortcut(QKeySequence.Redo, self)
|
|
self.copy_sc = QShortcut(QKeySequence.Copy, self)
|
|
self.paste_sc = QShortcut(QKeySequence.Paste, self)
|
|
|
|
def setup_table(self):
|
|
table = self.find(QTableView, "tableView")
|
|
self._table = TableModel(
|
|
data = self._study.river,
|
|
undo = self._undo_stack
|
|
)
|
|
table.setModel(self._table)
|
|
|
|
self._delegate_type = ComboBoxDelegate(
|
|
data = self._study.river,
|
|
mode = "type"
|
|
)
|
|
self._delegate_node = ComboBoxDelegate(
|
|
data = self._study.river,
|
|
mode = "node"
|
|
)
|
|
|
|
table.setItemDelegateForColumn(
|
|
1, self._delegate_type
|
|
)
|
|
table.setItemDelegateForColumn(
|
|
2, self._delegate_node
|
|
)
|
|
|
|
table.setSelectionBehavior(QAbstractItemView.SelectRows)
|
|
table.setAlternatingRowColors(True)
|
|
|
|
|
|
def setup_connections(self):
|
|
self.find(QAction, "action_add").triggered.connect(self.add)
|
|
self.find(QAction, "action_del").triggered.connect(self.delete)
|
|
self.find(QAction, "action_edit").triggered.connect(self.edit)
|
|
self.find(QAction, "action_sort").triggered.connect(self.sort)
|
|
|
|
self.undo_sc.activated.connect(self.undo)
|
|
self.redo_sc.activated.connect(self.redo)
|
|
self.copy_sc.activated.connect(self.copy)
|
|
self.paste_sc.activated.connect(self.paste)
|
|
|
|
|
|
def index_selected_row(self):
|
|
table = self.find(QTableView, "tableView")
|
|
return table.selectionModel()\
|
|
.selectedRows()[0]\
|
|
.row()
|
|
|
|
def index_selected_rows(self):
|
|
table = self.find(QTableView, "tableView")
|
|
return list(
|
|
# Delete duplicate
|
|
set(
|
|
map(
|
|
lambda i: i.row(),
|
|
table.selectedIndexes()
|
|
)
|
|
)
|
|
)
|
|
|
|
def add(self):
|
|
rows = self.index_selected_rows()
|
|
if len(self._lst) == 0 or len(rows) == 0:
|
|
self._table.add(0)
|
|
else:
|
|
self._table.add(rows[0])
|
|
|
|
def delete(self):
|
|
rows = self.index_selected_rows()
|
|
if len(rows) == 0:
|
|
return
|
|
|
|
self._table.delete(rows)
|
|
|
|
def sort(self):
|
|
self._table.sort(False)
|
|
|
|
def move_up(self):
|
|
row = self.index_selected_row()
|
|
self._table.move_up(row)
|
|
|
|
def move_down(self):
|
|
row = self.index_selected_row()
|
|
self._table.move_down(row)
|
|
|
|
|
|
def copy(self):
|
|
print("TODO")
|
|
|
|
def paste(self):
|
|
print("TODO")
|
|
|
|
def undo(self):
|
|
self._table.undo()
|
|
|
|
def redo(self):
|
|
self._table.redo()
|
|
|
|
def edit(self):
|
|
rows = self.index_selected_rows()
|
|
for row in rows:
|
|
win = EditBoundaryConditionWindow(
|
|
data=self._lst[row],
|
|
parent=self
|
|
)
|
|
win.show()
|