HYTOS

# coding: utf-8

""" This is item tree widget module """

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 EngineeringAbstractItem import QEngineeringAbstractItem

from SymbolSvgItem import SymbolSvgItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringNoteItem import QEngineeringNoteItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from EngineeringEquipmentItem import QEngineeringEquipmentItem

from EngineeringInstrumentItem import QEngineeringInstrumentItem

from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

from EngineeringUnknownItem import QEngineeringUnknownItem

from EngineeringErrorItem import QEngineeringErrorItem

from EngineeringEndBreakItem import QEngineeringEndBreakItem

from EngineeringFlowMarkItem import QEngineeringFlowMarkItem

from AppDocData import AppDocData

from Drawing import Drawing

class CustomTreeWidgetItem(QTreeWidgetItem):

    def __init__(self, *args, **kwargs):

        super(CustomTreeWidgetItem, self).__init__(*args, **kwargs)

    def setData(self, column, role, value):

        if role == Qt.EditRole:

            pass

        elif role == Qt.CheckStateRole:

            if self.treeWidget() is not None:

                state = Qt.CheckState.Unchecked if value is 0 else Qt.CheckState.Checked

                self.treeWidget().checkBoxToggled.emit(self, state)

        super(CustomTreeWidgetItem, self).setData(column, role, value)

