HYTOS

# coding: utf-8

""" This is ItemDataExportDialog module """

import os

import sys

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from AppDocData import AppDocData, Config

from openpyxl import *

from openpyxl.styles import *

import ItemDataExport_UI

# all view, list order, table : 0 Line, 1 Equipment, 2 Valve, 3 Instrument, 4 Note

dbListOrderName = ['LINE_DATA_LIST_EXPORT_ORDER', 'EQUIPMENT_DATA_LIST_EXPORT_ORDER', 'VALVE_DATA_LIST_EXPORT_ORDER',

                   'INSTRUMENT_DATA_LIST_EXPORT_ORDER', 'NOTE_DATA_LIST_EXPORT_ORDER']

class QItemDataExportDialog(QDialog):

    """ This is QItemDataExportDialog class """

    DATA_LIST = ['LINE_DATA_LIST', 'EQUIPMENT_DATA_LIST', 'VALVE_DATA_LIST', 'INSTRUMENT_DATA_LIST', 'NOTE_DATA_LIST',

                 'SPECIAL_ITEMS']

    def __init__(self, parent):

        QDialog.__init__(self, parent)

        self.setWindowFlag(Qt.WindowMinMaxButtonsHint)

        try:

            QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))

            self.delimiter = '!-!'

            self.delimiterCombine = '!@!'

            self.emptyCol = 'Empty Column'

            self.initialTables = []

            self.sceneLineData = {}

            self.sceneEquipData = {}

            self.scene_valve_data = {}

            self.sceneInstData = {}

            self.sceneNoteData = {}

            self.lineColumnListAll = []

            self.equipColumnListAll = []

            self.valveColumnListAll = []

            self.instColumnListAll = []

            self.noteColumnListAll = []

            self.columnListAll = \

                {

                    QItemDataExportDialog.DATA_LIST[0]: self.lineColumnListAll,

                    QItemDataExportDialog.DATA_LIST[1]: self.equipColumnListAll,

                    QItemDataExportDialog.DATA_LIST[2]: self.valveColumnListAll,

                    QItemDataExportDialog.DATA_LIST[3]: self.instColumnListAll,

                    QItemDataExportDialog.DATA_LIST[4]: self.noteColumnListAll,

                    QItemDataExportDialog.DATA_LIST[5]: []

                }

            self.lineOrder = []

            self.equipOrder = []

            self.valveOrder = []

            self.instOrder = []

            self.noteOrder = []

            self.columnOrder = \

                {

                    QItemDataExportDialog.DATA_LIST[0]: self.lineOrder,

                    QItemDataExportDialog.DATA_LIST[1]: self.equipOrder,

                    QItemDataExportDialog.DATA_LIST[2]: self.valveOrder,

                    QItemDataExportDialog.DATA_LIST[3]: self.instOrder,

                    QItemDataExportDialog.DATA_LIST[4]: self.noteOrder,

                    QItemDataExportDialog.DATA_LIST[5]: []

                }

            self.parent = parent

            self.ui = ItemDataExport_UI.Ui_ItemDataExportDialog()

            self.ui.setupUi(self)

            header = self.ui.tableWidgetDrawing.horizontalHeader()

            header.setSectionResizeMode(0, QHeaderView.ResizeToContents)

            # line no table setting combobox column

            self.nominalDiameterList = []

            self.fluidCodeList = []

            self.insulationPurposeList = []

            self.pipingMaterialClassList = []

            self.initLineNoAttrData()

            self.lineNoTableComboBoxDic = {}

            self.lineNoTableComboBoxDic[1] = self.nominalDiameterList

            self.lineNoTableComboBoxDic[2] = self.fluidCodeList

            self.lineNoTableComboBoxDic[4] = self.pipingMaterialClassList

            self.lineNoTableComboBoxDic[7] = self.fluidCodeList

            self.lineNoTableComboBoxDic[16] = self.insulationPurposeList

            try:

                self.init_drawings()

                self.viewTables = \

                    {

                        QItemDataExportDialog.DATA_LIST[0]: self.ui.tableWidgetLineDataList,

                        QItemDataExportDialog.DATA_LIST[1]: self.ui.tableWidgetEquipmentDataList,

                        QItemDataExportDialog.DATA_LIST[2]: self.ui.tableWidgetValveDataList,

                        QItemDataExportDialog.DATA_LIST[3]: self.ui.tableWidgetInstrumentDataList,

                        QItemDataExportDialog.DATA_LIST[4]: self.ui.tableWidgetNoteDataList,

                        QItemDataExportDialog.DATA_LIST[5]: self.ui.tableWidgetSpecialItems

                    }

                self.initTableWidget()

            except Exception as ex:

                from App import App

                from AppDocData import MessageType

                message = 'error occurred({}) 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 None

            # event connect

            self.ui.pushButtonItemDataFormat.clicked.connect(self.show_item_data_format_dialog)

            self.ui.pushButtonQuery.clicked.connect(self.query_engineering_list)

            self.ui.pushButtonExport.clicked.connect(self.save_excel)

            self.ui.pushButtonClose.clicked.connect(self.pushButtonCloseClicked)

            self.ui.pushButtonSelectAll.clicked.connect(self.select_all)

            self.ui.pushButtonUnSelectAll.clicked.connect(self.unselect_all)

        finally:

            QApplication.restoreOverrideCursor()

    @property

    def checked_drawings(self):

        """return checked drawings"""

        res = []

        for row in range(self.ui.tableWidgetDrawing.rowCount()):

            item = self.ui.tableWidgetDrawing.item(row, 0)

            if Qt.Checked == item.checkState():

                res.append(item.text())

        return res

    '''

        @brief      dialog close

        @author     euisung

        @date       2018.10.29

    '''

    def pushButtonCloseClicked(self):

        QDialog.reject(self)

    '''

        @brief      setting commbobox Data

        @author     kyouho

        @date       2018.08.16

    '''

    def initLineNoAttrData(self):

        docData = AppDocData.instance()

        lineProps = docData.getLineProperties()

        for prop in lineProps:

            if prop.AttributeType == 'Code Table':

                tableName = prop.Attribute.upper().replace(' ', '')

                if tableName == 'NOMINALDIAMETER':

                    self.nominalDiameterList = docData.getCodeTable(tableName, True)

                elif tableName == 'FLUIDCODE':

                    self.fluidCodeList = docData.getCodeTable(tableName, True)

                elif tableName == 'INSULATIONPURPOSE':

                    self.insulationPurposeList = docData.getCodeTable(tableName, True)

                elif tableName == 'PIPINGMATERIALSCLASS':

                    self.pipingMaterialClassList = docData.getCodeTable(tableName, True)

    def save_excel(self):

        """save engineering list to excel"""

        appDocData = AppDocData.instance()

        project = appDocData.getCurrentProject()

        options = QFileDialog.Options()

        options |= QFileDialog.DontUseNativeDialog

        fileName = QFileDialog.getSaveFileName(self, "Save xlsx file", project.path, "xlsx files(*.xlsx)",

                                               options=options)

        if fileName == ('', ''):

            return

        QApplication.setOverrideCursor(Qt.WaitCursor)

        try:

            wb = Workbook()

            wb.active.title = self.tr(self.ui.tabWidget.tabText(0))

            for i in range(1, self.ui.tabWidget.count()):

                wb.create_sheet(self.tr(self.ui.tabWidget.tabText(i)))

            for index in range(self.ui.tabWidget.count()):

                self.qtable_to_sheet(self.viewTables[QItemDataExportDialog.DATA_LIST[index]], wb.worksheets[index],

                                     index)

            fileName, ext = os.path.splitext(fileName[0])

            wb.save(fileName + ext if ext.upper() == '.XLSX' else fileName + '.xlsx')

            QMessageBox.about(self, self.tr("Information"), self.tr('Successfully saved.'))

            command = os.path.join(project.path, fileName + '.xlsx')

            os.startfile(command)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(repr(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:

            QApplication.restoreOverrideCursor()

    '''

        @brief      save excel

        @author     kyouho

        @date       2018.08.16

        @history    2018.10.26  euisung     export order apply

    '''

    def qtable_to_sheet(self, table, sheet, index):

        try:

            key = QItemDataExportDialog.DATA_LIST[index]

            self.set_sheet_header(table, sheet, key)

            self.set_sheet_data(table, sheet, key)

            self.auto_resize_columns(sheet)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

    def set_sheet_header(self, table, sheet, index):

        """ set list header """

        try:

            thin = Side(border_style='thin', color='000000')

            border = Border(left=thin, right=thin, top=thin, bottom=thin)

            _col = 1

            for col in range(table.columnCount()):

                logical_index = table.horizontalHeader().logicalIndex(col)

                col_name = table.horizontalHeaderItem(logical_index).text()

                if table.isColumnHidden(logical_index): continue

                sheet.cell(1, _col, col_name)

                sheet.cell(row=1, column=_col).alignment = Alignment(horizontal='center', vertical='center',

                                                                     wrapText=True)

                sheet.cell(row=1, column=_col).fill = PatternFill(patternType='solid', fill_type='solid',

                                                                  fgColor=Color('8DB4E2'))

                sheet.cell(row=1, column=_col).border = border

                _col += 1

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

    def set_sheet_data(self, table, sheet, index):

        """ write list data to sheet """

        try:

            thin = Side(border_style='thin', color='000000')

            border = Border(left=thin, right=thin, top=thin, bottom=thin)

            for rowIndex in range(table.rowCount()):

                _col = 1

                for col in range(table.columnCount()):

                    logical_index = table.horizontalHeader().logicalIndex(col)

                    if table.isColumnHidden(logical_index): continue

                    widgetItem = table.cellWidget(rowIndex, logical_index)

                    if widgetItem is None:

                        data = table.item(rowIndex, logical_index).text() if table.item(rowIndex,

                                                                                        logical_index) is not None else ''

                    else:

                        data = widgetItem.currentText() if widgetItem.currentIndex() >= 0 else ''

                    sheet.cell(rowIndex + 2, _col, data)

                    sheet.cell(row=rowIndex + 2, column=_col).border = border

                    _col += 1

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

    def auto_resize_columns(self, sheet):

        """ auto resize columns with contents """

        from openpyxl.utils import get_column_letter

        try:

            for col in sheet.columns:

                max_length = 0

                column = col[0].column  # Get the column name

                for cell in col:

                    try:  # Necessary to avoid error on empty cells

                        if len(str(cell.value)) > max_length:

                            max_length = len(cell.value)

                    except:

                        pass

                adjusted_width = (max_length + 2) * 1.2

                sheet.column_dimensions[get_column_letter(column) if type(column) is int else column].width = adjusted_width

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

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

    def init_drawings(self):

        """initialize drawing list"""

        app_doc_data = AppDocData.instance()

        documentNameList = []

        documentNameData = app_doc_data.get_document_name_list()

        documentNameList.extend(documentNameData)

        self.ui.tableWidgetDrawing.setColumnCount(1)

        self.ui.tableWidgetDrawing.setRowCount(len(documentNameData))

        index = 0

        for name in documentNameData:

            item = QTableWidgetItem(name)

            item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)

            item.setCheckState(Qt.Unchecked)

            self.ui.tableWidgetDrawing.setItem(index, 0, item)

            index += 1

        if not self.parent.graphicsView.hasImage():

            return

    '''

        @brief      init table widget

        @author     kyouho

        @date       2018.08.13

        @history    Euisung 2018.10.23 add list export order in db

                    Euisung 2018.10.24 add list sorting process with export order in db

                    Euisung 2018.10.25 add initial list saving process

    '''

    def initTableWidget(self):

        from SpecialItemTypesDialog import SpecialItemTypes

        app_doc_data = AppDocData.instance()

        special_item_types = SpecialItemTypes.instance()

        self.lineColumnListAll = ['UID', 'Drawing Name']

        self.lineColumnListAll.extend([prop.Attribute for prop in app_doc_data.getLineProperties()])

        self.lineColumnListAll = self.add_hmb_header(self.lineColumnListAll)

        self.equipColumnListAll = ['UID', 'ITEM_NO']

        self.equipColumnListAll.extend([prop.Attribute for prop in app_doc_data.get_equipment_attributes()])

        self.equipColumnListAll.append('Drawing Name')

        self.valveColumnListAll = ['UID', 'ITEM_NO']

        self.valveColumnListAll.extend([prop.Attribute for prop in app_doc_data.get_valve_attributes()])

        self.valveColumnListAll.append('Drawing Name')

        self.instColumnListAll = ['UID', 'ITEM_NO']

        self.instColumnListAll.extend([prop.Attribute for prop in app_doc_data.get_instrument_attributes()])

        self.instColumnListAll = self.add_hmb_header(self.instColumnListAll)

        self.instColumnListAll.append('Drawing Name')

        self.noteColumnListAll = ['UID', 'ITEM_NO']

        self.noteColumnListAll.extend([prop.Attribute for prop in app_doc_data.get_note_attributes()])

        self.noteColumnListAll.append('Drawing Name')

        self.columnListAll.clear()

        self.columnListAll[QItemDataExportDialog.DATA_LIST[0]] = self.lineColumnListAll

        self.columnListAll[QItemDataExportDialog.DATA_LIST[1]] = self.equipColumnListAll

        self.columnListAll[QItemDataExportDialog.DATA_LIST[2]] = self.valveColumnListAll

        self.columnListAll[QItemDataExportDialog.DATA_LIST[3]] = self.instColumnListAll

        self.columnListAll[QItemDataExportDialog.DATA_LIST[4]] = self.noteColumnListAll

        self.columnListAll[QItemDataExportDialog.DATA_LIST[5]] = ['UID', 'Line No'] + [code['Code'] for code in

                                                                                       special_item_types.values]

        # 엑셀 추출시 사용할 리스트 오더를 db에서 읽거나 없으면 db에 추가

        try:

            configs = []

            for data in QItemDataExportDialog.DATA_LIST:

                self.columnOrder[data] = app_doc_data.getConfigs('Order', data)

                if len(self.columnOrder[data]) is 0:  # use column name if setting does not exit

                    if data == 'LINE_DATA_LIST':

                        value = ''

                        for prop in app_doc_data.getLineProperties():

                            value += (prop.Attribute + self.delimiterCombine + prop.Attribute + self.delimiter)

                        value = value[:-len(self.delimiter)]

                        config = Config('Order', data, value)

                        configs.append(config)

                        self.columnOrder[data] = [config]

                    else:

                        value = ''

                        for col in self.columnListAll[data]:

                            value += (col + self.delimiterCombine + col + self.delimiter)

                        value = value[:-len(self.delimiter)]

                        config = Config('Order', data, value)

                        configs.append(config)

                        self.columnOrder[data] = [config]

            app_doc_data.saveConfigs(configs)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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 None

        try:

            for key in self.viewTables.keys():

                # set table column count

                self.viewTables[key].setColumnCount(len(self.columnListAll[key]))

                # Table Header Label 설정

                self.viewTables[key].setHorizontalHeaderLabels(self.columnListAll[key])

                # Table Header 크기 설정

                for col in range(len(self.columnListAll[key])):

                    self.viewTables[key].horizontalHeaderItem(col).setSizeHint(QSize(25, 25))

                    self.viewTables[key].setColumnWidth(col, len(self.columnListAll[key][col]) * 8 + 10)

                # UID column hide

                self.viewTables[key].hideColumn(0)

                self.viewTables[key].setSortingEnabled(True)

            self.sortListOrder()

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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      sort columns

        @author     humkyung 

    '''

    def sortListOrder(self):

        try:

            docData = AppDocData.instance()

            for key in self.viewTables.keys():

                config = docData.getConfigs('Order', key)

                if not config:

                    continue

                orders = docData.getConfigs('Order', key)[0].value.split(self.delimiter)

                headers = []

                for col in range(len(orders)):

                    header = orders[col].split(self.delimiterCombine)

                    headers.append(header)

                for header in headers:

                    if header[0] == self.emptyCol:

                        count = self.viewTables[key].columnCount()

                        self.viewTables[key].setColumnCount(count + 1)

                        item = QTableWidgetItem(header[1])

                        self.viewTables[key].setHorizontalHeaderItem(count, item)

                col = 0

                for header in headers:

                    if header[0] != self.emptyCol:

                        matches = [index for index in range(self.viewTables[key].columnCount()) if

                                   header[0] == self.viewTables[key].horizontalHeaderItem(index).text()]

                    else:

                        matches = [index for index in range(self.viewTables[key].columnCount()) if

                                   header[1] == self.viewTables[key].horizontalHeaderItem(index).text()]

                    if matches:

                        item = self.viewTables[key].horizontalHeaderItem(matches[0])

                        item.setText(header[1])  # display user column name

                        item.setData(Qt.UserRole, header[0])

                        _from = self.viewTables[key].horizontalHeader().visualIndex(matches[0])

                        self.viewTables[key].horizontalHeader().moveSection(_from, col)

                    col = col + 1

                # hide unselected columns by user

                for col in range(self.viewTables[key].columnCount()):

                    matches = [col for header in headers if

                               header[1] == self.viewTables[key].horizontalHeaderItem(col).text()]

                    if not matches:

                        self.viewTables[key].hideColumn(col)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

    def add_hmb_header(self, header_list):

        ''' add hmb data header '''

        app_doc_data = AppDocData.instance()

        hmb_datas = app_doc_data.get_hmb_data(None)

        names = ['PHASE']

        if hmb_datas:

            for data in hmb_datas[0].data:

                if data.name not in names:

                    names.append(data.name)

                    names.append(data.name + '_min')

                    names.append(data.name + '_max')

        header_list.extend(names)

        return header_list

    def add_hmb_data(self, hmb_datas, dataList):

        ''' add hmb data dependon stream no '''

        dataList_backup = dataList.copy()

        try:

            names = []

            if hmb_datas:

                for data in hmb_datas[0].data:

                    if data.name not in names:

                        names.append(data.name)

            else:

                return dataList

            for data in dataList:

                matches = [key for key in data.keys() if key == 'Stream No']

                if matches and data[matches[0]] != '' and data[matches[0]] != 'None':

                    stream_no = data[matches[0]]

                    matches = [hmb_data for hmb_data in hmb_datas if hmb_data.stream_no == stream_no]

                    if matches:

                        hmb_data = matches[0]

                        phase = hmb_data.phase

                        if phase and phase == 'Two':

                            phase = 'LIQUID'

                        elif not phase:

                            continue

                        data['PHASE'] = phase

                        datas = hmb_data.data

                        for name in names:

                            matches = [data for data in datas if data.name == name and data.phase == phase]

                            if matches:

                                value = matches[0].value

                                value_max = matches[0].value_max

                                value_min = matches[0].value_min

                                data[name] = value

                                data[name + '_min'] = value_min

                                data[name + '_max'] = value_max

                            else:

                                matches = [data for data in datas if data.name == name]

                                if matches:

                                    value = matches[0].value

                                    value_max = matches[0].value_max

                                    value_min = matches[0].value_min

                                    data[name] = value

                                    data[name + '_min'] = value_min

                                    data[name + '_max'] = value_max

            return dataList

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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 dataList_backup

    def set_line_list_data(self):

        pass

    '''

        @brief      setting line data

        @author     kyouho

        @date       2018.08.13

    '''

    def set_line_data(self):

        lineTable = self.ui.tableWidgetLineDataList

        docData = AppDocData.instance()

        # 기존 저장된 데이터 불러옴

        drawings = self.checked_drawings

        dataList = docData.get_line_data_list(drawings if drawings else None)

        lineTable.setRowCount(len(dataList))

        row = 0

        for data in dataList:

            for col in range(self.ui.tableWidgetLineDataList.columnCount()):

                col_item = self.ui.tableWidgetLineDataList.horizontalHeaderItem(col)

                matches = [value for value in data if value[0] == col_item.data(Qt.UserRole)]

                if matches:

                    item = QTableWidgetItem(matches[0][1] if matches[0][1] is not None else '')

                    item.setFlags(Qt.ItemIsEnabled)

                    lineTable.setItem(row, col, item)

            row += 1

    def set_equipment_data(self):

        """fill equipment data"""

        try:

            equipTable = self.ui.tableWidgetEquipmentDataList

            app_doc_data = AppDocData.instance()

            # 기존 저장된 데이터 불러옴

            drawings = self.checked_drawings

            dataList = app_doc_data.get_equipment_data_list(drawings if drawings else None)

            equipTable.setRowCount(len(dataList))

            row = 0

            for data in dataList:

                for col in range(equipTable.columnCount()):

                    col_item = equipTable.horizontalHeaderItem(col)

                    matches = [value for value in data if value[0] == col_item.data(Qt.UserRole)]

                    if matches:

                        item = QTableWidgetItem(matches[0][1] if matches[0][1] is not None else '')

                        item.setFlags(Qt.ItemIsEnabled)

                        equipTable.setItem(row, col, item)

                row += 1

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

    def set_valve_data(self):

        """setting valve data"""

        try:

            valve_table = self.ui.tableWidgetValveDataList

            docData = AppDocData.instance()

            # 기존 저장된 데이터 불러옴

            drawings = self.checked_drawings

            dataList = docData.get_valve_data_list(drawings if drawings else None)

            valve_table.setRowCount(len(dataList))

            row = 0

            for data in dataList:

                for col in range(self.ui.tableWidgetValveDataList.columnCount()):

                    col_item = self.ui.tableWidgetValveDataList.horizontalHeaderItem(col)

                    matches = [key for key in data.keys() if key == col_item.data(Qt.UserRole)]

                    if matches:

                        item = QTableWidgetItem(data[matches[0]])

                        item.setFlags(Qt.ItemIsEnabled)

                        valve_table.setItem(row, col, item)

                row += 1

            # set column headers

            headers = []

            for col in range(valve_table.columnCount()):

                headers.append(valve_table.horizontalHeaderItem(col).text())

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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      setting Inst data

        @author     kyouho

        @date       2018.08.14

    '''

    def set_instrument_data(self, hmb_datas=None):

        inst_table = self.ui.tableWidgetInstrumentDataList

        app_doc_data = AppDocData.instance()

        # 기존 저장된 데이터 불러옴

        drawings = self.checked_drawings

        dataList = app_doc_data.get_instrument_data_list(drawings if drawings else None)

        dataList = self.add_hmb_data(hmb_datas, dataList)

        inst_table.setRowCount(len(dataList))

        row = 0

        for data in dataList:

            for col in range(self.ui.tableWidgetInstrumentDataList.columnCount()):

                col_item = self.ui.tableWidgetInstrumentDataList.horizontalHeaderItem(col)

                matches = [key for key in data.keys() if key == col_item.data(Qt.UserRole)]

                if matches:

                    item = QTableWidgetItem(data[matches[0]])

                    item.setFlags(Qt.ItemIsEnabled)

                    inst_table.setItem(row, col, item)

            row += 1

        # set column headers

        headers = []

        for col in range(inst_table.columnCount()):

            headers.append(inst_table.horizontalHeaderItem(col).text())

    def set_note_data(self):

        """ set note data """

        note_table = self.ui.tableWidgetNoteDataList

        app_doc_data = AppDocData.instance()

        # 기존 저장된 데이터 불러옴

        drawings = self.checked_drawings

        dataList = app_doc_data.get_note_data_list(drawings if drawings else None)

        note_table.setRowCount(len(dataList))

        row = 0

        for data in dataList:

            for col in range(note_table.columnCount()):

                col_item = note_table.horizontalHeaderItem(col)

                matches = [key for key in data.keys() if key == col_item.data(Qt.UserRole)]

                if matches:

                    item = QTableWidgetItem(data[matches[0]])

                    item.setFlags(Qt.ItemIsEnabled)

                    note_table.setItem(row, col, item)

            row += 1

        # set column headers

        headers = []

        for col in range(note_table.columnCount()):

            headers.append(note_table.horizontalHeaderItem(col).text())

    def fill_special_items(self):

        """ fill table widget with special items """

        try:

            app_doc_data = AppDocData.instance()

            drawings = self.checked_drawings

            special_items = app_doc_data.get_special_items(drawings if drawings else None)

            merged_special_items = []

            for item in special_items:

                matches = [merged for merged in merged_special_items if merged['Line No'] == item[0]]

                if matches:

                    matches[0][item[1]] = 'O'

                else:

                    merged_special_items.append({'Line No': item[0], item[1]: 'O'})

            self.ui.tableWidgetSpecialItems.setRowCount(len(merged_special_items))

            row = 0

            for item in merged_special_items:

                for col in range(self.ui.tableWidgetSpecialItems.columnCount()):

                    if self.ui.tableWidgetSpecialItems.isColumnHidden(col): continue

                    col_name = self.ui.tableWidgetSpecialItems.horizontalHeaderItem(col).text()

                    widget_item = QTableWidgetItem(item[col_name]) if col_name in item.keys() else QTableWidgetItem('X')

                    widget_item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)

                    widget_item.setFlags(Qt.ItemIsEnabled)

                    self.ui.tableWidgetSpecialItems.setItem(row, col, widget_item)

                row += 1

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

    def show_item_data_format_dialog(self):

        """ show item data format dialog """

        from ItemDataFormatDialog import QItemDataFormatDialog

        dlg = QItemDataFormatDialog(self, self.columnListAll, self.columnOrder)

        if dlg.exec_():

            self.initTableWidget()

    def query_engineering_list(self, text):

        """query engineering list"""

        QApplication.setOverrideCursor(Qt.WaitCursor)

        try:

            hmb_datas = AppDocData.instance().get_hmb_data(None)

            configs = docData.getConfigs('Line List', 'Use Stream No')

            if configs and int(configs[0].value) == 1:

                self.set_line_list_data()

            else:

                self.set_line_data()

            self.set_equipment_data()

            self.set_valve_data()

            self.set_instrument_data(hmb_datas)

            self.set_note_data()

            self.fill_special_items()

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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:

            QApplication.restoreOverrideCursor()

    def select_all(self):

        """select all drawings"""

        for row in range(self.ui.tableWidgetDrawing.rowCount()):

            item = self.ui.tableWidgetDrawing.item(row, 0)

            item.setCheckState(Qt.Checked)

    def unselect_all(self):

        """unselect all drawings"""

        for row in range(self.ui.tableWidgetDrawing.rowCount()):

            item = self.ui.tableWidgetDrawing.item(row, 0)

            item.setCheckState(~Qt.Checked)