HYTOS

        @brief      Get drawing file list

        @author     euisung

        @date       2018.09.28

    '''

    def getDrawingFileList(self):

        """

        get drawing files which's extension is .png or jpg from drawing folder

        """

        try:

            project = AppDocData.instance().getCurrentProject()

            path = project.getDrawingFilePath()

            drawingFileList = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f)) and (os.path.splitext(f)[1] == '.png' or os.path.splitext(f)[1] == '.jpg' or os.path.splitext(f)[1] == '.jpeg' or os.path.splitext(f)[1] == '.JPEG' or os.path.splitext(f)[1] == '.PNG')]

            drawingFileList.sort()

        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))

        return drawingFileList

    '''

        @brief      Get Training file list

        @author     euisung

        @date       2018.10.16

    '''

    def getTrainingFileList(self):

        try:

            project = AppDocData.instance().getCurrentProject()

            path = project.getTrainingFilePath()

            drawingFileList = os.listdir(path)

            drawingFileList.sort()

        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)

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

        return drawingFileList

    '''

            # Get a cursor object

            cursor = conn.cursor()

            sqlFiles = ['App.Configuration.sql', 'App.Styles.sql']

            for sqlFile in sqlFiles:

                filePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Scripts', sqlFile)

                try:

                    file = QFile(filePath)

                    file.open(QFile.ReadOnly)

                    sql = file.readAll()

                    sql = str(sql, encoding='utf8')

                    cursor.executescript(sql)

                finally:

                    file.close()

            conn.commit()

        finally:

            # Close the db connection

            conn.close()

        configs = [Config('app', 'mode', 'advanced'), Config('app', 'error origin point', '51,72')]

        self.saveAppConfigs(configs)

        self.makeChildDir()

        self.copySvg()

    '''

        @brief      Copy Svg

        @author     yeonjin

        @date       19.07.31

    '''

    def copySvg(self):

        from shutil import copyfile

        sourceDir = os.path.join(path, 'svg')

        if not os.path.exists(sourceDir): 

            return

        project = AppDocData.instance().getCurrentProject()

        targetDir = project.getSvgFilePath()

        for root, dirs, files in os.walk(sourceDir):

            for file in files: # loops through directories and files

                sourceFile = os.path.join(root, file)

                targetFile = sourceFile.replace(sourceDir, targetDir)

                if not os.path.exists(targetFile):

                    dir = os.path.dirname(targetFile)

                    if not os.path.exists(dir):

                        os.makedirs(dir)

                    copyfile(sourceFile, targetFile)

        @brief      Make Directory

        @author     Jeongwoo

        @date       18.05.08

        @history    humkyung 2018.06.19 make 'Tile' directory

                    humkyung 2018.07.09 make drawing folder if not exists

                    euisung 2018.09.28 make training folder if not exists

    '''

    def makeChildDir(self):

        project = AppDocData.instance().getCurrentProject()

        dbDir = project.getDbFilePath()

        if not os.path.exists(dbDir):

            os.makedirs(dbDir)

        imgDir = project.getImageFilePath()

        if not os.path.exists(imgDir):

            os.makedirs(imgDir)

        svgDir = project.getSvgFilePath()

        if not os.path.exists(svgDir):

            os.makedirs(svgDir)

        outputDir = project.getOutputPath()

        if not os.path.exists(outputDir):

            os.makedirs(outputDir)

        tempDir = project.getTempPath()

        if not os.path.exists(tempDir):

            os.makedirs(tempDir)

        drawingPath = project.getDrawingFilePath()

        if not os.path.exists(drawingPath):

            os.makedirs(drawingPath)

        trainingPath = project.getTrainingFilePath()

        if not os.path.exists(trainingPath):

            os.makedirs(trainingPath)

        path = os.path.join(tempDir, 'Tile')

        if not os.path.exists(path):

            os.makedirs(path)

        borderDir = project.getBorderFilePath()    

        if not os.path.exists(borderDir):

            os.makedirs(borderDir)

    '''

    def deleteDrawingByUID(self, uid):

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            # 0. Delete Points

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

            cursor.execute(sql)

            # 1. Delete HMB

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

            cursor.execute(sql)

            # 2. Delete Components

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

            cursor.execute(sql)

            # 3. Delete DrawingsUnits

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

            cursor.execute(sql)

            # 4. Delete Drawings

            sql = "delete from Drawings where UID='{}'".format(uid)

            cursor.execute(sql)

            conn.commit()

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

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

        finally:

            # Close the db connection

            conn.close()

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath, isolation_level=None)

            # Get a cursor object

            cursor = conn.cursor()

            uid = self.activeDrawing.UID

            if index == 0:

                # 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)

            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])

            conn.commit()

        # Catch the exception

        except Exception as ex:

            from App import App

            # Roll back any change if something goes wrong

            conn.rollback()

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

            print(message)

            print(sql)

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

        finally:

            # Close the db connection

            conn.close()

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            sql = 'select UID,[NAME],[DATETIME] from Drawings'

            cursor.execute(sql)

            rows = cursor.fetchall()

            for row in rows:

                res.append([row[0], row[1], row[2]])

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

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

        finally:

            # Close the db connection

            conn.close()

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            sql = """update Drawings

                        set Name = ?

                          , DateTime = ?

                      where uid = ?"""

            param = (drawing[0][1], drawing[0][2], drawing[0][0])

            cursor.execute(sql, param)

            conn.commit()

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

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

        finally:

            # Close the db connection

            conn.close()

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            sql = 'insert or replace into Drawings(UID, [NAME], [DATETIME]) values(?, ?, ?)'

            param = (drawing[0][0], drawing[0][1], drawing[0][2])

            cursor.execute(sql, param)

            sql = "select Units, Units_UID from DrawingsUnits where drawings_UID = '00000000-0000-0000-0000-000000000000'"

            cursor.execute(sql)

            rows = cursor.fetchall()

            for row in rows:

                sql = """insert or replace into DrawingsUnits

                            (

                                UID

                                , Drawings_UID

                                , Units

                                , Units_UID

                             )

                             values 

                             (

                                ?

                                , ?

                                , ?

                                , ?

                             )"""

                param = (str(uuid.uuid4()), drawing[0][0], row[0], row[1])

            conn.commit()

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

            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)

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

        finally:

            # Close the db connection

            conn.close()

    '''

        @brief  get IsOriginDetect ComboBox Items

    '''

    def getIsOriginDetectComboBoxItems(self):

        return [("원본 도면", 0), ("텍스트 제거 도면", 1)]

    '''

        @brief  get IsOriginDetect ComboBox Items

    '''

    def getOcrOptionComboBoxItems(self):

        return [("OCR 미적용", 0), ("일반 심볼", 1), ("Instrument 계통", 2)]

        try:

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

            cursor = conn.cursor()

            sql = """select c.uid

                          , c.Name

                          , c.Symbols_UID

                          , t.Category

                          , t.type

                          , s.Name

                          , s.OriginalPoint

                          , c.X

                          , c.Y

                          , c.Rotation

                          , c.Scale

                          , p.uid

                          , p.[Index]

                          , p.x

                          , p.y

                          , p.ConnectedItem_UID

                       from points p

                       left join components c

                         on p.components_uid = c.uid

                       left join symbols s

                         on c.Symbols_UID = s.UID    

                       left join SymbolType t

                         on s.symboltype_uid = t.uid

                      where c.uid = ?

                      order by p.[Index]"""

            param = (uid,)                      

        finally:

            conn.close()

    def getComponentListByDrawingUID(self, uid):

        try:

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

            cursor = conn.cursor()

            sql = 'select UID from Components where Drawings_UID = ? order by x desc'

                param = (uid, )

                cursor.execute(sql, param)

        finally:

            conn.close()

    def __init__(self, name):

        self.name = name

        ''' set drawing uid '''

        drawings = app_doc_data.getDrawings()

        drawing = [drawing for drawing in drawings if self.name == os.path.splitext(drawing[1])[0]]

        self.UID = drawing[0][0] if drawing else uuid.uuid4()

        ''' up to here '''

        #self.setWindowTitle(_translate('New Drawing Dialog', 'New Drawing'))

        try:

            appDocData = AppDocData.instance()

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(appDocData.getCurrentProject().getDbFilePath(), App.NAME + '.db')

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            for data in self._hmbs:

                if data.isDeleted == False:

                    cols = ['UID', 'Components_UID', 'Stream_No', 'Phase_Type', 'Flowrate_Mass', 'Flowrate_Volume', 'Density', 'Viscosity',

                            'Temperature', 'Molecular_Weight', 'Specific_Heat_Ratio', 'Compress_Factor', 'Nominal_Pipe_Size', 'Inside_Pipe_Size',

                            'Schedule_No', 'Straight_Length', 'Equivalent_Length', 'Roughness', 'Limitation_Velocity', 'Limitation_Pressure_Drop',

                            'Velocity', 'Reynolds', 'Friction_Factor', 'Pressure_Drop', 'Pressure_Drop_Friction', 'Pressure_Drop_Static', 'Pressure_Pipe_End_Point', 'Power']

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

                    param = (str(data.uid), str(data.components_uid), data.stream_no, data.phase_type, data.flowrate_mass, data.flowrate_volume, data.density,

                             data.viscosity, data.temperature, data.molecular_weight, data.specific_heat_ratio, data.compress_factor, data.nominal_pipe_size,

                             data.inside_pipe_size, data.schedule_no, data.straight_length, data.equivalent_length, data.roughness, data.limitation_velocity,

                             data.limitation_pressure_drop, data.velocity, data.reynolds, data.friction_factor, data.pressure_drop, data.pressure_drop_friction,

                             data.pressure_drop_static, data.pressure_pipe_end_point, data.power)

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

                    cursor.execute(sql, param)

                else:

                    sql = "delete from HMB where uid=?"

                    param = (data.uid,)

                    cursor.execute(sql, param)

            conn.commit()

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

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

        finally:

            # Close the db connection

            conn.close()

                uid = item.text(2)

                appDocData = AppDocData.instance()

                if appDocData.activeDrawing is not None:                    

                    appDocData.activeDrawing = None

                appDocData.deleteDrawingByUID(uid)

        """

        display mouse position of graphics view

        """

            appDocData = AppDocData.instance()

            drawings = appDocData.getDrawings()

            for drawing in drawings:               

                if drawing[1] == 'Template':

                    continue

                QTreeWidgetItem(self.treeWidgetDrawingList.root, [drawing[1], drawing[2], drawing[0] if drawing and drawing[0] else ''])

        """

        @brief      open selected p&id drawing

        @author     humkyung

        @date       18.11.02

        """

        if item.parent() is not None:

            self.load_data(item.text(0))

            appDocData = AppDocData.instance()

            if appDocData.imgName is None or appDocData.activeDrawing is None:

            appDocData.activeDrawing.clearItemList()

                    appDocData.activeDrawing.allItems.append(item)

                        appDocData.texts.append(item)

            count = len(appDocData.activeDrawing.allItems)

            appDocData = AppDocData.instance()

            items = appDocData.activeDrawing.allItems

                    appDocData.saveToDatabase(item, index)         

            drawings = appDocData.getDrawings()

            drawing = [drawing for drawing in drawings if appDocData.imgName == os.path.splitext(drawing[1])[0]]

            if drawing[0]:

                drawing[0][2] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

        project = AppDocData.instance().getCurrentProject()

        borderDir = project.getBorderFilePath()    

        borderFile = os.path.join(borderDir, 'Border.png')

            if not os.path.exists(borderDir):

                os.makedirs(borderDir)

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

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

            appDocData.clear()

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

            appDocData.setImgFilePath(self.path)

            appDocData.activeDrawing = Drawing(appDocData.imgName)            

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

        from DrawingDialog import QDrawingDialog

        dlg = QDrawingDialog(self)

        drawingName = dlg.showDialog()

        if drawingName:

            self.load_data(drawingName)

            appDocData = AppDocData.instance()

                componentInfos = appDocData.getComponentByComponentUID(componentUID)

                            #symbols.append(item)

                            appDocData.symbols.append(item)

