HYTOS

from PyQt5 import QtWidgets

        self._mainWnd = None

        QtWidgets.qApp = self

    '''

        @brief      create hmb data from database record

        @author     humkyung

        @date       2018.07.12

    '''

    @staticmethod

    def mainWnd():

        return QtWidgets.qApp._mainWnd 

            app._mainWnd = MainWindow.instance()

            app._mainWnd.show()

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5 import QtWidgets

    from PyQt4.QtCore import *

    from PyQt4.QtGui import *

from enum import Enum

'''

    @brief      MessageType

    @author     humkyung 

    @date       2018.07.31

'''

class MessageType(Enum):

    Normal = 1

    Error = 2

                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(MessageType.Error, message)

from MainWindow import MainWindow

from AppDocData import AppDocData

from AppDocData import *

def detectSymbolOnPid(mainRes, targetSymbol, listWidget, worker):

                                ##message = '//// {}:{}-{} ////'.format(symbolName, searchedItemSp, hitRate)

                                ##worker.displayLog.emit(MessageType.Normal, message)

                            message = '{}->{}:{}-{}'.format(searchedSymbol.getName(), symbolName, searchedItemSp, hitRate)

                            worker.displayLog.emit(MessageType.Normal, message)

        worker.updateProgress.emit(maxProgressValue)

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

        worker.displayLog.emit(MessageType.Error, message)

def detectNozzleOnPid(equipment, nozzle, listWidget, worker):

        worker.updateProgress.emit(maxProgressValue)

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

        worker.displayLog(MessageType.Error, message)

def detectEquipmentOnPid(mainRes, targetSymbol, listWidget, worker):

        equipments = detectSymbolOnPid(mainRes, targetSymbol, listWidget, worker)

                detectNozzleOnPid(equipment, nozzle, listWidget, worker)

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

        worker.displayLog(MessageType.Error, message)

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

        MainWindow.instance().displayMessage.emit(MessageType.Error, message)

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

        MainWindow.instance().displayMessage.emit(MessageType.Error, message)

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

                MainWindow.instance().displayMessage.emit(MessageType.Error, message)

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

                MainWindow.instance().displayMessage.emit(MessageType.Error, message)

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

        MainWindow.instance().displayMessage.emit(MessageType.Error, message)

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

        MainWindow.instance().displayMessage.emit(MessageType.Error, message)

def executeRecognition(signal, path, listWidget, isSymbolTextChecked, worker):

                    pool.submit(detectEquipmentOnPid, mainRes, symbol, listWidget, worker)

                        pool.submit(detectSymbolsOnPid, mainRes, symbol, listWidget, worker)

                        pool.submit(detectSymbolOnPid, mainRes, symbol, listWidget, worker)

                textDetector.recognizeText(appDocData.imgSrc, offset, textAreas, searchedSymbolList, worker, listWidget, maxProgressValue)

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

        worker.displayLog.emit(MessageType.Error, message)

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

        MainWindow.instance().displayMessage.emit(MessageType.Error, message)

    <Compile Include="ItemPropertyTableWidget.py" />

    <Compile Include="ItemTreeWidget.py" />

            textDetector.recognizeText(appDocData.imgSrc, (worker.area[0], worker.area[1]), texts, [], worker, None, len(texts))

# coding: utf-8

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import *

        from PyQt4.QtGui import *

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

import os

import sys

import math

from SymbolSvgItem import SymbolSvgItem

from QEngineeringLineNoTextItem import QEngineeringLineNoTextItem

from EngineeringLineItem import QEngineeringLineItem

from QEngineeringNoteItem import QEngineeringNoteItem

from AppDocData import AppDocData

from Drawing import Drawing

from enum import Enum

'''

    @brief      ItemType

    @author     Jeongwoo

    @date       2018.04.27

    @history    2018.05.10  Jeongwoo    Add LINE_NO

'''

class ItemType(Enum):

    SYMBOL = 1

    NOTE = 2

    LINE_NO = 3

