HYTOS

# coding: utf-8

""" This is document data(SDI) class """

import sys

import os

import sqlite3

import datetime

from enum import Enum

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5 import QtWidgets

except ImportError:

    from PyQt4.QtCore import *

    from PyQt4.QtGui import *

import numpy as np

from App import App

from SingletonInstance import SingletonInstane

import symbol

from NominalPipeSize import NominalPipeSize

class Source:

    def __init__(self, source):

        if type(source) is np.ndarray:

            self.source = Image.fromarray(source)

        elif type(source) is PngImagePlugin.PngImageFile or type(source) is JpegImagePlugin.JpegImageFile:

            self.source = source

        elif type(source) is QImage:

            self.source = Image.fromqimage(source)

        elif type(source) is QPixmap:

            self.source = Image.fromqpixmap(source)

    '''

        @history    2018.05.18  Jeongwoo    When Parameter [rect] is None, return whole image

    '''

    def getPyImageOnRect(self, rect = None):

        if rect is not None:

            return self.source.copy().crop((rect.left(), rect.top(), rect.right(), rect.bottom()))

        else:

            return self.source.copy()

    def getQImageOnRect(self, rect = None):

        image = ImageQt(self.getPyImageOnRect(rect))

        return image.convertToFormat(QImage.Format_RGBA8888)

class Config:

    def __init__(self, section, key, value):

        self.section = section

        self.key = key

        self.value = value

'''

    @brief      MessageType

    @author     humkyung 

    @date       2018.07.31

'''

class MessageType(Enum):

    Normal = 1

    Error = 2