# Form implementation generated from reading ui file '.\UI\MainWindow.ui'

        @brief  return training path

        @author euisung

        @date   2018.09.28

    '''

    def getTrainingFilePath(self):

        return self.getPath() + '/Training'

    '''

        symbol = AppDocData.instance().getSymbolByQuery('uid', uid)

        svgFilePath = os.path.join(AppDocData.instance().getCurrentProject().getSvgFilePath(), symbol.getCategory(), symbol.getType(), svgFileName+'.svg')

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

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

                for area in appDocData.getAreaList():

                    if area.contains(pt):

                        item.area = area.name

                        break

            self.makeChildDir()

        @brief      Make Directory

        @author     Jeongwoo

        @date       18.04.??

        @history    18.04.12    Jeongwoo    Add output, temp Directory

    '''

    def makeChildDir(self):

        project = AppDocData.instance().getCurrentProject()

        dbDir = project.getDbFilePath()

        if not os.path.exists(dbDir):

            os.makedirs(dbDir)

        imgDir = project.getImageFilePath()

        if not os.path.exists(imgDir):

            os.makedirs(imgDir)

        svgDir = project.getSvgFilePath()

        if not os.path.exists(svgDir):

            os.makedirs(svgDir)

        outputDir = project.getOutputPath()

        if not os.path.exists(outputDir):

            os.makedirs(outputDir)

        tempDir = project.getTempPath()

        if not os.path.exists(tempDir):

            os.makedirs(tempDir)

    '''

