LC: Add code base (don't working).

src/View/LateralContribution/Edit/Plot.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+
+from datetime import datetime
+
+from tools import timer, trace
+from View.Plot.APlot import APlot
+
+from PyQt5.QtCore import (
+    QCoreApplication
+)
+
+from View.LateralContribution.Edit.translate import *
+
+_translate = QCoreApplication.translate
+
+class Plot(APlot):
+    def __init__(self, canvas=None, data=None,
+                 mode = "time", toolbar=None):
+        super(Plot, self).__init__(
+            canvas=canvas,
+            data=data,
+            toolbar=toolbar
+        )
+
+        self._mode = mode
+
+    def custom_ticks(self):
+        t0 = datetime.fromtimestamp(0)
+        nb = len(self.data.data)
+        mod = int(nb / 5)
+
+        fx = list(
+            map(
+                lambda x: x[1],
+                filter(
+                    lambda x: x[0] % mod == 0,
+                    enumerate(self.data.data)
+                )
+            )
+        )
+        xx = list(map(lambda v: v[0], fx))
+        if self._mode == "time":
+            xt = list(
+                map(
+                    lambda v: str(
+                        datetime.fromtimestamp(v[0]) - t0
+                    ).split(",")[0]\
+                    .replace("days", _translate("LateralContribution", "days"))\
+                    .replace("day", _translate("LateralContribution", "day")),
+                    fx
+                )
+            )
+        else:
+            xt = list(
+                map(
+                    lambda v: str(datetime.fromtimestamp(v[0]).date()),
+                    fx
+                )
+            )
+
+        self.canvas.axes.set_xticks(ticks=xx, labels=xt, rotation=45)
+
+
+    @timer
+    def draw(self):
+        self.canvas.axes.cla()
+        self.canvas.axes.grid(color='grey', linestyle='--', linewidth=0.5)
+
+        if len(self.data) == 0:
+            self._init = False
+            return
+
+        # Plot data
+        x = list(map(lambda v: v[0], self.data.data))
+        y = list(map(lambda v: v[1], self.data.data))
+        self._line, = self.canvas.axes.plot(
+            x, y,
+            color='r', lw=1.,
+            markersize=5, marker='+',
+            picker=30,
+        )
+
+        self.custom_ticks()
+
+        # Plot label
+        header = self.data.header
+        self.canvas.axes.set_xlabel(
+            table_headers[header[0]], color='black', fontsize=10
+        )
+        self.canvas.axes.set_ylabel(
+            table_headers[header[1]], color='black', fontsize=10
+        )
+
+        self.canvas.axes.autoscale_view(True, True, True)
+        self.canvas.figure.tight_layout()
+        self.canvas.figure.canvas.draw_idle()
+        #self.toolbar.update()
+
+        self._init = True
+
+    @timer
+    def update(self, ind=None):
+        if self._init == False:
+            self.draw()
+            return
+
+        x = list(map(lambda v: v[0], self.data.data))
+        y = list(map(lambda v: v[1], self.data.data))
+
+        self._line.set_data(x, y)
+
+        self.custom_ticks()
+
+        self.canvas.axes.relim()
+        self.canvas.axes.autoscale()
+        self.canvas.figure.tight_layout()
+        self.canvas.figure.canvas.draw_idle()

src/View/LateralContribution/Edit/Table.py

@@ -0,0 +1,302 @@
+# -*- coding: utf-8 -*-
+
+from datetime import date, time, datetime, timedelta
+
+from tools import trace, timer
+
+from View.ASubWindow import ASubMainWindow, AWidget
+from View.ListedSubWindow import ListedSubWindow
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect, QTime, QDateTime,
+)
+
+from PyQt5.QtWidgets import (
+    QTableView, QAbstractItemView, QSpinBox,
+    QTimeEdit, QDateTimeEdit, QItemDelegate,
+)
+
+from Model.LateralContribution.LateralContributionTypes import (
+    NotDefined, PonctualContribution,
+    TimeOverZ, TimeOverDebit, ZOverDebit
+)
+
+from View.LateralContribution.Edit.UndoCommand import (
+    SetDataCommand, AddCommand, DelCommand,
+    SortCommand, MoveCommand, PasteCommand,
+    DuplicateCommand,
+)
+from View.LateralContribution.Edit.translate import *
+
+_translate = QCoreApplication.translate
+
+
+class ExtendedTimeEdit(AWidget):
+    def __init__(self, parent=None):
+        super(ExtendedTimeEdit, self).__init__(
+            ui="extendedTimeEdit",
+            parent=parent
+        )
+        self.parent = parent
+
+        self.spinBox_days = self.find(QSpinBox, "spinBox_days")
+        self.timeEdit = self.find(QTimeEdit, "timeEdit")
+
+    def set_time(self, time):
+        days = 0
+        stime = time
+
+        # if ',' in time, time format is 'DD days, HH:MM:SS',
+        # otherelse is 'HH:MM:SS'
+        if "," in time:
+            s = time.strip().split(" ")
+            days = int(s[0])
+            stime = s[-1]
+
+        qtime = QTime.fromString(
+            stime,
+            "h:mm:ss"
+        )
+        self.spinBox_days.setValue(days)
+        self.timeEdit.setTime(qtime)
+
+    def get_time(self):
+        days = self.spinBox_days.value()
+        time = self.timeEdit.time().toPyTime()
+        secs = (
+            (time.hour * 3600) +
+            (time.minute * 60) +
+            time.second
+        )
+
+        return timedelta(days=days, seconds=secs)
+
+class ExtendedDateTimeEdit(AWidget):
+    def __init__(self, parent=None):
+        super(ExtendedDateTimeEdit, self).__init__(
+            ui="extendedDateTimeEdit",
+            parent=parent
+        )
+        self.parent = parent
+
+        self.dateTimeEdit = self.find(QDateTimeEdit, "dateTimeEdit")
+
+    def set_time(self, time):
+        qdatetime = QDateTime.fromString(
+            time,
+            "yyyy-MM-dd hh:mm:ss"
+        )
+        self.dateTimeEdit.setDateTime(qdatetime)
+
+    def get_time(self):
+        time = self.dateTimeEdit.dateTime().toPyDateTime()
+        return time
+
+class ExTimeDelegate(QItemDelegate):
+    def __init__(self, data=None, mode="time", parent=None):
+        super(ExTimeDelegate, self).__init__(parent)
+
+        self._data = data
+        self._mode = mode
+
+    def createEditor(self, parent, option, index):
+        if self._mode == "time":
+            self.editor = ExtendedTimeEdit(parent=parent)
+        else:
+            self.editor = ExtendedDateTimeEdit(parent=parent)
+        value = index.data(Qt.DisplayRole)
+        self.editor.set_time(value)
+        print(value)
+        return self.editor
+
+    def setModelData(self, editor, model, index):
+        time = editor.get_time()
+        if self._mode == "time":
+            model.setData(index, int(time.total_seconds()))
+        else:
+            print(time.timestamp())
+            model.setData(index, int(time.timestamp()))
+        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, mode="time", undo=None):
+        super(QAbstractTableModel, self).__init__()
+        self._headers = data.header
+        self._data = data
+        self._mode = mode
+        self._undo = undo
+
+    def flags(self, index):
+        options = Qt.ItemIsEnabled | Qt.ItemIsSelectable
+        options |= Qt.ItemIsEditable
+
+        return options
+
+    def rowCount(self, parent):
+        return len(self._data)
+
+    def columnCount(self, parent):
+        return len(self._headers)
+
+    def data(self, index, role):
+        if role == Qt.TextAlignmentRole:
+            return Qt.AlignHCenter | Qt.AlignVCenter
+
+        if role != Qt.ItemDataRole.DisplayRole:
+            return QVariant()
+
+        row = index.row()
+        column = index.column()
+
+        value = QVariant()
+
+        if 0 <= column < 2:
+            v = self._data.get_i(row)[column]
+            if self._data.get_type_column(column) == float:
+                value = f"{v:.4f}"
+            elif self._data.header[column] == "time":
+                if self._mode == "time":
+                    t0 = datetime.fromtimestamp(0)
+                    t = datetime.fromtimestamp(v)
+                    value = str(t - t0)
+                else:
+                    value = str(datetime.fromtimestamp(v))
+            else:
+                value = f"{v}"
+
+        return value
+
+    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()
+
+        self._undo.push(
+            SetDataCommand(
+                self._data, row, column, 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._data, row
+            )
+        )
+
+        self.endInsertRows()
+        self.layoutChanged.emit()
+
+    def delete(self, rows, parent=QModelIndex()):
+        self.beginRemoveRows(parent, rows[0], rows[-1])
+
+        self._undo.push(
+            DelCommand(
+                self._data, rows
+            )
+        )
+
+        self.endRemoveRows()
+
+    def sort(self, _reverse, parent=QModelIndex()):
+        self.layoutAboutToBeChanged.emit()
+
+        self._undo.push(
+            SortCommand(
+                self._data, _reverse
+            )
+        )
+
+        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._data, "up", row
+            )
+        )
+
+        self.endMoveRows()
+        self.layoutChanged.emit()
+
+    def move_down(self, index, parent=QModelIndex()):
+        if row > len(self._data):
+            return
+
+        target = row
+
+        self.beginMoveRows(parent, row + 1, row + 1, parent, target)
+
+        self._undo_stack.push(
+            MoveCommand(
+                self._data, "down", row
+            )
+        )
+
+        self.endMoveRows()
+        self.layoutChanged.emit()
+
+    def paste(self, row, header, data):
+        if len(data) == 0:
+            return
+
+        self.layoutAboutToBeChanged.emit()
+
+        self._undo.push(
+            PasteCommand(
+                self._data, row,
+                list(
+                    map(
+                        lambda d: self._data.new_from_data(header, d),
+                        data
+                    )
+                )
+            )
+        )
+
+        self.layoutAboutToBeChanged.emit()
+        self.layoutChanged.emit()
+
+
+    def undo(self):
+        self._undo.undo()
+        self.layoutChanged.emit()
+
+    def redo(self):
+        self._undo.redo()
+        self.layoutChanged.emit()

