HYTOS

# coding: utf-8

""" This is Streamline dialog module """

import os

import sys

from functools import partial

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from AppDocData import AppDocData, MessageType

from UI.Streamline_UI import Ui_StreamlineDialog

class FromToModel(QStandardItemModel):

    def __init__(self, parent=None, *args):

        QStandardItemModel.__init__(self, parent, *args)

        self._need_to_pick_backcolor = QColor(255, 0, 255)

        self._target_drawing_backcolor = QColor(Qt.green)

        self._new_data_backcolor = QColor(Qt.yellow)

    def data(self, index, role):

        if not index.isValid():

            return None

        if role in [Qt.BackgroundRole]:

            item = super(FromToModel, self).item(index.row(), index.column())

            if index.column() in [1, 2]:

                uid = item.data(Qt.UserRole)

                if not uid:

                    return self._need_to_pick_backcolor

                elif hasattr(item, '_new') and item._new:

                    return self._new_data_backcolor

            elif index.column() in [0]:

                app_doc_data = AppDocData.instance()

                uid = item.data(Qt.UserRole)

                if uid and uid == app_doc_data.activeDrawing.UID:

                    return self._target_drawing_backcolor

        return super(FromToModel, self).data(index, role)

class HmbModel(QStandardItemModel):

    def __init__(self, parent=None, *args):

        QStandardItemModel.__init__(self, parent, *args)

        self._target_drawing_backcolor = QColor(Qt.green)

        self._new_data_backcolor = QColor(Qt.yellow)

    def data(self, index, role):

        if not index.isValid():

            return None

        if role in [Qt.BackgroundRole]:

            item = super(HmbModel, self).item(index.row(), index.column())

            if index.column() in [1]:

                stream_no = item.text()

                if hasattr(item, '_new') and item._new:

                    return self._new_data_backcolor

                elif stream_no:

                    app_doc_data = AppDocData.instance()

                    rows = app_doc_data.get_stream_from_to(stream_no=stream_no)

                    if rows:

                        for row_ in rows:

                            if row_['Drawing_UID'] == app_doc_data.activeDrawing.UID:

                                return self._target_drawing_backcolor

        return super(HmbModel, self).data(index, role)

class FromToWidget(QWidget):

    def __init__(self, parent, column: int, from_to: str = ''):

        QWidget.__init__(self, parent)

        self._column = column

        layout = QHBoxLayout()

        layout.setAlignment(Qt.AlignRight)

        layout.setContentsMargins(0, 0, 0, 0)

        pick = QToolButton(self)

        pick.setIcon(QIcon(':/newPrefix/OK.svg'))

        pick.setMaximumHeight(32)

        pick.setMaximumWidth(32)

        pick.clicked.connect(partial(parent.parent().parent().parent().on_select_comp, self._column))

        layout.addWidget(pick)

        self.setLayout(layout)

