HYTOS

        from DisplayColors import DisplayColors

                color, width, _style, transparent = config.value.split(',')

                self._lineTypeConfigs.append((config.key, color, int(width), style, float(transparent)))

        return matches[0] if matches else (lineType, '#0000FF', 5, Qt.SolidLine, 50)        

        self.ui.tableWidgetLineTypes.setColumnCount(5)

        self.ui.tableWidgetLineTypes.setHorizontalHeaderLabels(['Name', 'Color', 'Width', 'Style', 'Opacity'])

            matches = [config for config in configs if config.key == lineType]

            # Color

            color_cell = QTableWidgetItem('')

            color_cell.setFlags(Qt.ItemIsEnabled)

            if matches:

                tokens = matches[0].value.split(',')

                color_cell.setBackground(QColor(tokens[0]) if len(tokens) == 4 else Qt.blue)

            else:

                color_cell.setBackground(Qt.blue)

            self.ui.tableWidgetLineTypes.setItem(row, 1, color_cell)

            if matches:

                tokens = matches[0].value.split(',')

                lineWidthSpinBox.setValue(int(tokens[1]) if len(tokens) == 4 else int(tokens[0]))

            else:

                lineWidthSpinBox.setValue(5)

            self.ui.tableWidgetLineTypes.setCellWidget(row, 2, lineWidthSpinBox)

            if matches:

                tokens = matches[0].value.split(',')

                lineStyleComboBox.setCurrentText(tokens[2] if len(tokens) == 4 else tokens[1])

            else:

                lineStyleComboBox.setCurrentText('SolidLine')

            self.ui.tableWidgetLineTypes.setCellWidget(row, 3, lineStyleComboBox)

            if matches:

                tokens = matches[0].value.split(',')

                lineTransparentSpinBox.setValue(int(tokens[3]) if len(tokens) == 4 else int(tokens[2]))

            else:

                lineTransparentSpinBox.setValue(100)

            self.ui.tableWidgetLineTypes.setCellWidget(row, 4, lineTransparentSpinBox)

        self.ui.tableWidgetLineTypes.cellDoubleClicked.connect(self.change_line_type_color)

    def change_line_type_color(self, row, column):

        """ change line type's color """

        if column == 1:

            color = QColorDialog.getColor()

            if color.isValid():

                item = self.ui.tableWidgetLineTypes.item(row, column)

                item.setBackground(color)

                color = self.ui.tableWidgetLineTypes.item(row, 1).background().color().name()

                width = self.ui.tableWidgetLineTypes.cellWidget(row, 2).text()

                style = self.ui.tableWidgetLineTypes.cellWidget(row, 3).currentText()

                transparent  = self.ui.tableWidgetLineTypes.cellWidget(row, 4).text()

                configs.append(Config('LineTypes', lineType, '{},{},{},{}'.format(color, width, style,transparent)))

# Created by: PyQt5 UI code generator 5.12

        self.tableWidgetLineTypes.setColumnCount(4)

        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabLineColor), _translate("ConfigurationDialog", "Line No Color"))

# coding: utf-8

"""

    This is DisplayColors module

"""

import sys

from enum import Enum

from AppDocData import AppDocData

from AppDocData import Config

from SingletonInstance import SingletonInstane

class DisplayOptions(Enum):

    """ This is display options class """

    DisplayByLineNo = 1

    DisplayByLineType = 2

class DisplayColors(SingletonInstane):

    """

    This is display colors class

    """

    def __init__(self, option=DisplayOptions.DisplayByLineNo):

        self._option = option

        self.load_data()

    @property

    def option(self):

        """ return display option """

        return self._option

    @option.setter

    def option(self, value):

        """ set display option"""

        self._option = value

    def load_data(self):

        """ load display option from database """

        app_doc_data = AppDocData.instance()

        configs = app_doc_data.getAppConfigs('app', 'display_option')

        if configs:

            self.option = DisplayOptions.DisplayByLineNo if configs[0].value == str(DisplayOptions.DisplayByLineNo) else DisplayOptions.DisplayByLineType

    def save_data(self):

        """ save display option to database """

        try:

            configs = []

            configs.append(Config('app', 'display_option', str(self._option)))

            AppDocData.instance().saveAppConfigs(configs)

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

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

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

        try:

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

                if issubclass(type(child), SymbolSvgItem):

                    if appDocData.isEquipmentType(child.type):

                        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:

                                symbolsRootItem = eqpTreeItem

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

                        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

                        self.SymbolsTreeItem.addChild(item)

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

                elif type(child) is QEngineeringLineNoTextItem:

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

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

                    item.setCheckState(0, Qt.Checked if child.isVisible() else Qt.Unchecked)

                    self.LineNoTreeItem.addChild(item)

                elif type(child) is QEngineeringTrimLineNoTextItem:

                    item = CustomTreeWidgetItem(['Trim 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 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

                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 occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

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

from DisplayColors import DisplayColors

from DisplayColors import DisplayOptions

        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._by_line_no.setChecked(True) if DisplayColors.instance().option == DisplayOptions.DisplayByLineNo else self._by_line_type.setChecked(True)

        """ display colors """

        from DisplayColors import DisplayColors

        from DisplayColors import DisplayOptions

        DisplayColors.instance().option = DisplayOptions.DisplayByLineNo if value == True else DisplayOptions.DisplayByLineType

        if hasattr(self, 'graphicsView'):

            self.graphicsView.scene.update()

            DisplayColors.instance().save_data()

            _pen.setWidth(configs[2])

            _pen.setStyle(configs[3])

            self.setOpacity(float(configs[4]) / 100)

            from App import App 

            from AppDocData import MessageType

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

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

            from App import App 

            from AppDocData import MessageType

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

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

        @brief  return color

        @author Jeongwoo

        @date   2018.05.11

    '''

    def getColor(self):

        from AppDocData import AppDocData

        from DisplayColors import DisplayColors

        from DisplayColors import DisplayOptions

        if DisplayOptions.DisplayByLineType == DisplayColors.instance().option:

            app_doc_data = AppDocData.instance()

            configs = app_doc_data.getConfigs('LineTypes', self.lineType)

            if configs:

                tokens = configs[0].value.split(',')

                return tokens[0] if len(tokens) == 4 else '#0000FF'

            else:

                return '#0000FF'

        else:

            return QEngineeringAbstractItem.getColor(self)

    '''

               <number>4</number>

              <column/>

       <string>Line No Color</string>