class QItemTreeWidget(QTreeWidget):

    """ This is item tree widget """

    TREE_DATA_ROLE = Qt.UserRole

    # Add Signal

    singleClicked = pyqtSignal(QEngineeringAbstractItem)

    noteNoSingleClicked = pyqtSignal(str, dict)

    #lineNoSingleClicked = pyqtSignal(QEngineeringAbstractItem)

    drawingClicked = pyqtSignal(Drawing)

    checkBoxToggled = pyqtSignal(QTreeWidgetItem, Qt.CheckState)

    '''

        @history    2018.05.11  Jeongwoo    Add Context Menu settings

    '''

    def __init__(self, imageViewer):

        QTreeWidget.__init__(self)

        self.checkBoxToggled.connect(self.itemCheckBoxToggled)

        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:

                            data.transfer.onRemoved.emit(data)

                            # self.imageViewer.scene.removeItem(data)

                            # if type(data) is QEngineeringLineNoTextItem:

                            #    self.imageViewer.mainWindow.removedItems['LINE'].append(str(data.uid))

                            # elif type(data) is QEngineeringInstrumentItem:

                            #    self.imageViewer.mainWindow.removedItems['INST'].append(str(data.uid))

                            # elif type(data) is QEngineeringEquipmentItem:

                            #    self.imageViewer.mainWindow.removedItems['EQUIP'].append(str(data.uid))

                            # elif type(data) is QEngineeringNoteItem:

                            #    self.imageViewer.mainWindow.removedItems['NOTE'].append(str(data.uid))

                            # 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 occurred({}) 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:

            if item is self.LineNoTreeItem:

                menu = QMenu()

                explode_action = QAction(self.tr("Explode"))

                explode_action.triggered.connect(lambda: self.explode_all_line_nos(item))

                menu.addAction(explode_action)

                explodeKeepFromTo_action = QAction(self.tr("Explode(keep from, to)"))

                explodeKeepFromTo_action.triggered.connect(lambda: self.explode_all_line_nos(item, True))

                menu.addAction(explodeKeepFromTo_action)

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

            else:

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

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

                    menu = QMenu()

                    pickColorAction = QAction(self.tr("Select Line Color"))

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

                    menu.addAction(pickColorAction)

                    explode_action = QAction(self.tr("Explode"))

                    freeze = data.prop('Freeze')

                    explode_action.setEnabled(not freeze)

                    explode_action.triggered.connect(lambda: self.explode_line_no(item))

                    menu.addAction(explode_action)

                    if type(data) is QEngineeringLineNoTextItem:

                        explodeKeepFromTo_action = QAction(self.tr("Explode(keep from, to)"))

                        explodeKeepFromTo_action.setEnabled(not freeze)

                        explodeKeepFromTo_action.triggered.connect(lambda: self.explode_line_no(item, True))

                        menu.addAction(explodeKeepFromTo_action)

                    reverse_flow_action = QAction(self.tr("Reverse Flow"))

                    reverse_flow_action.triggered.connect(lambda: self.reverse_line_flow(item))

                    menu.addAction(reverse_flow_action)

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

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

                    menu = QMenu()

                    lineTypeAction = QAction(self.tr("Select Line Type"))

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

                    menu.addAction(lineTypeAction)

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

                    freeze = line_no.prop('Freeze')

                    explode_action = QAction(self.tr("Explode"))

                    explode_action.setEnabled(not freeze)

                    explode_action.triggered.connect(lambda: self.explode_line_run(item))

                    menu.addAction(explode_action)

                    reverse_flow_action = QAction(self.tr("Reverse Flow"))

                    reverse_flow_action.triggered.connect(lambda: self.reverse_line_flow(item))

                    menu.addAction(reverse_flow_action)

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

            self.SymbolsTreeItem.sortChildren(0, Qt.AscendingOrder)

            self.EqpTreeItem.sortChildren(0, Qt.AscendingOrder)

    '''

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

            if lineNoItem:

                lineNoItem.change_color(color.name())

                lineNoItem.setColor(color.name())

                connectedItems = lineNoItem.getConnectedItems()

                if connectedItems is not None:

                    for connectedItem in connectedItems:

                        connectedItem.setColor(color.name())

                        connectedItem.update()

                    self.changeTreeWidgetItemColorRecursively(lineNoTreeWidgetItem, color)

    def explode_line_run(self, tree_widget_item):

        """ explode line run """

        try:

            line_run = tree_widget_item.data(0, self.TREE_DATA_ROLE)

            if line_run:

                for item in line_run.items:

                    if issubclass(type(item), SymbolSvgItem): self.addTreeItem(self.SymbolsTreeItem, item)

                for i in reversed(range(tree_widget_item.childCount())):

                    tree_widget_item.takeChild(i)

                line_run.explode()

                tree_widget_item.parent().takeChild(tree_widget_item.parent().indexOfChild(tree_widget_item))

        finally:

            pass

    def explode_all_line_nos(self, tree_widget_item, remainFromTo=False):

        """ explode all line nos """

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        for i in reversed(range(self.LineNoTreeItem.childCount())):

            if not self.LineNoTreeItem.child(i).data(0, self.TREE_DATA_ROLE).prop('Freeze'):

                self.explode_line_no(self.LineNoTreeItem.child(i), remainFromTo)

        # for item in [item for item in self.scene.items() if hasattr(item, 'owner')

    def reverse_line_flow(self, lineTreeWidgetItem):

        """ reverse line flow """

        try:

            line_item = lineTreeWidgetItem.data(0, self.TREE_DATA_ROLE)

            if line_item:

                line_item.reverse()

        finally:

            pass

    def explode_line_no(self, lineNoTreeWidgetItem, remainFromTo=False):

        """ explode line no """

        try:

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

            if line_no_item:

                connected_items = line_no_item.getConnectedItems()

                for item in connected_items:

                    self.addTreeItem(self.SymbolsTreeItem, item)

                for i in reversed(range(lineNoTreeWidgetItem.childCount())):

                    lineNoTreeWidgetItem.takeChild(i)

                line_no_item.explode(remainFromTo)

        finally:

            pass

    '''

        @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.setIcon(0, QIcon(':newPrefix/objects.png'))

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

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

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

        self.LineNoTreeItem.setFlags(self.root.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable)

        self.LineNoTreeItem.setCheckState(0, Qt.Checked)

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

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

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

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

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

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

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

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

        for idx in range(self.root.childCount()):

            child = self.root.child(idx)

            child.setIcon(0, QIcon(':newPrefix/folder-black.png'))

    '''

        @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:

                return treeItem

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

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

        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

        appDocData = AppDocData.instance()

        try:

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

                if issubclass(type(child), SymbolSvgItem):

                    isEquipmentType = appDocData.isEquipmentType(child.type)

                    if isEquipmentType:

                        item = QTreeWidgetItem(self.EqpTreeItem, [child.name])

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

                        # elif child.type == 'Nozzles':

                        #    for i in range(self.EqpTreeItem.childCount()):

                        #        eqpTreeItem = eqpRootTreeItem[0].child(i)

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

                        #        if child.owner is eqpSymbol:

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

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

                        #            break

                        if item is None:

                            item = QTreeWidgetItem(self.SymbolsTreeItem, [child.name])

                    elif child.type == 'Notes':

                        child.treeItem = True

                        return item

                    else:

                        item = QTreeWidgetItem(self.SymbolsTreeItem, [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

                        if isEquipmentType:

                            self.EqpTreeItem.addChild(item)

                            self.EqpTreeItem.sortChildren(0, Qt.AscendingOrder)  # sort childrens

                        else:

                            self.SymbolsTreeItem.addChild(item)

                            self.SymbolsTreeItem.sortChildren(0, Qt.AscendingOrder)  # sort childrens

                elif type(child) is QEngineeringLineNoTextItem:

                    for index in range(self.LineNoTreeItem.childCount()):

                        if child.text() == self.LineNoTreeItem.child(0).text(index) and self.LineNoTreeItem.child(

                                0).childCount() is 0:

                            self.LineNoTreeItem.takeChild(index)

                            break

                    item = CustomTreeWidgetItem([child.text().replace('\n', '')])

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

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

                    item.setCheckState(0, Qt.Checked if child.isVisible() else 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)

                    self.LineNoTreeItem.sortChildren(0, Qt.AscendingOrder)  # sort line nos

                elif type(child) is QEngineeringTrimLineNoTextItem:

                    item = CustomTreeWidgetItem(['Unknown Line'])

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

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

                    item.setCheckState(0, Qt.Checked if child.isVisible() else 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):

                    founds = None

                    for i in range(self.NotesTreeItem.childCount()):

                        item = self.NotesTreeItem.child(i)

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

                        founds = [note for note in notes if note.text() == child.text()]

                        if founds: break

                    if founds:

                        item.setData(0, self.TREE_DATA_ROLE, founds + [child, ])

                    else:

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

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

                        if parent is not None:

                            parent.addChild(item)

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

                    child.treeItem = item

                    item.setText(0, '{}({})'.format(child.text(), len(item.data(0, self.TREE_DATA_ROLE))))

                    # show note icon if note icon is setted

                    if child.symbol:

                        iconPath = os.path.join(appDocData.getCurrentProject().getSvgFilePath(), 'Notes',

                                                child.symbol.name + '.svg')

                        item.setIcon(0, QIcon(iconPath))

                elif (type(child) is QEngineeringUnknownItem):

                    item = QTreeWidgetItem(['Unknown'])

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

                    child.treeItem = item

                    self.UnknownTreeItem.addChild(item)

                    if child.lineIndicator == 'Match':

                        item.setHidden(True)

            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 and parent is not item.parent()):

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

                            if parentData is not None and 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

                            elif parent is not None:

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

                                parent.addChild(item)

                            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

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

        try:

            changedSceneItems = [item for item in items if ((issubclass(type(item), SymbolSvgItem) and

                                                                  type(item) is not QEngineeringErrorItem and

                                                                  type(item) is not QEngineeringEndBreakItem and

                                                                  type(item) is not QEngineeringFlowMarkItem) 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)]

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

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

            if first + second:

                self.initResultTreeWidget(first + second)

        finally:

            self.update_item_count()

    '''

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

                self.addTreeItem(self.NotesTreeItem, item)

            else:

                self.addTreeItem(self.root, item)

        if self.NotesTreeItem is not None:

            self.NotesTreeItem.sortChildren(0, Qt.AscendingOrder)

        self.expandAll()

    def itemCheckBoxToggled(self, item, checkState):

        """

        set visible of invisible of item

        """

        try:

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

            if (type(itemData) is QEngineeringLineNoTextItem) or (type(itemData) is QEngineeringTrimLineNoTextItem):

                itemData.setVisible(checkState == Qt.CheckState.Checked)

        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:

            pass

    '''

        @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

        from HighlightCommand import HighlightCommand

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

                HighlightCommand(self.imageViewer).execute(itemData)

                ## 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 QEngineeringRunItem:

                HighlightCommand(self.imageViewer).execute(itemData)

                self.singleClicked.emit(itemData)

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

                    item.child(child).setSelected(True)

            elif type(itemData) is QEngineeringLineNoTextItem:

                HighlightCommand(self.imageViewer).execute(itemData)

                # self.lineNoSingleClicked.emit(itemData)

                itemData.setSelected(True)

                # for child in range(item.childCount()):

                #    for cchild in range(item.child(child).childCount()):

                #        item.child(child).child(cchild).setSelected(True)

            elif type(itemData) is list and type(itemData[0]) is QEngineeringNoteItem:

                HighlightCommand(self.imageViewer).execute(itemData)

                '''

                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[0].findNoteContents(itemData[0].text())

                self.noteNoSingleClicked.emit(itemData[0].text(), noteContentsList)

            elif type(itemData) is QEngineeringUnknownItem:

                HighlightCommand(self.imageViewer).execute(itemData)

            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

        @history    2018.11.22  euisung     add delete note

    '''

    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().replace('\n', ''), 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

        elif type(item) is QEngineeringNoteItem:

            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 QEngineeringTrimLineNoTextItem:

            foundItems = self.findItems('Unknown Line', 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  Init LineNoItems child

        @author kyouho

        @date   2018.09.17

    '''

    def InitLineNoItems(self):

        try:

            removeLineItem = []

            for lineIndex in range(self.LineNoTreeItem.childCount()):

                ## LineNoItem, TrimLine Item

                lineItem = self.LineNoTreeItem.child(lineIndex)

                removeRunItem = []

                for runIndex in range(lineItem.childCount()):

                    ## RUN Item

                    runItem = lineItem.child(runIndex)

                    for symbolIndex in range(runItem.childCount()):

                        symbolItem = runItem.child(0)

                        symbol = symbolItem.data(0, self.TREE_DATA_ROLE)

                        symbolItem.parent().removeChild(symbolItem)

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

                            self.EqpTreeItem.addChild(symbolItem)

                        else:

                            self.SymbolsTreeItem.addChild(symbolItem)

                    ## 지울 Item 모음

                    removeRunItem.append(runItem)

                ## Run Item들 삭제

                for removeItem in removeRunItem:

                    lineItem.removeChild(removeItem)

                ## 지울 Trim Line 모음

                if lineItem.text(0) == 'Trim Line':

                    removeLineItem.append(lineItem)

            ## Trim Line들 삭제

            for removeItem in removeLineItem:

                self.LineNoTreeItem.removeChild(removeItem)

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

        @history    2018.11.22  euisung     add note, unknown

    '''

    @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().replace('\n', ''), 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 QEngineeringNoteItem:

            founds = None

            for i in range(self.NotesTreeItem.childCount()):

                child = self.NotesTreeItem.child(i)

                notes = child.data(0, self.TREE_DATA_ROLE)

                founds = [note for note in notes if note.text() == item.text()]

                if founds:

                    self.setCurrentItem(child)

                    return

        elif type(item) is QEngineeringUnknownItem:

            foundItems = self.findItems('Unknown', 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 QEngineeringTrimLineNoTextItem:

            foundItems = self.findItems('Unknown Line', 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

        # QMessageBox.warning(self, self.tr('Error'), self.tr('Can not find data for the selected symbol.'))

    '''

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

        try:

            found = self.findItemByData(item)

            if found and found.parent():

                found.data(0, self.TREE_DATA_ROLE).treeItem = None   # reset treeItem property

                found.parent().removeChild(found)

        finally:

            self.update_item_count()

    def update_item_count(self):

        """update items count"""

        if hasattr(self, 'LineNoTreeItem'):

            self.LineNoTreeItem.setText(0, 'LINE NO({})'.format(self.LineNoTreeItem.childCount()))

        if hasattr(self, 'EqpTreeItem'):

            self.EqpTreeItem.setText(0, 'EQUIPMENTS({})'.format(self.EqpTreeItem.childCount()))

        if hasattr(self, 'SymbolsTreeItem'):

            self.SymbolsTreeItem.setText(0, 'SYMBOLS({})'.format(self.SymbolsTreeItem.childCount()))

        if hasattr(self, 'NotesTreeItem'):

            self.NotesTreeItem.setText(0, 'NOTES({})'.format(self.NotesTreeItem.childCount()))

        if hasattr(self, 'UnknownTreeItem'):

            self.UnknownTreeItem.setText(0, 'UNKNOWN({})'.format(self.UnknownTreeItem.childCount()))