HYTOS

# coding: utf-8

""" This is MainWindow module """

import sys

import os

import subprocess

from functools import partial

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Commands')

import CreateCommand

import CropCommand

import AreaOcrCommand

import CreateSymbolCommand

import AreaZoomCommand

import FenceCommand

import PlaceLineCommand

import PlacePolygonCommand

import cv2

import numpy as np

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from PyQt5.QtSvg import *

from PIL import Image

import MainWindow_UI

import QtImageViewer

from SingletonInstance import SingletonInstane

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Shapes')

from EngineeringAbstractItem import QEngineeringAbstractItem

from EngineeringPolylineItem import QEngineeringPolylineItem

from EngineeringLineItem import QEngineeringLineItem

from SymbolSvgItem import SymbolSvgItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from EngineeringNoteItem import QEngineeringNoteItem

from QEngineeringSizeTextItem import QEngineeringSizeTextItem

from EngineeringUnknownItem import QEngineeringUnknownItem

from EngineeringEquipmentItem import QEngineeringEquipmentItem

from EngineeringInstrumentItem import QEngineeringInstrumentItem

from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

from EngineeringErrorItem import QEngineeringErrorItem

from EngineeringVendorItem import QEngineeringVendorItem

from EngineeringEndBreakItem import QEngineeringEndBreakItem

from EngineeringReducerItem import QEngineeringReducerItem

from EngineeringFlowMarkItem import QEngineeringFlowMarkItem

from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

from AppDocData import *

import SymbolTreeWidget, SymbolPropertyTableWidget

import SymbolEditorDialog

import ItemTreeWidget

import ItemPropertyTableWidget

from UserInputAttribute import UserInputAttribute

from TextItemFactory import TextItemFactory

from TrainingImageListDialog import QTrainingImageListDialog

from TrainingSymbolImageListDialog import QTrainingSymbolImageListDialog

from TextDataListDialog import QTextDataListDialog

from ImportTextFromCADDialog import QImportTextFromCADDialog

from SymbolThicknessDialog import QSymbolThicknessDialog

from DisplayColors import DisplayColors

from DisplayColors import DisplayOptions

import uuid

from openpyxl import *

from openpyxl.styles import *

