HYTOS

# coding: utf-8

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

import os.path

import sys

import AbstractCommand

try:

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

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QCursor, QMouseEvent, QTransform

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QTableWidgetItem

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

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

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

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

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

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

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

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

                        if not item.runs:

                            item.runs.append(QEngineeringRunItem())

                        if 1 == len(item.runs): item.runs[0].items.append(self._item)

                        self._item.owner = item

                        self.onSuccess.emit()

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

                        self._item.owner = item

                        self.onSuccess.emit()

                    elif item is not None and (type(self._item) is QEngineeringEndBreakItem) and (type(item) is QEngineeringLineItem) and self._attr.Attribute == 'Connected Line':

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

                        self.onSuccess.emit()

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

                        if self._attr.AttributeType not in self._item._associations:

                            self._item._associations[self._attr.AttributeType] = []

                        while len(self._item._associations[self._attr.AttributeType]) <= self._attr.AttrAt:

                            self._item._associations[self._attr.AttributeType].append(None)

                        self._item.add_assoc_item(item, self._attr.AttrAt)

                        self.onSuccess.emit()

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

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

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

                        self._item._properties[self._attr] = item

                        self.onSuccess.emit()

        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)       

        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