HYTOS

# coding: utf-8

""" This engineering opc 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 EngineeringConnectorItem import QEngineeringConnectorItem

class QEngineeringOPCItem(SymbolSvgItem):

    """ This is engineering opc item class """

    clicked = pyqtSignal(QGraphicsSvgItem)

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

        from SymbolAttr import SymbolProp

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

        self._properties = \

            {\

                SymbolProp(None, 'Logical', 'String', Expression=None):'Process', 

                SymbolProp(None, 'From', 'Text Item', Expression='self.From'):None, 

                SymbolProp(None, 'To', 'Text Item', Expression='self.To'):None 

            }

    '''

        @brief  getter of description

        @author humkyung

        @date   2018.05.08

    '''

    @property

    def description(self):

        return self._description

    '''

        @brief  setter of description

        @author humkyung

        @date   2018.05.08

    '''

    @description.setter

    def description(self, value):

        self._description = value

    @property

    def From(self):

        """ return From value """

        return ''

    @property

    def To(self):

        """ return To value """

        return ''

    def includes(self, item):

        topLeft = [item.loc[0], item.loc[1]]

        bottomRight = [item.loc[0] + item.size[0], item.loc[1] + item.size[1]]

        if self.contains(topLeft) and self.contains(bottomRight):

            return True

        else:

            return False

    def contains(self, pt):

        minX = self.loc[0]

        minY = self.loc[1]

        maxX = minX + self.size[0]

        maxY = minY + self.size[1]

        if pt[0] < minX: return False

        if pt[0] > maxX: return False

        if pt[1] < maxY: return False

        if pt[1] > minY: return False

        return True

    '''

        @brief  connect attribute

        @author humkyung

        @date   2018.05.02

    '''

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

        from AppDocData import AppDocData, MessageType

        from EngineeringLineItem import QEngineeringLineItem

        try:

            if clear:

                self.clear_attr_and_assoc_item()

            # return, opc attribute check manually

            '''

            app_doc_data = AppDocData.instance()

            matches = [connector.connectedItem for connector in self.connectors if connector is not None and type(connector.connectedItem) is QEngineeringLineItem]

            if matches:

                if matches[0].connectors[0].connectedItem is self:      # FROM

                    configs = app_doc_data.getConfigs('OPC Tag Rule', 'From Prefix')

                elif matches[0].connectors[1].connectedItem is self:    # TO

                    configs = app_doc_data.getConfigs('OPC Tag Rule', 'To Prefix')

                self.set_property('Logical', 'Process' if (matches[0].lineType == 'Primary' or matches[0].lineType == 'Secondary') else 'Instrument') # set OPC type

            rect = self.sceneBoundingRect()

            for attr in attributes:

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

                    if self.add_assoc_item(attr):

                        attr.owner = self

            self.associations() # to binding object from scene

            if 'Text Item' in self._associations and self._associations['Text Item']:

                if 0 == self.angle:

                    sorted(self._associations['Text Item'], key=lambda attr: attr.loc[0])                # sort by x coordinate

                elif 3.14 == self.angle:

                    sorted(self._associations['Text Item'], key=lambda attr: attr.loc[0], reverse=True)  # sort by x coordinate by descending

                elif 1.57 == self.angle:

                    sorted(self._associations['Text Item'], key=lambda attr: attr.loc[1], reverse=True)  # sort by y coordinate

                elif 4.71 == self.angle:

                    sorted(self._associations['Text Item'], key=lambda attr: attr.loc[1])                # sort by y coordinate

            '''

        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  generate xml code for attribute

        @author humkyung

        @date   2018.05.02

    '''

    def toXmlAsAttribute(self, parent):

        for attr in self.attrs:

            text = attr.text()

            if QRegExpValidator(QRegExp("^[0-9]+$")).validate(text, 0)[0] != QValidator.Invalid:

                parent.append(attr.toXml(self, 'OPC Tag'))

            else:

                parent.append(attr.toXml(self, 'Description'))