HYTOS

import sys

import os.path

import AbstractCommand

from AppDocData import AppDocData

from CodeTables import CodeTable

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QEvent

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImge, QPixmap, QPainterPath, QFileDialog, QCursor, QMouseEvent

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

'''

    QtImageViewer Select Attribute batch Command

'''

class SelectAttributeBatchCommand(AbstractCommand.AbstractCommand):

    onSuccess = pyqtSignal()

    def __init__(self, item, imageViewer):

        super(SelectAttributeBatchCommand, self).__init__(imageViewer)

        self.name = 'SelectAttributeBatch'

        self.imageViewer.setCursor(QCursor(Qt.ArrowCursor))

        #self.imageViewer.scene().clearSelection()

        self.selection_order = [item]

    def execute(self, param):

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringTextItem import QEngineeringTextItem

        event = param[1]

        scenePos = param[2]

        try:

            self.isTreated = False

            if 'mouseReleaseEvent' == param[0] and event.button() == Qt.LeftButton and event.modifiers() == Qt.ControlModifier:

                items = [item for item in self.imageViewer.scene().items(scenePos) \

                        if issubclass(type(item), SymbolSvgItem) or issubclass(type(item), QEngineeringTextItem) or type(item) is QEngineeringLineItem]

                if not items:

                    return

                else:

                    item = items[0]

                selected_items = self.imageViewer.scene().selectedItems()

                selected_items.append(item)

                if len(selected_items) == len(self.selection_order) + 1:

                    self.selection_order.append([item for item in selected_items if item not in self.selection_order][0])

            elif 'mouseReleaseEvent' == param[0]:

                self.isTreated = True

            elif ('keyPressEvent' == param[0] and Qt.Key_Return == event.key()):

                self.isTreated = True

                app_doc_data = AppDocData.instance()

                item = self.selection_order.pop(0)

                stream = [item for item in self.selection_order if issubclass(type(item), SymbolSvgItem) or type(item) is QEngineeringLineItem]

                values = [item for item in self.selection_order if issubclass(type(item), QEngineeringTextItem)]

                if len(stream) != 2 or len(values) % 2 !=0:

                    return

                spec = [stream[0], stream[1]]

                specBreakAttrsFull = [attr for attr in app_doc_data.getSymbolAttribute('Segment Breaks') if \

                            attr.Target == 'ALL' and (attr.AttributeType == 'Spec' or attr.AttributeType == 'String')]

                for attr in specBreakAttrsFull:

                    if attr.AttributeType != 'Spec':

                        continue

                    table = CodeTable.instance(attr.Attribute)

                    for index in range(0, len(values), 2):

                        up_value = table.find_match_exactly(values[index].text())

                        down_value = table.find_match_exactly(values[index + 1].text())

                        if up_value and down_value:

                            values[index].setPlainText(up_value)

                            values[index + 1].setPlainText(down_value)

                            spec.append([attr.Attribute, up_value, down_value])

                            break

                if len(spec) < 3:

                    return

                attrs = item.getAttributes()

                for key in attrs.keys():

                    if key.Attribute == 'UpStream':

                        attrs[key] = str(spec[0])

                        item.add_assoc_item(spec[0], key.AttrAt, force=True)

                        key.AssocItem = spec[0]

                    elif key.Attribute == 'DownStream':

                        attrs[key] = str(spec[1])

                        item.add_assoc_item(spec[1], key.AttrAt, force=True)

                        key.AssocItem = spec[1]

                for attr, value, value2 in spec[2:]:

                    for full in specBreakAttrsFull:

                        if full.Attribute == attr:

                            attrs[full] = [value, value2]

                self.onSuccess.emit()

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    def undo(self):

        pass

    def redo(self):

        pass