parouby
/
Pamhyr2
mirror of https://gitlab.com/pamhyr/pamhyr2
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

BC: Add multiple tab for liquid, solid and suspenssion.

mesh
Pierre-Antoine Rouby 2023-05-09 13:36:44 +02:00
parent cbc249299c
commit 3617fde986
7 changed files with 214 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Model/BoundaryCondition/BoundaryCondition.py
View File

@ -18,6 +18,10 @@ class BoundaryCondition(object):
def __len__(self):
return len(self._data)
@classmethod
def compatibility(cls):
return ["liquid", "solid", "suspenssion"]
@property
def name(self):
return self._name

62
src/Model/BoundaryCondition/BoundaryConditionList.py
View File

@ -11,56 +11,82 @@ from Model.BoundaryCondition.BoundaryConditionTypes import (
TimeOverZ, TimeOverDebit, ZOverDebit
)
class BoundaryConditionList(list):
class BoundaryConditionList(object):
def __init__(self):
super(BoundaryConditionList, self).__init__()
def new(self, index):
self._tabs = {
"liquid" : [],
"solid" : [],
"suspenssion" : []
}
def len(self, lst):
return len(self._tabs[lst])
def get_tab(self, lst):
return self._tabs[lst].copy()
def get(self, lst, row):
return self._tabs[lst][row]
def set(self, lst, row, new):
self._tabs[lst][row] = new
def new(self, lst, index):
n = NotDefined()
self.insert(index, n)
self._tabs[lst].insert(index, n)
return n
def delete(self, bcs):
for bc in bcs:
self.remove(bc)
def insert(self, lst, index, new):
self._tabs[lst].insert(index, new)
def delete_i(self, indexes):
def delete(self, lst, bcs):
for bc in bcs:
self._tabs[lst].remove(bc)
def delete_i(self, lst, indexes):
bcs = list(
map(
lambda x: x[1],
filter(
lambda x: x[0] in indexes,
enumerate(self)
enumerate(self._tabs[lst])
)
)
)
self.delete(bcs)
self.delete(lst, bcs)
def move_up(self, index):
if index < len(self):
def sort(self, lst, reverse=False, key=None):
self._tabs[lst].sort(reverse=reverse, key=key)
def move_up(self, lst, index):
if index < len(self._tabs[lst]):
next = index - 1
self[index], self[next] = self[next], self[index]
l = self._tabs[lst]
l[index], l[next] = l[next], l[index]
def move_down(self, index):
def move_down(self, lst, index):
if index >= 0:
prev = index + 1
self[index], self[prev] = self[prev], self[index]
l = self._tabs[lst]
l[index], l[prev] = l[prev], l[index]
def __copy__(self):
new = BoundaryConditionList()
for bc in self:
new.append(bc)
for l in self._tabs:
new.tabs[l] = self._tabs[l].copy()
return new
def __deepcopy__(self):
new = BoundaryConditionList()
for bc in self:
new.append(deepcopy(bc))
for l in self._tabs:
new.tabs[l] = self._tabs[l].deepcopy()
return new

16
src/Model/BoundaryCondition/BoundaryConditionTypes.py
View File

@ -19,6 +19,10 @@ class PonctualContribution(BoundaryCondition):
self._type = "PC"
self._header = ["time", "debit"]
@classmethod
def compatibility(cls):
return ["liquid"]
class TimeOverZ(BoundaryCondition):
def __init__(self, name:str = ""):
super(TimeOverZ, self).__init__(name=name)
@ -26,6 +30,10 @@ class TimeOverZ(BoundaryCondition):
self._type = "TZ"
self._header = ["time", "z"]
@classmethod
def compatibility(cls):
return ["liquid"]
class TimeOverDebit(BoundaryCondition):
def __init__(self, name:str = ""):
super(TimeOverDebit, self).__init__(name=name)
@ -33,6 +41,10 @@ class TimeOverDebit(BoundaryCondition):
self._type = "TD"
self._header = ["time", "debit"]
@classmethod
def compatibility(cls):
return ["liquid"]
class ZOverDebit(BoundaryCondition):
def __init__(self, name:str = ""):
super(ZOverDebit, self).__init__(name=name)
@ -41,6 +53,10 @@ class ZOverDebit(BoundaryCondition):
self._header = ["z", "debit"]
self._types = [float, float]
@classmethod
def compatibility(cls):
return ["liquid"]
@property
def _default_0(self):
return 0.0

106
src/View/BoundaryCondition/BCUndoCommand.py
View File

