HYTOS

# coding: utf-8

""" This is engineering equipment item module """

import sys

import os

import math

from PyQt5.QtGui import *

from PyQt5.QtCore import *

from PyQt5.QtSvg import *

from PyQt5.QtWidgets import (QApplication, QGraphicsItem)

from SymbolSvgItem import SymbolSvgItem

from EngineeringAbstractItem import QEngineeringAbstractItem

#from UserInputAttribute import UserInputAttribute

class QEngineeringEquipmentItem(SymbolSvgItem):

    """ This is engineering equipment item class """

    clicked = pyqtSignal(QGraphicsSvgItem)

    ZVALUE = 10

    EQUIP_COLUMN_LIST = None

    EQUIP_COLOR = None

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

        from SymbolAttr import SymbolProp

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

        self.setZValue(QEngineeringEquipmentItem.ZVALUE)

        self._properties = \

            { \

                #SymbolProp(None, 'Desc', 'String', Expression="self.desc"): None

                #SymbolProp(None, 'Name Tag', 'Tag No', Expression='self.EvaluatedName'): None

            }

        '''

        if QEngineeringEquipmentItem.EQUIP_COLUMN_LIST is None:

            from AppDocData import AppDocData

            appDocData = AppDocData.instance()

            QEngineeringEquipmentItem.EQUIP_COLUMN_LIST = appDocData.getColNames('EQUIPMENT_DATA_LIST')

        '''

    def texts(self):

        """ return text type of labels """

        from AppDocData import AppDocData

        from EngineeringTextItem import QEngineeringTextItem

        configs = AppDocData.instance().getConfigs('Symbol', 'EQ Setting')

        if configs and int(configs[0].value) != 1:

            return super().texts()

        else:

            return sorted([x for x in self.associations() if issubclass(type(x), QEngineeringTextItem)],

                          key=lambda attr: attr.loc[1])

    @property

    def tag_no(self):

        """ getter of tag_no """

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        matches = [assoc for assoc in self.associations() if type(assoc) is QEngineeringTagNoTextItem]

        return matches[0].text() if matches else None

    @property

    def desc(self):

        """ getter of desc """

        from CodeTables import CodeTable

        try:

            if self.tag_no:

                matches = [value for value in CodeTable.instance('EqpTagNames').values if value[1] == self.tag_no]

                if matches: return matches[0][2]

        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)

        return ''

    '''

        @brief  connect attribute

        @author humkyung

        @date   2018.05.03

    '''

    def connectAttribute(self, attributes, clear=True):

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        if clear:

            self.clear_attr_and_assoc_item()

        # tag no text item will find owner itself

        '''

        try:

            rect = self.sceneBoundingRect()

            attrs = [attr for attr in attributes if type(attr) is QEngineeringTagNoTextItem]

            for attr in attrs:

                if rect.contains(attr.center()):

                    self.add_assoc_item(attr)

                    attr.onwer = self

            # not have equipment name which is located inside equipment

            if not 'Tag No' in self._associations or not self._associations['Tag No']:

                minDist = None

                selected = None

                # get nearest text from equipment

                for attr in attrs:

                    dx = attr.center().x() - rect.center().x()

                    dy = attr.center().y() - rect.center().y()

                    dist = math.sqrt(dx*dx + dy*dy)

                    if (minDist is None) or (dist < minDist):

                        minDist = dist

                        selected = attr

                if selected is not None:

                    self.add_assoc_item(selected)

                    selected.onwer = self

        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 highlight(self, flag):

        """ highlight/unhighlight the equpment """

        try:

            self.hover = flag

            self.update()

            for assoc in self.associations():

                assoc.highlight(flag)

            for connector in self.connectors:

                connector.highlight(flag)

        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)

    '''

    @property

    def NameText(self):

        #from EngineeringTextItem import QEngineeringTextItem

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        if self.associations():

            matches = [assoc for assoc in self.associations() if type(assoc) is QEngineeringTagNoTextItem]

            if matches:

                return matches[0].text()

        else:

            matches = [prop for prop, _ in self._properties.items() if prop.Attribute == 'Name']

            if matches: return self._properties[matches[0]]

        return None

    @property

    def EvaluatedName(self):

        return self.NameText

    '''

        @brief      generate xml code for equipment

        @author     humkyung

        @date       2018.05.09

    '''

    def toXml(self):

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        try:

            node = SymbolSvgItem.toXml(self)

        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)

            return None

        return node