HYTOS

# coding: utf-8

""" This is select attribute command module """

import os.path

import sys

import AbstractCommand

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QEvent

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImge, QPixmap, QPainterPath, QFileDialog, QCursor, QMouseEvent

    except ImportError:

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

'''

    @brief      QtImageViewer Select Attribute Command

    @author     kyouho

    @date       18.04.10

'''

class SelectAttributeCommand(AbstractCommand.AbstractCommand):

    onSuccess = pyqtSignal()

    def __init__(self, item, attr, imageViewer):

        super(SelectAttributeCommand, self).__init__(imageViewer)

        self.name = 'SelectAttribute'

        self.imageViewer.setCursor(QCursor(Qt.ArrowCursor))

        self._item = item

        self._attr = attr

    '''

        @brief      Select Attribuew

        @author     kyouho

        @date       18.07.19

        @history    euising  2019.01.15  add specbreak

        @history    add Valve Oper Item 2019.04.15 by humkyung

    '''

    def execute(self, param):

        from SymbolAttr import SymbolAttr

        from SymbolAttr import SymbolProp

        event = param[1]

        scenePos = param[2]

        try:

            if 'mouseReleaseEvent' == param[0] and event.button() == Qt.LeftButton:

                from EngineeringAbstractItem import QEngineeringAbstractItem

                from SymbolSvgItem import SymbolSvgItem

                from EngineeringTextItem import QEngineeringTextItem

                from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

                from EngineeringRunItem import QEngineeringRunItem

                from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

                from EngineeringLineItem import QEngineeringLineItem

                from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

                from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

                from EngineeringConnectorItem import QEngineeringConnectorItem

                from EngineeringEndBreakItem import QEngineeringEndBreakItem

                from EngineeringVendorItem import QEngineeringVendorItem

                from EngineeringReservedWordTextItem import QEngineeringReservedWordTextItem

                if self._attr is not None and type(self._attr) is SymbolAttr:

                    item = self.imageViewer.scene().itemAt(scenePos, QTransform())

                    if self._item is not item:

                        if False:#item is not None and self._attr.AttributeType == 'Line Item' and issubclass(type(item), QEngineeringLineItem):

                            # unused code

                            self._item.conns.clear()

                            self._item.conns.append(item)

                            self.onSuccess.emit()

                        elif item is not None and self._attr.AttributeType == 'CONN' and (issubclass(type(item), QEngineeringLineItem) or issubclass(type(item), SymbolSvgItem) or type(item) is QEngineeringVendorItem or type(item) is QEngineeringReservedWordTextItem):

                            self._item.connectors[self._attr.AttrAt - 1].connect(item, QEngineeringAbstractItem.CONNECTED_AT_BODY)

                            if type(item) is QEngineeringReservedWordTextItem:

                                item.owner = self._item

                            self.onSuccess.emit()

                        elif item is not None and self._attr.AttributeType == 'CONN' and (type(item) is QEngineeringConnectorItem):

                            self._item.connectors[self._attr.AttrAt - 1].connect(item.parent, QEngineeringAbstractItem.CONNECTED_AT_PT)

                            self.onSuccess.emit()

                        #elif item is not None and issubclass(type(self._item), QEngineeringSpecBreakItem) and self._attr.AttributeType == 'Comp Item' and type(item) is not QGraphicsPixmapItem:

                        #    self._item.attrs[self._attr] = str(item.uid)

                        #    self.onSuccess.emit()

                        elif item is not None and (type(self._item) is not QEngineeringEndBreakItem) and (type(item) is QEngineeringLineNoTextItem) and self._attr.AttributeType == 'OWNER':

                            inserted = False

                            if item.runs:

                                for run in item.runs:

                                    for index in range(len(run.items)):

                                        if run.items[index].is_connected(self._item):

                                            if index + 1 != len(run.items) and index != 0 and run.items[index + 1].is_connected(self._item):

                                                run.items.insert(index + 1, self._item)

                                                inserted = True

                                                break

                                            elif index + 1 == len(run.items):

                                                run.items.append(self._item)

                                                inserted = True

                                                break

                                            elif index == 0:

                                                run.items.insert(0, self._item)

                                                inserted = True

                                                break

                                    if inserted:

                                        break

                                if not inserted:

                                    item.runs.append(QEngineeringRunItem())

                                    item.runs[-1].items.append(self._item)

                                    inserted = True

                            else:

                                item.runs.append(QEngineeringRunItem())

                                item.runs[0].items.append(self._item)

                                inserted = True

                            if inserted:

                                if not item.conns and type(self._item) is QEngineeringLineItem:

                                    item.conns.append(self._item)

                                self._item.owner = item

                            self.onSuccess.emit()

                        elif item is not None and (type(self._item) is QEngineeringEndBreakItem or issubclass(type(self._item), QEngineeringTextItem)) and (type(item) is QEngineeringLineItem or issubclass(type(item), SymbolSvgItem)) and self._attr.AttributeType == 'OWNER':

                            self._item.owner = item

                            self.onSuccess.emit()

                        elif item is not None and (self._attr.AttributeType == QEngineeringAbstractItem.assoc_type(item) or \

                                                    (self._attr.AttributeType == 'Comp Item' and (QEngineeringAbstractItem.assoc_type(item) == 'Symbol Item' or QEngineeringAbstractItem.assoc_type(item) == 'Line Item')) or \

                                                    (self._attr.AttributeType == 'EQ Item' and QEngineeringAbstractItem.assoc_type(item) == 'EQ Item')):

                            if self._attr.Freeze:

                                self.onSuccess.emit()

                                return

                            if QEngineeringAbstractItem.assoc_type(item) not in self._item._associations:

                                self._item._associations[QEngineeringAbstractItem.assoc_type(item)] = []

                            for key in self._item.attrs.keys():

                                if key.Attribute == self._attr.Attribute:

                                    if not key.Codes.values or (key.Codes.values and key.Codes.find_match_exactly(item.text())):

                                        key.AssocItem = item

                                        self._item.add_assoc_item(item, self._attr.AttrAt, force=True)

                                        # auto freeze when manually attribute setting

                                        self._item.getAttributes()  # attr rebinding so old key is not valid

                                        for neyKey in self._item.attrs.keys():

                                            if neyKey.Attribute == self._attr.Attribute:

                                                neyKey.Freeze = True

                                                break

                                        if issubclass(type(item), QEngineeringTextItem): item.owner = self._item

                                        self.onSuccess.emit()

                                        break

                elif self._attr is not None and type(self._attr) is SymbolProp:

                    item = self.imageViewer.scene().itemAt(scenePos, QTransform())

                    if self._item is not item and item is not None and self._attr.match_type(item):

                        self._item.set_property(self._attr.Attribute, item)

                        if issubclass(type(item), QEngineeringTextItem): item.owner = self._item

                        self.onSuccess.emit()

        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)       

        self.isTreated = True

    def undo(self):

        pass

    def redo(self):

        pass

    '''

        @brief      Find TextItem contain Point

        @author     kyouho

        @date       18.07.19

    '''

    def findTextItemInPoint(self, point):

        from EngineeringTextItem import QEngineeringTextItem

        for item in self.imageViewer.items():

            if type(item) is QEngineeringTextItem:

                if self.isOverlapItemAndPoint(item, point):

                    return (True, item)

        return (False,)

    '''

        @brief      Find Symbol Item contain Point

        @author     kyouho

        @date       18.07.19

    '''

    def findSymbolItemInPoint(self, point):

        from SymbolSvgItem import SymbolSvgItem

        for item in self.imageViewer.items():

            if issubclass(type(item), SymbolSvgItem):

                if self.isOverlapItemAndPoint(item, point):

                    return (True, item)

        return (False,)

    '''

        @brief      Check Overlap

        @author     kyouho

        @date       18.07.17

    '''

    def isOverlapItemAndPoint(self, item, point):

        x = point.x()

        y = point.y()

        loc = item.loc

        size = item.size

        if loc[0] <= x and loc[0] + size[0] >= x and loc[1] <= y and loc[1] + size[1] >= y:

            return True

        else:

            return False