src/View/LateralContribution/Edit/UndoCommand.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+
+from copy import deepcopy
+from tools import trace, timer
+
+from PyQt5.QtWidgets import (
+    QMessageBox, QUndoCommand, QUndoStack,
+)
+
+from Model.LateralContribution.LateralContribution import LateralContribution
+
+class SetDataCommand(QUndoCommand):
+    def __init__(self, data, index, column, new_value):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._index = index
+        self._column = column
+        self._old = self._data.get_i(self._index)[self._column]
+        self._new = new_value
+
+    def undo(self):
+        self._data._set_i_c_v(self._index, self._column, self._old)
+
+    def redo(self):
+        self._data._set_i_c_v(self._index, self._column, self._new)
+
+class AddCommand(QUndoCommand):
+    def __init__(self, data, index):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._index = index
+        self._new = None
+
+    def undo(self):
+        self._data.delete_i([self._index])
+
+    def redo(self):
+        if self._new is None:
+            self._new = self._data.add(self._index)
+        else:
+            self._data.insert(self._index, self._new)
+
+class DelCommand(QUndoCommand):
+    def __init__(self, data, rows):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._rows = rows
+
+        self._bc = []
+        for row in rows:
+            self._bc.append((row, self._data.get_i(row)))
+        self._bc.sort()
+
+    def undo(self):
+        for row, el in self._bc:
+            self._data.insert(row, el)
+
+    def redo(self):
+        self._data.delete_i(self._rows)
+
+class SortCommand(QUndoCommand):
+    def __init__(self, data, _reverse):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._reverse = _reverse
+
+        self._old = self._data.data
+        self._indexes = None
+
+    def undo(self):
+        ll = self._data.data
+        self._data.sort(
+            key=lambda x: self._indexes[ll.index(x)]
+        )
+
+    def redo(self):
+        self._data.sort(
+            _reverse=self._reverse,
+            key=lambda x: x[0]
+        )
+        if self._indexes is None:
+            self._indexes = list(
+                map(
+                    lambda p: self._old.index(p),
+                    self._data.data
+                )
+            )
+            self._old = None
+
+
+class MoveCommand(QUndoCommand):
+    def __init__(self, data, up, i):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._up = up == "up"
+        self._i = i
+
+    def undo(self):
+        if self._up:
+            self._data.move_up(self._i)
+        else:
+            self._data.move_down(self._i)
+
+    def redo(self):
+        if self._up:
+            self._data.move_up(self._i)
+        else:
+            self._data.move_down(self._i)
+
+
+class PasteCommand(QUndoCommand):
+    def __init__(self, data, row, bcs):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._row = row
+        self._bcs = bcs
+        self._bcs.reverse()
+
+    def undo(self):
+        self._data.delete(self._bcs)
+
+    def redo(self):
+        for bc in self._bcs:
+            self._data.insert(self._row, bc)
+
+
+class DuplicateCommand(QUndoCommand):
+    def __init__(self, data, rows, bc):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._rows = rows
+        self._bc = deepcopy(bc)
+        self._bc.reverse()
+
+    def undo(self):
+        self._data.delete(self._bc)
+
+    def redo(self):
+        for bc in self._bcs:
+            self._data.insert(self._rows[0], bc)

