ProfileWindow.py

# -*- coding: utf-8 -*-

import copy
import sys
import csv
from time import time

from tools import trace, timer

from PyQt5 import QtWidgets, QtGui
from PyQt5.QtCore import QModelIndex, Qt, QEvent, QCoreApplication
from PyQt5.QtWidgets import QApplication, QMainWindow, QFileDialog, QCheckBox

from View.Geometry.Profile.mainwindow_ui_profile import Ui_MainWindow

from Model.Geometry.Reach import Reach
from Model.Geometry.ProfileXYZ import ProfileXYZ
from View.Geometry.Profile.qtableview_profile import *

from View.Plot.mpl_canvas_onpick_event import OnpickEvent

_translate = QCoreApplication.translate


class ProfileWindow(QMainWindow):
    def __init__(self, profile=None, parent=None):
        self.parent = parent
        super(ProfileWindow, self).__init__(self.parent)

        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self._profile = profile
        self._model = None

        self.setup_window()
        self.setup_model()
        self.setup_connections()
        self.graph()

        self._model.dataChanged.connect(self.graph)
        self.fileName = None

        self.ui.tableView.installEventFilter(self)
        self.status_change_tableview = False

        self._model.dataChanged.connect(self.tableview_is_modified)

        self.reference_data = None
        self.ui.btn_go_back.setEnabled(False)
        self.ui.btn_check.setEnabled(False)
        self._model.dataChanged.connect(self.set_enable_cancel_btn)
        self._model.dataChanged.connect(self.set_enable_validate_changes_btn)
        self.ui.btn_reset.setEnabled(False)
        self._model.dataChanged.connect(self.set_enable_go_back_initial_state_btn)

    def setup_window(self):
        name = self._profile.name
        if self._profile.name is None or self._profile.name:
            name = _translate("MainWindowProfile", "(no name)")

        header = _translate("MainWindowProfile", "Profile")

        self.setWindowTitle(
            header + " - " +
            f"{self._profile.reach.name}" + " - " +
            f"{name} ({self._profile.kp})"
        )

    def tableview_is_modified(self):
        self.status_change_tableview = True

    def setup_connections(self):
        self.ui.btn_sort_asc_x.clicked.connect(self.sort_X_ascending)
        self.ui.btn_sort_desc_x.clicked.connect(self.sort_X_descending)
        self.ui.btn_sort_asc_y.clicked.connect(self.sort_Y_ascending)
        self.ui.btn_sort_desc_y.clicked.connect(self.sort_Y_descending)
        self.ui.btn_move_up.clicked.connect(self.move_row_up)
        self.ui.btn_move_down.clicked.connect(self.move_row_down)
        self.ui.btn_export.clicked.connect(self.handleSave)
        self.ui.btn_add.clicked.connect(self.insert_row)
        self.ui.btn_delete.clicked.connect(self.delete_row)
        self.ui.btn_copy.clicked.connect(self.copyTable)
        self.ui.btn_paste.clicked.connect(self.pasteTable)
        self.ui.btn_check.clicked.connect(self.validate_changes)
        self.ui.btn_go_back.clicked.connect(self.cancel_validate_changes)
        self.ui.btn_reset.clicked.connect(self.go_back_to_initial_state)

    def setup_model(self):
        self._model = PandasModelEditable(self._profile)
        self._last_saved_model_data = copy.deepcopy(self._model.model_data)
        self.__initial_model_data = copy.deepcopy(self._model.model_data)

        self.ui.tableView.setModel(self._model)
        self.ui.tableView.setItemDelegate(Delegate())

    @timer
    def graph(self):
        """
        Returns: Le tracé de la cote z en fonction de l'abscisse (calculée).
        """
        x = self._profile.get_station()
        y = self._profile.z()
        gl = self._profile.name()
        x_carto = self._profile.x()
        y_carto = self._profile.y()

        self.ui.canvas.axes.cla()
        self.ui.canvas.axes.grid(color='grey', linestyle='--', linewidth=0.5)

        if (len(x_carto) >= 3 and
            len(y_carto) >= 3 and
            len(x) >= 3):
            self.profile_line2D, = self.ui.canvas.axes.plot(
                x, y, color='r', lw=1.5, markersize=7, marker='+',
                picker=30
            )
            self.ui.canvas.axes.set_xlabel(
                _translate("MainWindowProfile",
                           "Abscisse en travers (m)"),
                color='black', fontsize=10
            )
            self.ui.canvas.axes.set_ylabel(
                _translate("MainWindowProfile", "Cote (m)"),
                color='black', fontsize=10
            )

            # Add label on graph
            self.annotation = []
            for i, txt in enumerate(list(gl)):
                annotation = self.ui.canvas.axes.annotate(
                    txt, (x[i], y[i]),
                    horizontalalignment='left',
                    verticalalignment='top',
                    annotation_clip=True, fontsize=10,
                    color='black'
                )
                annotation.set_position((x[i], y[i]))
                annotation.set_color("black")
                self.annotation.append(annotation)

            al = 8.
            arrowprops = dict(
                clip_on=True,
                headwidth=5.,
                facecolor='k'
            )
            kwargs = dict(
                xycoords='axes fraction',
                textcoords='offset points',
                arrowprops=arrowprops,
            )

            self.ui.canvas.axes.annotate("", (1, 0), xytext=(-al, 0), **kwargs)
            self.ui.canvas.axes.annotate("", (0, 1), xytext=(0, -al), **kwargs)

            self.ui.canvas.axes.spines[['top', 'right']].set_color('none')
            self.ui.canvas.axes.yaxis.tick_left()
            self.ui.canvas.axes.xaxis.tick_bottom()
            self.ui.canvas.axes.set_facecolor('#F9F9F9')
            self.ui.canvas.figure.patch.set_facecolor('white')

            try:
                self.onpick_event = OnpickEvent(
                    self.ui.canvas.axes,
                    x, y, x_carto, y_carto,
                    self.ui.tableView
                )
                self.ui.canvas\
                       .figure\
                       .canvas\
                       .mpl_connect('pick_event', self.onpick_event.onpick)

                self.onclick_event = OnpickEvent(
                    self.ui.canvas.axes,
                    x, y, x_carto, y_carto,
                    self.ui.tableView
                )
                self.ui.canvas\
                       .figure\
                       .canvas\
                       .mpl_connect('button_press_event', self.onclick_event.onclick)
            except:
                print("TODO")

            self.ui.canvas.figure.tight_layout()
            self.ui.canvas.figure.canvas.draw_idle()

    def insert_row(self):
        if len(self.tableView.selectedIndexes()) == 0:
            self._tablemodel.insert_row(self._tablemodel.rowCount())
        else:
            row = self.index_selected_row()
            self._tablemodel.insert_row(row + 1)

    def delete_row(self):
        rows = sorted(
            list(
                set(
                    [index.row() for index in self.tableView.selectedIndexes()]
                )
            )
        )

        if len(rows) > 0:
            self._tablemodel.remove_rows(rows)

    def sort_X_ascending(self):
        self._model.sort('x', order=Qt.AscendingOrder)
        self.graph()

    def sort_X_descending(self):
        self._model.sort('x', order=Qt.DescendingOrder)
        self.graph()

    def sort_Y_ascending(self):
        self._model.sort('y', order=Qt.AscendingOrder)
        self.graph()

    def sort_Y_descending(self):
        self._model.sort('y', order=Qt.DescendingOrder)
        self.graph()

    def move_row_down(self):
        rows = list(
            set(
                [index.row() for index in self.ui.tableView.selectedIndexes()]
            )
        )

        for row in rows:
            if row < self._model.rowCount() - 1:
                self._model.moveRowDown(row)

        self.graph()

    def move_row_up(self):
        rows = list(
            set(
                [index.row() for index in self.ui.tableView.selectedIndexes()]
            )
        )

        for row in rows:
            if 0 < row:
                self._model.moveRowUp(row)

        self.graph()

    def eventFilter(self, source, event):
        if event.type() == QEvent.KeyPress:
            if event == QtGui.QKeySequence.Copy:
                self.copyTable()
                return True

            elif event == QtGui.QKeySequence.Paste:
                self.pasteTable()
                return True

        elif event.type() == QEvent.ContextMenu:
            menu = QtWidgets.QMenu()
            copyAction = menu.addAction('Copy')
            pasteAction = menu.addAction('Paste')

            if not self.ui.tableView.selectedIndexes():
                pass

            return True

        return super(View, self).eventFilter(source, event)

    def copySelection(self):
        self.clipboard.clear()
        selected = self.ui.tableView.selectedIndexes()
        rows = []
        columns = []

        for index in selected:
            rows.append(index.row())
            columns.append(index.column())

        minRow = min(rows)
        minCol = min(columns)
        print(minCol)
        print(minRow, columns)
        for index in selected:
            self.clipboard.append(
                (index.row() - minRow,
                 index.column() - minCol,
                 index.data_frame())
            )

    def pasteSelection(self):
        if not self.clipboard:
            return

        current = self.ui.tableView.currentIndex()
        if not current.isValid():
            # In the rare case that there is no current index, use the
            # first row and column as target
            current = self._model.index(0, 0)

        firstRow = current.row()
        firstColumn = current.column()

        # optional: Get the selection model so that pasted indexes
        # will be automatically selected at the end
        selection = self.ui.tableView.selectionModel()

        for row, column, data in self.clipboard:
            # Get the index, with rows and columns relative to the
            # current index = self._model.index(firstRow + row,
            # firstColumn + column)
            index = self._model.index(firstRow, column)

            # Set the profile for the index
            self._model.setData(index, data, Qt.EditRole)
            # Add the index to the selection
            selection.select(index, selection.Select)

        # Apply the selection model
        self.ui.tableView.setSelectionModel(selection)

    def copyTable(self):
        if len(self.ui.tableView.selectedIndexes()) == 0:
            self._model.copyTable(0, self._model.rowCount())
        else:
            rows = list(set([index.row() for index in self.ui.tableView.selectedIndexes()]))
            rows.sort()
            df = self._model.model_data.loc[rows, :]
            df.to_clipboard(header=None, index=False, excel=True, sep='\t')

    def pasteTable(self):
        if len(self.ui.tableView.selectedIndexes()) == 0:
            self._model.pasteTable(self._model.rowCount())
        else:
            rows = list(set([index.row() for index in self.ui.tableView.selectedIndexes()]))
            for row in rows:
                try:
                    self._model.pasteTable(row + 1)
                except:
                    print("TODO")

        self.graph()

    def handleSave(self):
        if self.fileName is None or self.fileName == '':
            self.fileName, self.filters = QFileDialog.getSaveFileName(
                self, filter="CSV files (*.csv)"
            )

        if self.fileName != '':
            with open(self.fileName, 'w') as stream:
                csvout = csv.writer(stream, delimiter='\t', quotechar=' ',
                                    escapechar=None,
                                    quoting=csv.QUOTE_NONNUMERIC,
                                    lineterminator='\n')

                for row in range(self._model.rowCount(QModelIndex())):
                    rowdata = []
                    for column in range(self._model.columnCount(QModelIndex())):
                        item = self._model.index(
                            row, column, QModelIndex()
                        ).data(Qt.DisplayRole)

                        if item is not None:
                            rowdata.append(item)

                        if item == 'nan':
                            rowdata.remove(item)

                    csvout.writerow(rowdata)

    def handleOpen(self):
        self.fileName, self.filterName = QFileDialog.getOpenFileName(self)

        if self.fileName != '':
            with open(self.fileName, 'r') as f:
                reader = csv.reader(f, delimiter='\t')
                header = next(reader)

                buf = []
                for row in reader:
                    row[0] = QCheckBox("-")
                    buf.append(row)

                self._model = None
                self._model = PandasModelEditable(buf)
                self.ui.tableView.setModel(self._model)
                self.fileName = ''

    def cancel_validate_changes(self):
        self._model.model_data = copy.deepcopy(self._last_saved_model_data)
        self.graph()
        self.ui.btn_go_back.setEnabled(False)

    def validate_changes(self):
        self.remove_duplicates_point_names()
        self.delete_empty_rows()
        self._last_saved_model_data = copy.deepcopy(self._model.model_data)
        self.ui.btn_check.setEnabled(False)
        self.ui.btn_go_back.setEnabled(False)
        self.status_change_tableview = False
        self.graph()
        self._model.valide_all_changes()
        self.parent.update_graphic_2()
        self.parent.update_graphic_1()
        self.selected_row = list(set(
            [index.row() for index in self.parent.tableView.selectedIndexes()]
        ))
        self.parent.update_graphic_3(self.selected_row[0])

    def set_enable_validate_changes_btn(self):
        self.ui.btn_check.setEnabled(True)

    def set_enable_cancel_btn(self):
        self.ui.btn_go_back.setEnabled(True)

    def set_enable_go_back_initial_state_btn(self):
        self.ui.btn_reset.setEnabled(True)

    def delete_empty_rows(self):
        if self._model.data_contains_nan():
            buttonReply = QtWidgets.QMessageBox.question(
                self,
                _translate("MainWindowProfile",
                           "Suppression les lignes incomplètes"),
                _translate("MainWindowProfile",
                           "Supprimer les lignes des cellules"
                           " non renseignées ?"),
                QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No
            )

            if buttonReply == QtWidgets.QMessageBox.Yes:
                self._model.delete_empty_rows()

            if buttonReply == QtWidgets.QMessageBox.No:
                pass

    def remove_duplicates_point_names(self):
        counter_list = []
        list_deleted_names = []

        for ind, name_point in enumerate(self._model.name):
            if name_point not in counter_list:
                counter_list.append(name_point)
            elif len(name_point.strip()) > 0 and name_point in counter_list:
                if name_point not in list_deleted_names:
                    list_deleted_names.append(name_point)

        if list_deleted_names:
            self.msg_box_check_duplication_names(list_deleted_names)

    def go_back_to_initial_state(self):

        reply = QtWidgets.QMessageBox.question(
            self,
            _translate("MainWindowProfile", "Retour à l'état initial "),
            _translate("MainWindowProfile",
                       "Voulez-vous vraiment annuler toutes "
                       "les modifications?\n\n "
                       "\tOui : Revenir à l'état initial\n"
                       "\tNon : Garder l'état actuel des "
                       "données du profil"),
            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No
        )

        if reply == QtWidgets.QMessageBox.Yes:
            self._model.model_data = copy.deepcopy(self.__initial_model_data)
            self._model.valide_all_changes()
            self.graph()
            self.ui.btn_reset.setEnabled(False)
            self.ui.btn_check.setEnabled(False)
            self.ui.btn_go_back.setEnabled(False)
        elif reply == QtWidgets.QMessageBox.No:
            pass

    def closeEvent(self, event):
        if self.status_change_tableview:
            reply = QtWidgets.QMessageBox.question(
                self,
                _translate("MainWindowProfile", "Terminer l'édition du profil "),
                _translate("MainWindowProfile", "Voulez-vous vraiment quitter "
                           "?\n Oui : Valider et quitter\n"
                           "Non : Annuler"),
                QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No
            )

            if reply == QtWidgets.QMessageBox.Yes:
                self.validate_changes()
                self.graph()
                event.accept()
            else:
                event.ignore()
                self.ui.btn_check.setEnabled(True)
                self.ui.btn_go_back.setEnabled(True)

    def msg_box_check_duplication_names(self, list_deleted_names):  # name_point,list_deleted_names,counter_list):
        if len(list_deleted_names) == 1:
            text = _translate("MainWindowProfile",
                              "Le nom ''{}'' est dupliqué."
                              " \n\nYes : Ne garder que la première occurrence. \nNo :"
                              " Annuler la suppression.".format(list_deleted_names[0]))
        else:
            text = _translate("MainWindowProfile",
                              "Les noms suivants :  \n{} sont dupliqués"
                              "  \n\nYes : Ne garder que la première occurrence de "
                              "chaque nom. \nNo :"
                              " Annuler la suppression.".format(list_deleted_names))

        buttonReply = QtWidgets.QMessageBox.question(
            self, _translate("MainWindowProfile",
                             "Suppression des noms répétés"),
            text,
            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No
        )

        if buttonReply == QtWidgets.QMessageBox.Yes:
            self._model.remove_duplicates_names()

    def ask_quit(self):
        choice = QtWidgets.QMessageBox.question(
            self,
            _translate("MainWindowProfile", "Quittez ?"),
            _translate("MainWindowProfile",
                       "Etes-vous sûr de vouloir quitter ?"),
            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No
        )
        return choice == QtWidgets.QMessageBox.Yes

    def initial_state_model(self, profile_initial_state):
        return profile_initial_state