HYTOS

# coding: utf-8

import os.path

import copy

import sys

try:

    from PyQt5.QtCore import Qt, QPointF, QRectF, pyqtSignal, QObject, QT_VERSION_STR, QRect

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QBrush, QPen, QTransform, QFont, QColor, QFontMetricsF

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, \

        QGraphicsTextItem

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QRect, QObject, QT_VERSION_STR

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QFont, \

            QColor, QFontMetricsF

    except ImportError:

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

from EngineeringPolylineItem import QEngineeringPolylineItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from AppDocData import *

from EngineeringAbstractItem import QEngineeringAbstractItem

from TextInfo import TextInfo

class QEngineeringCalloutTextItem(QGraphicsTextItem, QEngineeringAbstractItem):

    lost_focus = pyqtSignal(QGraphicsTextItem)

    selected_change = pyqtSignal(QGraphicsItem)

    HIGHLIGHT = '#BC4438'

    ZVALUE = 210

    '''

        @history    2018.05.17  Jeongwoo    Add self._owner variable

    '''

    def __init__(self, uid=None, parent=None):

        import uuid

        QGraphicsTextItem.__init__(self, parent)

        QEngineeringAbstractItem.__init__(self)

        self.uid = uuid.uuid4() if uid is None else uuid.UUID(uid, version=4)

        self.type = 'TEXT'

        self.loc = None

        self.angle = 0  # angle in radian

        self.setFlags(QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable | QGraphicsItem.ItemIsMovable)

        self.setAcceptHoverEvents(True)

        self.setAcceptTouchEvents(True)

        self._savedColor = None

        self.attribute = ''

        self.transfer = Transfer()

        self.setZValue(QEngineeringCalloutTextItem.ZVALUE)

    def __str__(self):

        """ return string represent uuid """

        return str(self.uid)

    '''

        @brief  return text string

        @author humkyung

        @date   2018.04.16

    '''

    def text(self):

        return self.toPlainText()

    '''

        @brief  return center position of text

        @author humkyung

        @date   2018.04.16

    '''

    def center(self):

        return self.sceneBoundingRect().center()

    '''

        @brief      hover event

        @authro     humkyung

        @date       

    '''

    def hoverEnterEvent(self, event):

        self.highlight(True)

    def hoverLeaveEvent(self, event):

        self.highlight(False)

    '''

        @brief      set highlight

        @author     kyouho

        @date       2018.08.27

    '''

    def highlight(self, flag):

        self.hover = flag

        if flag:

            if self._savedColor is None:

                self._savedColor = self.getColor()

            #self.setColor(QEngineeringTextItem.HIGHLIGHT)

        elif hasattr(self, '_savedColor'):

            self.setColor(self._savedColor)

        self.update()

    def hoverMoveEvent(self, event):

        pass

    def keyPressEvent(self, event):

        try:

            if event.key() == Qt.Key_Escape:

                self.lost_focus.emit(self)

                self.clearFocus()

            super(QEngineeringCalloutTextItem, self).keyPressEvent(event)

        except Exception as ex:

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

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

            self.addMessage.emit(MessageType.Error, message)

    def itemChange(self, change, value):

        if change == QGraphicsItem.ItemSelectedChange:

            self.selected_change.emit(self)

        return value

    def focusOutEvent(self, event):

        self.setTextInteractionFlags(Qt.NoTextInteraction)

        self.lost_focus.emit(self)

        super(QEngineeringCalloutTextItem, self).focusOutEvent(event)

    def mouseDoubleClickEvent(self, event):

        if self.textInteractionFlags() == Qt.NoTextInteraction:

            self.setTextInteractionFlags(Qt.TextEditorInteraction)

            self.setFocus()

        super(QEngineeringCalloutTextItem, self).mouseDoubleClickEvent(event)

    def setColor(self, color):

        pass

    def highlight(self, flag):

        if flag:

            self.setDefaultTextColor(QColor(QEngineeringAbstractItem.HOVER_COLOR))

        else:

            self.setDefaultTextColor(Qt.black)

        self.update()

    def update_label_contents(self):

        """build stream no"""

        from AppDocData import AppDocData

        from EngineeringStreamNoTextItem import QEngineeringStreamNoTextItem

        app_doc_data = AppDocData.instance()

        font_size = None

        configs = app_doc_data.getAppConfigs('option', 'CalloutFontSize')

        if configs and len(configs) == 1:

            _font = self.font()

            _font.setPointSizeF(float(configs[0].value))

            self.setFont(_font)

        configs = app_doc_data.getAppConfigs('option', 'CalloutTextColor')

        if configs and len(configs) == 1:

            self.setDefaultTextColor(QColor(configs[0].value))

    '''

            @brief  override paint(draw connection points)

            @author humkyung

            @date   2018.07.08

        '''

    def paint(self, painter, options=None, widget=None):

        super(QEngineeringCalloutTextItem, self).paint(painter, options, widget)

        if self.isSelected():

            if not hasattr(self, '_selected_pen'):

                self._selected_pen = QPen(Qt.SolidLine)

                self._selected_pen.setColor(QColor(255, 0, 0, 127))

                self._selected_pen.setWidthF(1)

            painter.setPen(self._selected_pen)

        else:

            if not hasattr(self, '_focuspen'):

                self._focuspen = QPen(Qt.SolidLine)

                self._focuspen.setColor(Qt.black)

                self._focuspen.setWidthF(1.5)

            painter.setPen(self._focuspen)

        painter.drawRect(self.boundingRect())

    @staticmethod

    def fromDatabase(componentInfos):

        """ create a callout from database """

        from PlaceCalloutCommand import PlaceCalloutCommand

        item = None

        try:

            uid = componentInfos[0]['Comp_UID']  # uid@Components

            tag_no = componentInfos[0]['Name']  # name@Components

            index = componentInfos[0]['Comp_Index']

            dbUid = componentInfos[0]['Symbols_UID']  # Symbol_UID@Components

            category = componentInfos[0]['Category']  # Category@SymbolType

            _type = componentInfos[0]['Type']  # Type@SymbolType

            name = componentInfos[0]['Symbol_Name']  # Name@Symbols

            originalPoint = componentInfos[0]['OriginalPoint']  # OriginalPoint@Symbols

            x = componentInfos[0]['Comp_X']  # X@Components

            y = componentInfos[0]['Comp_Y']  # Y@Components

            angle = componentInfos[0]['Rotation']  # Rotation@Components

            scale = componentInfos[0]['Scale']  # Scale@Components

            pt = QPointF(float(x), float(y))

            item = PlaceCalloutCommand.create_item(pt)

            item.setHtml(tag_no)

        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 item

    def toSql(self):

        """convert callout data to sql query"""

        from AppDocData import AppDocData

        """ generate sql string to save label to database """

        res = []

        try:

            cols = ['UID', 'Symbols_UID', 'Name', 'X', 'Y']

            values = ['?', "(select uid from Symbols where Name='Callout')", '?', '?', '?']

            param = [str(self.uid), self.toHtml(), self.pos().x(), self.pos().y()]

            sql = f"insert or replace into Components({','.join(cols)}) values({','.join(values)})"

            res.append((sql, tuple(param)))

            cols, values = ['UID', 'Components_UID', '[Index]', 'X', 'Y'], ['?', '?', '?', '?', '?']

            param = [str(self.uid), str(self.uid), 0, self.pos().x(), self.pos().y()]

            sql = 'insert or replace into Points({}) values({})'.format(','.join(cols), ','.join(values))

            res.append((sql, tuple(param)))

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            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)

        return res

'''

    @brief      The class transfer pyqtSignal Event. Cause Subclass of QGraphicsRectItem can't use pyqtSignal

    @author     Jeongwoo

    @date       2018.06.18

'''

class Transfer(QObject):

    onRemoved = pyqtSignal(QGraphicsItem)

    def __init__(self, parent=None):

        QObject.__init__(self, parent)