WeldingSpotPerformance/src/gui/settings_window.py

from typing import Callable, Optional, Any
from PyQt5.QtWidgets import (QWidget, QPushButton, 
                             QLineEdit, QHBoxLayout, 
                             QVBoxLayout, QLabel, 
                             QTableWidget, QTableWidgetItem,
                             QStyledItemDelegate)
from PyQt5.QtGui import QIntValidator, QDoubleValidator

from utils.json_tools import read_json, write_json
from utils import qt_settings as qts

class settingsWindow(QWidget):
    def __init__(self, path: str, name: str, upd_func: Callable[[], None], names: dict):
        """
        Окно настроек для редактирования параметров.
        :param path: Путь к файлу настроек (JSON).
        :param name: Название набора настроек.
        :param upd_func: Функция обновления (коллбэк).
        """
        super().__init__()
        self._settingsPath = path
        self._name = name
        self._data: dict[str, list[Any]] = {}
        self._upd_func = upd_func

        self._num_points: Optional[QLineEdit] = None
        self._param_table: Optional[QTableWidget] = None
        self._assosiated_names = names

        self.load_settings()
        self._init_ui()

    def load_settings(self) -> None:
        """Загружает настройки из JSON-файла."""
        data = read_json(self._settingsPath)
        if isinstance(data, dict):
            self._data = data
        else:
            self._data = {}

    def write_settings(self) -> None:
        """Записывает текущие настройки в JSON-файл."""
        write_json(self._settingsPath, self._data)

    def getParams(self) -> dict:
        """Возвращает текущий словарь параметров."""
        return self._data

    def _init_ui(self) -> None:
        """Инициализирует UI: кнопки, поля ввода, таблицу."""
        save_button = QPushButton("Save")
        restore_button = QPushButton("Restore")

        self._num_points = QLineEdit()
        self._num_points.setPlaceholderText("Enter the number of welding points")
        self._num_points.setValidator(QIntValidator())

        control_layout = QHBoxLayout()
        control_layout.addWidget(save_button)
        control_layout.addWidget(restore_button)
        control_layout.addWidget(self._num_points)

        save_button.pressed.connect(self._save)
        restore_button.pressed.connect(self._restore)
        self._num_points.editingFinished.connect(self._expand)

        self._param_table = QTableWidget()
        self._populate_table()

        layout = QVBoxLayout()
        header = QLabel(self._name)
        layout.addWidget(header)
        layout.addLayout(control_layout)
        layout.addWidget(self._param_table)
        self.setLayout(layout)
        self.setStyleSheet(qts.dark_style)

    def _populate_table(self) -> None:
        """Заполняет таблицу значениями из self._data."""
        # Если нет данных для заполнения
        if not self._data:
            self._param_table.setRowCount(0)
            self._param_table.setColumnCount(0)
            return

        # Предполагаем, что у всех ключей одинаковая длина списков параметров.
        first_key = next(iter(self._data), None)
        if first_key is None:
            self._param_table.setRowCount(0)
            self._param_table.setColumnCount(0)
            return

        column_count = len(self._data[first_key])
        self._param_table.setRowCount(len(self._data))
        self._param_table.setColumnCount(column_count)
        headers = [self._assosiated_names[key] for key in self._data.keys()]
        self._param_table.setVerticalHeaderLabels(headers)

        int_delegate = ValidatorDelegate(data_type='int', parent=self._param_table)
        float_delegate = ValidatorDelegate(data_type='float', parent=self._param_table)
        str_delegate = ValidatorDelegate(data_type='str', parent=self._param_table)

        for i, (_, items) in enumerate(self._data.items()):
            for j, item in enumerate(items):
                self._param_table.setItem(i, j, QTableWidgetItem(str(item)))

            if type(item) == int:
                self._param_table.setItemDelegateForRow(i, int_delegate)
            elif type(item) == float:
                self._param_table.setItemDelegateForRow(i, float_delegate)
            else:
                self._param_table.setItemDelegateForRow(i, str_delegate)
            
                
    def _save(self) -> None:
        """Сохраняет текущие параметры из таблицы в self._data и вызывает _upd_func()."""
        new_data = {}
        col_count = self._param_table.columnCount()
        for i, key in enumerate(self._data.keys()):
            row_data = []
            for j in range(col_count):
                cell_item = self._param_table.item(i, j)
                if cell_item is None:
                    continue
                param_str = cell_item.text()
                # Если ключ не trace_storage_path, конвертируем в float
                if key != "trace_storage_path":
                    try:
                        param = float(param_str)
                    except ValueError:
                        param = 0.0
                else:
                    param = param_str
                row_data.append(param)

            new_data[key] = row_data

        self._data = new_data
        self.write_settings()
        self._upd_func()

    def _restore(self) -> None:
        """Перезагружает данные из файла и обновляет таблицу."""
        self.load_settings()
        self._populate_table()

    def _expand(self) -> None:
        """Расширяет количество столбцов таблицы в зависимости от введённого значения."""
        if not self._num_points:
            return

        num_points_text = self._num_points.text()
        if not num_points_text.isdigit():
            return

        num_points = int(num_points_text)
        if num_points < 0:
            return

        prev_columns = self._param_table.columnCount()
        desired_columns = num_points

        if desired_columns <= 0:
            return

        self._param_table.setColumnCount(desired_columns)

        # Новые столбцы заполняем последним известным параметром для каждого ключа
        for i, (key, items) in enumerate(self._data.items()):
            # Если нет данных, пропускаем
            if not items:
                continue
            last_value = str(items[-1])
            for col in range(prev_columns, desired_columns):
                self._param_table.setItem(i, col, QTableWidgetItem(last_value))
                # Добавляем новый элемент также в self._data для консистентности
                # После этого можно будет сохранить при нажатии Save
            # Дополним также и в self._data
            additional_count = desired_columns - prev_columns
            self._data[key].extend([float(last_value) if key != "trace_storage_path" else last_value] * additional_count)


