HYTOS

                    #    self._item.attrs[self._attr] = str(item.uid)

                    #    self.onSuccess.emit()

                    elif item is not None and self._attr.AttributeType == QEngineeringAbstractItem.assoc_type(item):

                        if self._attr.AttributeType not in self._item._associations:

                            self._item._associations[self._attr.AttributeType] = []

from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

from EngineeringErrorItem import QEngineeringErrorItem

from EngineeringVendorItem import QEngineeringVendorItem

from AppDocData import *

from Drawing import Drawing

from enum import Enum

    def state_changed(self, state):

        """ check box state is changed """

        if self.col == 0:

            widget = self.table.cellWidget(self.row, 3)

            if widget:

                widget.setEnabled(False) if state else widget.setEnabled(True)

                for lineno in self._lineNos:

                    _from = lineno.prop('From')

                    _to = lineno.prop('To')

                    lineno.conns.clear()

                    minDist = None

                    startLine = None

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

        """ try to connect label to valve """

            and type(symbol) is not QEngineeringOPCItem and type(symbol) is not QEngineeringSpecBreakItem]

        for valve in valves:

            valve.connectAttribute(labels, clear=False)

        self._owner = value

    @property

        """ check this is connected to other """

        for connector in self.connectors:

            if connector.connectedItem: return True

        return _type

    def add_assoc_item(self, item, at=None):

        """ add given item to association """

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        _type = QEngineeringAbstractItem.assoc_type(item)

        if _type is not None:

            if not _type in self._associations:

                self._associations[_type] = []

            if at is None:

                self._associations[_type].append(item)

            else:

                while len(self._associations[_type]) <= at: self._associations[_type].append(None)

                self._associations[_type][at] = item

    def remove_assoc_item(self, item):

        """ remove given item from association """

        _type = QEngineeringAbstractItem.assoc_type(item)

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        if clear:

        try:

            rect = self.sceneBoundingRect()

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

            message = 'error occured({}) 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 getColor(self):

        """ return equipment's color """

        @date   2018.05.06

    '''

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

        try:

            rect = self.sceneBoundingRect()

            for attr in attributes:

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

                    if issubclass(type(attr), QEngineeringTextItem):

                    elif issubclass(type(attr), SymbolSvgItem):

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

        from EngineeringInstrumentItem import QEngineeringInstrumentItem

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        try:

            #configs = AppDocData.instance().getConfigs('Size', 'Delimiter')

            #delimiter = configs[0].value if configs else 'X'

            configs = AppDocData.instance().getConfigs('Range', 'Detection Ratio')

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

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

                        if math.sqrt(dx*dx + dy*dy) < dist:

            if selected is not None:

        except Exception as ex:

            from App import App 

                        selected = symbol

            if selected is not None:

        except Exception as ex:

            from App import App 

        from AppDocData import AppDocData, MessageType

        from EngineeringLineItem import QEngineeringLineItem

        try:

            app_doc_data = AppDocData.instance()

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

                        minDist = length

                        selected = symbol

        except Exception as ex:

            from App import App 

                            selected = symbol

            if selected is not None:

        except Exception as ex:

            from App import App 

        from EngineeringInstrumentItem import QEngineeringInstrumentItem

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        try:

            configs = AppDocData.instance().getConfigs('Range', 'Detection Ratio')

            ratio = float(configs[0].value) if 1 == len(configs) else 1.5

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

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

                        if math.sqrt(dx*dx + dy*dy) < dist:

            if selected is not None:

        except Exception as ex:

            from App import App 

        self.UID = uuid.uuid4() if UID is None else uuid.UUID(UID, version=4)

        self.Freeze = Freeze

        self.AttributeType = AttributType

        self.DisplayAttribute = DisplayAttribute if DisplayAttribute else Attribute

        self.Length = Length