# coding: utf-8

""" This is xml generator module """

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

import symbol

import SymbolBase

import TextInfo as ti

import math

import os

import sys

from AppDocData import AppDocData

ROOT_NODE_NAME = "DWG"

ROOT_DWGNAME_NODE_NAME = "DWGNAME"

ROOT_SIZE_NODE_NAME = "SIZE"

SYMBOL_LIST_NODE_NAME = "SYMBOLS"

TEXT_INFO_LIST_NODE_NAME = "TEXTINFOS"

IMG_LINE_LIST_NODE_NAME = "IMGLINES"

NOTE_TEXT_INFO_LIST_NOTE_NAME = "NOTES"

SCATEGORY_NODE_NAME = "SYMBOL"

SNAME_NODE_NAME = "NAME"

STYPE_NOTE_NAME = "TYPE"

SCLASS_NODE_NAME = "CLASS"

SITEM_NODE_NAME = "ITEM"

SSUB_TEXT = "TEXT"

SSUB_ORIGINAL_POINT = "ORIGINALPOINT"

SSUB_CONNECTION_POINT = "CONNECTIONPOINT"

SSUB_PARENT = "PARENT"

SSUB_CHILD = "CHILD"

SSUB_ANGLE = "ANGLE"

SSUB_START_POINT = "STARTPOINT"

