HYTOS

                        self._streamline._vertices[-1] = selected.center() if type(selected) is QEngineeringConnectorItem else selected.parentItem().center()

                    #QGraphicsView.mouseReleaseEvent(self.imageViewer, event)

                    self._streamline.update()

                    self.onSuccess.emit()

                    self.connectorItems.clear()

        return resultStr

from EngineeringEndBreakItem import QEngineeringEndBreakItem

from EngineeringReducerItem import QEngineeringReducerItem

from AppDocData import *

import SymbolEditorDialog

from UserInputAttribute import UserInputAttribute

from TextItemFactory import TextItemFactory

from TextDataListDialog import QTextDataListDialog

        self.graphicsView = QtImageViewer.QtImageViewer(self)

        self.graphicsView.setParent(self.centralwidget)

        self.graphicsView.setMouseTracking(True)

        self.graphicsView.viewport().installEventFilter(self)

        self.symbolTreeWidget.header().hide()

        self.verticalLayoutSymbolList.addWidget(self.symbolTreeWidget)

        self.treeWidgetDrawingList.setHeaderHidden(False)

        self.treeWidgetDrawingList.header().setStretchLastSection(True)

        self.treeWidgetDrawingList.header().setDefaultAlignment(Qt.AlignCenter)

        self.treeWidgetDrawingList.hideColumn(2)

        self.treeWidgetDrawingList.itemDoubleClicked.connect(self.open_selected_drawing)

        # Initialize Action group

        self.actionGroup = QActionGroup(self)

        self.actionGroup.addAction(self.actionLine)

    def clear_data(self):

        self.clear_HMB()

    def eventFilter(self, source, event):

        """

        items = [item for item in self.graphicsView.scene.items() if issubclass(type(item), QEngineeringTextItem)]

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

    def dbUpdate(self):

        '''

            @brief      db update when save or recognition

                    itemTypes.append(type(item))

            ##

            self._save_work_cmd = SaveWorkCommand()

            self._save_work_cmd.display_message.connect(self.onAddMessage)

            self._save_work_cmd.finished.connect(self.save_finished)

            self._movie.start()

            self._save_work_cmd.start()

        except Exception as ex:

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

        items = [item for item in self.graphicsView.scene.selectedItems() if issubclass(type(item), SymbolSvgItem) or type(item) is QEngineeringStreamlineItem ]

        if items:

            item = items[-1]

            if type(item) is QEngineeringErrorItem:

                for index in range(self.tableWidgetHMB.rowCount()):

            self.path = os.path.join(project.getDrawingFilePath(), drawing + '.png')

            appDocData.setImgFilePath(self.path)

            appDocData.activeDrawing = Drawing(appDocData.imgName)

            ## Load data on database     

            components = appDocData.getComponentListByDrawingUID(appDocData.activeDrawing.UID)

            count = len(components)

            if count > 0:

            self.changeViewCheckedState(True)

        except Exception as ex:

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

            self.addMessage.emit(MessageType.Error, message)

                            _chan, w, h = img.shape[::-1]

                        svg = SymbolSvgItem(svgPath)

                        svg.buildItem(newSym.getName(), newSym.getType(), 0, [offsetX, offsetY], [w, h], [float(x) for x in newSym.getOriginalPoint().split(',')], [(float(x.split(',')[0]), float(x.split(',')[1])) for x in newSym.getConnectionPoint().split('/')], newSym.getBaseSymbol(), newSym.getAdditionalSymbol(), newSym.getHasInstrumentLabel)

                        svg.addSvgItemToScene(self.graphicsView.scene)

                        for connector in svg.connectors:

                            self.graphicsView.scene.addItem(connector)

    '''

    def itemRemoved(self, item):

        try:

            matches = [_item for _item in self.graphicsView.scene.items() if hasattr(_item, 'connectors') and \

            [connector for connector in _item.connectors if connector.connectedItem is not None and connector.connectedItem.parentItem() is item]]

            for match in matches:

                childSymbol = symbol.getAdditionalSymbol()

                hasInstrumentLabel = symbol.getHasInstrumentLabel()

                if os.path.isfile(svgFilePath):

                    svg = SymbolSvgItem.createItem(_type, svgFilePath, owner=None, flip=flip)

                    #print(pt)

            for componentUID in componentsUID:

                componentInfos = appDocData.getComponentByComponentUID(componentUID)

                if (len(componentInfos)) > 0:                    

                    if category == 'Stream Line':

                        item = QEngineeringStreamlineItem.fromDatabase(componentInfos)     

                        if item is not None:

        self.toolBar.setIconSize(QtCore.QSize(32, 32))

        self.toolBar.setObjectName("toolBar")

        MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)

        self.actionOpen = QtWidgets.QAction(MainWindow)

        icon = QtGui.QIcon()

        icon.addPixmap(QtGui.QPixmap(":/newPrefix/file.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)

        self.treeWidgetDrawingList.setSortingEnabled(True)

        self.dockWidgetHMBList.setWindowTitle(_translate("MainWindow", "HMB List"))

        self.toolBar.setWindowTitle(_translate("MainWindow", "Main Toolbar"))

        self.actionOpen.setText(_translate("MainWindow", "Open"))

        self.actionOpen.setToolTip(_translate("MainWindow", "Open(Ctrl + O)"))

        self.actionOpen.setShortcut(_translate("MainWindow", "Ctrl+O"))

            self._font.setPointSizeF(5)

            self._conn_index = index

    @property

    def connectedItem(self):

        """ getter of connectedItem """

        import uuid

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

            if matches:

                self._connectedItem = matches[0]

    def toSql(self, index):

        """ generate sql string to save connectors to database """

        cols = ['UID', 'Components_UID', '[Index]', 'X', 'Y']

        values = ['?', '?', '?', '?', '?']

        sql = 'insert or replace into Points({}) values({})'.format(','.join(cols), ','.join(values))

        return (sql, tuple(param))

        except Exception as ex:

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

        """ build connectors for stream line

            connected is target connector

        """

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringConnectorItem import QEngineeringConnectorItem 

        index = 0

            connector.setPos(vertex)

            connector.setParentItem(self)

            connector.connectPoint = vertex

            self.connectors.append(connector)

            if len(connected) > index:

                connector.connect(connected[index])

            index = index + 1

        """ connect symbol's on_pos_changed signal """

            symbol.transfer.on_pos_changed.connect(self.on_symbol_pos_changed)

        self.update_arrow()

        # save vertices to database

        index = 1

            sql = 'insert or replace into Points({}) values({})'.format(','.join(cols), ','.join(values))

            index += 1

        # up to here

        return res

    @staticmethod 

    def fromDatabase(componentInfos):

        from EngineeringConnectorItem import QEngineeringConnectorItem

        try:

            item = QEngineeringStreamlineItem(uid)

            connectorItems = []

            item.setVisible(False)

            item.__buildItem()

            item.update()

        except Exception as ex:

        @history    2018.05.09  Jeongwoo    Clear self.connectors

                    2018.05.30  Jeongwoo    Add parameters (parentSymbol, childSymbol)

    '''

        try:

            docData = AppDocData.instance()

            self.name = name

                    break

                tokens = connectionPoints[index].split(',')

                symbol_idx = '0'

                if len(tokens) == 2:

                    x = float(tokens[0])

                    y = float(tokens[1])

                    y = float(tokens[2])

                    symbol_idx = tokens[3]

                self.connectors[index].direction = direction

                self.connectors[index].symbol_idx = symbol_idx

                self.connectors[index].setPos((x, y))

                self.connectors[index].connectPoint = (x, y)

            tooltip = '<b>{}</b><br>{}={}'.format(str(self.uid), self.type, self.name)

            self.setToolTip(tooltip)

        except Exception as ex:

    @staticmethod 

    def fromDatabase(componentInfos):

        item = None

        try:

            pt = []

            connPts = []

            for componentInfo in componentInfos:

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

            if os.path.isfile(svgFilePath):

                item = SymbolSvgItem.createItem(_type, svgFilePath, uid)

                item.setVisible(False)

                for area in appDocData.getAreaList():

                    if area.contains(pt):

        @author     kyouho

        @date       2018.07.26

    '''

        connector.setParentItem(self)

        self.connectors.append(connector)