class AppDocData(SingletonInstane):

    def __init__(self):

        from DisplayColors import DisplayColors

        self._imgFilePath = None

        self.imgName = None

        self.imgWidth = 0

        self.imgHeight = 0

        self._OCRData = None

        self._areas = []

        self.equipments = []

        self.lineNos = []

        self.lines = []

        self.texts = []

        self.symbols = []

        self.unknowns = []

        self.tracerLineNos = []

        self.lineIndicators = []

        self._colors = None

        self._lineNoProperties = None

        self._lineTypes = None

        self._lineTypeConfigs = None

        self._activeDrawing = None

        self._titleBlockProperties = None

        self.needReOpening = None

        self.configTable = None

    def clearItemList(self, trim):

        '''

            @brief      clear item list

            @author     euisung

            @date       2018.11.28

        '''

        self.equipments.clear()

        self.symbols.clear()

        self.lineNos.clear()

        self.texts.clear()

        self.lines.clear()

        self.unknowns.clear()

        self.lineIndicators.clear()

        if trim:

            self.tracerLineNos.clear()

    '''

        @brief      clear

        @author     humkyung

        @date       2018.09.06

    '''

    def clear(self):

        self._imgFilePath = None

        self.imgName = None

        self.imgWidth = 0

        self.imgHeight = 0

        self._areas.clear()

        self.equipments.clear()

        self.lineNos.clear()

        self.lines.clear()

        self.texts.clear()

        self.symbols.clear()

        self.unknowns.clear()

        self.tracerLineNos.clear()

        self.lineIndicators.clear()

        self._colors = None

        self._lineNoProperties = None

        self._lineTypeConfigs = None

        self._activeDrawing = None

        self._titleBlockProperties = None

    '''

        @brief      Get DB file path in ProgramData

        @author     Jeongwoo

        @date       2018.06.27

        @history    2018.06.29  Jeongwoo    Change method to get template db path

    '''

    def getTemplateDbPath(self):

        path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)

        templateDbPath = os.path.join(path, 'Template.db')

        return templateDbPath

    def getAppDbPath(self):

        """

        @brief      Get application DB file path in ProgramData

        @author     humkyung

        @date       2018.10.01

        """

        path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)

        app_database = os.path.join(path, 'App.db')

        return app_database 

    '''

        @brief  build application database

        @author humkyung

        @date   2018.04.20

    '''

    def buildAppDatabase(self):

        try:

            path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)

            appDatabaseFilePath = os.path.join(path, 'App.db')

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

            conn = sqlite3.connect(appDatabaseFilePath)

            with conn:

                # Get a cursor object

                cursor = conn.cursor()

                sqlFiles = ['App.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()

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

    '''

        @brief  load app style

        @author humkyung

        @date   2018.04.20

    '''

    def loadAppStyle(self):

        style = 'Fusion'

        return style

    @property

    def border_file_path(self):

        """ return border file path """

        path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)

        return os.path.join(path, 'Border.png')

    @property

    def symbol_file_path(self):

        """ return svg symbol file path """

        path = os.path.join(os.getenv('ALLUSERSPROFILE'), App.NAME)

        return os.path.join(path, 'svg')

    def getRoughness(self):

        res = []

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            try:

                conn.row_factory = sqlite3.Row

                # Get a cursor object

                cursor = conn.cursor()

                sql = "select UID, Material, Meter, Inch, Feet, Milimeter from Roughness" 

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:                

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

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

        return res

    def getInsideDiameter(self, nominaldiameter_uid, schedule_uid):

        res = []

        try:

            db = sqlite3.connect(self.activeDrawing.path)

            # Get a cursor object

            cursor = db.cursor()

            sql = """select UID

                          , Milimeter

                          , Inch 

                       from InsideDiameter

                      where NominalDiameter_UID = ?

                        and Schedule_UID = ?"""

            param = (nominaldiameter_uid, schedule_uid)

            cursor.execute(sql, param)

            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

            db.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

            db.close()

        return res

    def getSchedule(self):

        res = []

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = "select UID, No from Schedule" 

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:                

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

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

        return res

    def getNominalDiameter(self):        

        res = []

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

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = "select UID, Milimeter, Inch from NominalDiameter" 

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

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

        return res

    def getAppConfigs(self, section, key=None):

        """

            @brief  get application configurations

            @author humkyung

            @date   2018.11.01

        """

        res = []

        try:

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

            dbPath = self.getAppDbPath()

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            if key is not None:

                sql = "select * from configuration where section=? and key=?"

                param = (section, key)

            else:

                sql = "select * from configuration where section=?"

                param = (section,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:

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

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

        return res

    def saveAppConfigs(self, configs):

        """

        @brief      save application configurations

        @author     humkyung

        @date       2018.10.01

        """

        try:

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

            dbPath = self.getAppDbPath()

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            for config in configs:

                value = config.value

                if type(value) is str and "'" in value:

                    value = value.replace("'", "''")

                sql = "insert or replace into configuration values(?,?,?)"

                param = (config.section, config.key, value)

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

    def initializeDataByDrawingUID(self, uid):

        try:

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

            conn = sqlite3.connect(self.activeDrawing.path)

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

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

    def deleteDrawingByName(self, drawingName):

        """ delete given drawing """

        conn = sqlite3.connect(self.getAppDbPath())

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = 'delete from Drawings where Name=?'

                param = (drawingName,)

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

    def deleteAppConfigs(self, section, key=None):

        """

        @brief  delete application configurations

        @author humkyung

        @date   2018.11.01

        """

        try:

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

            dbPath = self.getAppDbPath()

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            if key is not None:

                sql = "delete from configuration where section='{}' and key='{}'".format(section, key)

            else:

                sql = "delete from configuration where section='{}'".format(section)

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

    '''

        @brief  get symbol name

        @history    18.04.24    Jeongwoo    Add isExceptDetect Field

    '''

    def getSymbolByQuery(self, fieldName, param):

        ret = None

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            cursor = conn.cursor()

            sql = """select s.UID

                            , s.Name

                            , t.Category

                            , t.Type

                            , s.OriginalPoint

                            , s.ConnectionPoint

                        from Symbols s

                        inner join SymbolType t

                            on s.SymbolType_UID = t.UID 

                        where """ + "s." + fieldName + '=?'

            try:

                cursor.execute(sql, (param,))

                rows = cursor.fetchall()

                if rows is not None and len(rows) > 0:

                    symbolTuple = rows[0]

                    ret = symbol.SymbolBase(symbolTuple[0], symbolTuple[1], symbolTuple[2], symbolTuple[3], symbolTuple[4], symbolTuple[5]) 

            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 ret

    def getSymbolListByUID(self, uid):

        """ get symbol list by given uid """

        ret = []

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            cursor = conn.cursor()

            sql = """select s.UID

                            , s.Name

                            , t.Category

                            , t.Type

                            , s.OriginalPoint

                            , s.ConnectionPoint

                        from Symbols s

                        inner join SymbolType t

                            on s.SymbolType_UID = t.uid 

                        where s.SymbolType_UID = ?"""

            try:

                cursor.execute(sql, (uid,))

                rows = cursor.fetchall()

                if rows is not None and len(rows) > 0:

                    for row in rows:

                        sym = symbol.SymbolBase(row[0], row[1], row[2], row[3], row[4], row[5])

                        ret.append(sym)

            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 ret

    def getResistanceCoefficientByMethod(self, method):

        res = []

        try:

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

            dbPath = os.path.join(self.activeDrawing.path)

            db = sqlite3.connect(dbPath)

            db.row_factory = sqlite3.Row

            # Get a cursor object

            cursor = db.cursor()

            sql = """select UID

                          , Method

                          , Category

                          , Type

                          , Name

                          , K 

                       from ResistanceCoefficient 

                      where Method = ?

                      order by rowid""" 

            param = (method,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:                

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

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            db.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

            db.close()

        return res

    '''

        @brief      save to database

        @author     yjkim

        @date       2019.08.28

    '''

    def saveToDatabase(self, item, index):

        """ save given items to database """

        conn = sqlite3.connect(self.activeDrawing.path, isolation_level=None)

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                if index == 0:

                    # delete Points

                    sql = 'delete from Points'

                    cursor.execute(sql)

                    # delete HMB

                    sql = 'delete from HMB'

                    cursor.execute(sql)

                    # delete Components 

                    sql = 'delete from Components'

                    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)

    def getDrawings(self):

        """

        @brief      get drawings

        @author     humkyung

        @date       2018.11.03

        """

        from Drawing import Drawing

        res = []

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

        dbPath = self.getAppDbPath()

        conn = sqlite3.connect(dbPath)

        with conn:

            try:

                conn.row_factory = sqlite3.Row

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

        return res

    '''

        @brief      update drawings

        @author     yeonjin

        @date       2019.08.07

    '''

    def updateDrawing(self, drawing):

        import uuid

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

        dbPath = self.getAppDbPath()

        conn = sqlite3.connect(dbPath)

        with conn:

            try:

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

    '''

        @brief      save drawings

        @author     humkyung

        @date       2018.11.03

    '''

    def saveDrawing(self, drawing):

        import uuid

        from shutil import copyfile       

        conn = sqlite3.connect(self.getAppDbPath())

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

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

                param = (drawing.UID, drawing.path, drawing.date_time)

                cursor.execute(sql, param)

                conn.commit()

                if not os.path.exists(drawing.path): copyfile(self.getTemplateDbPath(), drawing.path)

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

    '''

        @brief      Return Symbol Category Items

        @author     yeonjin

        @date       19.07.11

    '''

    def getSymbolCategoryList(self):

        SymbolCategoryList = []

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            cursor = conn.cursor()

            sql = 'SELECT DISTINCT CATEGORY FROM SymbolType ORDER BY type ASC'

            try:

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    SymbolCategoryList.append((row[0])) # category

            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 SymbolCategoryList

    def getComponentByComponentUID(self, uid):

        ComponentList = []

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            try:

                conn.row_factory = sqlite3.Row

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

                cursor.execute(sql, param)

                rows = cursor.fetchall()

                for row in rows:

                    data = []

                    for index in range(len(cursor.description)):

                        data.append(row[index])

                    ComponentList.append(data) # Components_UID

            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 ComponentList

    def get_nozzle_data(self, uid):

        """ get nozzle data of given uid """

        from EngineeringConnectorItem import NozzleData

        res = None

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            conn.row_factory = sqlite3.Row

            cursor = conn.cursor()

            sql = 'select Pressure, Pressure_Drop, Elevation, Over_Design_CV from Nozzles where Points_UID=?' 

            param = (uid, )

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            if rows:

                res = NozzleData()

                if rows[0]['Pressure']:

                    res.pressure = float(rows[0]['Pressure'])

                if rows[0]['Pressure_Drop']:

                    res.pressure_drop = float(rows[0]['Pressure_Drop'])

                if rows[0]['Elevation']:

                    res.elevation = float(rows[0]['Elevation'])

                if rows[0]['Over_Design_CV']:

                    res.over_design_cv = float(rows[0]['Over_Design_CV'])

        return res

    def getDrawingsUnitsByDrawingUID(self, drawing):

        """ get units of drawing """

        unitsList = []

        conn = sqlite3.connect(drawing.path)

        with conn:

            cursor = conn.cursor()

            sql = 'select du.Units, u.Value from DrawingsUnits du \

                                                 left join units u on du.Units_UID = u.uid'

            try:

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    unitsList.append((row[0], row[1])) 

            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 unitsList

    '''

        @brief      Return Components By DrawingUID

        @author     yeonjin

        @date       19.07.29

    '''

    def getComponentListByDrawingUID(self, drawing):

        ComponentList = []

        conn = sqlite3.connect(drawing.path)

        with conn:

            try:

                conn.row_factory = sqlite3.Row

                cursor = conn.cursor()

                sql = 'select UID from Components order by x desc'

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    ComponentList.append((row[0])) # Components_UID

            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 ComponentList

    '''

        @brief      Return Symbol Type Items By Category

        @author     yeonjin

        @date       19.07.11

    '''

    def getSymbolTypeListByCategory(self, category):

        symbolTypeList = []

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            cursor = conn.cursor()

            sql = 'SELECT UID, Category, Type FROM SymbolType WHERE Category = "' + category + '"'

            try:

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    symbolTypeList.append((row[0], row[1], row[2])) # UID, Category, Type

            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 symbolTypeList

    def getUnits(self):

        unitsList = []

        try:            

            conn = sqlite3.connect(self.activeDrawing.path)

            cursor = conn.cursor()

            sql = 'Select UID, Key, Value From Units'

            try:

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    unitsList.append((row[0], row[1], row[2])) # UID, Key, Value

            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)

        finally:

            conn.close()

        return unitsList

    def getHMBDisplayNameAndUnitsExpression(self):

        res = []

        if self.activeDrawing:

            conn = sqlite3.connect(self.activeDrawing.path)

            with conn:

                cursor = conn.cursor()

                sql = """SELECT dn.DISPLAY_NAME

                                , hu.Units_Expression

                            FROM DisplayNames dn

                            left join HMBUnits hu

                                on dn.COLUMN_NAME = Hu.Column_Name

                            where dn.Table_Name = 'HMB'

                            order by dn.[Order]"""    

                try:

                    cursor.execute(sql)  

                    rows = cursor.fetchall()

                    for row in rows:

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

                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 res

    '''

        @brief      Get Symbol Category by Symbol Type

        @author     Jeongwoo

        @date       2018.05.09

    '''

    def getSymbolCategoryByType(self, type):

        category = None

        conn = sqlite3.connect(self.activeDrawing.path)

        with conn:

            try:

                cursor = conn.cursor()

                sql = 'SELECT Category FROM SymbolType WHERE type = "' + type + '"'

                cursor.execute(sql)

                rows = cursor.fetchall()

                if rows is not None and len(rows) > 0:

                    category = rows[0][0]

            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 category

    '''

        @brief  getter of activeDrawing

        @author humkyung

        @date   2018.07.07

    '''

    @property

    def activeDrawing(self):

        return self._activeDrawing

    '''

        @brief  setter of activeDrawing

        @author humkyung

        @date   2018.07.07

    '''

    @activeDrawing.setter

    def activeDrawing(self, value):

        self._activeDrawing = value