class QStreamlineDialog(QDialog):

    """ This Streamline dialog class """

    def __init__(self, parent):

        QDialog.__init__(self, parent)

        self._from_to_widgets = {}

        self._from_to_models = {}

        self.ui = Ui_StreamlineDialog()

        self.ui.setupUi(self)

        self.ui.splitterHorizontal.setSizes([200, 700])

        self.fill_hmb_data()

        self.ui.tableViewStreamNo.selectionModel().selectionChanged.connect(self.on_selection_changed)

        self.ui.toolButtonAddFromTo.clicked.connect(self.on_add_new_from_to)

        self.ui.toolButtonDelFromTo.clicked.connect(self.on_del_from_to)

        self.ui.pushButtonSaveFromTo.clicked.connect(self.on_save_from_to)

        #self.ui.buttonBox.button(QDialogButtonBox.Ok).setIcon(QIcon(':/newPrefix/OK.svg'))

        self.ui.buttonBox.button(QDialogButtonBox.Close).setIcon(QIcon(':/newPrefix/Remove.svg'))

        self.ui.tableViewFromTo.clicked.connect(self.listCellClicked)

    def listCellClicked(self, index):

        from HighlightCommand import HighlightCommand

        if index.isValid():

            col = index.column()

            row = index.row()

        else:

            return

        if not (col == 1 or col == 2):

            return

        self.ui.tableViewFromTo.clearSelection()

        HighlightCommand(self.parent().graphicsView).execute(index.model().item(row, col).text())

    def fill_hmb_data(self):

        """load hmb data and fill table view"""

        import uuid

        hmbs = AppDocData.instance().get_hmb_data(None)

        if not hmbs:

            return

        model= HmbModel()

        header = ['UID', 'Stream No']

        for hmb in hmbs:

            UID = hmb.uid

            STREAM_NO = hmb.stream_no

            items = [QStandardItem(UID), QStandardItem(STREAM_NO)]

            for data in sorted(hmb.datas[0], key=lambda param: param.index):

                if hmbs.index(hmb) == 0:

                    header.append(f"{data.name}\n({data.unit})" if data.unit else f"{data.name}")

                items.append(QStandardItem(data.value))

            model.appendRow(items)

        model.setHorizontalHeaderLabels(header)

        self.ui.tableViewStreamNo.setModel(model)

        self.ui.tableViewStreamNo.resizeColumnsToContents()

        self.ui.tableViewStreamNo.setEditTriggers(QAbstractItemView.NoEditTriggers)

        for col in range(self.ui.tableViewStreamNo.model().columnCount()):

            self.ui.tableViewStreamNo.setColumnHidden(col, col != 1)  # hide all columns except index is 1

    def on_selection_changed(self, selection):

        """show stream line from, to related to selected hmb"""

        if selection.indexes():

            row = selection.indexes()[0].row()

            stream_no = self.ui.tableViewStreamNo.model().item(row, 1).text()

            if stream_no not in self._from_to_models:

                model = FromToModel()

                self._from_to_models[stream_no] = model

                self.ui.tableViewFromTo.setModel(model)

                app_doc_data = AppDocData.instance()

                rows = app_doc_data.get_stream_from_to(stream_no=stream_no)

                if rows:

                    for row_ in rows:

                        from_ = row_['From_Component_UID']

                        from_item = QStandardItem(from_)

                        from_item.setData(row_['From_Component_UID'], Qt.UserRole)

                        to_ = row_['To_Component_UID']

                        to_item = QStandardItem(to_)

                        to_item.setData(row_['To_Component_UID'], Qt.UserRole)

                        drawing = row_['Name']

                        drawing_item = QStandardItem(drawing)

                        drawing_item.setData(row_['Drawing_UID'], Qt.UserRole)

                        items = [drawing_item, from_item, to_item]

                        model.appendRow(items)

                model.setHorizontalHeaderLabels(['Drawing No', 'From', 'To'])

            else:

                model = self._from_to_models[stream_no]

            self.ui.tableViewFromTo.setModel(model)

            self.ui.tableViewFromTo.resizeColumnsToContents()

            self._from_to_widgets.clear()

            for row_ in range(self.ui.tableViewFromTo.model().rowCount()):

                i = self.ui.tableViewFromTo.model().index(row_, 1)

                data = self.ui.tableViewFromTo.model().data(i, Qt.DisplayRole)

                from_button = FromToWidget(self.ui.tableViewFromTo, 1, data)

                i = self.ui.tableViewFromTo.model().index(row_, 1)

                self.ui.tableViewFromTo.setIndexWidget(i, from_button)

                self._from_to_widgets[from_button] = (row_, 1)

                i = self.ui.tableViewFromTo.model().index(row_, 2)

                data = self.ui.tableViewFromTo.model().data(i, Qt.DisplayRole)

                to_button = FromToWidget(self.ui.tableViewFromTo, 2, data)

                self.ui.tableViewFromTo.setIndexWidget(i, to_button)

                self._from_to_widgets[to_button] = (row_, 2)

            """Properties"""

            if not self.ui.tableViewProperties.model():

                model_property = QStandardItemModel()

                self.ui.tableViewProperties.setModel(model_property)

            model_property = self.ui.tableViewProperties.model()

            model_property.clear()

            for col in range(self.ui.tableViewStreamNo.model().columnCount()):

                value = self.ui.tableViewStreamNo.model().item(row, col).text()

                property_ = self.ui.tableViewStreamNo.model().headerData(col, Qt.Horizontal)

                items = [QStandardItem(property_), QStandardItem(value)]

                model_property.appendRow(items)

            model_property.setHorizontalHeaderLabels(['Property', 'Value'])

            self.ui.tableViewProperties.setModel(model_property)

            self.ui.tableViewFromTo.horizontalHeader().setResizeMode(QHeaderView.Stretch)

            self.ui.tableViewProperties.resizeColumnsToContents()

            self.ui.tableViewProperties.setEditTriggers(QAbstractItemView.NoEditTriggers)

            self.ui.tableViewProperties.setRowHidden(0, True)  # hide all columns except index is 1

            self.ui.tableViewProperties.verticalHeader().setVisible(False)

    def on_add_new_from_to(self):

        """add a new from/to record"""

        if not self.ui.tableViewFromTo.model():

            return

        rows = self.ui.tableViewFromTo.model().rowCount()

        index = self.ui.tableViewFromTo.model().index(rows, 0)

        app_doc_data = AppDocData.instance()

        drawing_item = QStandardItem(app_doc_data.activeDrawing.name)

        drawing_item.setData(app_doc_data.activeDrawing.UID, Qt.UserRole)

        self.ui.tableViewFromTo.model().insertRow(rows, [drawing_item, QStandardItem(), QStandardItem()])

        self.ui.tableViewFromTo.selectionModel().setCurrentIndex(index, QItemSelectionModel.NoUpdate)

        from_button = FromToWidget(self.ui.tableViewFromTo, 1)

        i = self.ui.tableViewFromTo.model().index(rows, 1)

        self.ui.tableViewFromTo.setIndexWidget(i, from_button)

        self._from_to_widgets[from_button] = (i.row(), 1)

        to_button = FromToWidget(self.ui.tableViewFromTo, 2)

        i = self.ui.tableViewFromTo.model().index(rows, 2)

        self.ui.tableViewFromTo.setIndexWidget(i, to_button)

        self._from_to_widgets[to_button] = (i.row(), 2)

        row = self.ui.tableViewStreamNo.selectionModel().currentIndex().row()

        self.ui.tableViewStreamNo.model().item(row, 1)._new = True

    def on_del_from_to(self):

        """delete selected from/to"""

        current = self.ui.tableViewFromTo.selectionModel().currentIndex()

        self.ui.tableViewFromTo.model().removeRow(current.row())

        row = self.ui.tableViewStreamNo.selectionModel().currentIndex().row()

        self.ui.tableViewStreamNo.model().item(row, 1)._new = True

    def on_select_comp(self, column: int):

        """select from or to component"""

        from App import App

        from Commands.SelectCompCommand import SelectCompCommand

        def on_success_select_comp(selected):

            current = self.ui.tableViewFromTo.selectionModel().currentIndex()

            row = current.row()

            column = current.column()

            item = self.ui.tableViewFromTo.model().item(row, column)

            item.setText(str(selected))

            item.setData(str(selected.uid), Qt.UserRole)

            item._new = True

            row = self.ui.tableViewStreamNo.selectionModel().currentIndex().row()

            self.ui.tableViewStreamNo.model().item(row, 1)._new = True

            App.mainWnd().graphicsView.useDefaultCommand()

        # save column index

        if self.sender().parent() in self._from_to_widgets:

            row, column = self._from_to_widgets[self.sender().parent()]

            self.ui.tableViewFromTo.setCurrentIndex(self.ui.tableViewFromTo.model().index(row, column))

            app_doc_data = AppDocData.instance()

            drawing_item = self.ui.tableViewFromTo.model().item(row, 0)

            if drawing_item.data(Qt.UserRole) != app_doc_data.activeDrawing.UID:

                return

        # up to here

        cmd = SelectCompCommand(App.mainWnd().graphicsView)

        cmd.onSuccess.connect(on_success_select_comp)

        App.mainWnd().graphicsView.command = cmd

    def on_save_from_to(self):

        """save current from/to data"""

        hmb_model = self.ui.tableViewStreamNo.model()

        changes = []

        for row in range(hmb_model.rowCount()):

            item = hmb_model.item(row, 1)

            if hasattr(item, '_new') and item._new:

                item._new = False

                changes.append(item.text())

        for stream_no, model in self._from_to_models.items():

            if stream_no not in changes:

                continue

            from_to_data = []

            for row in range(model.rowCount()):

                drawing_ = model.item(row, 0)

                drawing_uid = drawing_.data(Qt.UserRole)

                from_ = model.item(row, 1)

                from_uid = from_.data(Qt.UserRole)

                to_ = model.item(row, 2)

                to_uid = to_.data(Qt.UserRole)

                if hasattr(drawing_, '_new') and drawing_._new:

                    drawing_._new = False

                if hasattr(from_, '_new') and from_._new:

                    from_._new = False

                if hasattr(to_, '_new') and to_._new:

                    to_._new = False

                from_to_data.append((drawing_uid, from_uid, to_uid, stream_no))

            AppDocData.save_stream_line_data([stream_no, from_to_data])

        QMessageBox.about(self, self.tr("Information"), self.tr('Successfully saved.'))

    def accept(self):

        QDialog.accept(self)

    def reject(self):

        QDialog.reject(self)