src/View/LateralContribution/Edit/Window.py

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+
+from tools import timer, trace
+
+from View.ASubWindow import ASubMainWindow
+from View.ListedSubWindow import ListedSubWindow
+
+from PyQt5.QtGui import (
+    QKeySequence,
+)
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel, QCoreApplication,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QHeaderView,
+)
+
+from View.Plot.MplCanvas import MplCanvas
+
+from View.LateralContribution.translate import long_types
+from View.LateralContribution.Edit.Table import TableModel, ExTimeDelegate
+from View.LateralContribution.Edit.Plot import Plot
+
+_translate = QCoreApplication.translate
+
+class EditLateralContributionWindow(ASubMainWindow, ListedSubWindow):
+    def __init__(self, title="Edit boundary condition",
+                 data=None, study=None, parent=None):
+        self._data = data
+        self._study = study
+        self._title = title
+
+        self.compute_title()
+
+        super(EditLateralContributionWindow, self).__init__(
+            name=self._title, ui="EditLateralContributions", parent=parent
+        )
+
+        self.ui.setWindowTitle(self._title)
+
+        self.setup_sc()
+        self.setup_table()
+        self.setup_plot()
+        self.setup_connections()
+
+    def compute_title(self):
+        if self._data is not None:
+            node_name = (self._data.node.name if self._data.node is not None
+                         else _translate("LateralContribution", "Not associate"))
+            self._title = (
+                _translate("Edit boundary condition", self._title) +
+                f" - {self._study.name} " +
+                f" - {self._data.name} " +
+                f"({long_types[self._data.bctype]} - {node_name})"
+            )
+
+    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._data,
+            undo = self._undo_stack,
+            mode = self._study.time_system
+        )
+
+        if self._data.header[0] == "time":
+            self._delegate_time = ExTimeDelegate(
+                data = self._data,
+                mode = self._study.time_system,
+                parent = self
+            )
+
+            table.setItemDelegateForColumn(
+                0, self._delegate_time
+            )
+
+        table.setModel(self._table)
+        table.setSelectionBehavior(QAbstractItemView.SelectRows)
+        table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        table.setAlternatingRowColors(True)
+
+    def setup_plot(self):
+        self.canvas = MplCanvas(width=5, height=4, dpi=100)
+        self.canvas.setObjectName("canvas")
+        self.verticalLayout.addWidget(self.canvas)
+
+        self.plot = Plot(
+            canvas = self.canvas,
+            data = self._data,
+            mode = self._study.time_system,
+        )
+        self.plot.draw()
+
+
+    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_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)
+
+        self._table.dataChanged.connect(self.update)
+
+    def update(self):
+        self.plot.update()
+
+    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._data) == 0 or len(rows) == 0:
+            self._table.add(0)
+        else:
+            self._table.add(rows[0])
+
+        self.plot.update()
+
+    def delete(self):
+        rows = self.index_selected_rows()
+        if len(rows) == 0:
+            return
+
+        self._table.delete(rows)
+        self.plot.update()
+
+    def sort(self):
+        self._table.sort(False)
+        self.plot.update()
+
+    def move_up(self):
+        row = self.index_selected_row()
+        self._table.move_up(row)
+        self.plot.update()
+
+    def move_down(self):
+        row = self.index_selected_row()
+        self._table.move_down(row)
+        self.plot.update()
+
+
+    def copy(self):
+        rows = self.index_selected_rows()
+
+        table = []
+        table.append(self._data.header)
+
+        data = self._data.data
+        for row in rows:
+            table.append(list(data[row]))
+
+        self.copyTableIntoClipboard(table)
+
+    def paste(self):
+        header, data = self.parseClipboardTable()
+
+        if len(data) == 0:
+            return
+
+        row = 0
+        rows = self.index_selected_rows()
+        if len(rows) != 0:
+            row = rows[0]
+
+        self._table.paste(row, header, data)
+        self.plot.update()
+
+    def undo(self):
+        self._table.undo()
+        self.plot.update()
+
+    def redo(self):
+        self._table.redo()
+        self.plot.update()

