HYTOS

            if self.code_area:

                if self.code_area.scene():

                self.code_area = None

            if self.desc_area:

                if self.desc_area.scene():

                self.desc_area = None

            self.ui.pushButtonRead.setText('Read from Legend')

        else:

            if self.code_area:

                if self.code_area.scene():

                self.code_area = None

            if self.desc_area:

                if self.desc_area.scene():

                self.desc_area = None

            self.ui.pushButtonRead.setText('Read from Legend')

        if self.ui.pushButtonRead.text() == 'Draw Code Area':

            item = QGraphicsBoundingBoxItem(x, y, width, height)

            item.setPen(QPen(Qt.red, THICKNESS, Qt.SolidLine))

            self.code_area = item

            self.ui.pushButtonRead.setText('Draw Description Area')

        elif self.ui.pushButtonRead.text() == 'Draw Description Area' and self.code_area and self.code_area.scene():

            item = QGraphicsBoundingBoxItem(x, y, width, height)

            item.setPen(QPen(Qt.blue, THICKNESS, Qt.SolidLine))

            self.desc_area = item

            self.ui.pushButtonRead.setText('Read')

            self.graphicsView.command = None

                graphicsView = App.mainWnd().graphicsView

                if dialog.code_area:

                    if dialog.code_area.scene():

                if dialog.desc_area:

                    if dialog.desc_area.scene():

                graphicsView.useDefaultCommand()

        except Exception as ex:

            if self.ui.lineEditHMBArea.tag is None:

                item = QGraphicsBoundingBoxItem(x, y, width, height)

                item.setPen(QPen(Qt.red, THICKNESS, Qt.SolidLine))

                self.ui.lineEditHMBArea.tag = item

            else:

                                                       sys.exc_info()[-1].tb_lineno))

        finally:

            if self.ui.lineEditHMBArea.tag is not None:

        QDialog.accept(self)

    def reject(self):

        if self.ui.lineEditHMBArea.tag is not None:

        QDialog.reject(self)

        @date   2018.07.20

    '''

    def onStreamNoChanged(self, param):

        if items is not None and len(items) == 1:

            if type(items[0]) is QEngineeringLineNoTextItem:

                stream_no = self.streamNoComboBox.itemText(param)

        from SymbolAttr import SymbolAttr

        if event.key() == Qt.Key_Delete:

            selectedIndexes = self.selectedIndexes()

            if selectedIndexes and selectedIndexes[0].column() == 3 and self.item(selectedIndexes[0].row(), 1).text() == 'OWNER':

                items[0].owner = None

                    items[0].connectors[connNum - 1].connectedItem = None

                    self.show_item_property(items[0])

                        if hasattr(sceneItem, 'uid') and str(sceneItem.uid) == selectedUID and hasattr(sceneItem, 'connectors'):

                            for sceneConnector in sceneItem.connectors:

                                if sceneConnector.connectedItem is not None and items[0].uid == sceneConnector.connectedItem.uid:

        from SymbolAttr import SymbolProp

        if column == 2:

            keyCell = self.item(row, 1)

            attr = keyCell.data(Qt.UserRole)

            if hasattr(keyCell, 'tag') and type(items[0]) is not QEngineeringSpecBreakItem:

        self.actionImport_Text_From_CAD.triggered.connect(self.onImportTextFromCAD)

        self.actionSymbol_Thickness_Reinforcement.triggered.connect(self.onSymbolThickness)

        self.actionHelp.triggered.connect(self.on_help)

        self.actionInitialize.triggered.connect(self.onInitializeScene)

        self.actionSave.triggered.connect(self.actionSaveCliked)

        self.addMessage.connect(self.onAddMessage)

        self.actionFindReplaceText.triggered.connect(self.findReplaceTextClicked)

        self.actionEditRecognizeLine.triggered.connect(self.on_recognize_line)

        self.pushButtonDetectSymbol.clicked.connect(self.show_detect_symbol_dialog)

        configs = docData.getAppConfigs('app', 'mode')

        if configs and 1 == len(configs) and 'advanced' == configs[0].value:

            dlg = QValidationDialog(self)

            if QDialog.Accepted == dlg.exec_():

                # remove error items

                    if type(item) is QEngineeringErrorItem:

                        item.transfer.onRemoved.emit(item)

                # up to here

                self.progress_bar.setValue(0)

                cmd = ValidateCommand(self.graphicsView)

                cmd.show_progress.connect(self.progress_bar.setValue)

                for error in errors:

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

                self.tableWidgetInconsistency.clearContents()

                self.tableWidgetInconsistency.setRowCount(len(errors))

            for line in lines:

                vertices = [[line[0][0] + x, line[0][1] + y], [line[1][0] + x, line[1][1] + y]]

                line_item = QEngineeringGraphicsLineItem(vertices)

        except Exception as ex:

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

    def display_number_of_items(self):

        """display count of symbol, line, text"""

        if len(items) > 0:

            self.labelStatus.setText(

                "<font color='red'>" + self.tr('Unrecognition') + " : {}</font>".format(len(items)))

            self.labelStatus.setText(

                "<font color='black'>" + self.tr('Unrecognition') + " : {}</font>".format(len(items)))

                 issubclass(type(item), SymbolSvgItem) and type(item) is not QEngineeringErrorItem]

        self.labelSymbolStatus.setText("<font color='blue'>" + self.tr('Symbol') + " : {}</font>".format(len(items)))

        self.labelLineStatus.setText("<font color='blue'>" + self.tr('Line') + " : {}</font>".format(len(items)))

        self.labelTextStatus.setText("<font color='blue'>" + self.tr('Text') + " : {}</font>".format(len(items)))

    def dbUpdate(self):

        '''

            app_doc_data.clearItemList(False)

            # for check line disappear bug

            disappear_lines = [line for line in app_doc_data.lines if line not in items]

    '''

    def refreshResultPropertyTableWidget(self):

        if len(items) == 1:

            self.resultPropertyTableWidget.show_item_property(items[0])

    '''

    def onRotate(self, action):

        if len(selected) == 1:

            selected[0].rotateSymbol()

                item = QEngineeringVendorItem(polygon, pack_type=self.packageComboBox.currentText())

                item.area = 'Drawing'

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

        finally:

            self.actionVendor.tag.reset()

    '''

    def onSelectionChanged(self):

        """selection changed"""

                 type(item) is QEngineeringLineItem or issubclass(type(item), QEngineeringTextItem) or

                 type(item) is QEngineeringUnknownItem or type(item) is QEngineeringVendorItem]

        if items:

                appDocData = AppDocData.instance()

                appDocData.clearItemList(True)

                for item in items:

                    if type(item) is not QGraphicsPixmapItem and item.scene() is not None:

                        # if hasattr(item, 'tranfer'):

                        #    item.tranfer.onRemoved.emit(item)

                        # else:

                        '''

                        if type(item) is QEngineeringLineNoTextItem:

            (res, textInfoList) = dialog.showDialog()

            if QDialog.Accepted == res and textInfoList:

                for textInfo in textInfoList:

                    if item:

                        item.setDefaultTextColor(Qt.blue)

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

        dlg.exec_()

        if dlg.code_area:

            if dlg.code_area.scene():

        if dlg.desc_area:

            if dlg.desc_area.scene():

        self.graphicsView.useDefaultCommand()

    def onShowCustomCodeTable(self):

    def onLineTypeChanged(self, param):

        lineType = self.lineComboBox.itemText(param)

        if selected:

            for item in selected:

                item.lineType = lineType

        DisplayColors.instance().option = DisplayOptions.DisplayByLineNo if value is True else DisplayOptions.DisplayByLineType

        if hasattr(self, 'graphicsView'):

            DisplayColors.instance().save_data()

    def open_image_drawing(self, drawing):

                    self.show_Progress_bar()

                    # disconnect scene changed if signal is connected

                    SymbolSvgItem.DOCUMENTS.clear()

                    self.display_number_of_items()

                    # connect scene changed signal

                finally:

                    if hasattr(self, 'progress'):

                        self.progress.setValue(self.progress.maximum())

        file_path, _ = QFileDialog.getSaveFileName(self, "Export as svg", os.getcwd(), "svg file(*.svg)",

                                                   options=options)

        if file_path:

            cmd.display_message.connect(self.onAddMessage)

            if cmd.execute(file_path):

                QMessageBox.information(self, self.tr('Information'), self.tr('Successfully export to svg file'))

                # hide image drawing

                self.onViewImageDrawing(False)

                cmd.display_message.connect(self.onAddMessage)

                if cmd.execute(file_path):

            @date   2019.04.22

        '''

        self.changeViewCheckedState(not isChecked, False)

            if type(item) is not QGraphicsPixmapItem:

                item.setVisible(not isChecked)

    '''

    def onViewImageDrawing(self, isChecked):

            if type(item) is QGraphicsPixmapItem:

                item.setVisible(isChecked)

                break

    '''

    def onViewText(self, isChecked):

        for item in selected:

            item.setVisible(isChecked)

    '''

    def onViewSymbol(self, isChecked):

                    (issubclass(type(item), SymbolSvgItem) and type(item) is not QEngineeringErrorItem)]

        for item in selected:

            item.setVisible(isChecked)

    '''

    def onViewLine(self, isChecked):

        for item in selected:

            item.setVisible(isChecked)

            @author euisung

            @date   2019.04.03

        '''

        for item in selected:

            item.setVisible(isChecked)

    '''

    def onViewUnknown(self, isChecked):

        for item in selected:

            item.setVisible(isChecked)

            @author euisung

            @date   2019.04.29

        '''

        for item in selected:

            item.setVisible(isChecked)

                                      newSym.getAdditionalSymbol(), newSym.getHasInstrumentLabel)

                        svg.transfer.onRemoved.connect(self.itemTreeWidget.itemRemoved)

                        for connector in svg.connectors:

        finally:

            self.onCommandRejected()

            QApplication.restoreOverrideCursor()

                        lineItem.connect_if_possible(items[-1], 5)

                    else:

                        pt = lineItem.startPoint()

                                    type(item) is QEngineeringConnectorItem or type(item) is QEngineeringLineItem]

                        if selected and selected[0] is not lineItem:

                            if type(selected[0]) is QEngineeringConnectorItem:

                                detector.connectLineToLine(selected[0], lineItem, 5)

                    items.append(lineItem)

                    app_doc_data.lines.append(lineItem)

                pt = items[-1].endPoint()

                            (type(item) is QEngineeringConnectorItem and item.parent is not items[-1]) or

                            type(item) is QEngineeringLineItem]

                if selected and selected[0] is not items[-1]:

                        detector.connectLineToLine(selected[0], items[-1], 5)

        finally:

            self.actionLine.tag.reset()

    '''

        try:

            if type(cmd) is PlaceLineCommand.PlaceLineCommand:

                if self.actionLine.tag._polyline:

                self.actionLine.tag.reset()

                self.actionLine.setChecked(False)

                self.actionVendor.setChecked(False)

            else:

                if hasattr(self.actionLine, 'tag') and self.actionLine.tag._polyline:

                    self.actionLine.tag.reset()

                if hasattr(self.actionVendor, 'tag') and self.actionVendor.tag._polyline:

                    self.actionVendor.tag.reset()

                self.actionLine.setChecked(False)

                self.actionZoom.setChecked(False)

            elif event.key() == Qt.Key_M:  # merge text as vertical

                from TextInfo import TextInfo

                             type(text) is QEngineeringTextItem]

                if not textItems or len(textItems) is 1:

                    return

                    item.size = (width, height)

                    item.angle = angle

                    item.setDefaultTextColor(Qt.blue)

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

            elif event.key() == Qt.Key_D:

                # pop up development toolkit dialog

                else:

                    return

                               issubclass(type(symbol), SymbolSvgItem)]

                old_symbol = None

                if symbolItems and len(symbolItems) is 1:

                configs = app_doc_data.getAppConfigs('app', 'mode')

                if configs and 1 == len(configs) and 'advanced' == configs[0].value:

                    advanced = True

                    if items:

                        item = self.symbolTreeWidget.currentItem()

                        if item:

            else:

                self.itemTreeWidget.itemRemoved(item)

                           hasattr(_item, 'connectors') and [connector for connector in _item.connectors if

                                                             connector.connectedItem is item]]

                for match in matches:

                            connector.connectedItem = None

                            connector.highlight(False)

                # for _item in matches:

                #    _item.remove_assoc_item(item)

                if type(item) is QEngineeringLineItem and item in app_doc_data.lines:

                    app_doc_data.lines.remove(item)

                           type(_item) is QEngineeringLineNoTextItem]

                matches.extend([lineNo for lineNo in app_doc_data.tracerLineNos if

                                type(lineNo) is QEngineeringTrimLineNoTextItem])

                                    app_doc_data.tracerLineNos.pop(app_doc_data.tracerLineNos.index(match))

                            # break

                for match in matches:

                    if match.owner is item:

                        match.owner = None

                # done = False

                for match in matches:

                    assocs = match.associations()

            return

        try:

            dlg.setWindowFlags(self.windowFlags() & ~Qt.WindowCloseButtonHint & ~Qt.WindowContextHelpButtonHint)

            dlg.exec_()

            if dlg.isRunned:

            self.createDetectedTitleBlockTextItem(titleBlockTextInfoList)

            # update scene

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

                if issubclass(type(symbol), SymbolSvgItem):

                    self.addSvgItemToScene(symbol)

                else:

            for text in appDocData.texts:

                self.addTextItemToScene(text)

                self.addTextItemToScene(lineNo)

            for line in appDocData.lines:

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

                for conn in line.connectors:

                    conn.transfer.onPosChanged.connect(line.onConnectorPosChaned)

            for unknown in appDocData.unknowns + appDocData.lineIndicators:

        finally:

            # update scene

    def postDetectLineProcess(self):

        '''

            tableNameFormat = tableName.replace(' ', '').replace('&&', 'n')

            tableDatas.append(appDocData.getCodeTable(tableNameFormat))

        for item in items:

            if type(item) is not QEngineeringTextItem:

                continue

                lineItem.size = item.size

                lineItem.angle = item.angle

                lineItem.area = item.area

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

                item.transfer.onRemoved.emit(item)

                appDocData.lineNos.append(lineItem)

        for pts in lineList:

            processLine = QEngineeringLineItem(vertices=[(area.x + param[0], area.y + param[1]) for param in pts])

            processLine.area = 'Drawing'

            appDocData.lines.append(processLine)

            appDocData.allItems.append(processLine)

                    item.isSymbol = True

                    item.angle = angle

                    item.setPen(QPen(Qt.red, 5, Qt.SolidLine))

                    # appDocData.symbols.append(item)

                    appDocData.allItems.append(item)

            # up to here

                    item.isSymbol = True

                    item.angle = angle

                    item.setPen(QPen(Qt.red, 5, Qt.SolidLine))

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

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

                item = QEngineeringLineItem.from_database(line)

                if item:

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

                    lines.append(item)

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

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

                if item is not None:

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

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

                item = QEngineeringVendorItem.from_database(component)

                if item is not None:

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

            # connect flow item to line

            for line in lines:

        def update_items(items):

            for item in items:

                # binding items

            return items

        docData = AppDocData.instance()

        try:

            symbols = []

            lines = []

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

                    symbols.append(item)

                    docData.symbols.append(item)

                else:

                    pt = [float(x) for x in symbol.find('LOCATION').text.split(',')]

                    size = [float(x) for x in symbol.find('SIZE').text.split(',')]

                    item.isSymbol = True

                    item.angle = angle

                    item.setPen(QPen(Qt.red, 5, Qt.SolidLine))

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

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

                item = QEngineeringLineItem.fromXml(line)

                if item:

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

                    lines.append(item)

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

                item = QEngineeringUnknownItem.fromXml(unknown)

                if item is not None:

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

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

                for vendor in root.find('VENDORS').iter('VENDOR'):

                    item = QEngineeringVendorItem.fromXml(vendor)

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

            # connect flow item to line

            for line in lines:

            # up to here

            """ update scene """

                up_progress = False

                # binding items

                item.setVisible(True)

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

        finally:

            self.itemTreeWidget.update_item_count()

            self.itemTreeWidget.expandAll()

    '''

        @brief      Remove added item on same place and Add GraphicsItem

    '''

    def addSvgItemToScene(self, svgItem):

    '''

        @brief      Remove added item on same place and Add GraphicsItem

    '''

    def addTextItemToScene(self, textItem):

    '''

        @brief      Remove added item on same place and Add GraphicsItem

    '''

    def addLineItemToScene(self, lineItem):

    '''

        @brief      generate output xml file

        try:

            appDocData = AppDocData.instance()

            appDocData.lines.clear()

                                type(item) is QEngineeringLineItem and item.owner is None]

            appDocData.symbols.clear()

                                  issubclass(type(item), SymbolSvgItem) and item.owner is None]

            appDocData.equipments.clear()

                if type(item) is QEngineeringEquipmentItem:

                    appDocData.equipments.append(item)

            appDocData.texts.clear()

                                issubclass(type(item), QEngineeringTextItem) and type(

                                    item) is not QEngineeringLineNoTextItem]

            appDocData.imgOutput = np.ones((appDocData.activeDrawing.height, appDocData.activeDrawing.width),

                                           np.uint8) * 255

    def display_text_rect(self):

        """display text bounding rectangle"""

            if type(item) is not QGraphicsPixmapItem:

        for text_info in self.textInfoList:

                                            text_info.getW(), text_info.getH(), QPen(Qt.red, 1, Qt.SolidLine))

    '''

            text_info.setW(rect.width())

            text_info.setH(rect.height())

                                            QPen(Qt.red, 1, Qt.SolidLine))

    '''

        self.mainWindow = mainWindow

        # Image is displayed as a QPixmap in a QGraphicsScene attached to this QGraphicsView.

        self.command = None

        self.scaleFactor = 1.0

        self.numScheduledScalings = 0

        """ Removes the current image pixmap from the scene if it exists.

        """

        if self.hasImage():

            self._pixmapHandle = None

    def pixmap(self):

                raise RuntimeError("ImageViewer.setImage: Argument must be a QImage or QPixmap.")

            self.clearImage()

            if self.hasImage():

                self._pixmapHandle.setPixmap(pixmap)

            else:

                self._pixmapHandle.setFlags(QGraphicsItem.ItemClipsChildrenToShape)

            self.setSceneRect(QRectF(pixmap.rect()))  # Set scene size to image size.

            right_bottom = self.mapToScene(clickPos.x() + HALF_SIZE // adjust, clickPos.y() + HALF_SIZE // adjust)

            zoomArea = QRectF(left_top, right_bottom)

            if zoomArea.isValid():

                self.zoomStack.append(zoomArea)

                self.updateViewer(zoomArea)

        else:

            zoomNewRect = None

            clickPos = self.mapToScene(clickPos.x() // adjust, clickPos.y() // adjust)

            if self.zoomStack:

                zoomNewRect = self.zoomStack.pop()

                zoomNewRect = QRectF(clickPos.x() - zoomNewRect.width() / 2, clickPos.y() - zoomNewRect.height() / 2, zoomNewRect.width(), zoomNewRect.height())

            print('error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno))

        QGraphicsView.mouseMoveEvent(self, event)

                scenePos = self.mapToScene(event.pos())

                instance = self.command.execute(['mouseReleaseEvent', event, scenePos])

                if instance is not None:

                if self.command is not None and self.command.isTreated == True:

                    if self.command.name == 'Default' and self.command.isCopy:

        try:

            if event.key() == Qt.Key_Delete:

                    item.transfer.onRemoved.emit(item)

            elif event.key() == Qt.Key_Escape:

                if self.command is not None:

                self.mainWindow.keyPressEvent(event)

            if event.key() == Qt.Key_Up or event.key() == Qt.Key_Down or event.key() == Qt.Key_Left or event.key() == Qt.Key_Right:

                         issubclass(type(text), QEngineeringTextItem) or issubclass(type(text), SymbolSvgItem)]

                    for item in items:

                        item.keyPressEvent(event)

                    return

        pen.setStyle(Qt.DashLine)

        pen.setWidthF(0.5)

        if isShow:

            for item in self.GUIDELINE_ITEMS:

                if item in items:

            self.GUIDELINE_ITEMS.clear()

            if pos is not None:

            else:

            self.GUIDELINE_ITEMS.append(verticalLine)

            self.GUIDELINE_ITEMS.append(horizontalLine)

        else:

            for item in self.GUIDELINE_ITEMS:

                if item in items:

            self.GUIDELINE_ITEMS.clear()

    '''

    def dragMoveEvent(self, event):

        scenePos = self.mapToScene(event.pos())

                 type(item) is not QGraphicsPixmapItem and type(item) is not QGraphicsTextItem]

        if len(items) > 0:

            if not hasattr(self, '_underItem') or self._underItem is not items[0]:

                if hasattr(self, '_underItem') and self._underItem is not None:

                        self._underItem.highlight(False)

                    else:

                        self._underItem = None

        from AppDocData import AppDocData

        import symbol

            return

            self._underItem.hoverLeaveEvent(event)

            self._underItem = None

        else:

        svg.transfer.onRemoved.connect(self.mainWindow.itemRemoved)

                 type(item) is not QGraphicsPixmapItem and type(item) is not QGraphicsTextItem]

        connectors = []

        if len(items) > 0 and type(items[0]) is QEngineeringConnectorItem:

            scenePos = QPointF(items[0].center()[0], items[0].center()[1])

            connectors = [connector for connector in items if issubclass(type(connector.parentItem()), SymbolSvgItem)]

                   (type(item) is QEngineeringLineItem) and (item.distanceTo((scenePos.x(), scenePos.y())) < 20)]

        allowed_error = 0.00001

        if False:  # len(matches) == 1:

                0].sceneBoundingRect().center().y() + dy

            svg.loc = [x - svg.symbolOrigin[0], y - svg.symbolOrigin[1]]

            svg.origin = [x, y]

            items = [item for item in self.scene.items(scenePos) if

                     type(item) is not QGraphicsPixmapItem and type(item) is not QGraphicsTextItem]

            svg.origin = [round(scenePos.x(), 1), round(scenePos.y(), 1)]

            if len(svg.connectors) == 1:

                # single connection item assistant

                         type(item) is QEngineeringConnectorItem and item.parentItem() is not svg and issubclass(

                             type(item.parentItem()), SymbolSvgItem) and not item.connectedItem]

                if items:

                    items[0].connectedItem = svg

                    items[0].highlight(False)

        # svg.reSettingConnetors()

            item.setSelected(False)

        self.setFocus()

        svg.setSelected(True)

    '''

        @brief  find item by uid (SymbolSvgItem 기반, QEngineeringConnectorItem 제외, QEngineeringLineItem 포함)

    def findItemByUid(self, uid):

        from EngineeringConnectorItem import QEngineeringConnectorItem

        return items[0] if items else None

    def convertQImageToMat(self, incomingImage):

        self.isCreated = False

        self._vertices = []

        connector = QEngineeringConnectorItem(parent=self, symbol=False)

        connector.setPos((x, y))

        connector.setParentItem(self)

        connector.setAcceptTouchEvents(True)

        connector.transfer.onPosChanged.connect(self.onConnectorPosChaned)

        self.connectors.append(connector)

        self.setFlags(QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable)

        self.transfer = Transfer()

        """ return string represent uuid """

        return str(self.uid)

    @property

    def owner(self):

        import uuid

        if self._owner and type(self._owner) is uuid.UUID:

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

        if type(self._owner) is not uuid.UUID and type(self._owner) is not str:

            return self._owner

                                _attr.AttrAt = matchAttr.AttrAt

                                _attr.Expression = matchAttr.Expression

                                _attr.Length = matchAttr.Length

                            if _attr.AttributeType == 'Spec':

                                item.attrs[_attr] = [attr.text.split(',')[0], attr.text.split(',')[1]]

                            else:

                                _attr.AssocItem = uuid.UUID(attr.text) if attr.text and attr.text != 'None' else None

                                item.attrs[_attr] = attr.text

                            '''

                            elif _attr.Attribute == 'UpStream':

                graphicsView = App.mainWnd().graphicsView

                if dialog.code_area:

                    if dialog.code_area.scene():

                if dialog.desc_area:

                    if dialog.desc_area.scene():

                graphicsView.useDefaultCommand()

            # target setting

            elif column == 6:

        text_items = []

        if int(self.ui.checkBoxUID.checkState()) is int(Qt.Checked):

                              if hasattr(item, 'uid') and str(item.uid).count(text)]

        else:

                              if issubclass(type(item), QEngineeringTextItem) and item.text().count(text)]

        if not text_items: