HYTOS

        """ explode all line nos """

        try:

                self.explode_line_no(self.LineNoTreeItem.child(i))

        finally:

            pass

            self._lineNos = lineNos

            self._spec_breaks = specBreak

            self._lineIndicator = lineIndicator

            """

            for spec in self._specBreak:

                matches = [spec_break for spec_break in self._spec_breaks if spec_break.is_connected(obj)]

                if matches or issubclass(type(obj), QEngineeringEquipmentItem): continue

                """ end loop if obj is to """

                if type(obj) is QEngineeringLineItem:

                    symbolMatches = [x for x in self._symbols if (x.owner is None) and (x not in visited) and obj.is_connected(x)]

        lineNos = []

        specBreak = []

        lineIndicator = []

        for item in worker.graphicsView.scene.items():

            if type(item) is QEngineeringSpecBreakItem:

                specBreak.append(item)

            elif type(item) is QEngineeringLineNoTextItem:

                lineNos.append(item)

            elif type(item) is QEngineeringLineItem:

            elif type(item) is QEngineeringUnknownItem and item.lineIndicator != 'False':

                lineIndicator.append(item)

        # trace line no

        tracer.execute(worker.displayMessage, worker.updateProgress)

        # up to here

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

        for valve in valves:

            valve.connectAttribute(labels, clear=False)

    except Exception as ex:

        from App import App 

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

        self.actionRecognition.triggered.connect(self.recognize)

        self.pushButtonBatchRecognition.clicked.connect(self.recognizeBatch)

        self.pushButtonRefreshDrawings.clicked.connect(self.load_drawing_list)

        self.actionArea.triggered.connect(self.areaConfiguration)

        self.actionConfiguration.triggered.connect(self.configuration)

        self.actionOCR.triggered.connect(self.onAreaOcr)

                    Jeongwoo 2018.05.25 Move codes about LineDetector

                    humkyung 2018.06.17 show progress dialog

    '''

        from LineNoTracer import LineNoTracer

        from ConnectAttrDialog import QConnectAttrDialog

            for line in root.find('LINEINFOS').iter('LINE'):

                item = QEngineeringLineItem.fromXml(line)

                item.transfer.onRemoved.connect(self.itemRemoved)

                self.progress.setValue(self.progress.value() + 1)

                                uid = uidElement.text

                                run_item = self.graphicsView.findItemByUid(uid)

                                if run_item is not None:

                                    line_run.items.append(run_item)

                        line_run.owner = line_no

                        line_no.runs.append(line_run)

            # up to here

            """ update scene """

            self.graphicsView.scene.update(self.graphicsView.sceneRect())

            for item in self.graphicsView.scene.items():

        self._symbol_idx = '0'

        self._spec_break = None

        self.highlight = False

        self._connected_at = QEngineeringAbstractItem.CONNECTED_AT_PT      # default value is connected at pt

        self.sceneConnectPoint = None

        self.connectPoint = None

        self._drawing_mode = QEngineeringConnectorItem.AXIS_MODE

    '''

        @brief      getter of direction

        @author     humkyung

        """ parse given node """

        import uuid

    @staticmethod

    def fromXml(node):

    def toXml(self):

        """ generate xml code for connector """

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

        try:

            node.attrib['UID'] = str(self.uid)

            node.attrib['CONNECTED_AT'] = str(self._connected_at)

            connectedItemNode = Element('CONNECTEDITEM')

            connectPointNode = Element('CONNECTPOINT')

            connectPointNode.text = str(self.connectPoint[0]) + ',' + str(self.connectPoint[1])

            sceneConnectPointNode = Element('SCENECONNECTPOINT')

            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)

        return item

import SelectAttributeCommand

class SymbolSvgItem(QGraphicsSvgItem, QEngineeringAbstractItem):

    clicked = pyqtSignal(QGraphicsSvgItem)

    ZVALUE = 50

    HOVER_COLOR = 'url(#hover)'

    @property

    def properties(self):

        """ getter of properties """

        return self._properties

    @properties.setter

        """ setter of properties """

        self._properties = value

    def validate(self):

        '''

            @brief  validation check : flow

    def __init__(self, UID, Attribute, AttributType, DisplayAttribute=None, Length=None, Expression=None):

        import uuid

        self.Attribute = Attribute 

        self.AttributeType = AttributType

        self.DisplayAttribute = DisplayAttribute if DisplayAttribute else Attribute

        """ parse xml node for property """

        import uuid

        self.Attribute = node.attrib['Attribute']

        self.AttributeType = node.attrib['AttributeType']

        self.DisplayAttribute = node.attrib['DisplayAttribute']

        import uuid

        attr = SymbolAttr()

        attr.Attribute = node.attrib['Attribute']

        attr.DisplayAttribute = node.attrib['DisplayAttribute']

        attr.AttributeType = node.attrib['AttributeType']

            if node:

                resultDic[key][0] += 1

            else:

                resultDic[key][1].append(str(item.uid))