src/View/LateralContribution/Edit/translate.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+from PyQt5.QtCore import QCoreApplication
+
+_translate = QCoreApplication.translate
+
+table_headers = {
+    "x": _translate("LateralContribution", "X"),
+    "y": _translate("LateralContribution", "Y"),
+    "time": _translate("LateralContribution", "Time"),
+    "debit": _translate("LateralContribution", "Debit"),
+    "z": _translate("LateralContribution", "Z (m)")
+}

src/View/LateralContribution/Table.py

@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+
+from tools import trace, timer
+
+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.LateralContribution.UndoCommand import (
+    SetNameCommand, SetNodeCommand, SetTypeCommand,
+    AddCommand, DelCommand, SortCommand,
+    MoveCommand, PasteCommand, DuplicateCommand,
+)
+
+from Model.LateralContribution.LateralContributionTypes import (
+    NotDefined, PonctualContribution,
+    TimeOverZ, TimeOverDebit, ZOverDebit
+)
+from View.LateralContribution.translate import *
+
+_translate = QCoreApplication.translate
+
+class ComboBoxDelegate(QItemDelegate):
+    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":
+            lst = list(
+                map(
+                    lambda k: long_types[k],
+                    filter(
+                        lambda k: self._tab in BC_types[k].compatibility(),
+                        BC_types.keys()
+                    )
+                )
+            )
+            self.editor.addItems(
+                lst
+            )
+        else:
+            self.editor.addItems(
+                [_translate("LateralContribution", "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, tab=""):
+        super(QAbstractTableModel, self).__init__()
+        self._headers = list(table_headers.keys())
+        self._data = data
+        self._undo = undo
+        self._tab = tab
+        self._lcs = self._data.boundary_condition
+
+    def flags(self, index):
+        options = Qt.ItemIsEnabled | Qt.ItemIsSelectable
+        options |= Qt.ItemIsEditable
+
+        return options
+
+    def rowCount(self, parent):
+        return self._lcs.len(self._tab)
+
+    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._lcs.get(self._tab, row).name
+        elif self._headers[column] == "type":
+            t = self._lcs.get(self._tab, row).bctype
+            return long_types[t]
+        elif self._headers[column] == "node":
+            n = self._lcs.get(self._tab, row).node
+            if n is None:
+                return _translate("LateralContribution", "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._lcs, 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._lcs, self._tab,row, BC_types[key]
+                )
+            )
+        elif self._headers[column] == "node":
+            self._undo.push(
+                SetNodeCommand(
+                    self._lcs, self._tab,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._lcs, self._tab,row
+            )
+        )
+
+        self.endInsertRows()
+        self.layoutChanged.emit()
+
+    def delete(self, rows, parent=QModelIndex()):
+        self.beginRemoveRows(parent, rows[0], rows[-1])
+
+        self._undo.push(
+            DelCommand(
+                self._lcs, self._tab,rows
+            )
+        )
+
+        self.endRemoveRows()
+        self.layoutChanged.emit()
+
+    def sort(self, _reverse, parent=QModelIndex()):
+        self.layoutAboutToBeChanged.emit()
+
+        self._undo.push(
+            SortCommand(
+                self._lcs, self._tab,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._lcs, self._tab,"up", row
+            )
+        )
+
+        self.endMoveRows()
+        self.layoutChanged.emit()
+
+    def move_down(self, index, parent=QModelIndex()):
+        if row > len(self._lcs):
+            return
+
+        target = row
+
+        self.beginMoveRows(parent, row + 1, row + 1, parent, target)
+
+        self._undo_stack.push(
+            MoveCommand(
+                self._lcs, self._tab,"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()

src/View/LateralContribution/UndoCommand.py

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+
+from copy import deepcopy
+from tools import trace, timer
+
+from PyQt5.QtWidgets import (
+    QMessageBox, QUndoCommand, QUndoStack,
+)
+
+from Model.LateralContribution.LateralContribution import LateralContribution
+from Model.LateralContribution.LateralContributionList import LateralContributionList
+
+class SetNameCommand(QUndoCommand):
+    def __init__(self, lcs, tab, index, new_value):
+        QUndoCommand.__init__(self)
+
+        self._lcs = lcs
+        self._tab = tab
+        self._index = index
+        self._old = self._lcs.get(self._tab, self._index).name
+        self._new = new_value
+
+    def undo(self):
+        self._lcs.get(self._tab, self._index).name = self._old
+
+    def redo(self):
+        self._lcs.get(self._tab, self._index).name = self._new
+
+class SetNodeCommand(QUndoCommand):
+    def __init__(self, lcs, tab, index, node):
+        QUndoCommand.__init__(self)
+
+        self._lcs = lcs
+        self._tab = tab
+        self._index = index
+        self._old = self._lcs.get(self._tab, self._index).node
+        self._new = node
+
+    def undo(self):
+        self._lcs.get(self._tab, self._index).node = self._old
+
+    def redo(self):
+        self._lcs.get(self._tab, self._index).node = self._new
+
+class SetTypeCommand(QUndoCommand):
+    def __init__(self, lcs, tab, index, _type):
+        QUndoCommand.__init__(self)
+
+        self._lcs = lcs
+        self._tab = tab
+        self._index = index
+        self._type = _type
+        self._old = self._lcs.get(self._tab, self._index)
+        self._new = self._lcs.get(self._tab, self._index)\
+                             .convert(self._type)
+
+    def undo(self):
+        self._lcs.set(self._tab, self._index, self._old)
+
+    def redo(self):
+        self._lcs.set(self._tab, self._index, self._new)
+
+class AddCommand(QUndoCommand):
+    def __init__(self, lcs, tab, index):
+        QUndoCommand.__init__(self)
+
+        self._lcs = lcs
+        self._tab = tab
+        self._index = index
+        self._new = None
+
+    def undo(self):
+        self._lcs.delete_i(self._tab, [self._index])
+
+    def redo(self):
+        if self._new is None:
+            self._new = self._lcs.new(self._tab, self._index)
+        else:
+            self._lcs.insert(self._tab, self._index, self._new)
+
+class DelCommand(QUndoCommand):
+    def __init__(self, lcs, tab, rows):
+        QUndoCommand.__init__(self)
+
+        self._lcs = lcs
+        self._tab = tab
+        self._rows = rows
+
+        self._bc = []
+        for row in rows:
+            self._bc.append((row, self._lcs.get(self._tab, row)))
+        self._bc.sort()
+
+    def undo(self):
+        for row, el in self._bc:
+            self._lcs.insert(self._tab, row, el)
+
+    def redo(self):
+        self._lcs.delete_i(self._tab, self._rows)
+
+class SortCommand(QUndoCommand):
+    def __init__(self, lcs, tab, _reverse):
+        QUndoCommand.__init__(self)
+
+        self._lcs = lcs
+        self._tab = tab
+        self._reverse = _reverse
+
+        self._old = self._lcs.get_tab(self._tab)
+        self._indexes = None
+
+    def undo(self):
+        ll = self._lcs.get_tab(self._tab)
+        self._lcs.sort(
+            self._tab,
+            key=lambda x: self._indexes[ll.index(x)]
+        )
+
+    def redo(self):
+        self._lcs.sort(
+            self._tab,
+            reverse=self._reverse,
+            key=lambda x: x.name
+        )
+        if self._indexes is None:
+            self._indexes = list(
+                map(
+                    lambda p: self._old.index(p),
+                    self._lcs.get_tab(self._tab)
+                )
+            )
+            self._old = None
+
+
+class MoveCommand(QUndoCommand):
+    def __init__(self, lcs, tab, up, i):
+        QUndoCommand.__init__(self)
+
+        self._lcs = lcs
+        self._tab = tab
+        self._up = up == "up"
+        self._i = i
+
+    def undo(self):
+        if self._up:
+            self._lcs.move_up(self._tab, self._i)
+        else:
+            self._lcs.move_down(self._tab, self._i)
+
+    def redo(self):
+        if self._up:
+            self._lcs.move_up(self._tab, self._i)
+        else:
+            self._lcs.move_down(self._tab, self._i)
+
+
+class PasteCommand(QUndoCommand):
+    def __init__(self, lcs, tab, row, bc):
+        QUndoCommand.__init__(self)
+
+        self._lcs = lcs
+        self._tab = tab
+        self._row = row
+        self._bc = deepcopy(bc)
+        self._bc.reverse()
+
+    def undo(self):
+        self._lcs.delete(self._tab, self._bc)
+
+    def redo(self):
+        for bc in self._bc:
+            self._lcs.insert(self._tab, self._row, bc)
+
+
+class DuplicateCommand(QUndoCommand):
+    def __init__(self, lcs, tab, rows, bc):
+        QUndoCommand.__init__(self)
+
+        self._lcs = lcs
+        self._tab = tab
+        self._rows = rows
+        self._bc = deepcopy(bc)
+        self._bc.reverse()
+
+    def undo(self):
+        self._lcs.delete(self._tab, self._bc)
+
+    def redo(self):
+        for bc in self._lcs:
+            self._lcs.insert(self._tab, self._rows[0], bc)

src/View/LateralContribution/Window.py

@@ -0,0 +1,209 @@
+# -*- 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, QVBoxLayout, QHeaderView, QTabWidget,
+)
+
+from View.LateralContribution.UndoCommand import (
+    SetNameCommand, SetNodeCommand, SetTypeCommand,
+    AddCommand, DelCommand, SortCommand,
+    MoveCommand, PasteCommand, DuplicateCommand,
+)
+
+from Model.LateralContribution.LateralContributionTypes import (
+    NotDefined, PonctualContribution,
+    TimeOverZ, TimeOverDebit, ZOverDebit
+)
+
+from View.LateralContribution.Table import (
+    TableModel, ComboBoxDelegate
+)
+
+from View.Network.GraphWidget import GraphWidget
+from View.LateralContribution.translate import *
+from View.LateralContribution.Edit.Window import EditLateralContributionWindow
+
+_translate = QCoreApplication.translate
+
+
+class LateralContributionWindow(ASubMainWindow, ListedSubWindow):
+    def __init__(self, title="Lateral contribution", study=None, parent=None):
+        title = title + " - " + study.name
+
+        super(LateralContributionWindow, self).__init__(
+            name=title, ui="LateralContributions", parent=parent
+        )
+
+        self._study = study
+        self._lcs = self._study.river.lateral_contribution
+
+        self.setup_sc()
+        self.setup_table()
+        self.setup_graph()
+        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):
+        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,
+                tab = t,
+            )
+            table.setModel(self._table[t])
+
+            self._delegate_type = ComboBoxDelegate(
+                data = self._study.river,
+                mode = "type",
+                tab = t,
+                parent=self
+            )
+            self._delegate_node = ComboBoxDelegate(
+                data = self._study.river,
+                mode = "node",
+                tab = t,
+                parent=self
+            )
+
+            table.setItemDelegateForColumn(
+                1, self._delegate_type
+            )
+            table.setItemDelegateForColumn(
+                2, self._delegate_node
+            )
+
+            table.setSelectionBehavior(QAbstractItemView.SelectRows)
+            table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+            table.setAlternatingRowColors(True)
+
+    def setup_graph(self):
+        self.graph_widget = GraphWidget(
+            self._study.river,
+            min_size=None, size=(200,200),
+            only_display=True,
+            parent=self
+        )
+        self.graph_layout = self.find(QVBoxLayout, "verticalLayout")
+        self.graph_layout.addWidget(self.graph_widget)
+
+    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 current_tab(self):
+        return self.find(QTabWidget, "tabWidget")\
+                   .currentWidget()\
+                   .objectName()\
+                   .replace("tab_", "")
+
+    def index_selected_row(self):
+        tab = self.current_tab()
+        table = self.find(QTableView, f"tableView_{tab}")
+        return table.selectionModel()\
+                    .selectedRows()[0]\
+                    .row()
+
+    def index_selected_rows(self):
+        tab = self.current_tab()
+        table = self.find(QTableView, f"tableView_{tab}")
+        return list(
+            # Delete duplicate
+            set(
+                map(
+                    lambda i: i.row(),
+                    table.selectedIndexes()
+                )
+            )
+        )
+
+    def add(self):
+        tab = self.current_tab()
+        rows = self.index_selected_rows()
+        if self._lcs.len(tab) == 0 or len(rows) == 0:
+            self._table[tab].add(0)
+        else:
+            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[tab].delete(rows)
+
+    def sort(self):
+        tab = self.current_tab()
+        self._table[tab].sort(False)
+
+    def move_up(self):
+        tab = self.current_tab()
+        row = self.index_selected_row()
+        self._table[tab].move_up(row)
+
+    def move_down(self):
+        tab = self.current_tab()
+        row = self.index_selected_row()
+        self._table[tab].move_down(row)
+
+    def copy(self):
+        print("TODO")
+
+    def paste(self):
+        print("TODO")
+
+    def undo(self):
+        tab = self.current_tab()
+        self._table[tab].undo()
+
+    def redo(self):
+        tab = self.current_tab()
+        self._table[tab].redo()
+
+    def edit(self):
+        tab = self.current_tab()
+        rows = self.index_selected_rows()
+        for row in rows:
+            win = EditLateralContributionWindow(
+                data=self._lcs.get(tab, row),
+                study=self._study,
+                parent=self
+            )
+            win.show()

src/View/LateralContribution/translate.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+from PyQt5.QtCore import QCoreApplication
+
+from Model.LateralContribution.LateralContributionTypes import (
+    NotDefined, PonctualContribution,
+    TimeOverZ, TimeOverDebit, ZOverDebit
+)
+
+_translate = QCoreApplication.translate
+
+long_types = {
+    "ND": _translate("LateralContribution", "Not defined"),
+    "PC": _translate("LateralContribution", "Ponctual contribution"),
+    "TZ": _translate("LateralContribution", "Time over Z"),
+    "TD": _translate("LateralContribution", "Time over Debit"),
+    "ZD": _translate("LateralContribution", "Z over Debit"),
+}
+
+table_headers = {
+    "name": _translate("LateralContribution", "Name"),
+    "type": _translate("LateralContribution", "Type"),
+    "node": _translate("LateralContribution", "Node")
+}
+
+BC_types = {
+    "ND": NotDefined,
+    "PC": PonctualContribution,
+    "TZ": TimeOverZ,
+    "TD": TimeOverDebit,
+    "ZD": ZOverDebit
+}