class MainWindow(QMainWindow, MainWindow_UI.Ui_MainWindow, SingletonInstane):

    """ This is MainWindow class """

    addMessage = pyqtSignal(Enum, str)

    '''

        @brief      initialize

        @author 

        @date   

        @history    humkyung 2018.04.12 add splitter widget

                    Jeongwoo 2018.04.27 Add Signal/Slot Connection 'noteNoSingleClicked'

                    Jeongwoo 2018.05.09 Initialize Action group

                    Jeongwoo 2018.05.10 Add Signal/Slot Connection 'lineNoSingleClicked'

                                        Add QActionGroup for managing checkable action

                    Jeongwoo 2018.06.27 Add Action [Zoom, Fit Window] and Add new actions into ActionGroup

                    humkyung 2018.08.23 add labelStatus to statusbar

                    Euisung 2018.09.27 add OCR Training , Signal/Slot Connection 'oCRTrainingClicked'

                    Euisung 2018.10.05 add OCR Editor , Signal/Slot Connection 'oCRTrainingEdidorClicked'

                    Euisung 2018.10.22 delete Signal/Slot Connection 'oCRTrainingEdidorClicked'

    '''

    def __init__(self):

        from App import App

        from LineTypeConditions import LineTypeConditions

        super(self.__class__, self).__init__()

        self.setupUi(self)

        self.progress_bar = QProgressBar()

        self._label_mouse = QLabel(self.statusbar)

        self._label_mouse.setText(self.tr('mouse pos : ({},{})'.format(0, 0)))

        self.labelStatus = QLabel(self.statusbar)

        self.labelStatus.setText(self.tr('Unrecognition : '))

        self.labelSymbolStatus = QLabel(self.statusbar)

        self.labelSymbolStatus.setText(self.tr('Symbol : '))

        self.labelLineStatus = QLabel(self.statusbar)

        self.labelLineStatus.setText(self.tr('Line : '))

        self.labelTextStatus = QLabel(self.statusbar)

        self.labelTextStatus.setText(self.tr('Text : '))

        self.statusbar.addWidget(self._label_mouse)

        self.statusbar.addPermanentWidget(self.progress_bar, 1)

        self.statusbar.addPermanentWidget(self.labelSymbolStatus)

        self.statusbar.addPermanentWidget(self.labelLineStatus)

        self.statusbar.addPermanentWidget(self.labelTextStatus)

        self.statusbar.addPermanentWidget(self.labelStatus)

        docData = AppDocData.instance()

        docData.clear()

        project = docData.getCurrentProject()

        _translate = QCoreApplication.translate

        version = QCoreApplication.applicationVersion()

        # set title

        self.setWindowTitle(_translate(f"{App.NAME}({version}) - {project.name}",

                                       f"{App.NAME}({version}) - {project.name}"))

        self.lineComboBox = QComboBox(self.toolBar)

        for condition in LineTypeConditions.items():

            self.lineComboBox.addItem(condition.name)

        configs = docData.getConfigs('Line', 'Default Type')

        value = configs[0].value if 1 == len(configs) else ''

        if value:

            at = self.lineComboBox.findText(value)

            self.lineComboBox.setCurrentIndex(at)

        else:

            at = self.lineComboBox.findText('Secondary')

            self.lineComboBox.setCurrentIndex(at)

        #self.lineComboBox.currentIndexChanged.connect(self.onLineTypeChanged)

        self.toolBar.insertWidget(self.actionOCR, self.lineComboBox)

        self.toolBar.insertSeparator(self.actionOCR)

        self.graphicsView = QtImageViewer.QtImageViewer(self)

        self.graphicsView.setParent(self.centralwidget)

        self.graphicsView.useDefaultCommand()  # USE DEFAULT COMMAND

        self.graphicsView.setMouseTracking(True)

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

        self._display_widget = QWidget()

        layout = QVBoxLayout()

        self._by_line_no = QRadioButton()

        self._by_line_no.setChecked(True)

        self._by_line_no.setText('By Group')

        self._by_line_no.toggled.connect(self.display_colors)

        layout.addWidget(self._by_line_no)

        self._by_line_type = QRadioButton()

        self._by_line_type.setText('By Type')

        layout.addWidget(self._by_line_type)

        self._display_widget.setLayout(layout)

        self.EditToolbar.insertWidget(None, self._display_widget)

        self._by_line_no.setChecked(

            True) if DisplayColors.instance().option == DisplayOptions.DisplayByLineNo else self._by_line_type.setChecked(

            True)

        self.verticalLayout.addWidget(self.graphicsView)

        # Add Custom TreeWidget

        self.dirTreeWidget = SymbolTreeWidget.QSymbolTreeWidget()

        self.dirTreeWidget.header().hide()

        self.symbolTabVerticalLayout.addWidget(self.dirTreeWidget)

        # Add Custom Property TableWidget

        self.propertyTableWidget = SymbolPropertyTableWidget.QSymbolPropertyTableWidget()

        self.symbolTabVerticalLayout.addWidget(self.propertyTableWidget)

        self.dirTreeWidget.singleClicked.connect(self.propertyTableWidget.getClickedSymbol)

        # add splitter widget

        splitter = QSplitter(Qt.Vertical)

        splitter.addWidget(self.dirTreeWidget)

        splitter.addWidget(self.propertyTableWidget)

        self.symbolTabVerticalLayout.addWidget(splitter)

        # up to here

        # Add Custom Result Tree Widget (Symbol Explorer)

        self.itemTreeWidget = ItemTreeWidget.QItemTreeWidget(self.graphicsView)

        self.itemTreeWidget.header().hide()

        self.symbolExplorerVerticalLayout.addWidget(self.itemTreeWidget)

        # Add Empty Widget

        self.resultPropertyTableWidget = ItemPropertyTableWidget.QItemPropertyTableWidget(self)

        self.symbolExplorerVerticalLayout.addWidget(self.resultPropertyTableWidget)

        self.itemTreeWidget.singleClicked.connect(self.resultPropertyTableWidget.onSymbolClicked)

        self.itemTreeWidget.noteNoSingleClicked.connect(self.resultPropertyTableWidget.onNoteClicked)

        self.itemTreeWidget.lineNoSingleClicked.connect(self.resultPropertyTableWidget.onLineNoClicked)

        self.itemTreeWidget.drawingClicked.connect(self.resultPropertyTableWidget.onDrawingClicked)

        # add splitter widget

        splitter = QSplitter(Qt.Vertical)

        splitter.addWidget(self.itemTreeWidget)

        splitter.addWidget(self.resultPropertyTableWidget)

        self.symbolExplorerVerticalLayout.addWidget(splitter)

        # up to here

        # Initialize Action group

        self.actionGroup = QActionGroup(self)

        self.actionGroup.addAction(self.actionRecognition)

        self.actionGroup.addAction(self.actionLineRecognition)

        self.actionGroup.addAction(self.actionLine)

        self.actionGroup.addAction(self.actionGenerateOutput)

        self.actionGroup.addAction(self.actionOCR)

        self.actionGroup.addAction(self.actionZoom)

        self.actionGroup.addAction(self.actionFitWindow)

        self.actionGroup.addAction(self.actionSave)

        self.actionGroup.addAction(self.actionValidate)

        self.actionGroup.addAction(self.actionVendor)

        self.actionGroup.triggered.connect(self.actionGroupTriggered)

        # connect signals and slots

        self.actionClose.triggered.connect(self.close)

        self.actionOpen.triggered.connect(self.onOpenImageDrawing)

        self.actionLine.triggered.connect(self.onPlaceLine)

        self.actionRecognition.triggered.connect(self.recognize)

        self.pushButtonBatchRecognition.clicked.connect(self.recognizeBatch)

        self.pushButtonRefreshDrawings.clicked.connect(self.load_drawing_list)

        self.actionLineRecognition.triggered.connect(self.connect_attributes)

        self.actionArea.triggered.connect(self.areaConfiguration)

        self.actionConfiguration.triggered.connect(self.configuration)

        self.actionOCR.triggered.connect(self.onAreaOcr)

        self.actionGenerateOutput.triggered.connect(self.generateOutput)

        self.pushButtonCreateSymbol.clicked.connect(self.onCreateSymbolClicked)

        self.pushButtonClearLog.clicked.connect(self.onClearLog)

        self.actionHMB_DATA.triggered.connect(self.onHMBData)

        self.actionItem_Data_List.triggered.connect(self.showItemDataList)

        self.actionText_Data_List.triggered.connect(self.showTextDataList)

        self.actionSpecialItemTypes.triggered.connect(self.on_show_special_item_types)  # show special item types dialog

        self.actionDataTransfer.triggered.connect(self.on_show_data_transfer)  # show data transfer dialog

        self.actionDataExport.triggered.connect(self.on_show_data_export)

        self.actionExportEqpDatasheet.triggered.connect(

            self.on_show_eqp_datasheet_export)  # show eqp datasheet export dialog

        self.actionOPCRelation.triggered.connect(self.on_show_opc_relation)  # show OPC Relation dialog

        self.actionCodeTable.triggered.connect(self.onShowCodeTable)

        self.actionImage_Drawing.triggered.connect(self.onViewImageDrawing)

        self.actionDrawing_Only.triggered.connect(self.onViewDrawingOnly)

        self.actionValidate.triggered.connect(self.onValidation)

        self.actionViewText.triggered.connect(self.onViewText)

        self.actionViewSymbol.triggered.connect(self.onViewSymbol)

        self.actionViewLine.triggered.connect(self.onViewLine)

        self.actionViewUnknown.triggered.connect(self.onViewUnknown)

        self.actionViewInconsistency.triggered.connect(self.onViewInconsistency)

        self.actionViewVendor_Area.triggered.connect(self.onViewVendorArea)

        self.actionRotate.triggered.connect(self.onRotate)

        self.actionZoom.triggered.connect(self.onAreaZoom)

        self.actionVendor.triggered.connect(self.onVendor)

        self.actionFitWindow.triggered.connect(self.fitWindow)

        self.actionpdf_to_image.triggered.connect(self.onConvertPDFToImage)

        self.actionImport_Text_From_CAD.triggered.connect(self.onImportTextFromCAD)

        self.actionSymbol_Thickness_Reinforcement.triggered.connect(self.onSymbolThickness)

        self.actionHelp.triggered.connect(self.on_help)

        self.graphicsView.scene.selectionChanged.connect(self.onSelectionChanged)

        self.actionInitialize.triggered.connect(self.onInitializeScene)

        self.actionSave.triggered.connect(self.actionSaveCliked)

        self.addMessage.connect(self.onAddMessage)

        self.actionFindReplaceText.triggered.connect(self.findReplaceTextClicked)

        self.pushButtonDetectSymbol.clicked.connect(self.onShowDetectSymbol)

        #self.graphicsView.scene.contents_changed.connect(self.scene_changed)

        configs = docData.getAppConfigs('app', 'mode')

        if configs and 1 == len(configs) and 'advanced' == configs[0].value:

            self.actionOCR_Training.triggered.connect(self.oCRTrainingClicked)

            self.actionSymbol_Training.triggered.connect(self.symbolTrainingClicked)

        else:

            self.actionOCR_Training.setVisible(False)

            self.actionSymbol_Training.setVisible(False)

            self.pushButtonBatchRecognition.setVisible(False)

            self.pushButtonCreateSymbol.setVisible(False)

            self.pushButtonDetectSymbol.setVisible(False)

        self.delimiter = '"'

        self.resizeDocks({self.dockWidget}, {self.dockWidgetObjectExplorer.sizeHint().width()}, Qt.Horizontal)

        self.treeWidgetDrawingList.setHeaderHidden(False)

        self.treeWidgetDrawingList.header().setStretchLastSection(False)

        self.treeWidgetDrawingList.setHeaderLabels([self.tr('Name'), self.tr('DateTime')])

        self.treeWidgetDrawingList.header().setSectionResizeMode(0, QHeaderView.ResizeToContents)

        self.treeWidgetDrawingList.header().setSectionResizeMode(1, QHeaderView.ResizeToContents)

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

        self.load_drawing_list()

        # load stylesheet file list

        stylesheet_name = QtWidgets.qApp.stylesheet_name

        files = [os.path.splitext(file)[0] for file in os.listdir(os.path.dirname(os.path.realpath(__file__))) if

                 os.path.splitext(file)[1] == '.qss']

        for file in files:

            action = self.menuTheme.addAction(file)

            action.setCheckable(True)

            action.setChecked(True) if stylesheet_name == file else action.setChecked(False)

            action.triggered.connect(partial(self.load_stylesheet, file))

        # up to here

        # load language files

        language_name = QtWidgets.qApp.language_name

        files = ['en_us']  # englisgh is default language

        files.extend([os.path.splitext(file)[0] for file in

                      os.listdir(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'translate')) if

                      os.path.splitext(file)[1] == '.qm'])

        for file in files:

            action = self.menuLanguage.addAction(file)

            action.setCheckable(True)

            action.setChecked(True) if language_name.lower() == file.lower() else action.setChecked(False)

            action.triggered.connect(partial(self.load_language, file))

        # up to here

        # inconsistency table

        self.tableWidgetInconsistency.setColumnCount(3)

        self.tableWidgetInconsistency.setHorizontalHeaderLabels(['Owner', 'Type', 'Message'])

        self.tableWidgetInconsistency.setEditTriggers(QAbstractItemView.NoEditTriggers)

        self.tableWidgetInconsistency.itemClicked.connect(self.inconsistencyItemClickEvent)

        self.tableWidgetInconsistency.keyPressEvent = self.inconsistencyTableKeyPressEvent

        self.tableWidgetInconsistency.setSortingEnabled(True)

    def eventFilter(self, source, event):

        """display mouse position of graphics view"""

        if (event.type() == QEvent.MouseMove):

            pos = self.graphicsView.mapToScene(event.pos())

            self._label_mouse.setText('mouse pos : ({},{})'.format(round(pos.x()), round(pos.y())))

        return QWidget.eventFilter(self, source, event)

    def closeEvent(self, event):

        """ask user to save drawing which is modified"""

        self.save_drawing_if_necessary()

        AppDocData.instance().clear()

        event.accept()

    def inconsistencyTableKeyPressEvent(self, event):

        try:

            row = self.tableWidgetInconsistency.selectedIndexes()[0].row()

            col = self.tableWidgetInconsistency.selectedIndexes()[0].column()

            from HighlightCommand import HighlightCommand

            if event.key() == Qt.Key_Up:

                if row is not 0:

                    errorItem = self.tableWidgetInconsistency.item(row - 1, 1).tag

                    HighlightCommand(self.graphicsView).execute(errorItem)

            elif event.key() == Qt.Key_Down:

                if row is not self.tableWidgetInconsistency.rowCount() - 1:

                    errorItem = self.tableWidgetInconsistency.item(row + 1, 1).tag

                    HighlightCommand(self.graphicsView).execute(errorItem)

            elif event.key() == Qt.Key_Delete:

                item = self.tableWidgetInconsistency.item(row, 0).tag

                if item and item.scene(): item.scene().removeItem(item)

                self.tableWidgetInconsistency.removeRow(row)

        except Exception as ex:

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

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

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

        # finally:

        #    return QTableView.keyPressEvent(self.tableWidgetInconsistency, event)

    def onValidation(self):

        """

        @brief  validation check

        @author euisung

        @date   2019.04.01

        """

        from ValidateCommand import ValidateCommand

        if not self.graphicsView.hasImage():

            self.showImageSelectionMessageBox()

            return

        try:

            # remove error items

            for item in self.graphicsView.scene.items():

                if type(item) is QEngineeringErrorItem:

                    item.transfer.onRemoved.emit(item)

            # up to here

            cmd = ValidateCommand(self.graphicsView)

            errors = cmd.execute(self.graphicsView.scene.items())

            for error in errors:

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

                self.graphicsView.scene.addItem(error)

            self.tableWidgetInconsistency.clearContents()

            self.tableWidgetInconsistency.setRowCount(len(errors))

            for index in range(len(errors)):

                self.makeInconsistencyTableRow(index, errors[index])

        except Exception as ex:

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

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

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

    def makeInconsistencyTableRow(self, row, errorItem):

        '''

            @brief  make row data for inconsistency widget

            @author euisung

            @date   2019.04.16

        '''

        item = QTableWidgetItem(str(errorItem.parent))

        item.tag = errorItem

        self.tableWidgetInconsistency.setItem(row, 0, item)

        item = QTableWidgetItem(str(type(errorItem.parent)))

        item.tag = errorItem

        self.tableWidgetInconsistency.setItem(row, 1, item)

        item = QTableWidgetItem(errorItem.msg)

        item.tag = errorItem

        self.tableWidgetInconsistency.setItem(row, 2, item)

    def inconsistencyItemClickEvent(self, item):

        """

        @brief  inconsistency table item clicked

        @author euisung

        @date   2019.04.02

        """

        from HighlightCommand import HighlightCommand

        HighlightCommand(self.graphicsView).execute(item.tag)

    def load_stylesheet(self, file):

        """

        @brief  load stylesheets

        @author humkyung

        @date   2018.10.29

        """

        QtWidgets.qApp.loadStyleSheet(os.path.join(os.path.dirname(os.path.realpath(__file__)), file))

        app_doc_data = AppDocData.instance()

        configs = [Config('app', 'stylesheet', file)]

        app_doc_data.saveAppConfigs(configs)

        for action in self.menuTheme.actions():

            if action.text() == file: continue

            action.setChecked(False)

    def load_language(self, file):

        """

        load language file and then apply selected language 

        """

        try:

            qm_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'translate', '{0}.qm'.format(file))

            QtWidgets.qApp.load_language(qm_file)

            app_doc_data = AppDocData.instance()

            configs = [Config('app', 'language', file)]

            app_doc_data.saveAppConfigs(configs)

            for action in self.menuLanguage.actions():

                if action.text().lower() == file.lower(): continue

                action.setChecked(False)

        finally:

            self.retranslateUi(self)

            self.propertyTableWidget.retranslateUi()

    '''

        @brief      Clear TreeWidget and Set Current PID

        @author     Jeongwoo

        @date       18.04.11

        @history    2018.04.26  Jeongwoo    Add Child [SYMBOLS, NOTES] into root item

                    2018.05.09  Jeongwoo    Change method to add default tree items

                    humkyung 2018.06.10 add tree item for Line No and Unknown Item

    '''

    def load_drawing_list(self):

        """load p&id drawing list"""

        from Drawing import Drawing

        try:

            app_doc_data = AppDocData.instance()

            drawings = app_doc_data.getDrawings()

            self.treeWidgetDrawingList.clear()

            self.treeWidgetDrawingList.root = QTreeWidgetItem(self.treeWidgetDrawingList,

                                                              [self.tr('P&ID Drawings'), ''])

            self.treeWidgetDrawingList.root.setFlags(

                self.treeWidgetDrawingList.root.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable)

            self.treeWidgetDrawingList.root.setCheckState(0, Qt.Unchecked)

            files = app_doc_data.getDrawingFileList()

            for file in files:

                drawing = [drawing for drawing in drawings if drawing.name == file]

                if not drawing or not drawing[0].UID:

                    drawings.append(Drawing(None, file, None))

                item = QTreeWidgetItem(self.treeWidgetDrawingList.root,

                                       [file, drawing[0].datetime if drawing else None])

                item.setIcon(0, QIcon(':newPrefix/image.png'))

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

                item.setCheckState(0, Qt.Unchecked)

            self.treeWidgetDrawingList.root.setText(0, self.tr('P&ID Drawings') + '({})'.format(

                self.treeWidgetDrawingList.root.childCount()))

            self.treeWidgetDrawingList.expandItem(self.treeWidgetDrawingList.root)

            self.treeWidgetDrawingList.root.sortChildren(0, Qt.AscendingOrder)

            self.treeWidgetDrawingList.resizeColumnToContents(0)

            app_doc_data.saveDrawings(drawings)

        except Exception as ex:

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

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

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

    def open_selected_drawing(self, item, column):

        """

        @brief      open selected p&id drawing

        @author     humkyung

        @date       18.11.02

        """

        appDocData = AppDocData.instance()

        drawing = os.path.join(appDocData.getCurrentProject().getDrawingFilePath(), item.text(0))

        self.onOpenImageDrawing(drawing)

    def onShowDetectSymbol(self):

        from DetectSymbolDialog import QDetectSymbolDialog

        dlgDetectSymbol = QDetectSymbolDialog(self)

        dlgDetectSymbol.show()

        dlgDetectSymbol.exec_()

    '''

        @brief      OCR Editor

        @author     euisung

        @date       2018.10.05

        @history    2018.10.16 euisung      no more used, Integrated with oCRTrainingClicked

    '''

    def oCRTrainingEdidorClicked(self):

        from TrainingEditorDialog import QTrainingEditorDialog

        try:

            dialog = QTrainingEditorDialog(self)

            dialog.exec_()

        except Exception as ex:

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

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

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

        return

    '''

        @brief      OCR Training

        @author     euisung

        @date       2018.09.27

        @history    euisung 2018.10.16 TrainingListDialog -> TrainingImageListDialog

    '''

    def oCRTrainingClicked(self):

        try:

            dialog = QTrainingImageListDialog(self)

            dialog.exec_()

        except Exception as ex:

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

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

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

    def symbolTrainingClicked(self):

        try:

            dialog = QTrainingSymbolImageListDialog(self)

            dialog.exec_()

        except Exception as ex:

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

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

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

    '''

        @brief      show unknownitem's count

        @author     kyouho

        @date       2018.08.27

    '''

    def findReplaceTextClicked(self):

        if not self.graphicsView.hasImage():

            self.showImageSelectionMessageBox()

            return

        from TextItemEditDialog import QTextItemEditDialog

        self.dlgTextItemEdit = QTextItemEditDialog(self)

        self.dlgTextItemEdit.show()

        self.dlgTextItemEdit.exec_()

    def display_number_of_items(self):

        """display count of symbol, line, text"""

        items = [item for item in self.graphicsView.scene.items() if type(item) is QEngineeringUnknownItem]

        if len(items) > 0:

            self.labelStatus.setText(

                "<font color='red'>" + self.tr('Unrecognition') + " : {}</font>".format(len(items)))

        else:

            self.labelStatus.setText(

                "<font color='black'>" + self.tr('Unrecognition') + " : {}</font>".format(len(items)))

        items = [item for item in self.graphicsView.scene.items() if

                 issubclass(type(item), SymbolSvgItem) and type(item) is not QEngineeringErrorItem]

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

        items = [item for item in self.graphicsView.scene.items() if type(item) is QEngineeringLineItem]

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

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

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

        self.itemTreeWidget.sceneChanged(self.graphicsView.scene.items())

    def dbUpdate(self):

        '''

            @brief      db update when save or recognition

            @author     euisung

            @date       2018.11.12

            @history    2018.11.02      euisung     remove scene dependency

        '''

        try:

            appDocData = AppDocData.instance()

            titleBlockProps = appDocData.getTitleBlockProperties()

            # items = self.graphicsView.scene.items()

            items = appDocData.allItems

            titleBlockItems = []

            for item in items:

                # if type(item) is QEngineeringLineNoTextItem:

                #    item.saveLineData()

                if type(item) is QEngineeringTextItem:

                    for titleBlockProp in titleBlockProps:

                        if item.area == titleBlockProp[0]:

                            titleBlockItems.append(item)

            # unknown item is not saved now for performance

            db_items = [item for item in items if issubclass(type(item), QEngineeringAbstractItem) and type(item) is not QGraphicsBoundingBoxItem and type(item) is not QEngineeringErrorItem and type(item) is not QEngineeringLineNoTextItem and type(item) is not QEngineeringUnknownItem]

            db_items.extend([item for item in items if type(item) is QEngineeringLineNoTextItem])

            db_items.extend([line for line in appDocData.tracerLineNos if type(line) is QEngineeringTrimLineNoTextItem])

            db_items.extend(titleBlockItems)

            configs = appDocData.getConfigs('Data Load', 'Xml First')

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

                db_items.extend([item for item in items if type(item) is QEngineeringUnknownItem])

            '''

            dbItems = [item for item in items if

                       type(item) is QEngineeringInstrumentItem or type(item) is QEngineeringEquipmentItem or type(

                           item) is QEngineeringReducerItem or \

                       type(item) is QEngineeringNoteItem or type(item) is SymbolSvgItem or type(

                           item) is QEngineeringLineNoTextItem or type(

                           item) is QEngineeringVendorItem] + titleBlockItems

            '''

            appDocData.saveToDatabase(db_items)

        except Exception as ex:

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

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

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

    def save_drawing_if_necessary(self):

        """ask to user to save drawing or not when drawing is modified"""

        app_doc_data = AppDocData.instance()

        if app_doc_data.activeDrawing and app_doc_data.activeDrawing.modified:

            if QMessageBox.Yes == QMessageBox.question(self, self.tr("Question"),

                                                       self.tr("Do you want to save drawing?"),

                                                       QMessageBox.Yes | QMessageBox.No):

                self.actionSaveCliked()

    '''

        @brief      action save click event

        @author     kyouho

        @date       2018.08.09

        @history    2018.11.02      euisung     add line data list db update

                    humkyung save saved time to database

                    2018.11.05      euisung     add note data list db update

                    2018.11.05      euisung     add db delete process before save

                    2018.11.12      euisung     db part move new method to dbUpdate

    '''

    def actionSaveCliked(self):

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from SaveWorkCommand import SaveWorkCommand

        try:

            app_doc_data = AppDocData.instance()

            if app_doc_data.imgName is None:

                self.showImageSelectionMessageBox()

                return

            app_doc_data.clearItemList(False)

            items = self.graphicsView.scene.items()

            for item in items:

                if issubclass(type(item), QEngineeringAbstractItem):

                    app_doc_data.allItems.append(item)

                    if issubclass(type(item), QEngineeringTextItem):

                        app_doc_data.texts.append(item)

            itemTypes = []

            for item in items:

                typeExist = False

                for itemType in itemTypes:

                    if type(item) is itemType:

                        typeExist = True

                        break

                if not typeExist:

                    itemTypes.append(type(item))

            self._save_work_cmd = SaveWorkCommand()

            self._save_work_cmd.show_progress.connect(self.progress_bar.setValue)

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

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

            self._save_work_cmd.start()

        except Exception as ex:

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

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

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

    def save_finished(self):

        """reload drawing list"""

        self._save_work_cmd.show_progress.emit(100)

        QMessageBox.about(self.graphicsView, self.tr('Information'), self._save_work_cmd.resultStr)

        self.load_drawing_list()

        app_doc_data = AppDocData.instance()

        app_doc_data.activeDrawing.modified = False

        title = self.windowTitle()

        self.setWindowTitle(title[:-1] if title[-1] == '*' else title)

    '''

        @brief      refresh resultPropertyTableWidget

        @author     kyouho

        @date       2018.07.19

    '''

    def refreshResultPropertyTableWidget(self):

        items = self.graphicsView.scene.selectedItems()

        if len(items) == 1:

            self.resultPropertyTableWidget.show_item_property(items[0])

    '''

        @brief  add message listwidget

        @author humkyung

        @date   2018.07.31

    '''

    def onAddMessage(self, messageType, message):

        from AppDocData import MessageType

        try:

            current = QDateTime.currentDateTime()

            item = QListWidgetItem('{}: {}'.format(current.toString('hh:mm:ss'), message))

            item.setFlags(item.flags() | Qt.ItemIsEditable)

            if messageType == MessageType.Error:

                item.setBackground(Qt.red)

            self.listWidgetLog.insertItem(0, item)

        except Exception as ex:

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

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

    '''

        @brief      clear log

        @author     humkyung

        @date       2018.08.01

    '''

    def onClearLog(self):

        self.listWidgetLog.clear()

    '''

        @brief      rotate selected symbol

        @author     humkyung

        @date       2018.08.15

    '''

    def onRotate(self, action):

        selected = [item for item in self.graphicsView.scene.selectedItems() if issubclass(type(item), SymbolSvgItem)]

        if len(selected) == 1:

            selected[0].rotateSymbol()

    '''

        @brief      Area Zoom

        @author     Jeongwoo

        @date       2018.06.27

        @history    connect command's rejected signal

    '''

    def onAreaZoom(self, action):

        if self.actionZoom.isChecked():

            cmd = AreaZoomCommand.AreaZoomCommand(self.graphicsView)

            cmd.onRejected.connect(self.onCommandRejected)

            self.graphicsView.command = cmd

    def onVendor(self, action):

        '''

            @brief      make vendor package area

            @author     euisung

            @date       2019.04.29

        '''