@ -11,105 +11,114 @@ from Model.BoundaryCondition.BoundaryCondition import BoundaryCondition
from Model.BoundaryCondition.BoundaryConditionList import BoundaryConditionList
class SetNameCommand(QUndoCommand):
def __init__(self, lst, index, new_value):
def __init__(self, bcs, tab, index, new_value):
QUndoCommand.__init__(self)
self._lst = lst
self._bcs = bcs
self._tab = tab
self._index = index
self._old = self._lst[self._index].name
self._old = self._bcs.get(self._tab, self._index).name
self._new = new_value
def undo(self):
self._lst[self._index].name = self._old
self._bcs.get(self._tab, self._index).name = self._old
def redo(self):
self._lst[self._index].name = self._new
self._bcs.get(self._tab, self._index).name = self._new
class SetNodeCommand(QUndoCommand):
def __init__(self, lst, index, node):
def __init__(self, bcs, tab, index, node):
QUndoCommand.__init__(self)
self._lst = lst
self._bcs = bcs
self._tab = tab
self._index = index
self._old = self._lst[index].node
self._old = self._bcs.get(self._tab, self._index).node
self._new = node
def undo(self):
self._lst[self._index].node = self._old
self._bcs.get(self._tab, self._index).node = self._old
def redo(self):
self._lst[self._index].node = self._new
self._bcs.get(self._tab, self._index).node = self._new
class SetTypeCommand(QUndoCommand):
def __init__(self, lst, index, _type):
def __init__(self, bcs, tab, index, _type):
QUndoCommand.__init__(self)
self._lst = lst
self._bcs = bcs
self._tab = tab
self._index = index
self._type = _type
self._old = self._lst[index]
self._new = self._lst[index].convert(self._type)
self._old = self._bcs.get(self._tab, self._index)
self._new = self._bcs.get(self._tab, self._index)\
.convert(self._type)
def undo(self):
self._lst[self._index] = self._old
self._bcs.set(self._tab, self._index, self._old)
def redo(self):
self._lst[self._index] = self._new
self._bcs.set(self._tab, self._index, self._new)
class AddCommand(QUndoCommand):
def __init__(self, lst, index):
def __init__(self, bcs, tab, index):
QUndoCommand.__init__(self)
self._lst = lst
self._bcs = bcs
self._tab = tab
self._index = index
self._new = None
def undo(self):
self._lst.delete_i([self._index])
self._bcs.delete_i(self._tab, [self._index])
def redo(self):
if self._new is None:
self._new = self._lst.new(self._index)
self._new = self._bcs.new(self._tab, self._index)
else:
self._lst.insert(self._index, self._new)
self._bcs.insert(self._tab, self._index, self._new)
class DelCommand(QUndoCommand):
def __init__(self, lst, rows):
def __init__(self, bcs, tab, rows):
QUndoCommand.__init__(self)
self._lst = lst
self._bcs = bcs
self._tab = tab
self._rows = rows
self._bc = []
for row in rows:
self._bc.append((row, self._lst[row]))
self._bc.append((row, self._bcs.get(self._tab, row)))
self._bc.sort()
def undo(self):
for row, el in self._bc:
self._lst.insert(row, el)
self._bcs.insert(self._tab, row, el)
def redo(self):
self._lst.delete_i(self._rows)
self._bcs.delete_i(self._tab, self._rows)
class SortCommand(QUndoCommand):
def __init__(self, lst, _reverse):
def __init__(self, bcs, tab, _reverse):
QUndoCommand.__init__(self)
self._lst = lst
self._bcs = bcs
self._tab = tab
self._reverse = _reverse
self._old = self._lst.copy()
self._old = self._bcs.get_tab(self._tab)
self._indexes = None
def undo(self):
ll = self._lst.copy()
self._lst.sort(
ll = self._bcs.get_tab(self._tab)
self._bcs.sort(
self._tab,
key=lambda x: self._indexes[ll.index(x)]
)
def redo(self):
self._lst.sort(
self._bcs.sort(
self._tab,
reverse=self._reverse,
key=lambda x: x.name
)
@ -117,62 +126,65 @@ class SortCommand(QUndoCommand):
self._indexes = list(
map(
lambda p: self._old.index(p),
self._lst
self._bcs.get_tab(self._tab)
)
)
self._old = None
class MoveCommand(QUndoCommand):
def __init__(self, lst, up, i):
def __init__(self, bcs, tab, up, i):
QUndoCommand.__init__(self)
self._lst = lst
self._bcs = bcs
self._tab = tab
self._up = up == "up"
self._i = i
def undo(self):
if self._up:
self._lst.move_up(self._i)
self._bcs.move_up(self._tab, self._i)
else:
self._lst.move_down(self._i)
self._bcs.move_down(self._tab, self._i)
def redo(self):
if self._up:
self._lst.move_up(self._i)
self._bcs.move_up(self._tab, self._i)
else:
self._lst.move_down(self._i)
self._bcs.move_down(self._tab, self._i)
class PasteCommand(QUndoCommand):
def __init__(self, lst, row, bc):
def __init__(self, bcs, tab, row, bc):
QUndoCommand.__init__(self)
self._lst = lst
self._bcs = bcs
self._tab = tab
self._row = row
self._bc = deepcopy(bc)
self._bc.reverse()
def undo(self):
self._lst.delete(self._bc)
self._bcs.delete(self._tab, self._bc)
def redo(self):
for bc in self._bc:
self._lst.insert(self._row, bc)
self._bcs.insert(self._tab, self._row, bc)
class DuplicateCommand(QUndoCommand):
def __init__(self, lst, rows, bc):
def __init__(self, bcs, tab, rows, bc):
QUndoCommand.__init__(self)
self._lst = lst
self._bcs = bcs
self._tab = tab
self._rows = rows
self._bc = deepcopy(bc)
self._bc.reverse()
def undo(self):
self._lst.delete(self._bc)
self._bcs.delete(self._tab, self._bc)
def redo(self):
for bc in self._bcs:
self._lst.insert(self._rows[0], bc)
self._bcs.insert(self._tab, self._rows[0], bc)

59
src/View/BoundaryCondition/BoundaryConditionWindow.py
View File

@ -19,7 +19,7 @@ from PyQt5.QtWidgets import (
QDialogButtonBox, QPushButton, QLineEdit,
QFileDialog, QTableView, QAbstractItemView,
QUndoStack, QShortcut, QAction, QItemDelegate,
QComboBox, QVBoxLayout, QHeaderView
QComboBox, QVBoxLayout, QHeaderView, QTabWidget,
)
from View.BoundaryCondition.BCUndoCommand import (
@ -69,20 +69,28 @@ class BoundaryConditionWindow(ASubMainWindow, ListedSubWindow):
self.paste_sc = QShortcut(QKeySequence.Paste, self)
def setup_table(self):
table = self.find(QTableView, "tableView_liquid")
self._table = TableModel(
self._table = {}
for t in ["liquid", "solid", "suspenssion"]:
table = self.find(QTableView, f"tableView_{t}")
self._table[t] = TableModel(
data = self._study.river,
undo = self._undo_stack
undo = self._undo_stack,
tab = t,
)
table.setModel(self._table)
table.setModel(self._table[t])
self._delegate_type = ComboBoxDelegate(
data = self._study.river,
mode = "type"
mode = "type",
tab = t,
parent=self
)
self._delegate_node = ComboBoxDelegate(
data = self._study.river,
mode = "node"
mode = "node",
tab = t,
parent=self
)
table.setItemDelegateForColumn(
@ -117,15 +125,22 @@ class BoundaryConditionWindow(ASubMainWindow, ListedSubWindow):
self.copy_sc.activated.connect(self.copy)
self.paste_sc.activated.connect(self.paste)
def current_tab(self):
return self.find(QTabWidget, "tabWidget")\
.currentWidget()\
.objectName()\
.replace("tab_", "")
def index_selected_row(self):
table = self.find(QTableView, "tableView_liquid")
tab = self.current_tab()
table = self.find(QTableView, f"tableView_{tab}")
return table.selectionModel()\
.selectedRows()[0]\
.row()
def index_selected_rows(self):
table = self.find(QTableView, "tableView_liquid")
tab = self.current_tab()
table = self.find(QTableView, f"tableView_{tab}")
return list(
# Delete duplicate
set(
@ -137,30 +152,34 @@ class BoundaryConditionWindow(ASubMainWindow, ListedSubWindow):
)
def add(self):
tab = self.current_tab()
rows = self.index_selected_rows()
if len(self._lst) == 0 or len(rows) == 0:
self._table.add(0)
if self._lst.len(tab) == 0 or len(rows) == 0:
self._table[tab].add(0)
else:
self._table.add(rows[0])
self._table[tab].add(rows[0])
def delete(self):
tab = self.current_tab()
rows = self.index_selected_rows()
if len(rows) == 0:
return
self._table.delete(rows)
self._table[tab].delete(rows)
def sort(self):
self._table.sort(False)
tab = self.current_tab()
self._table[tab].sort(False)
def move_up(self):
tab = self.current_tab()
row = self.index_selected_row()
self._table.move_up(row)
self._table[tab].move_up(row)
def move_down(self):
tab = self.current_tab()
row = self.index_selected_row()
self._table.move_down(row)
self._table[tab].move_down(row)
def copy(self):
print("TODO")
@ -169,10 +188,12 @@ class BoundaryConditionWindow(ASubMainWindow, ListedSubWindow):
print("TODO")
def undo(self):
self._table.undo()
tab = self.current_tab()
self._table[tab].undo()
def redo(self):
self._table.redo()
tab = self.current_tab()
self._table[tab].redo()
def edit(self):
rows = self.index_selected_rows()

48
src/View/BoundaryCondition/Table.py
View File

@ -30,17 +30,30 @@ from View.BoundaryCondition.translate import *
_translate = QCoreApplication.translate
class ComboBoxDelegate(QItemDelegate):
def __init__(self, data=None, mode="type", parent=None):
def __init__(self, data=None, mode="type", tab="", parent=None):
super(ComboBoxDelegate, self).__init__(parent)
self._data = data
self._mode = mode
self._tab = tab
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()])
lst = list(
map(
lambda k: long_types[k],
filter(
lambda k: self._tab in BC_types[k].compatibility(),
BC_types.keys()
)
)
)
print(lst)
self.editor.addItems(
lst
)
else:
self.editor.addItems(
[_translate("BoundaryCondition", "Not associate")] +
@ -72,12 +85,13 @@ class ComboBoxDelegate(QItemDelegate):
class TableModel(QAbstractTableModel):
def __init__(self, data=None, undo=None):
def __init__(self, data=None, undo=None, tab=""):
super(QAbstractTableModel, self).__init__()
self._headers = list(table_headers.keys())
self._data = data
self._undo = undo
self._lst = self._data.boundary_condition
self._tab = tab
self._bcs = self._data.boundary_condition
def flags(self, index):
options = Qt.ItemIsEnabled | Qt.ItemIsSelectable
@ -86,7 +100,7 @@ class TableModel(QAbstractTableModel):
return options
def rowCount(self, parent):
return len(self._lst)
return self._bcs.len(self._tab)
def columnCount(self, parent):
return len(self._headers)
@ -99,12 +113,12 @@ class TableModel(QAbstractTableModel):
column = index.column()
if self._headers[column] == "name":
return self._lst[row].name
return self._bcs.get(self._tab, row).name
elif self._headers[column] == "type":
t = self._lst[row].bctype
t = self._bcs.get(self._tab, row).bctype
return long_types[t]
elif self._headers[column] == "node":
n = self._lst[row].node
n = self._bcs.get(self._tab, row).node
if n is None:
return _translate("BoundaryCondition", "Not associate")
return n.name
@ -127,20 +141,20 @@ class TableModel(QAbstractTableModel):
if self._headers[column] == "name":
self._undo.push(
SetNameCommand(
self._lst, row, value
self._bcs, self._tab,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]
self._bcs, self._tab,row, BC_types[key]
)
)
elif self._headers[column] == "node":
self._undo.push(
SetNodeCommand(
self._lst, row, self._data.node(value)
self._bcs, self._tab,row, self._data.node(value)
)
)
@ -152,7 +166,7 @@ class TableModel(QAbstractTableModel):
self._undo.push(
AddCommand(
self._lst, row
self._bcs, self._tab,row
)
)
@ -164,7 +178,7 @@ class TableModel(QAbstractTableModel):
self._undo.push(
DelCommand(
self._lst, rows
self._bcs, self._tab,rows
)
)
@ -176,7 +190,7 @@ class TableModel(QAbstractTableModel):
self._undo.push(
SortCommand(
self._lst, False
self._bcs, self._tab,False
)
)
@ -193,7 +207,7 @@ class TableModel(QAbstractTableModel):
self._undo_stack.push(
MoveCommand(
self._lst, "up", row
self._bcs, self._tab,"up", row
)
)
@ -201,7 +215,7 @@ class TableModel(QAbstractTableModel):
self.layoutChanged.emit()
def move_down(self, index, parent=QModelIndex()):
if row > len(self._lst):
if row > len(self._bcs):
return
target = row
@ -210,7 +224,7 @@ class TableModel(QAbstractTableModel):
self._undo_stack.push(
MoveCommand(
self._lst, "down", row
self._bcs, self._tab,"down", row
)
)

6
src/View/ui/BoundaryConditions.ui
View File

@ -33,7 +33,7 @@
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="tab">
<widget class="QWidget" name="tab_liquid">
<attribute name="title">
<string>Liquid</string>
</attribute>
@ -43,7 +43,7 @@
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_2">
<widget class="QWidget" name="tab_solid">
<attribute name="title">
<string>Solid</string>
</attribute>
@ -53,7 +53,7 @@
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_3">
<widget class="QWidget" name="tab_suspenssion">
<attribute name="title">
<string>Suspenssion</string>
</attribute>