class SystemSettings(settingsWindow):
    def __init__(self, path, name, upd_func):
        assosiated_names = {
            "trace_storage_path": "Trace path",
            "monitor_update_period": "Monitoring period",
            "a_max_1": "Max lin accel FE, m/s^2",
            "v_max_1": "Max lin speed FE, m/s",
            "a_max_2":"Max lin accel ME, m/s^2",
            "v_max_2": "Max lin speed FE, m/s",
            "mass_1": "Mass FE, kg",
            "mass_2": "Mass ME, kg",
            "k_hardness_1": "Hardness coef FE, N/m",
            "k_hardness_2": "Hardness coef ME, N/m",
            "torque_max_1": "Max torque FE, N*m",
            "torque_max_2": "Max torque ME, N*m",
            "transmission_ratio_1": "Transmission ratio FE",
            "transmission_ratio_2": "Transmission ratio ME",
            "contact_distance_1": "Contact distance FE, m",
            "contact_distance_2": "Contact distance ME, m",
            "k_prop": "Proportionality factor",
            "time_capture": "Calculated points per sec",
            "UML_time_scaler": "UML_time_scaler",
            "Range ME, mm": "Range ME, mm"
            }
        super().__init__(path, name, upd_func, assosiated_names)
        self._num_points.setVisible(False)

    def _expand(self):
        pass     

class OperatorSettings(settingsWindow):
    def __init__(self, path, name, upd_func):
        assosiated_names = {
            "distance_h_start_1": "Closing start dist FE, m" ,
            "distance_h_start_2": "Closing start dist ME, m",
            "distance_s_1": "Rob movement start dist FE, m",
            "distance_s_2": "Rob movement start dist ME, m",
            "distance_l_1": "Max oncoming dist FE, m",
            "distance_l_2": "Max oncoming dist ME, m",
            "distance_h_end1": "Oncoming end dist FE, m",
            "distance_h_end2": "Oncoming end dist FE, m",
            "time_wielding": "Time of welding, sec",
            "time_command": "Communication time compensator, sec",
            "time_robot_movement": "Rob movement time, sec",
            "object_thickness": "Workpiece thickness, m",
            "force_target": "Target force, N",
            "force_capture": "Capture force, N",
            "Tesla closing": "Client closing time, sec",
            "Tesla squeeze": "Client squeeze time, sec",
            "Tesla welding": "Client welding time, sec",
            "Tesla oncomming_relief": "Client moving to next point time, sec",
            "Tesla summary time": "Client summary time, sec"
            }
        super().__init__(path, name, upd_func, assosiated_names)
    pass 


class ValidatorDelegate(QStyledItemDelegate):
    def __init__(self, data_type='str', parent=None):
        super().__init__(parent)
        self.data_type = data_type
        if self.data_type == 'int':
            self.validator = QIntValidator()
        elif self.data_type == 'float':
            self.validator = QDoubleValidator()
            self.validator.setNotation(QDoubleValidator.StandardNotation)
        else:
            self.validator = None

    def createEditor(self, parent, option, index):
        editor = QLineEdit(parent)
        if self.validator:
            editor.setValidator(self.validator)
        return editor



if __name__ == '__main__':
    import pyqtgraph as pg
    app = pg.mkQApp("Parameter Tree Example")
    window = settingsWindow('params\operator_params.json', 'operator')
    app.exec()