SSUB_SIZE = "SIZE"

LINE_NO_LIST_NODE_NAME = "LINE_NOS"

TEXT_INFO_NODE_NAME = "TEXTINFO"

TTEXT_NODE_NAME = "TEXT"

TTEXT_X_NODE_NAME = "X"

TTEXT_Y_NODE_NAME = "Y"

TTEXT_WIDTH_NODE_NAME = "WIDTH"

TTEXT_HEIGHT_NODE_NAME = "HEIGHT"

TTEXT_ANGLE_NODE_NAME = "ANGLE"

IMG_LINE_NODE_NAME = "IMGLINE"

ISP_NODE_NAME = "START"

IEP_NODE_NAME = "END"

NOTE_TEXT_INFO_NOTE_NAME = "NOTE"

TNOTE_TEXT_NODE_NAME = "TEXT"

TNOTE_TEXT_X_NODE_NAME = "X"

TNOTE_TEXT_Y_NODE_NAME = "Y"

TNOTE_TEXT_WIDTH_NODE_NAME = "WIDTH"

TNOTE_TEXT_HEIGHT_NODE_NAME = "HEIGHT"

TNOTE_TEXT_ANGLE_NODE_NAME = "ANGLE"

LINE_INFOS_NODE_NAME = "LINEINFOS"

LLINE_INFO_NODE_NAME = "LINEINFO"

LLINE_UUID = "UUID"

LLINE_START_POINT_NODE_NAME = "STARTPOINT"

LLINE_END_POINT_NODE_NAME = "ENDPOINT"

LINE_NOS_NODE_NAME = "LINENOS"

TRIM_LINE_NOS_NODE_NAME = "TRIMLINENOS"

UNKNOWNS_NODE_NAME = "UNKNOWNS"

VENDOR_NODE_NAME = "VENDORS"

#END_BREAK = "END_BREAKS"

'''

    @brief  

    @author 

    @date   

    @history    2018.05.25  Jeongwoo    Remove parameter 'imgLineList'

'''

def writeXml(pidName, pidWidth, pidHeight, searchedSymbolList, textInfoList, noteTextInfoList):

    path = os.path.join(AppDocData.instance().getCurrentProject().getTempPath(), pidName + '.xml')

    try:

        xmlData = generateXml(pidName, pidWidth, pidHeight, searchedSymbolList, textInfoList, noteTextInfoList)

        ElementTree(xmlData).write(path)

    except Exception as ex:

        from App import App

        from AppDocData import MessageType

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

        print(message)

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

    return path

'''

    @brief  write output xml

    @author humkyung

    @date   2018.04.23

'''

