HYTOS

# coding: utf-8

""" This is Symbol Tree Widget module """

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 AppDocData import *

import os

import sys

import SymbolBase

import symbol

import SymbolEditorDialog

import QSymbolDisplayDialog

class SearchProxyModel(QSortFilterProxyModel):

    def setFilterRegExp(self, pattern):

        if isinstance(pattern, str):

            pattern = QRegExp( pattern, Qt.CaseInsensitive, QRegExp.FixedString)

        super(SearchProxyModel, self).setFilterRegExp(pattern)

    def _accept_index(self, idx):

        if idx.isValid():

            text = idx.data(Qt.DisplayRole)

            if hasattr(self, 'text') and 'HIDDEN' in self.text.upper() and '(HIDDEN)' in text.upper():

                return True

            elif '(HIDDEN)' in text.upper():

                return False

            if self.filterRegExp().indexIn(text) >= 0:

                return True

            for row in range(idx.model().rowCount(idx)):

                if self._accept_index(idx.model().index(row, 0, idx)):

                    return True

        return False

    def filterAcceptsRow(self, source_row, source_parent):

        idx = self.sourceModel().index(source_row, 0, source_parent)

        return self._accept_index(idx)

class QSymbolTreeWidget(QTreeView):

    # Add signal

    singleClicked = pyqtSignal(SymbolBase.SymbolBase)

    symbols_loaded = pyqtSignal([SymbolBase.SymbolBase])

    TREE_DATA_ROLE = Qt.UserRole

    def __init__(self):

        QTreeView.__init__(self)

        self.setIconSize(QSize(32, 32))

        self.setDragEnabled(True) # enable drag

        self.initSymbolTreeView()

        self.isDoubleClicked = False

        self.doubleClicked.connect(self.itemDoubleClickEvent)

        self.setContextMenuPolicy(Qt.CustomContextMenu)

        self.customContextMenuRequested.connect(self.openContextMenu)

    @property

    def symbols(self):

        """return symbols"""

        res = []

        try:

            tree_item_stack = [self.model().sourceModel().invisibleRootItem()]

            while tree_item_stack:

                tree_item = tree_item_stack.pop(0)

                if tree_item and tree_item.rowCount():

                    for idx in range(tree_item.rowCount()):

                        child = tree_item.child(idx)

                        tree_item_stack.append(child)

                elif tree_item and tree_item.data(Qt.UserRole):

                    if type(tree_item.data(Qt.UserRole)) is SymbolBase.SymbolBase and tree_item.data(Qt.UserRole).iType != -1:

                        res.append(tree_item.data(Qt.UserRole))

        except Exception as ex:

            from App import App

            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 res

    def openContextMenu(self, position):

        """show context menu"""

        item_position = self.mapTo(self, position)

        index = self.indexAt(item_position)

        item = self.model().sourceModel().itemFromIndex(self.model().mapToSource(index))

        data = item.data(self.TREE_DATA_ROLE)

        advanced = False

        app_doc_data = AppDocData.instance()

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

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

            advanced = True

        indexes = self.selectedIndexes()

        if data is not None and type(data) is symbol.SymbolBase:

            sym = self.getSymbolByItemName(item, 0)

            text = item.text()

            if len(indexes) > 0:

                level = 0

                index = indexes[0]

                while index.parent().isValid():

                    index = index.parent()

                    level += 1

            if sym is not None:

                menu = QMenu()

                if advanced:

                    editSymbolAction = QAction(self.tr("Edit Symbol"))

                    editSymbolAction.triggered.connect(lambda: self.editSymbolActionClickEvent(item, 0))

                    menu.addAction(editSymbolAction)

                    editDisplaySymbolAction = QAction(self.tr("Edit Symbol for Display"))

                    editDisplaySymbolAction.triggered.connect(lambda: self.editDisplaySymbolActionClickEvent(item, 0))

                    menu.addAction(editDisplaySymbolAction)

                displaySymbolAction = QAction(self.tr("Display Symbol"))

                displaySymbolAction.triggered.connect(lambda: self.displaySymbolActionClickEvent(item, 0))

                menu.addAction(displaySymbolAction)

                if advanced:

                    deleteSymbolAction = QAction(self.tr("Delete Symbol"))

                    deleteSymbolAction.triggered.connect(lambda: self.deleteSymbolActionClickEvent(sym.getType(), text))

                    menu.addAction(deleteSymbolAction)

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

        else:

            if advanced:

                menu = QMenu()

                editAttrAction = QAction(self.tr("Edit Attribute"))

                editAttrAction.triggered.connect(lambda: self.onEditAttrClicked(item, 0))

                menu.addAction(editAttrAction)

                configs = app_doc_data.getConfigs('Project', 'Operation Code')

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

                if code == 'nK6uurpuiw==': # Samsung

                    spaceAttrAction = QAction(self.tr("================"))

                    menu.addAction(spaceAttrAction)

                    deleteAttrAction = QAction(self.tr("Delete Unused Symbols"))

                    deleteAttrAction.triggered.connect(lambda: self.onDeleteSymbolBatchByCategory(item))

                    menu.addAction(deleteAttrAction)

                resetDefaultScaleAction = QAction(self.tr("Reset All Default Symbol Scale"))

                resetDefaultScaleAction.triggered.connect(self.resetDefaultScale)

                menu.addAction(resetDefaultScaleAction)

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

    def resetDefaultScale(self):

        text, result = QInputDialog.getText(self, self.tr('Reset all default symbol scale'), self.tr('To proceed, enter "Confirm" in the input box below.'))

        if result and text == 'Confirm':

            app_doc_data = AppDocData.instance()

            for sym in self.symbols:

                sym.setScale()

                app_doc_data.updateSymbol(sym)

            self.initSymbolTreeView()

            QMessageBox.information(self, self.tr('Information'), self.tr('Succeeded'))

    def editSymbolActionClickEvent(self, item, columNo):

        self.showSymbolEditorDialog(item, columNo)

    def editDisplaySymbolActionClickEvent(self, item, columNo):

        self.showSymbolEditorDialog(item, columNo, True)

    def onDeleteSymbolBatchByCategory(self, item):

        """Delete unused symbol by category"""

        msg = QMessageBox()

        msg.setIcon(QMessageBox.Critical)

        msg.setText(self.tr('Are you sure you want to delete symbols in this category?\nData can not be restored!'))

        msg.setWindowTitle(self.tr('Delete symbols'))

        msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)

        result = msg.exec_()

        self.handleDeleteSymbolBatchAction(result, item)

    def handleDeleteSymbolBatchAction(self, result, item):

        if result == QMessageBox.Ok:

            text, result = QInputDialog.getText(self, self.tr('Delete symbols'), self.tr('To proceed, enter "Confirm" in the input box below.'))

            if result and text == 'Confirm':

                app_doc_data = AppDocData.instance()

                project = app_doc_data.getCurrentProject()

                data = item.data(self.TREE_DATA_ROLE)

                itemType = data[2]

                unusedSymbols = app_doc_data.getSymbolNameListByUnused()

                unusedUIDs = [symbol[0] for symbol in unusedSymbols]

                categorySymbols = app_doc_data.getSymbolListByType('type', itemType)

                itemNames = [symbol.sName for symbol in categorySymbols if symbol.uid in unusedUIDs]

                for itemName in itemNames:

                    res, _ = app_doc_data.deleteSymbol(itemName)

                    if res:

                        imagePath = os.path.join(project.getImageFilePath(), itemType,

                                                itemName + '.png')  # itemName DOESN'T includes ".png"

                        imageDisplayPath = os.path.join(project.getImageFilePath(), itemType,

                                                itemName + '_display' + '.png')  # itemName DOESN'T includes ".png"

                        if os.path.exists(imagePath):

                            os.remove(imagePath)

                        if os.path.exists(imageDisplayPath):

                            os.remove(imageDisplayPath)

                        svgPath = os.path.join(project.getSvgFilePath(), itemType, itemName + '.svg')

                        if os.path.exists(svgPath):

                            os.remove(svgPath)

                else:

                    pass

                self.initSymbolTreeView()

    def onEditAttrClicked(self, item, columnNo):

        """pop up attribute editor dialog"""

        from SymbolAttrEditorDialog import QSymbolAttrEditorDialog

        try:

            data = item.data(self.TREE_DATA_ROLE)

            dlg = QSymbolAttrEditorDialog(self, data)

            dlg.show()

            dlg.exec_()

        except Exception as ex:

            from App import App

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

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

    def displaySymbolActionClickEvent(self, item, columnNo):

        # project = AppDocData.instance().getCurrentProject()

        # image = QImage(os.path.join(project.getImageFilePath(), itemType, itemName, "PNG")) #itemName includes ".png"

        try:

            sym = self.getSymbolByItemName(item, columnNo)

            if sym is not None:

                # origin symbol image

                path = sym.getPath()

                image = QImage(path, "PNG")

                # symbol image for display

                path = os.path.splitext(path)

                path = path[0] + '_display' + path[1]

                image2 = QImage(path, "PNG") if os.path.exists(path) else None

                dialog = QSymbolDisplayDialog.QSymbolDisplayDialog(image, image2)

                dialog.showDialog()

            else:

                QMessageBox.about(self, self.tr('Error'), self.tr('Error occurs during loading symbol data.'))

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

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

    def deleteSymbolActionClickEvent(self, itemType, itemName):

        msg = QMessageBox()

        msg.setIcon(QMessageBox.Critical)

        msg.setText(self.tr('Are you sure you want to delete selected symbol?\nData can not be restored!'))

        msg.setWindowTitle(self.tr('Delete symbol'))

        msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)

        result = msg.exec_()

        self.handleDeleteSymbolAction(result, itemType, itemName)

    '''

        @history    2018.05.03  Jeongwoo    Modify file path with ".png" and ".svg"

                                            Use project object when making svgPath

    '''

    def handleDeleteSymbolAction(self, result, itemType, itemName):

        if result == QMessageBox.Ok:

            res, _ = AppDocData.instance().deleteSymbol(itemName)

            if res:

                project = AppDocData.instance().getCurrentProject()

                imagePath = os.path.join(project.getImageFilePath(), itemType,

                                        itemName + '.png')  # itemName DOESN'T includes ".png"

                imageDisplayPath = os.path.join(project.getImageFilePath(), itemType,

                                        itemName + '_display' + '.png')  # itemName DOESN'T includes ".png"

                if os.path.exists(imagePath):

                    os.remove(imagePath)

                if os.path.exists(imageDisplayPath):

                    os.remove(imageDisplayPath)

                svgPath = os.path.join(project.getSvgFilePath(), itemType, itemName + '.svg')

                if os.path.exists(svgPath):

                    os.remove(svgPath)

            self.initSymbolTreeView()

        else:

            pass

    def initSymbolTreeView(self):

        """initialize symbol tree view"""

        project = AppDocData.instance().getCurrentProject()

        if project is not None:

            if self.model():

                self.model().clear()

            projectPath = project.getPath().replace("\\", "/")

            self.load_symbol_info()

            self.expandAll()

        self.selectionModel().selectionChanged.connect(self.on_selection_changed)

    def load_symbol_info(self):

        """load symbol information and display it on tree view"""

        try:

            app_doc_data = AppDocData.instance()

            model = QStandardItemModel()

            symbolTypeList = app_doc_data.getSymbolTypeList()

            for row, symbolType in enumerate(symbolTypeList):

                item = QStandardItem(symbolType[2])

                item.setData(symbolType, self.TREE_DATA_ROLE)

                item.setEditable(False)

                item.setSelectable(False)

                symbolList = app_doc_data.getSymbolListByType('UID', symbolType[0])

                for symbol in symbolList:

                    child = QStandardItem(symbol.getName())

                    child.setData(symbol, self.TREE_DATA_ROLE)

                    child.setEditable(False)

                    _, svg = app_doc_data.read_symbol_shape(symbol.sName)

                    if svg:

                        symbol.pixmap = QPixmap()

                        symbol.pixmap.loadFromData(svg if isinstance(svg, bytes) else svg.encode())

                        icon = QIcon(symbol.pixmap)

                        child.setIcon(icon)

                        child.svgFilePath = None  # save svg file path

                    else:

                        svgPath = symbol.getSvgFileFullPath()

                        symbol.pixmap = QPixmap(svgPath)

                        icon = QIcon(symbol.pixmap)

                        child.setIcon(icon)

                        child.svgFilePath = svgPath  # save svg file path

                    item.appendRow(child)

                item.sortChildren(0, Qt.AscendingOrder)

                model.appendRow(item)

            proxy_model = SearchProxyModel()

            proxy_model.setSourceModel(model)

            proxy_model.setDynamicSortFilter(True)

            proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)

            self.setModel(proxy_model)

            """

            symbolTypeList = app_doc_data.getSymbolTypeList()

            for symbolType in symbolTypeList:

                if not symbolType[1]: continue  # skip if category is empty

                parent = QTreeWidgetItem(self, [symbolType[2]])

                parent.setData(0, self.TREE_DATA_ROLE, symbolType)

                symbolList = app_doc_data.getSymbolListByType('UID', symbolType[0])

                for symbol in symbolList:

                    symbolItem = QTreeWidgetItem(parent, [symbol.getName()])

                    symbolItem.setData(0, self.TREE_DATA_ROLE, symbol)

                    _, svg = app_doc_data.read_symbol_shape(symbol.sName)

                    if svg:

                        symbol.pixmap = QPixmap()

                        symbol.pixmap.loadFromData(svg if isinstance(svg, bytes) else svg.encode())

                        icon = QIcon(symbol.pixmap)

                        symbolItem.setIcon(0, icon)

                        symbolItem.svgFilePath = None   # save svg file path

                    else:

                        svgPath = symbol.getSvgFileFullPath()

                        symbol.pixmap = QPixmap(svgPath)

                        icon = QIcon(symbol.pixmap)

                        symbolItem.setIcon(0, icon)

                        symbolItem.svgFilePath = svgPath  # save svg file path

                parent.sortChildren(0, Qt.AscendingOrder)

            """

        except Exception as ex:

            from App import App

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

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

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

    def showSymbolEditorDialog(self, item, columnNo, display=False):

        """pop up symbol editor dialog"""

        try:

            sym = self.getSymbolByItemName(item, columnNo)

            if sym and display:

                # for symbol image for display

                path = os.path.splitext(sym.getPath())

                path = path[0] + '_display' + path[1]

                if os.path.exists(path):

                    image = QImage(path, "PNG")

                else:

                    path = sym.getPath()

                    image = QImage(path, "PNG")

                symbolEditorDialog = SymbolEditorDialog.QSymbolEditorDialog(self, image,

                                                                            AppDocData.instance().getCurrentProject(),

                                                                            sym, True)

                (isAccepted, isImmediateInsert, offsetX, offsetY, newSym) = symbolEditorDialog.showDialog()

                if isAccepted:

                    self.initSymbolTreeView()

            elif sym:

                # for symbol data and detection image

                path = sym.getPath()

                image = QImage(path, "PNG")

                symbolEditorDialog = SymbolEditorDialog.QSymbolEditorDialog(self, image,

                                                                            AppDocData.instance().getCurrentProject(),

                                                                            sym, False)

                (isAccepted, isImmediateInsert, offsetX, offsetY, newSym) = symbolEditorDialog.showDialog()

                if isAccepted:

                    self.initSymbolTreeView()

            else:

                QMessageBox.about(self, self.tr('Error'), self.tr('Error occurs during loading symbol data.'))

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

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

    def select_symbol(self, symbol):

        ''' no more used '''

        """select a tree with given symbol"""

        founds = self.findItems(symbol.name, Qt.MatchExactly | Qt.MatchRecursive, 0)

        if founds:

            self.setCurrentItem(founds[0])

    def itemDoubleClickEvent(self, index):

        """pop up symbol editor"""

        item = self.model().sourceModel().itemFromIndex(self.model().mapToSource(index))

        if item:

            data = item.data(Qt.UserRole)

            if data and type(data) is SymbolBase.SymbolBase:

                sym = self.getSymbolByItemName(item, 0)

                itemName = item.text()

                if sym is not None:

                    self.showSymbolEditorDialog(item, 0)

    def getSymbolByItemName(self, item, columnNo):

        """Get Symbol data by symbol name"""

        name = item.text()

        sym = AppDocData.instance().getSymbolByQuery("name", name)

        return sym

    def on_selection_changed(self, new_selection, old_selection):

        """show symbol's property when selection changed"""

        if new_selection.indexes():

            proxy_model = self.model()

            item = proxy_model.sourceModel().itemFromIndex(proxy_model.mapToSource(new_selection.indexes()[0]))

            if item is not None:

                data = item.data(self.TREE_DATA_ROLE)

                if data is not None and type(data) is symbol.SymbolBase:

                    self.singleClicked.emit(data)

    def onCurrentItemChanged(self, current, previous):

        """show symbol's property when selection changed"""

        item = self.currentItem()

        if item is not None:

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

            if data is not None and type(data) is symbol.SymbolBase:

                self.singleClicked.emit(data)

    def startDrag(self, dropAction):

        """start drag"""

        try:

            index = self.currentIndex()

            proxy_model = self.model()

            items = [proxy_model.sourceModel().itemFromIndex(proxy_model.mapToSource(index))]

            if items and hasattr(items[0], 'svgFilePath') and os.path.exists(items[0].svgFilePath):

                symData = items[0].data(self.TREE_DATA_ROLE)

                mime = QMimeData()

                mime.setText(symData.getName())

                mime.tag = symData

                drag = QDrag(self)

                drag.setMimeData(mime)

                originalPoint = symData.getOriginalPoint() if not symData.getConvertingPoint() else symData.getConvertingPoint()

                drag.setHotSpot(QPoint(int(float(originalPoint.split(",")[0])), int(float(originalPoint.split(",")[1]))))

                pix = QPixmap(symData.pixmap.size())

                pix.fill(Qt.transparent)

                painter = QPainter(pix)

                painter.setOpacity(0.3)

                painter.drawPixmap(QPoint(), symData.pixmap)

                painter.end()

                drag.setPixmap(pix)

                drag.exec(Qt.CopyAction)

        except Exception as ex:

            from App import App

            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)