class QItemPropertyTableWidget(QTableWidget):

    def __init__(self, mainWindow):

        QTableWidget.__init__(self)

        self.symData = None

        self.initResultPropertyTableWidget()

        self.mainWindow = mainWindow

    '''

        @brief  show item's property

        @author humkyung

        @date   2018.07.03

    '''

    def showItemProperty(self, item):

        if type(item) is QEngineeringLineItem:

            self.initTitleCell(item)

            self.setItem(0, 1, QTableWidgetItem(str(item.uid)))

            self.setItem(1, 1, QTableWidgetItem(item.lineType))

            pt = item.startPoint()

            self.setItem(2, 1, QTableWidgetItem('({},{})'.format(pt[0], pt[1])))

            pt = item.endPoint()

            self.setItem(3, 1, QTableWidgetItem('({},{})'.format(pt[0], pt[1])))

            self.setItem(4, 1, QTableWidgetItem('{}'.format('None' if item.connectors[0].connectedItem is None else item.connectors[0].connectedItem.uid)))

            self.setItem(5, 1, QTableWidgetItem('{}'.format('None' if item.connectors[1].connectedItem is None else item.connectors[1].connectedItem.uid)))

        elif issubclass(type(item), SymbolSvgItem):

            self.onSymbolClicked(item)

        elif type(item) is QEngineeringLineNoTextItem:

            self.onLineNoClicked(item)

        elif type(item) is QEngineeringNoteItem:

            self.onNoteClicked(item)

    '''

        @brief      Initialize TableWidget

        @author     Jeongwoo

        @date       18.04.13

        @history    humkyung 2018.07.08 show column header

    '''

    def initResultPropertyTableWidget(self):

        self.setColumnCount(2)

        self.setHorizontalHeaderLabels(['Name', 'Value'])

        self.horizontalHeaderItem(0).setSizeHint(QSize(25, 25))

        self.setRowCount(13)

        self.verticalHeader().hide()

        self.horizontalHeader().setStretchLastSection(True)

        self.setEditTriggers(QAbstractItemView.NoEditTriggers)

    '''

        @brief      Slot to accept item click event

        @author     Jeongwoo

        @date       18.04.13

        @history    humkyung 2018.04.17 check if given symbol type is SymbolSvgItem

    '''

    @pyqtSlot(SymbolSvgItem)

    def onSymbolClicked(self, symbol):

        if issubclass(type(symbol), SymbolSvgItem):

            self.symData = symbol

            self.symbolChanged(symbol)

    '''

        @brief      show drawing' attributes

        @author     humkyung 

        @date       2018.07.07

    '''

    @pyqtSlot(Drawing)

    def onDrawingClicked(self, drawing):

        self.setRowCount(len(drawing.attrs))

        row = 0

        for attr in drawing.attrs:

            name = attr[0]

            item = QTableWidgetItem(name)

            item.setFlags(Qt.ItemIsEnabled)

            item.setBackground(QColor(220, 220, 220))

            self.setItem(row, 0, item)

            value = attr[1]

            item = QTableWidgetItem(value)

            item.setFlags(Qt.ItemIsEnabled)

            self.setItem(row, 1, item)

            row = row + 1

    '''

        @brief      Slot to accept Note item click event

        @author     Jeongwoo

        @date       18.04.27

        @history    humkyung 2018.07.08 change method name to onNoteClicked

    '''

    @pyqtSlot(str, list)

    def onNoteClicked(self, noteNoStr, noteContentsList):

        self.noteChanged(noteNoStr, noteContentsList)

    '''

        @brief      Slot to accept Line No Item Click event

        @author     Jeongwoo

        @date       18.05.10

        @hisotry    humkyung 2018.07.08 change method name to onLineNoClicked

    '''

    @pyqtSlot(QEngineeringLineNoTextItem)

    def onLineNoClicked(self, item):

        self.lineNoChanged(item)

    '''

        @brief      Reset table with new SymbolSvgItem

        @author     Jeongwoo

        @date       18.04.13

        @history    .

    '''

    def symbolChanged(self, item):

        self.initTitleCell(item)

        self.initContentsCell()

    '''

        @brief      Reset table with note info

        @author     Jeongwoo

        @date       18.04.27

    '''

    def noteChanged(self, noteNoStr, noteContentsList):

        self.initTitleCell(QEngineeringNoteItem())

        self.initNoteCell(noteNoStr, noteContentsList)

    '''

        @brief      Reset table with line no item

        @author     Jeongwoo

        @date       18.05.10

    '''

    def lineNoChanged(self, item):

        from EngineeringRunItem import QEngineeringRunItem

        if type(item) is QEngineeringLineNoTextItem:

            self.initTitleCell(item)

            self.initLineNoCell(item)

        elif type(item) is QEngineeringRunItem:

            self.initLineRunCell(item)

    '''

        @brief      Initialize Title Cell

        @author     Jeongwoos

        @date       18.04.13

        @history    2018.04.27 Jeongwoo Add if-statement by ItemType

                    2018.05.10 Jeongwoo Add if-statement LINE_NO ItemType

    '''

    def initTitleCell(self, item):

        try:

            if issubclass(type(item), SymbolSvgItem):

                self.setRowCount(6)

                self.setItem(0, 0, QTableWidgetItem("UID"))

                self.setItem(1, 0, QTableWidgetItem("심볼명"))

                self.setItem(2, 0, QTableWidgetItem("타입"))

                self.setItem(3, 0, QTableWidgetItem("각도"))

                self.setItem(4, 0, QTableWidgetItem("원점"))

                self.setItem(5, 0, QTableWidgetItem("OWNER"))

            elif type(item) is QEngineeringNoteItem:

                self.setRowCount(1)

                widgetItem = QTableWidgetItem("노트번호")

                self.setItem(0, 0, widgetItem)

            elif type(item) is QEngineeringLineNoTextItem:

                '''

                DO NOTHING / initLineNoCell

                '''

            elif type(item) is QEngineeringLineItem:

                self.setRowCount(6)

                self.setItem(0, 0, QTableWidgetItem('UID'))

                self.setItem(1, 0, QTableWidgetItem("타입"))

                self.setItem(2, 0, QTableWidgetItem("시작점"))

                self.setItem(3, 0, QTableWidgetItem("끝점"))

                self.setItem(4, 0, QTableWidgetItem("CONN1"))

                self.setItem(5, 0, QTableWidgetItem("CONN2"))

            for index in range(self.rowCount()):

                item = self.item(index, 0)

                if item is not None:

                    item.setFlags(Qt.ItemIsEnabled)

                    item.setBackground(QColor(220, 220, 220))

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

    '''

        @brief      Initialize Contents Cell

        @author     Jeongwoo

        @date       18.04.13

        @history    humkyung 2018.06.14 display symbol attributes 

                    humkyung 2018.07.05 display connectivity

    '''

    def initContentsCell(self):

        from QEngineeringInstrumentItem import QEngineeringInstrumentItem

        if self.symData is not None:

            self.setItem(0, 1, QTableWidgetItem(str(self.symData.uid)))

            self.setItem(1, 1, QTableWidgetItem(self.symData.name))

            self.setItem(2, 1, QTableWidgetItem(self.symData.type))

            self.setItem(3, 1, QTableWidgetItem(str(round(math.degrees(self.symData.angle)))))

            self.setItem(4, 1, QTableWidgetItem(str(self.symData.origin)))

            self.setItem(5, 1, QTableWidgetItem('{}'.format(self.symData.owner)))

            row = self.rowCount()

            self.setRowCount(row + len(self.symData.getAttributes()) + len(self.symData.connectors))

            # display attributes of symbol

            attrs = self.symData.getAttributes()

            if attrs is not None:

                attrItems = list(attrs.items())

                for index in range(len(attrItems)):

                    key = attrItems[index][0]

                    value = attrItems[index][1]

                    keyItem = QTableWidgetItem(key)

                    keyItem.setBackground(QColor(220, 220, 220))

                    docData = AppDocData.instance()

                    valueItem = QTableWidgetItem(value)

                    if docData.checkAttribute(key):

                        from PyQt5 import QtGui

                        icon = QtGui.QIcon()

                        icon.addPixmap(QtGui.QPixmap(":/newPrefix/doubleclick.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)

                        valueItem.setIcon(icon)

                    self.setItem(row, 0, keyItem)

                    self.setItem(row, 1, valueItem)

                    row = row + 1

            # up to here

            # display connectivity

            count = 1

            for connector in self.symData.connectors:

                item = QTableWidgetItem('CONN{}'.format(count))

                item.setFlags(Qt.ItemIsEnabled)

                item.setBackground(QColor(220, 220, 220))

                self.setItem(row, 0, item)

                item = QTableWidgetItem('{}'.format('None' if connector.connectedItem is None else str(connector.connectedItem.uid)))

                item.setFlags(Qt.ItemIsEnabled)

                self.setItem(row, 1, item)

                row = row + 1

                count = count + 1

            # up to here

        else:

            self.setRowCount(0)

    '''

        @brief      Initialize Note Contents Cell

        @author     Jeongwoo

        @date       18.04.27

    '''

    def initNoteCell(self, noteNoStr, noteContentsList):

        self.setItem(0, 1, QTableWidgetItem(noteNoStr))

        row = self.rowCount()

        count = 1

        self.setRowCount(row + len(noteContentsList))

        for index in range(len(noteContentsList)):

            item = QTableWidgetItem("노트내용{}".format(count))

            item.setFlags(Qt.ItemIsEnabled)

            self.setItem(row, 0, item)

            self.setItem(row, 1, QTableWidgetItem(noteContentsList[index]))

            row = row + 1

            count = count + 1

    '''

        @brief      Initialize Line No Contents Cell

        @author     Jeongwoo

        @date       18.05.10

        @history    humkyung 2018.07.20 display combobox when key is 'Stream No'

    '''

    def initLineNoCell(self, lineNoItem):

        self.setRowCount(1 + len(lineNoItem.getLineNoAttributes()))

        lineNoTitleItem = QTableWidgetItem("Line No.")

        lineNoTitleItem.setBackground(QColor(220, 220, 220))

        lineNoTitleItem.setFlags(Qt.ItemIsEnabled)

        self.setItem(0, 0, lineNoTitleItem)

        self.setItem(0, 1, QTableWidgetItem(lineNoItem.text()))

        attrItems = lineNoItem.getLineNoAttributes()

        if attrItems is not None:

            for index in range(len(attrItems)):

                key = attrItems[index][0]

                value = attrItems[index][1]

                item = QTableWidgetItem(key)

                item.setFlags(Qt.ItemIsEnabled)

                item.setBackground(QColor(220, 220, 220))

                self.setItem(1 + index, 0, item)

                if key == 'Stream No':

                    self.streamNoComboBox = QComboBox()

                    self.streamNoComboBox.tag = lineNoItem

                    self.streamNoComboBox.currentIndexChanged.connect(self.onStreamNoChanged)

                    appDocData = AppDocData.instance()

                    streamNos = sorted(list(appDocData.hmbTable.streamNos()))

                    for streamNo in streamNos:

                        self.streamNoComboBox.addItem(streamNo)

                    self.setCellWidget(1 + index, 1, self.streamNoComboBox)

                    self.streamNoComboBox.setCurrentText(value)

                else:

                    self.setItem(1 + index, 1, QTableWidgetItem(value))

    '''

        @brief  change selected lines' type by selected line type

        @author humkyung

        @date   2018.07.20

    '''

    def onStreamNoChanged(self, param):

        streamNo = self.streamNoComboBox.itemText(param)

        self.streamNoComboBox.tag.setAttribute('Stream No', streamNo)

    '''

        @brief      Initialize Run Contents Cell

        @author     humkyung 

        @date       2018.05.27

    '''

    def initLineRunCell(self, item):

        self.setRowCount(1)

        lineTypeItem = QTableWidgetItem("라인 타입")

        lineTypeItem.setBackground(QColor(220, 220, 220))

        lineTypeItem.setFlags(Qt.ItemIsEnabled)

        self.setItem(0, 0, lineTypeItem)

        self.setItem(0, 1, QTableWidgetItem(item.lineType))

    '''

        @brief      Key Press Event

        @author     kyouho

        @date       2018.07.19

    '''

    def keyPressEvent(self, event):

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

            items = self.mainWindow.graphicsView.scene.selectedItems()

            selectedIndexes = self.selectedIndexes()

            if len(items) == 1 and len(selectedIndexes) == 1:

                if selectedIndexes[0].column() == 1:

                    attributeStr = self.item(selectedIndexes[0].row(), 0).text()

                    items[0].removeSelfAttr(attributeStr)

                    self.mainWindow.refreshResultPropertyTableWidget()

# coding: utf-8

import os

import re

import sys

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import *

        from PyQt4.QtGui import *

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

from SymbolSvgItem import SymbolSvgItem

from QEngineeringTextItem import QEngineeringTextItem

from QEngineeringNoteItem import QEngineeringNoteItem

from QEngineeringLineNoTextItem import QEngineeringLineNoTextItem

from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

from QEngineeringUnknownItem import QEngineeringUnknownItem

from AppDocData import AppDocData

from Drawing import Drawing

class QItemTreeWidget(QTreeWidget):

    TREE_DATA_ROLE = Qt.UserRole

    #Add Signal

    singleClicked = pyqtSignal(SymbolSvgItem)

    noteNoSingleClicked = pyqtSignal(str, list)

    lineNoSingleClicked = pyqtSignal(QEngineeringLineNoTextItem)

    drawingClicked = pyqtSignal(Drawing)

    '''

        @history    2018.05.11  Jeongwoo    Add Context Menu settings

    '''

    def __init__(self, imageViewer):

        QTreeWidget.__init__(self)

        self.itemClicked.connect(self.itemClickEvent)

        self.imageViewer = imageViewer

        self.scene = imageViewer.scene

        self.root = None

        self.setContextMenuPolicy(Qt.CustomContextMenu)

        self.customContextMenuRequested.connect(self.openContextMenu)

    '''

        @brief      delete selected symbol

        @author     humkyung

        @date       2018.07.20

    '''

    def keyPressEvent(self, event):

        try:

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

                if self.selectedItems():

                    for item in self.selectedItems():

                        data = item.data(0, self.TREE_DATA_ROLE)

                        if data is not None:

                            self.imageViewer.scene.removeItem(data)

                            item.parent().removeChild(item)

                event.accept()

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

                if self.selectedItems():

                    item = self.selectedItems()[0]

                    aboveItem = self.itemAbove(item)

                    if aboveItem is not None:

                        self.setCurrentItem(aboveItem)

                        self.scrollToItem(aboveItem, QAbstractItemView.EnsureVisible)

                        self.itemClickEvent(aboveItem, 0)

                event.accept()

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

                if self.selectedItems():

                    item = self.selectedItems()[0]

                    belowItem = self.itemBelow(item)

                    if belowItem is not None:

                        self.setCurrentItem(belowItem)

                        self.scrollToItem(belowItem, QAbstractItemView.EnsureVisible)

                        self.itemClickEvent(belowItem, 0)

                event.accept()

            else:

                event.ignore()

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

    '''

        @brief      Show Context Menu

        @author     Jeongwoo

        @date       18.05.11

        @history    18.06.14    Jeongwoo    Add item None check

                    humkyung 2018.06.27 add menu of run item for selecting line type

    '''

    def openContextMenu(self, position):

        from EngineeringRunItem import QEngineeringRunItem

        indexes = self.selectedIndexes()

        itemPosition = self.mapTo(self, position)

        item = self.itemAt(itemPosition)

        if item is not None:

            data = item.data(0, self.TREE_DATA_ROLE)

            if len(indexes) > 0 and data is not None and issubclass(type(data), QEngineeringLineNoTextItem):

                index = indexes[0]

                menu = QMenu()

                pickColorAction = QAction(self.tr("색상 설정"))

                pickColorAction.triggered.connect(lambda : self.pickColorClickEvent(item))

                menu.addAction(pickColorAction)

                menu.exec_(self.viewport().mapToGlobal(position))

            elif len(indexes) > 0 and data is not None and issubclass(type(data), QEngineeringRunItem):

                index = indexes[0]

                menu = QMenu()

                lineTypeAction = QAction(self.tr("라인 타입 설정"))

                lineTypeAction.triggered.connect(lambda : self.lineTypeClickEvent(item))

                menu.addAction(lineTypeAction)

                menu.exec_(self.viewport().mapToGlobal(position))

    '''

        @brief      Pick Color for Line No

        @author     Jeongwoo

        @date       18.05.11

        @history    18.05.14    Jeongwoo    Change method to change color by changeTreeWidgetItemColorRecursively()

    '''

    def pickColorClickEvent(self, lineNoTreeWidgetItem):

        ''''''

        color = QColorDialog.getColor() # Dialog returns QColor

        if color is not None:

            lineNoTreeWidgetItem.setForeground(0, QBrush(color))

            lineNoTreeWidgetItem.setFont(0, lineNoTreeWidgetItem.font(0))

            lineNoItem = lineNoTreeWidgetItem.data(0, self.TREE_DATA_ROLE)

            lineNoItem.setColor(color.name())

            connectedItems = lineNoItem.getConnectedItems()

            if connectedItems is not None:

                for connectedItem in connectedItems:

                    connectedItem.setColor(color.name())

                self.changeTreeWidgetItemColorRecursively(lineNoTreeWidgetItem, color)

    '''

        @brief      pick line type

        @author     humkyung 

        @date       2018.06.27

    '''

    def lineTypeClickEvent(self, item):

        pass

    '''

        @brief      Change Color recursively

        @author     Jeongwoo

        @date       18.05.14

    '''

    def changeTreeWidgetItemColorRecursively(self, item, color):

        for index in range(item.childCount()):

            child = item.child(index)

            child.setForeground(0, QBrush(color))

            child.setFont(0, child.font(0))

            self.changeTreeWidgetItemColorRecursively(child, color)

    '''

        @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 setCurrentPID(self, drawingName):

        appDocData = AppDocData.instance()

        self.clear()

        self.root = QTreeWidgetItem(self, [drawingName])

        self.root.setData(0, self.TREE_DATA_ROLE, appDocData.activeDrawing)

        self.root.addChild(QTreeWidgetItem(['LINE NO']))

        self.LineNoTreeItem = self.root.child(self.root.childCount() - 1)

        self.root.addChild(QTreeWidgetItem(['EQUIPMENTS']))

        self.root.addChild(QTreeWidgetItem(['SYMBOLS']))

        self.root.addChild(QTreeWidgetItem(['NOTES']))

        self.root.addChild(QTreeWidgetItem(['UNKNOWN']))

        self.UnknownTreeItem = self.root.child(self.root.childCount() - 1)

    '''

        @brief  create tree item for pipe run if need

        @author humkyung

        @date   2018.05.15

        @history    2018.05.17  Jeongwoo    Change run item color with parent(LineNo Item) color

    '''

    def addPipeRunTreeItemIfNeed(self, lineNoTreeItem, pipeRun):

        for index in range(lineNoTreeItem.childCount()):

            treeItem = lineNoTreeItem.child(index)

            itemData = treeItem.data(0, self.TREE_DATA_ROLE)

            if itemData is not None and itemData == pipeRun.uid:

                return treeItem

        runItem = QTreeWidgetItem(['RUNS {}'.format(lineNoTreeItem.childCount()+1)])

        runItem.setData(0, self.TREE_DATA_ROLE, pipeRun.uid)

        brush = lineNoTreeItem.foreground(0)

        runItem.setForeground(0, brush)

        runItem.setFont(0, runItem.font(0))

        lineNoTreeItem.addChild(runItem)

        return runItem

    '''

        @brief      add a tree item

        @author     humkyung

        @date       2018.04.17

        @history    humkyung 2018.04.19 treat a case parent is changed

                    Jeongwoo 2018.04.26 QEngineeringTextItem → QEngineeringLineNoTextItem

                                        Insert if-statement for QEngineeringNoteItem

                                        Add if-statement for QEngineeringLineNoTextItem

                    Jeongwoo 2018.05.11 Set color when SymbolSvgItem moved into new parent(Line No)

                    Jeongwoo 2018.05.15 Add break keyword on if-statement

                    Jeongwoo 2018.05.17 Set TreeWidgetItem's color with data's color And Set Data's color on LineNoTextItem Setting

                    humkyung 2018.06.12 add unknown item

                    humkyung 2018.07.20 append nozzle to equipment

    '''

    def addTreeItem(self, parent, child):

        item = None

        if (not hasattr(child, 'treeItem')) or (child.treeItem is None):

            if issubclass(type(child), SymbolSvgItem):

                if AppDocData.instance().isEquipmentType(child.type):

                    symbolsRootItem = self.findItems('EQUIPMENTS', Qt.MatchExactly|Qt.MatchRecursive, 0)

                    symbolsRootItem = symbolsRootItem[0]

                    item = QTreeWidgetItem(symbolsRootItem, [child.name])

                    item.setData(0, self.TREE_DATA_ROLE, child)

                elif child.type == 'Nozzles':

                    eqpRootTreeItem = self.findItems('EQUIPMENTS', Qt.MatchExactly|Qt.MatchRecursive, 0)

                    for i in range(eqpRootTreeItem[0].childCount()):

                        eqpTreeItem = eqpRootTreeItem[0].child(i)

                        eqpSymbol = eqpTreeItem.data(0, self.TREE_DATA_ROLE)

                        if child.owner is eqpSymbol:

                            symbolsRootItem = eqpTreeItem

                            item = QTreeWidgetItem(eqpTreeItem, [child.name])

                            item.setData(0, self.TREE_DATA_ROLE, child)

                            break

                    if item is None:

                        symbolsRootItem = self.findItems('SYMBOLS', Qt.MatchExactly|Qt.MatchRecursive, 0)

                        symbolsRootItem = symbolsRootItem[0]

                        item = QTreeWidgetItem(symbolsRootItem, [child.name])

                else:

                    symbolsRootItem = self.findItems('SYMBOLS', Qt.MatchExactly|Qt.MatchRecursive, 0)

                    symbolsRootItem = symbolsRootItem[0]

                    item = QTreeWidgetItem(symbolsRootItem, [child.name])

                if item is not None:

                    iconPath = os.path.join(AppDocData.instance().getCurrentProject().getSvgFilePath(), child.type , child.name + ".svg")

                    item.setIcon(0, QIcon(iconPath))

                    item.setData(0, self.TREE_DATA_ROLE, child)

                    brush = QBrush()

                    brush.setColor(QColor(child.getColor()))

                    item.setForeground(0, brush)

                    item.setFont(0, item.font(0))

                    child.treeItem = item

                    symbolsRootItem.addChild(item)

                    symbolsRootItem.sortChildren(0, Qt.AscendingOrder)  # sort childrens

            elif type(child) is QEngineeringLineNoTextItem:

                item = QTreeWidgetItem([child.text()])

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

                item.setData(0, self.TREE_DATA_ROLE, child)

                item.setCheckState(0, Qt.Unchecked)

                brush = QBrush()

                brush.setColor(QColor(child.getColor()))

                item.setForeground(0, brush)

                item.setFont(0, item.font(0))

                child.treeItem = item

                self.LineNoTreeItem.addChild(item)

            elif type(child) is QEngineeringTrimLineNoTextItem:

                item = QTreeWidgetItem(['Trim Line'])

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

                item.setData(0, self.TREE_DATA_ROLE, child)

                item.setCheckState(0, Qt.Unchecked)

                brush = QBrush()

                brush.setColor(QColor(child.getColor()))

                item.setForeground(0, brush)

                item.setFont(0, item.font(0))

                child.treeItem = item

                self.LineNoTreeItem.addChild(item)

            elif (type(child) is QEngineeringNoteItem):

                item = QTreeWidgetItem([child.text()])

                item.setData(0, self.TREE_DATA_ROLE, child)

                child.treeItem = item

                if parent is not None:

                    parent.addChild(item)

            elif (type(child) is QEngineeringUnknownItem):

                item = QTreeWidgetItem(['Unknown'])

                item.setData(0, self.TREE_DATA_ROLE, child)

                child.treeItem = item

                self.UnknownTreeItem.addChild(item)

        elif issubclass(type(child), SymbolSvgItem):  # change item's parent

            foundItems = self.findItems(child.name, Qt.MatchExactly|Qt.MatchRecursive, 0)

            if foundItems is not None:

                for item in foundItems:

                    data = item.data(0, self.TREE_DATA_ROLE)

                    if data is not None and (data == child) and (parent is not item.parent()):

                        parentData = parent.data(0, self.TREE_DATA_ROLE)

                        if issubclass(type(parentData), QEngineeringLineNoTextItem):

                            for index in range(len(parentData.runs)):

                                runGroup = parentData.runs[index]

                                if data in runGroup.items:

                                    item.parent().removeChild(item) # remove item from original parent

                                    runItem = self.addPipeRunTreeItemIfNeed(parent, runGroup) #parent.child(index)

                                    brush = QBrush()

                                    brush.setColor(QColor(item.data(0, self.TREE_DATA_ROLE).getColor()))

                                    item.setForeground(0, brush)

                                    #item.data(0, self.TREE_DATA_ROLE).setColor(brush.color().name())

                                    item.setFont(0, item.font(0))

                                    runItem.addChild(item)

                                    break

                                else:

                                    pass

                        break

        elif type(child) is QEngineeringLineNoTextItem:

            foundItems = self.findItems(child.text(), Qt.MatchExactly|Qt.MatchRecursive, 0)

            if foundItems is not None:

                for item in foundItems:

                    data = item.data(0, self.TREE_DATA_ROLE)

                    if data is not None and (data == child):

                        connectedItems = data.getConnectedItems()

                        color = data.getColor()

                        for connectedItem in connectedItems:

                            connectedItem.setColor(color)

                        return item

        return item

    '''

        @brief      Scene Changed Listener

        @author     Jeongwoo

        @date       18.04.11

        @history    Jeongwoo 2018.04.25 Add QEngineeringNoteItem to list for loop  / NOT QEngineeringTextItem

                    Jeongwoo 2018.04.26 Change changedSceneItems conditions in loop (QEngineeringTextItem → QEngineeringLineNoTextItem)

                    humkyung 2018.07.20 put items which's owner is None before item which's owner is not None

    '''

    lastSceneItems = None

    def sceneChanged(self, sceneItems):

        changedSceneItems = [item for item in sceneItems if ((issubclass(type(item), SymbolSvgItem)) or (type(item) is QEngineeringNoteItem) or (type(item) is QEngineeringLineNoTextItem) 

                            or (type(item) is QEngineeringUnknownItem)) and (not hasattr(item, 'treeItem') or item.treeItem is None)] # Sublist includes SymbolSvgItem

        first = [item for item in changedSceneItems if item.owner is None]

        second = [item for item in changedSceneItems if item.owner is not None]

        self.initResultTreeWidget(first + second)

    '''

        @brief      Initialize TreeWidget

                    Tree Item Clear and Add Item

        @author     Jeongwoo

        @date       2018.04.11

        @history    2018.04.12 Jeongwoo    Declare self.TREE_DATA_ROLE for QTreeWidgetItem.data(column, role)

        @history    2018.04.17 humkyung NOT remove child of root

                    2018.04.25 Jeongwoo     Add QEngineeringNoteItem Child

                    2018.04.26 Jeongwoo     Change method to insert child

    '''

    def initResultTreeWidget(self, items):

        for item in items:

            if (type(item) is QEngineeringNoteItem):

                notesRootItem = self.findItems('NOTES', Qt.MatchExactly|Qt.MatchRecursive, 0)

                notesRootItem = notesRootItem[0]

                self.addTreeItem(notesRootItem, item)

            else:

                self.addTreeItem(self.root, item)

        notesRootItem = self.findItems('NOTES', Qt.MatchExactly|Qt.MatchRecursive, 0)

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

            notesRootItem[0].sortChildren(0, Qt.AscendingOrder)

        self.expandAll()

    '''

        @brief      TreeWidget Item click listener

        @author     Jeongwoo

        @date       18.04.11

        @history    18.04.12    Jeongwoo    Declare self.TREE_DATA_ROLE for QTreeWidgetItem.data(column, role)

                    18.04.13    Jeongwoo    Signal 'singleClicked' emit SymbolSvgItem

                                            CenterOn() with Symbol's center

                    18.04.25    Jeongwoo    Add QEngineeringNoteItem Click event

                    18.04.26    Jeongwoo    QEngineeringTextItem → QEngineeringLineNoTextItem

                    18.04.27    Jeongwoo    Find NOTE Contents when NOTE No. Clicked

                                            Move singClicked to if-statement type(itemData) is SymbolSvgItem:

                    18.05.10    Jeongwoo    Add lineNoSingleClicked emit

                    humkyung 2018.07.07 emit singleClicked signal when user click drawing name

    '''

    def itemClickEvent(self, item, columnNo, isSvgClick = False):

        from Drawing import Drawing

        from EngineeringRunItem import QEngineeringRunItem

        hilightColor = QColor(255, 0, 0, 127)

        itemData = item.data(0, self.TREE_DATA_ROLE)

        if itemData is not None: ## Not PID Name

            if issubclass(type(itemData), SymbolSvgItem):

                ## Draw rectangle on selected symbol

                rect = itemData.sceneBoundingRect()

                if isSvgClick == False:

                    self.imageViewer.centerOn(rect.center())

                ## Send new event to imageViewer's zoomImage Method

                self.imageViewer.zoomImage(True, QMouseEvent(QEvent.MouseButtonPress, self.imageViewer.mapFromScene(QPointF(rect.left(), rect.top())), Qt.LeftButton, Qt.LeftButton, Qt.NoModifier), 3)

                self.singleClicked.emit(itemData)

            elif (type(itemData) is QEngineeringLineNoTextItem) or (type(itemData) is QEngineeringRunItem):

                if type(itemData) is QEngineeringLineNoTextItem:

                    rect = itemData.sceneBoundingRect()

                    if isSvgClick == False:

                        self.imageViewer.centerOn(rect.center())

                    ## Send new event to imageViewer's zoomImage Method

                    self.imageViewer.zoomImage(True, QMouseEvent(QEvent.MouseButtonPress, self.imageViewer.mapFromScene(QPointF(rect.left(), rect.top())), Qt.LeftButton, Qt.LeftButton, Qt.NoModifier), 3)

                else:

                    pass

                self.lineNoSingleClicked.emit(itemData)

            elif type(itemData) is QEngineeringNoteItem:

                rect = itemData.sceneBoundingRect()

                if isSvgClick == False:

                    self.imageViewer.centerOn(rect.center())

                ## Send new event to imageViewer's zoomImage Method

                self.imageViewer.zoomImage(True, QMouseEvent(QEvent.MouseButtonPress, self.imageViewer.mapFromScene(QPointF(rect.left(), rect.top())), Qt.LeftButton, Qt.LeftButton, Qt.NoModifier), 3)

                noteContentsList = itemData.findNoteContents(itemData.text())

                self.noteNoSingleClicked.emit(itemData.text(), noteContentsList)

            elif type(itemData) is QEngineeringUnknownItem:

                rect = itemData.sceneBoundingRect()

                self.imageViewer.centerOn(rect.center())

                self.imageViewer.zoomImage(True, QMouseEvent(QEvent.MouseButtonPress, self.imageViewer.mapFromScene(QPointF(rect.left(), rect.top())), Qt.LeftButton, Qt.LeftButton, Qt.NoModifier), 3)

            elif type(itemData) is Drawing:

                self.drawingClicked.emit(itemData)

            if issubclass(type(itemData), QGraphicsItem):

                itemData.setSelected(True)

                itemData.update()

    '''

        @brief  find item which has data is given item

        @author humkyung

        @date   2018.04.23

        @history    2018.06.18  Jeongwoo    Add if-statement for QEngineeringUnknownItem

    '''

    def findItemByData(self, item):

        if issubclass(type(item), SymbolSvgItem):

            foundItems = self.findItems(item.name, Qt.MatchExactly|Qt.MatchRecursive, 0)

            for foundItem in foundItems:

                data = foundItem.data(0, self.TREE_DATA_ROLE)

                if data is not None and data is item:

                    return foundItem

        elif type(item) is QEngineeringLineNoTextItem:

            foundItems = self.findItems(item.text() , Qt.MatchExactly|Qt.MatchRecursive, 0)

            for foundItem in foundItems:

                data = foundItem.data(0, self.TREE_DATA_ROLE)

                if data is not None and data is item:

                    return foundItem

        elif type(item) is QEngineeringUnknownItem:

            foundItems = self.findItems('Unknown' , Qt.MatchExactly|Qt.MatchRecursive, 0)

            for foundItem in foundItems:

                data = foundItem.data(0, self.TREE_DATA_ROLE)

                if data is not None and data is item:

                    return foundItem

        return None

    '''

        @brief      Find QTreeWidgetItem by SymbolSvgItem object

        @author     Jeongwoo

        @date       18.04.11

        @history    18.04.12    Jeongwoo    Change Flags (Qt.MatchExactly → Qt.MatchExactly|Qt.MatchRecursive)

                                            Declare self.TREE_DATA_ROLE for QTreeWidgetItem.data(column, role)

    '''

    @pyqtSlot(SymbolSvgItem)

    def findItem(self, item):

        if issubclass(type(item), SymbolSvgItem):

            foundItems = self.findItems(item.name, Qt.MatchExactly|Qt.MatchRecursive, 0)

            if foundItems is not None:

                for fItem in foundItems:

                    data = fItem.data(0, self.TREE_DATA_ROLE)

                    if data is not None and data == item:

                        self.setCurrentItem(fItem)

                        return

        elif type(item) is QEngineeringLineNoTextItem:

            foundItems = self.findItems(item.text(), Qt.MatchExactly|Qt.MatchRecursive, 0)

            if foundItems is not None:

                for fItem in foundItems:

                    data = fItem.data(0, self.TREE_DATA_ROLE)

                    if data is not None and data == item:

                        self.setCurrentItem(fItem)

                        return

        ## Not found

        msg = QMessageBox()

        msg.setIcon(QMessageBox.Warning)

        msg.setText('선택하신 심볼의 데이터를 찾을 수 없습니다.')

    '''

        @brief      remove given item

        @author     humkyung

        @date       2018.04.23

        @history    Jeongwoo 2018.05.25 Remove Highlighting when item removed

                    humkyung 2018.07.22 removed code to Remove highlighting

    '''

    @pyqtSlot(QGraphicsItem)

    def itemRemoved(self, item):

        foundItem = self.findItemByData(item)

        if foundItem is not None:

            foundItem.parent().removeChild(foundItem)

from AppDocData import *

import ItemTreeWidget

import ItemPropertyTableWidget

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

        self.resultPropertyTableWidget = ItemPropertyTableWidget.QItemPropertyTableWidget(self)

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

    '''

        @brief  add message listwidget

        @author humkyung

        @date   2018.07.31

    '''

    def addMessage(self, messageType, message):

        from AppDocData import MessageType

        try:

            current = QDateTime.currentDateTime()

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

            if messageType == MessageType.Error:

                item.setBackground(Qt.red)

            self.listWidgetLog.insertItem(0, item)

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

    '''

        @brief      clear log

        @author     humkyung

        @date       2018.08.01

    '''

    def onClearLog(self):

        self.listWidgetLog.clear()

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

            self.addMessage(MessageType.Error, message)

            self.onClearLog()

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

            self.addMessage(MessageType.Error, message)

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

            self.addMessage(MessageType.Error, message)

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

            self.addMessage(MessageType.Error, message)

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

            self.addMessage(MessageType.Error, message)

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

            self.addMessage(MessageType.Error, message)

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

            self.addMessage(MessageType.Error, message)

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

            self.addMessage(MessageType.Error, message)

        try:

            unknownRect = unknownItem.boundingRectOnScene()

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

            if items is not None:

                for item in items:

                    if issubclass(type(item), QEngineeringUnknownItem):

                        itemRect = item.boundingRectOnScene()

                        if itemRect.topLeft() == unknownRect.topLeft() and itemRect.size() == unknownRect.size(): # Equal

                            item.deleteUnknownItemFromScene()

            unknownItem.setZValue(-10)

            unknownItem.addUnknownItemToScene(self.graphicsView.scene)

        except Exception as ex:

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

            self.addMessage(MessageType.Error, message)

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

            self.addMessage(MessageType.Error, message)

            app._mainWnd = MainWindow.instance()

            app._mainWnd.show()

        MainWindow.resize(1280, 888)