def writeOutputXml(pidName, pidWidth, pidHeight):

    try:

        path = os.path.join(AppDocData.instance().getCurrentProject().getOutputPath(), pidName + '.xml')

        xmlData = generateOutputXml(pidName, pidWidth, pidHeight)

        ElementTree(xmlData).write(path)

    except Exception as ex:

        from App import App 

        from AppDocData import MessageType

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

        print(message)

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

    return path

'''

    @brief      generate output xml for converter

    @author     humkyung

    @date       2018.04.23

    @history    humkyung 2018.05.02 write equipment node

                humkyung 2018.05.10 write orphan lines

                humkyung 2018.05.16 remove code to write orphan lines and symbols

                humkyung 2018.09.06 write text to xml

'''

def generateOutputXml(pidName, pidWidth, pidHeight):

    appDocData = AppDocData.instance()

    try:

        xml = Element(ROOT_NODE_NAME) # Root Node

        SubElement(xml, ROOT_DWGNAME_NODE_NAME).text = pidName

        SubElement(xml, ROOT_SIZE_NODE_NAME).text = str(pidWidth) + "," + str(pidHeight)

        SubElement(xml, 'UNIT').text = appDocData.getCurrentProject().unit()

        for equipment in appDocData.equipments:

            equipmentNode = Element('EQUIPMENT')

            equipmentNode.append(equipment.toXml())

            xml.append(equipmentNode)

        sortedList = sorted(appDocData.lineNos, key=lambda param:param.text())

        for lineno in sortedList:

            xml.append(lineno.toXml())

        for text in appDocData.texts:

            xml.append(text.toXml())

    except Exception as ex:

        from App import App

        from AppDocData import MessageType

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

        print(message)

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

    return xml

'''

    @history    2018.04.30  Jeongwoo    noteTextInfoList None Check

                2018.05.25  Jeongwoo    Remove parameter 'imgLineList' and Check if variable is None or not

'''

def generateXml(pidName, pidWidth, pidHeight, searchedSymbolList, textInfoList, noteTextInfoList):

    xml = Element(ROOT_NODE_NAME) # Root Node

    SubElement(xml, ROOT_DWGNAME_NODE_NAME).text = pidName

    SubElement(xml, ROOT_SIZE_NODE_NAME).text = str(pidWidth) + "," + str(pidHeight)

    try:

        if searchedSymbolList is not None:

            symbolListNode = Element(SYMBOL_LIST_NODE_NAME) # Symbol List Node

            sortedList = sorted(searchedSymbolList, key=lambda sym:sym.getName())

            for symbol in sortedList:

                node = getSymbolInfoNode(symbol)

                symbolListNode.append(node)

            xml.append(symbolListNode)

        if textInfoList is not None:

            textInfoListNode = Element(TEXT_INFO_LIST_NODE_NAME) # Text Info List Node

            for textInfo in textInfoList:

                node = getTextInfoNode(textInfo)

                textInfoListNode.append(node)

            xml.append(textInfoListNode)

        noteTextInfoListNode = Element(NOTE_TEXT_INFO_LIST_NOTE_NAME)

        if noteTextInfoList is not None:

            for noteTextInfo in noteTextInfoList:

                node = getNoteTextInfoNode(noteTextInfo)

                noteTextInfoListNode.append(node)

        xml.append(noteTextInfoListNode)

    except Exception as ex:

        from App import App

        from AppDocData import MessageType

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

        print(message)

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

    return xml

def getSymbolInfoNode(symbol):

    sName = symbol.getName()

    sSp = symbol.getSp()

    sAngle = symbol.getRotatedAngle()

    sType = symbol.getType()

    sText = symbol.getText()

    sOriginalPoint = symbol.getOriginalPoint()

    sConnectionPoint = symbol.getConnectionPoint()

    sWidth = symbol.getWidth()

    sHeight = symbol.getHeight()

    sBaseSymbol = symbol.getBaseSymbol()

    sAdditionalSymbol = symbol.getAdditionalSymbol()

    sCategoryNode = Element(SCATEGORY_NODE_NAME)

    sNameNode = Element(SNAME_NODE_NAME)

    sNameNode.text = sName

    sTypeNode = Element(STYPE_NOTE_NAME)

    sTypeNode.text = sType

    sOriginalPointNode = Element(SSUB_ORIGINAL_POINT)

    sOpX = sSp[0] + int(sOriginalPoint.split(',')[0])

    sOpY = sSp[1] + int(sOriginalPoint.split(',')[1])

    sOriginalPointNode.text = str(sOpX) + "," + str(sOpY)

    sConnectionPointNode = Element(SSUB_CONNECTION_POINT)