HYTOS

# coding: utf-8

import sys

import os

import math

from PyQt5.QtGui import *

from PyQt5.QtCore import *

from PyQt5.QtSvg import *

from PyQt5.QtWidgets import QApplication, QGraphicsItem, QGraphicsTextItem

from SymbolSvgItem import SymbolSvgItem

from SymbolAttr import SymbolAttr

#from UserInputAttribute import UserInputAttribute

from EngineeringConnectorItem import QEngineeringConnectorItem

from AppDocData import AppDocData

from EngineeringFromMarkItem import EngineeringFromMarkItem

from EngineeringToMarkItem import EngineeringToMarkItem

class QEngineeringSpecBreakItem(SymbolSvgItem):

    """ This is engineering specbreak item class """

    ZVALUE = 20

    clicked = pyqtSignal(QGraphicsSvgItem)

    '''

    '''

    def __init__(self, path, uid=None, flip=0):

        from SymbolAttr import SymbolProp        

        SymbolSvgItem.__init__(self, None, path, uid, flip=flip)

        '''

        attr = SymbolAttr()

        attr.Attribute = 'UpStream'

        attr.AttributeType = 'Comp Item'

        self.attrs[attr] = None

        attr = SymbolAttr()

        attr.Attribute = 'DownStream'

        attr.AttributeType = 'Comp Item'

        self.attrs[attr] = None

        '''

        '''

        specBreakAttrs = AppDocData.instance().getSymbolAttribute('Segment Breaks')

        self.attrs[[up for up in specBreakAttrs if up.Attribute == 'UpStream'][0]] = None

        self.attrs[[down for down in specBreakAttrs if down.Attribute == 'DownStream'][0]] = None

        '''

        self._properties = \

            {\

                SymbolProp(None, 'Freeze', 'Boolean'):False,

                SymbolProp(None, 'Show', 'Boolean'):False

            }

    def is_connected(self, item):

        """ check if given item is connected to spec break """

        import uuid

        matches = [(attr,value) for attr,value in self.attrs.items() if (attr.Attribute == 'UpStream' or attr.Attribute == 'DownStream')]

        for match in matches:

            if (type(match[1]) is uuid.UUID) and (match[1] == item.uid):

                return True

            elif not (type(match[1]) is uuid.UUID) and (match[1] == item):

                return True

        return False

    def hoverEnterEvent(self, event):

        super().hoverEnterEvent(event)

        try:

            # display Up / Down indicator

            add_doc_data = AppDocData.instance()

            attrs = self.getAttributes()

            up = [attr.AssocItem for attr in attrs if attr.Attribute == 'UpStream' and attr.AssocItem]

            down = [attr.AssocItem for attr in attrs if attr.Attribute == 'DownStream' and attr.AssocItem]

            if not add_doc_data.SpecBreakUpDownIndicator or len(add_doc_data.SpecBreakUpDownIndicator) < 2:

                if up and down:

                    for item in [up[0], down[0]]:

                        _label = EngineeringFromMarkItem(10) \

                            if not add_doc_data.SpecBreakUpDownIndicator else EngineeringToMarkItem(10)

                        _label.setZValue(500)

                        self.scene().addItem(_label)

                        _label.setPos(QPointF(item.origin[0] - 25, item.origin[1] - 25))

                        add_doc_data.SpecBreakUpDownIndicator.append(_label)

            elif add_doc_data.SpecBreakUpDownIndicator:

                if up and down:

                    add_doc_data.SpecBreakUpDownIndicator[0].setPos(QPointF(up[0].origin[0] - 25, up[0].origin[1] - 25))

                    add_doc_data.SpecBreakUpDownIndicator[0].setVisible(True)

                    add_doc_data.SpecBreakUpDownIndicator[1].setPos(QPointF(down[0].origin[0] - 25, down[0].origin[1] - 25))

                    add_doc_data.SpecBreakUpDownIndicator[1].setVisible(True)

            # up to here

        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 hoverLeaveEvent(self, event):

        super().hoverLeaveEvent(event)

        try:

            add_doc_data = AppDocData.instance()

            if add_doc_data.SpecBreakUpDownIndicator:

                for _label in add_doc_data.SpecBreakUpDownIndicator:

                    _label.setVisible(False)

        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)

    '''

        @brief      get attribute

        @author     humkyung

        @date       2018.06.14

        @history    kyouho  2018.07.18  Add only attr QEngineeringTextItem

                    euisung 2019.01.15  return self.attrs

    def getAttributes(self):

        """ attributes MUST have UpStream, DownStream attribute """

        from AppDocData import AppDocData

        if not len(self.attrs):

            specBreakAttrs = AppDocData.instance().getSymbolAttribute('Segment Breaks')

            self.attrs[[up for up in specBreakAttrs if up.Attribute == 'UpStream'][0]] = None

            self.attrs[[down for down in specBreakAttrs if down.Attribute == 'DownStream'][0]] = None

        for attr, value in self.attrs.items():

            if attr.AttributeType != 'Spec' and attr.AssocItem:

                self.attrs[attr] = str(attr.AssocItem)

        return self.attrs

    '''

    @property

    def up_stream(self):

        """ return up stream attribute """

        matches = [self.attrs[attr] for attr in self.attrs if attr.Attribute == 'UpStream']

        return matches[0] if matches else None

    @property

    def down_stream(self):

        """ return down stream attribute """

        matches = [self.attrs[attr] for attr in self.attrs if attr.Attribute == 'DownStream']

        return matches[0] if matches else None

    def validate(self, rules):

        """ validate specbreak item """

        from AppDocData import AppDocData

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from SymbolSvgItem import SymbolSvgItem

        from ValidateCommand import SymbolValidation

        errors = []

        app_doc_data = AppDocData.instance()

        dataPath = app_doc_data.getErrorItemSvgPath()

        # UpStream and DownStream must be connected

        if not (self.up_stream and self.down_stream):

            if SymbolValidation.UpStreamOrDownStreamIsDisconnected in rules:

                error = SymbolSvgItem.createItem('Error', None, dataPath)

                error.parent = self

                error.msg = self.tr('UpStream or DownStream is disconnected')

                error.setToolTip(error.msg)

                error.area = 'Drawing'

                error.name = 'Error'

                errors.append(error)

        elif self.up_stream and self.down_stream:

            up_stream_item = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(self.up_stream)]

            down_stream_item = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(self.down_stream)]

            if not (up_stream_item and down_stream_item):

                if SymbolValidation.UpStreamOrDownStreamIsNone in rules:

                    error = SymbolSvgItem.createItem('Error', None, dataPath)

                    error.parent = self

                    error.msg = self.tr('UpStream or DownStream is None')

                    error.setToolTip(error.msg)

                    error.area = 'Drawing'

                    error.name = 'Error'

                    errors.append(error)

            else:

                if SymbolValidation.UpStreamAndDownStreamIsMisconnected in rules:

                    connected = [False, False]

                    for connector in up_stream_item[0].connectors:

                        if connector.connectedItem == down_stream_item[0]:

                            connected[0] = True

                            if connector._connected_at == QEngineeringAbstractItem.CONNECTED_AT_BODY:

                                connected[1] = True

                    if connected[1] == False:

                        for connector in down_stream_item[0].connectors:

                            if connector.connectedItem == up_stream_item[0]:

                                connected[1] = True

                                if connector._connected_at == QEngineeringAbstractItem.CONNECTED_AT_BODY:

                                    connected[0] = True

                    if not (connected[0] and connected[1]):

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('UpStream and DownStream is misconnected')

                        error.setToolTip(error.msg)

                        error.area = 'Drawing'

                        error.name = 'Error'

                        error.items = [ up_stream_item[0], down_stream_item[0] ]

                        errors.append(error)

        # set error position

        for error in errors:

            error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

        return errors