HYTOS

    def saveToDatabase(self, items):

            # delete Points

            sql = "delete from Points where Components_UID in (select UID from Components where Drawings_UID = '{}')".format(uid)

            cursor.execute(sql)

            # delete HMB

            sql = "delete from HMB where Components_UID in (select UID from Components where Drawings_UID = '{}')".format(uid)

            cursor.execute(sql)

            # delete Components 

            sql = "delete from Components where Drawings_UID = '{}'".format(uid)

            cursor.execute(sql)

            for item in items:

                sql = item.toSql()

                if type(sql) is list:

                    for item in sql:

                        if item is not None and 2 == len(item):

                            cursor.execute(item[0], item[1])

                else:

                    if sql is not None and 2 == len(sql):

                        cursor.execute(sql[0], sql[1])

            ##

            itemTypes = []

            for item in items:

                typeExist = False

                for itemType in itemTypes:

                    if type(item) is itemType:

                        typeExist = True

                        break

                if not typeExist:

                    itemTypes.append(type(item))

            ##

            #SaveWorkCommand.save()            

            self._save_work_cmd = SaveWorkCommand()

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

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

            """ show spinner gif animation """

            self.label_spinner.setWindowFlags(Qt.WindowStaysOnTopHint)

            if not hasattr(self, '_movie'):

                self._movie = QMovie(':/newPrefix/spinner.gif')

                self.label_spinner.setMovie(self._movie)

            self.label_spinner.show()

            self._movie.start()

            self._save_work_cmd.start()

    def save_finished(self):

        """ stop movie and hide label after finishing save """

        self._movie.stop()

        self.label_spinner.hide()

        QMessageBox.information(self, self.tr('Notice'), self._save_work_cmd.resultStr)

        self.load_drawing_list()

        @history    2018.05.25  Jeongwoo    Moved from MainWindow

                                            SvgItem and TextItem Connect with method in this class

                                            Change method to add GraphicsItem

                    2018.05.28  Jeongwoo    Make QGraphicsItem by symbol, text object. Not xml

                    2018.05.29  Jeongwoo    Change method name and Moved from QRecognitionDialog

                    2018.05.30  Jeongwoo    Add parameters on SymbolSvgItem.__init__() (parentSymbol, childSymbol)

                                            Change Method name and seperate each item

                    humkyung 2018.06.11     display difference between original and recognized image

                    Jeongwoo 2018.06.18     Update Scene after all item added

                    2018.11.05  euisung     add save note item because of dependency

                    2018.11.05  euisung     add db delete process before save

                    2018.11.12  euisung     add title block properties

                    2018.11.12  euisung     db part move new method to dbUpdate

                    2018.11.26  euisung     isolate scene adding part -> drawDetectedItemsToScene()

                    2018.11.29  euisung     change name drawDetectedItems() -> createDetectedItems

    '''

    def createDetectedItems(self, symbolList, textInfoList, otherTextInfoList, titleBlockTextInfoList):

        try:

            appDocData = AppDocData.instance()

            QApplication.processEvents()

            self.createDetectedSymbolItem(symbolList)

            QApplication.processEvents()

            self.createDetectedTextItem(textInfoList)

            QApplication.processEvents()

            self.createDetectedOtherTextItem(otherTextInfoList)

            QApplication.processEvents()

            self.createDetectedTitleBlockTextItem(titleBlockTextInfoList)

            self.dbUpdate()

            # update scene

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

        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)

    def drawDetectedItemsToScene(self):

        '''

            @brief  add detected items to scene

            @author euisung

            @date   2018.11.26

        '''

        appDocData = AppDocData.instance()

        try:

            for symbol in appDocData.symbols:

                if issubclass(type(symbol), SymbolSvgItem):

                    self.addSvgItemToScene(symbol)

                else:

                    self.graphicsView.scene.addItem(symbol)

            for text in appDocData.texts:

                self.addTextItemToScene(text)

            for lineNo in appDocData.tracerLineNos:

                self.addTextItemToScene(lineNo)

            for line in appDocData.lines:

                self.graphicsView.scene.addItem(line)

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

                for conn in line.connectors:

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

            for unknown in appDocData.unknowns + appDocData.lineIndicators:

                self.graphicsView.scene.addItem(unknown)

        finally:

            # update scene

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

    def postDetectLineProcess(self):

        '''

            @brief  check allowables among undetected items

            @author euisung

            @date   2018.11.15

            @history    2018.11.15  euisung    no more used, moved to TextItemFactoy isLineNo()

        '''

        from AppDocData import AppDocData

        from TextItemFactory import TextItemFactory

        appDocData = AppDocData.instance()

        tableNames = ["Fluid Code", "Insulation Purpose", "PnID Number", "Piping Materials Class", "Unit Number"]

        tableDatas = []

        for tableName in tableNames:

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

            tableDatas.append(appDocData.getCodeTable(tableNameFormat))

        items = self.graphicsView.scene.items()

        for item in items:

            if type(item) is not QEngineeringTextItem:

                continue

            text = item.text()

            for tableData in tableDatas:

                for data in tableData:

                    if data[3] == '':

                        continue

                    else:

                        allows = data[3].split(',')

                        for allow in allows:

                            text = text.replace(allow, data[1])

            lineItem = TextItemFactory.instance().createTextItem(text)

            if type(lineItem) is QEngineeringLineNoTextItem:

                lineItem.loc = item.loc

                lineItem.size = item.size

                lineItem.angle = item.angle

                lineItem.area = item.area

                #lineItem.addTextItemToScene(self.graphicsView.scene)

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

                item.transfer.onRemoved.emit(item)

                appDocData.lineNos.append(lineItem)

    def createDetectedTitleBlockTextItem(self, textInfoList):

        '''

            @brief  draw title block

            @author euisung

            @date   2018.11.12

            @history    2018.11.26  euisung     remove scene dependency

                        2018.11.29  euisung     change name drawDetectedTitleBlockTextItem() -> createDetectedTitleBlockTextItem

        '''

        from TextItemFactory import TextItemFactory

        import math

        try:

            appDocData = AppDocData.instance()

            # parse texts

            for textInfo in textInfoList:

                if len(textInfo[1]) is 0:

                    continue

                x = textInfo[1][0].getX()

                y = textInfo[1][0].getY()

                width = textInfo[1][0].getW()

                height = textInfo[1][0].getH()

                angle = round(math.radians(textInfo[1][0].getAngle()), 2)

                text = textInfo[1][0].getText()

                item = TextItemFactory.instance().createTextItem(textInfo)

                if item is not None:

                    item.loc = (x, y)

                    item.size = (width, height)

                    item.angle = angle

                    item.area = textInfo[0]

                    #self.addTextItemToScene(item)

                    #appDocData.texts.append(item)

                    appDocData.activeDrawing.allItems.append(item)

        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)

    '''

        @brief      

        @author     humkyung

        @date       2018.08.23

        @history    2018.11.26  euisung     remove scene dependency

                    2018.11.26  euisung     isolate scene adding part -> drawDetectedItemsToScene()

                    2018.11.    euisung     no more used

                    2018.11.29  euisung     change name drawDetectedLines() -> createDetectedLines

    '''

    def createDetectedLines(self, lineList, worker):

        appDocData = AppDocData.instance()

        area = appDocData.getArea('Drawing')

        for pts in lineList:

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

            processLine.area = 'Drawing'

            #self.graphicsView.scene.addItem(processLine)

            appDocData.lines.append(processLine)

            appDocData.activeDrawing.allItems.append(processLine)

            if processLine.length() > 100: # TODO: check critical length

                processLine.addFlowArrow()

        # re-order process line's start,end according to flow mark

        #worker.arrangeLinePosition(lines, symbols, listWidget)

        # up to here

    '''

        history     2018.06.09  humkyung    check length of original and connection point is 2 while parsing

                    2018.11.26  euisung     remove scene dependency

                    2018.11.29  euisung     change name drawDetectedSymbolItem() -> createDetectedSymbolItem

    '''

    def createDetectedSymbolItem(self, symbolList):

        from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

        from SymbolSvgItem import SymbolSvgItem

        import math

        try:

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

            searchedMap = []

            for symbol in symbolList:

                pt = [float(x) for x in symbol.getSp()]

                size = [symbol.getWidth(), symbol.getHeight()]

                name = symbol.getName()

                angle = round(math.radians(symbol.getRotatedAngle()), 2)

                category = symbol.getCategory()

                _type = symbol.getType()

                flip = symbol.getDetectFlip()

                origin = [0,0]

                if 2 == len(symbol.getOriginalPoint().split(',')):

                    tokens = symbol.getOriginalPoint().split(',')

                    origin = [pt[0] + float(tokens[0]), pt[1] + float(tokens[1])]

                connPts = []

                if symbol.getConnectionPoint() is not None and symbol.getConnectionPoint() != '':

                    for param in symbol.getConnectionPoint().split('/'):

                        tokens = param.split(',')

                        connPts.append(('AUTO', pt[0] + float(tokens[0]), pt[1] + float(tokens[1]), '0') if len(tokens) == 2 else \

                                       (tokens[0], pt[0] + float(tokens[1]), pt[1] + float(tokens[2]), '0') if len(tokens) == 3 else \

                                       (tokens[0], pt[0] + float(tokens[1]), pt[1] + float(tokens[2]), tokens[3]) if len(tokens) == 4 else None)

                parentSymbol = symbol.getBaseSymbol()

                childSymbol = symbol.getAdditionalSymbol()

                hasInstrumentLabel = symbol.getHasInstrumentLabel()

                svgFilePath = os.path.join(project.getSvgFilePath(s), category, _type, name + '.svg')

                if os.path.isfile(svgFilePath):

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

                    #print(pt)

                    #print(origin)

                    svg.buildItem(name, _type, angle, pt, size, origin, connPts, parentSymbol, childSymbol, hasInstrumentLabel)

                    svg.reCalculationRotatedItem()

                    svg.area = 'Drawing'

                    # set owner - 2018.07.20 added by humkyung                   

                    matches = [searched for searched in searchedMap if searched[0] == symbol.owner]

                    if len(matches) == 1:

                        svg.owner = matches[0][1]

                    searchedMap.append((symbol, svg))

                    # up to here

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

                    #self.addSvgItemToScene(svg)

                    appDocData.symbols.append(svg)

                    appDocData.activeDrawing.allItems.append(svg)

                else:

                    item = QGraphicsBoundingBoxItem(pt[0], pt[1], size[0], size[1])

                    item.isSymbol = True

                    item.angle = angle

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

                    #self.graphicsView.scene.addItem(item)

                    #appDocData.symbols.append(item)

                    appDocData.activeDrawing.allItems.append(item)

            # up to here

        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)

    '''

        @history    2018.06.08  Jeongwoo    Add parameter on round method

        @history    2018.11.02  euisung     Add save note text item

        @history    2018.11.05  euisung     delete save note text item and move to drawDetectedItems()

                    2018.11.26  euisung     remove scene dependency

                    2018.11.29  euisung     change name drawDetectedTextItem() -> createDetectedTextItem

    '''

    def createDetectedTextItem(self, textInfoList):

        from TextItemFactory import TextItemFactory

        import math

        try:

            appDocData = AppDocData.instance()

            # parse texts

            for textInfo in textInfoList:

                x = textInfo.getX()

                y = textInfo.getY()

                width = textInfo.getW()

                height = textInfo.getH()

                angle = round(math.radians(textInfo.getAngle()), 2)

                text = textInfo.getText()

                if not text: continue

                item = TextItemFactory.instance().createTextItem(textInfo)

                if item is not None:

                    item.loc = (x, y)

                    item.size = (width, height)

                    item.angle = angle

                    item.area = 'Drawing'

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

                    #self.addTextItemToScene(item)

                    #appDocData.texts.append(item)

                    appDocData.activeDrawing.allItems.append(item)

        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)

    '''

        @brief      draw detected texts except which in drawing area

        @history    2018.11.29  euisung     change name drawDetectedOtherTextItem() -> createDetectedOtherTextItem

    '''

    def createDetectedOtherTextItem(self, otherTextInfoList):

        from TextItemFactory import TextItemFactory

        import math

        try:

            appDocData = AppDocData.instance()

            # parse notes

            for textInfoMap in otherTextInfoList:

                if textInfoMap[0]=='Note':

                    pass

                for textInfo in textInfoMap[1]:

                    x = textInfo.getX()

                    y = textInfo.getY()

                    width = textInfo.getW()

                    height = textInfo.getH()

                    angle = round(math.radians(textInfo.getAngle()))

                    text = textInfo.getText()

                    item = TextItemFactory.instance().createTextItem(textInfo)

                    item.loc = (x, y)

                    item.size = (width, height)

                    item.angle = angle

                    item.area = textInfoMap[0]

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

                    #appDocData.texts.append(item)

                    appDocData.activeDrawing.allItems.append(item)

        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)

    '''

        @date       2019.07.30

            symbols = []

            lines = []

            project = appDocData.getCurrentProject()

                            symbols.append(item)