Pamhyr2/src/view/ConfigureWindow.py

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

from config import Config
from view.ASubWindow import ASubWindow
from view.ListedSubWindow import ListedSubWindow
from view.ConfigureAddSolverWindow import ConfigureAddSolverWindow

from PyQt5.QtCore import (
    Qt, QVariant, QAbstractTableModel,
)

from PyQt5.QtWidgets import (
    QDialogButtonBox, QPushButton, QLineEdit,
    QFileDialog, QTableView,
)


class SolverTableModel(QAbstractTableModel):
    def __init__(self, headers=[], rows=[]):
        super(QAbstractTableModel, self).__init__()
        self.rows = rows
        self.headers = headers

    def rowCount(self, parent):
        # How many rows are there?
        return len(self.rows)

    def columnCount(self, parent):
        # How many columns?
        return len(self.headers)

    def data(self, index, role):
        if role != Qt.ItemDataRole.DisplayRole:
            return QVariant()

        return self.rows[index.row()][self.headers[index.column()]]

    def headerData(self, section, orientation, role):
        if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
            return self.headers[section].capitalize()

        if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Vertical:
            return section

        return QVariant()

    def removeRow(self, index):
        del self.rows[index.row()]
        self.layoutChanged.emit()

    def add_solver(self, solver):
        self.rows.append(solver)
        self.layoutChanged.emit()

    def change_solver(self, solver, index):
        self.rows[index.row()] = solver
        self.layoutChanged.emit()


class ConfigureWindow(ASubWindow, ListedSubWindow):
    def __init__(self, conf=None, title="Configure", parent=None):
        super(ConfigureWindow, self).__init__(name=title, ui="ConfigureDialog", parent=parent)
        self.ui.setWindowTitle(title)

        if conf is None:
            self.conf = Config()
        else:
            self.conf = conf

        # Solver
        self.solver_table_model = SolverTableModel(
            headers = ["name", "type", "description"],
            rows = conf.solvers.copy()
        )
        self.find(QTableView, "tableView_solver").setModel(self.solver_table_model)

        # Mailleur
        self.set_line_edit_text("lineEdit_mailleur", self.conf.mailleur)

        # Const
        self.set_line_edit_text("lineEdit_segment", str(self.conf.segment))
        self.set_line_edit_text("lineEdit_max_listing", str(self.conf.max_listing))

        # Backup
        self.set_check_box("checkBox_backup", self.conf.backup_enable)
        self.set_line_edit_text("lineEdit_backup_path", self.conf.backup_path)
        self.set_time_edit("timeEdit_backup_frequence", self.conf.backup_frequence)
        self.set_spin_box("spinBox_backup_max", self.conf.backup_max)

        self.find(QTableView, "tableView_solver").resizeColumnsToContents()
        self.connect()

    def connect(self):
        # File button
        buttons = {
            "pushButton_solver_add": self.add_solver,
            "pushButton_solver_del": self.remove_solver,
            "pushButton_solver_edit": self.edit_solver,
            "pushButton_backup_path": lambda: self.file_dialog(
                select_file = False,
                callback = lambda f: self.set_line_edit_text(
                    "lineEdit_backup_path", f[0]
                )
            ),
            "pushButton_mailleur" : lambda: self.file_dialog(
                select_file = True,
                callback = lambda f: self.set_line_edit_text(
                    "lineEdit_mailleur", f[0]
                )
            ),
        }

        for button in buttons:
            self.find(QPushButton, button).clicked.connect(buttons[button])

    def accept(self):
        # Solvers
        self.conf.solvers = self.solver_table_model.rows.copy()

        # Mailleur
        self.conf.mailleur = self.get_line_edit_text("lineEdit_mailleur")

        # Const
        self.conf.segment = self.get_line_edit_text("lineEdit_segment")
        self.conf.max_listing = self.get_line_edit_text("lineEdit_max_listing")

        # Backup
        self.conf.backup_enable = self.get_check_box("checkBox_backup")
        self.conf.backup_path = self.get_line_edit_text("lineEdit_backup_path")
        self.conf.backup_frequence = self.get_time_edit("timeEdit_backup_frequence")
        self.conf.backup_max = self.get_spin_box("spinBox_backup_max")

        self.end()

    def reject(self):
        # Nothing todo
        self.end()

    def end(self):
        self.conf.save()
        self.close()

    def edit_solver(self):
        indices = self.find(QTableView, "tableView_solver").selectionModel().selectedRows()
        for index in indices:
            self.edit_solver = ConfigureAddSolverWindow(
                data=self.solver_table_model.rows[index.row()],
                parent=self
            )
            if self.edit_solver.exec_():
                self.solver_table_model.change_solver(self.edit_solver.data, index)

    def add_solver(self):
        dialog_solver = ConfigureAddSolverWindow(parent=self)
        if dialog_solver.exec_():
            self.solver_table_model.add_solver(dialog_solver.data)

    def remove_solver(self):
        indices = self.find(QTableView, "tableView_solver").selectionModel().selectedRows()
        for index in sorted(indices):
            self.solver_table_model.removeRow(index)