HYTOS

# coding: utf-8

import os.path

import copy

import sys

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

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

from SymbolSvgItem import SymbolSvgItem

class Highlighter(QSyntaxHighlighter):

    err_format = QTextCharFormat()

    err_format.setUnderlineColor(Qt.red)

    err_format.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)

    def __init__(self, *args):

        QSyntaxHighlighter.__init__(self, *args)

        self.white_char_list = None

    def highlightBlock(self, text):

        pos = 0

        for word in text.split():

            if self.white_char_list and any((c not in self.white_char_list) for c in word):

                self.setFormat(pos, len(word), self.err_format)

            pos += len(word) + 1

class QEngineeringTextItem(QGraphicsTextItem, QEngineeringAbstractItem):

    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)

        self.type = 'TEXT'

        self.loc = None

        self.size = None

        self.angle = 0  # angle in radian

        self._owner = None

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

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

        self.setAcceptHoverEvents(True)

        self.setAcceptTouchEvents(True)

        self.setColor(self._color)

        self._savedColor = None

        self.delimiter = '"'

        self.lineNoDelimiter = '!-!'

        self.attribute = ''

        self._properties = {}

        self.highlighter = None

        self.transfer = Transfer()

        self.setZValue(QEngineeringTextItem.ZVALUE)

    def __str__(self):

        """ return string represent uuid """

        return str(self.uid)

    '''

        @brief      Get owner

        @author     Jeongwoo

        @date       2018.05.17

    '''

    @property

    def owner(self):

        import uuid

        # find owner with uid

        if self.scene() and self._owner and type(self._owner) is uuid.UUID:

            #matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(self._owner)]

            matches = []

            for x in self.scene().items():

                if hasattr(x, 'uid') and str(x.uid) == str(self._owner):

                    matches = [x]

                    break

            if matches:

                self._owner = matches[0]

            return matches[0] if matches else None

        # up to here

        if type(self._owner) is not uuid.UUID and type(self._owner) is not str:

            return self._owner

        else:

            self._owner = None

            return None

    '''

        @brief      Set owner

        @author     Jeongwoo

        @date       2018.05.17

        @history    2018.05.17  Jeongwoo    Add Calling setColor if self._owner is None or not

    '''

    @owner.setter

    def owner(self, value):

        self._owner = value

        if self._owner is None:

            self._color = self.DEFAULT_COLOR

        self.setColor(self._color)

    '''

        @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()

    @property

    def text_size(self):

        if self.angle == 1.57 or self.angle == 4.71:

            return QRectF(0, 0, self.size[1], self.size[0])

        else:

            return QRectF(0, 0, self.size[0], self.size[1])

    def boundingRect(self) -> QRectF:

        return self.text_size

    '''

        @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 validate(self):

        """ validation check """

        from EngineeringLineItem import QEngineeringLineItem

        errors = []

        try:

            app_doc_data = AppDocData.instance()

            dataPath = app_doc_data.getErrorItemSvgPath()

            # check overlapping

            texts = [item for item in self.scene().items() if item is not self and issubclass(type(item), QEngineeringTextItem)]

            for text in texts:

                textRect = text.sceneBoundingRect()

                rect1 = QRectF(textRect.left() - 3, textRect.top() - 3, textRect.width() + 6, textRect.height() + 6)

                rect2 = QRectF(textRect.left() + 3, textRect.top() + 3, textRect.width() - 6, textRect.height() - 6)

                if rect1.contains(self.sceneBoundingRect()) or rect2.contains(self.sceneBoundingRect().center()):

                    error = SymbolSvgItem.createItem('Error', None, dataPath)

                    error.parent = self

                    error.msg = self.tr('Text overlapping warning')

                    error.setToolTip(error.msg)

                    error.area = self.area

                    error.name = 'Warning'

                    error.items = [ text ]

                    errors.append(error)

                    error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

            lines = [item for item in self.scene().items() if item is not self and issubclass(type(item), QEngineeringLineItem)]

            for line in lines:

                lineRect = line.sceneBoundingRect()

                if lineRect.intersects(self.sceneBoundingRect()):

                    error = SymbolSvgItem.createItem('Error', None, dataPath)

                    error.parent = self

                    error.msg = self.tr('Text overlapping waring')

                    error.setToolTip(error.msg)

                    error.area = self.area

                    error.name = 'Warning'

                    error.items = [ line ]

                    errors.append(error)

                    error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

        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 errors

    def contextMenuEvent(self, event):

        items = self.scene().selectedItems()

        if len(items) > 0 and self in items:

            menu = QMenu()

            if len(items) > 1:

                mergeAction = QAction('Merge(M)', None)

                mergeAction.triggered.connect(self.contextMerge)

                menu.addAction(mergeAction)

            if len(items) == 1:

                editAction = QAction('Edit(Return)', None)

                editAction.triggered.connect(self.contextEdit)

                menu.addAction(editAction)

                rotateAction = QAction('Rotate(R)', None)

                rotateAction.triggered.connect(self.contextRotate)

                menu.addAction(rotateAction)

            if len(items) >= 1:

                trimAction = QAction('Remove Space', None)

                trimAction.triggered.connect(self.contextTrim)

                menu.addAction(trimAction)

            deleteAction = QAction('Delete(E)', None)

            deleteAction.triggered.connect(self.contextDelete)

            menu.addAction(deleteAction)

            menu.exec_(event.screenPos())

    def contextTrim(self):

        textItems = [item for item in self.scene().selectedItems() if type(item) is QEngineeringTextItem]

        for text in textItems:

            text.setPlainText(text.text().replace(' ', ''))

    def contextMerge(self):

        event = QKeyEvent(QEvent.KeyPress, Qt.Key_M, Qt.NoModifier)

        self.keyPressEvent(event)

    def contextDelete(self):

        event = QKeyEvent(QEvent.KeyPress, Qt.Key_Delete, Qt.NoModifier)

        self.scene().keyPressEvent(event)

    def contextEdit(self):

        event = QKeyEvent(QEvent.KeyPress, Qt.Key_Return, Qt.NoModifier)

        self.keyPressEvent(event)

    def contextRotate(self):

        self.textRotate()

    def textRotate(self):

        # degree 0

        if 0 == self.angle:

            self.angle = 1.57

        # degree 90

        elif 1.57 == self.angle:

            self.angle = 3.14

        # degree 180

        elif 3.14 == self.angle:

            self.angle = 4.71

        # degree 270

        elif 4.71 == self.angle:

            self.angle = 0

        width = self.size[0]

        height = self.size[1]

        self.size = [height, width]

        self.rotate()

    def keyPressEvent(self, event):

        #print('item :' + str(event.key()))

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

            self.edit_text()

        elif event.key() == Qt.Key_Up:  # translate up/down/left/right

            modifiers = QApplication.keyboardModifiers()

            delta = 10 if modifiers == Qt.ControlModifier else 1

            trans = QTransform()

            trans.rotateRadians(self.angle)

            dx, dy = trans.map(0, -1)

            self.loc[1] = self.loc[1] - delta

            trans = self.transform()

            trans.translate(dx*delta, dy*delta)

            self.setTransform(trans)

        elif event.key() == Qt.Key_Down:

            modifiers = QApplication.keyboardModifiers()

            delta = 10 if modifiers == Qt.ControlModifier else 1

            trans = QTransform()

            trans.rotateRadians(self.angle)

            dx, dy = trans.map(0, 1)

            self.loc[1] = self.loc[1] + delta

            trans = self.transform()

            trans.translate(dx * delta, dy * delta)

            self.setTransform(trans)

        elif event.key() == Qt.Key_Left:

            modifiers = QApplication.keyboardModifiers()

            delta = 10 if modifiers == Qt.ControlModifier else 1

            trans = QTransform()

            trans.rotateRadians(self.angle)

            dx, dy = trans.map(-1, 0)

            self.loc[0] = self.loc[0] - delta

            trans = self.transform()

            trans.translate(dx * delta, dy * delta)

            self.setTransform(trans)

        elif event.key() == Qt.Key_Right:

            modifiers = QApplication.keyboardModifiers()

            delta = 10 if modifiers == Qt.ControlModifier else 1

            trans = QTransform()

            trans.rotateRadians(self.angle)

            dx, dy = trans.map(1, 0)

            self.loc[0] = self.loc[0] + delta

            trans = self.transform()

            trans.translate(dx * delta, dy * delta)

            self.setTransform(trans)

        elif event.key() == Qt.Key_M:

            from App import App

            App.mainWnd().keyPressEvent(event)

        # QGraphicsTextItem.keyPressEvent(self, event)

    def mouseMoveEvent(self, event):

        modifiers = QApplication.keyboardModifiers()

        if modifiers == Qt.ShiftModifier:

            super().mouseMoveEvent(event)

    def itemChange(self, change, value):

        """ call signals when item's position or rotation is changed """

        if not self.scene(): return super().itemChange(change, value)

        if change == QGraphicsItem.ItemPositionHasChanged:

            scene_origin = self.sceneBoundingRect()

            configs = AppDocData.instance().getConfigs('Data', 'Grid')

            grid = int(configs[0].value) if 1 == len(configs) else -1

            if grid == 1:

                self.loc = [round(scene_origin.x()), round(scene_origin.y())]

            else:

                self.loc = [round(scene_origin.x(), 1), round(scene_origin.y(), 1)]

            if hasattr(self.scene(), 'contents_changed'):

                self.scene().contents_changed.emit()

            return value

        return super().itemChange(change, value)

    '''

        @brief  draw rect when item is selected

        @author humkyung

        @date   2018.07.08

    '''

    def drawFocusRect(self, painter):

        if not hasattr(self, '_focus_pen'):

            self._focus_pen = QPen(Qt.DotLine)

            self._focus_pen.setColor(Qt.black)

            self._focus_pen.setWidthF(1.5)

        if not hasattr(self, '_hilight_color'):

            self._hilight_color = QColor(255, 0, 0, 127)

        painter.setBrush(QBrush(self._hilight_color))

        painter.setPen(self._focus_pen)

        painter.drawRect(self.text_size)

    '''

        @brief  override paint(draw connection points)

        @author humkyung

        @date   2018.07.08

    '''

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

        import math

        painter.setClipRect(options.exposedRect)

        self.setColor(self.getColor())

        #if self.angle == 1.57 or self.angle == 4.71:

        #    rect = QRectF(0, 0, self.size[1], self.size[0])

        #else:

        #    rect = QRectF(0, 0, self.size[0], self.size[1])

        # draw onwer indicator

        if self.owner and issubclass(type(self.owner), QEngineeringAbstractItem):

            painter.setPen(Qt.magenta)

            rect = self.text_size

            center = self.sceneBoundingRect().center()

            center2 = self.owner.sceneBoundingRect().center()

            dx = center2.x() - center.x()

            dy = center2.y() - center.y()

            if self.angle == 1.57:

                rad = 90 * (math.pi / 180.0)

                nx = math.cos(rad) * dx - math.sin(rad) * dy

                ny = math.sin(rad) * dx + math.cos(rad) * dy

                dx, dy = nx, ny

            painter.drawLine(rect.center().x(), rect.center().y(), rect.center().x() + dx, rect.center().y() + dy)

        painter.setFont(self.font())

        color = self.defaultTextColor()

        # draw white background during hover

        if self.hover:

            configs = AppDocData.instance().getConfigs('Text', 'Background')

            if not configs or not int(configs[0].value) != 1:

                painter.setPen(Qt.NoPen)

                painter.setBrush(Qt.white)

                painter.drawRect(self.text_size)

        # up to here

        painter.setPen(QPen(color))

        if self.isSelected():

            self.drawFocusRect(painter)

        #painter.drawText(rect, Qt.AlignCenter, self.text())

        QGraphicsTextItem.paint(self, painter, options, widget)

    '''

        @brief      Return real item position

        @author     Jeongwoo

        @date       2018.05.25

    '''

    def boundingRectOnScene(self):

        rect = self.text_size

        rect.moveTo(self.loc[0], self.loc[1])

        return rect

    @staticmethod

    def create_text_with(scene, text_info):

        """create a text using text_info"""

        from TextItemFactory import TextItemFactory

        x = text_info.getX()

        y = text_info.getY()

        angle = text_info.getAngle()

        text = text_info.getText()

        if not text.replace(' ', '').replace('\n', ''):

            return None

        width = text_info.getW()

        height = text_info.getH()

        configs = AppDocData.instance().getConfigs('Text Style', 'Font Size')

        fontSize = int(configs[0].value) if configs else -1

        if fontSize != -1:

            textItems = [item for item in scene.items() if issubclass(type(item), QEngineeringTextItem)]

            if textItems:

                _height = textItems[0].size[1] if textItems[0].angle == 0 else textItems[0].size[0]

                if angle == 0:

                    height = _height

                else:

                    width = _height

        item = TextItemFactory.instance().createTextItem(text_info)

        if item is not None:

            item.loc = [x, y]

            item.size = (width, height)

            item.angle = angle

            item.addTextItemToScene(scene)

        return item

    def edit_text(self):

        """edit text by using ocr dialog"""

        from TextItemFactory import TextItemFactory

        from OcrResultDialog import QOcrResultDialog

        item = None

        try:

            dialog = QOcrResultDialog(None, self.scene().views()[0].image().copy(self.loc[0], self.loc[1],

                                                                               self.size[0], self.size[1]),

                                      QRect(self.loc[0], self.loc[1], self.size[0], self.size[1]), text_item=self)

            (res, textInfoList) = dialog.showDialog()

            if QDialog.Accepted == res and textInfoList:

                # create new texts

                for text_info in textInfoList:

                    item = QEngineeringTextItem.create_text_with(self.scene(), text_info)

                    if item:

                        item.area = self.area

                        item.transfer.onRemoved.connect(self.transfer.onRemoved)

                        #item.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

                self.transfer.onRemoved.emit(self)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}-{}) in {}:{}'.format(repr(ex), self.text(),

                                                              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 focusOutEvent(self, event: QFocusEvent) -> None:

        self.setTextInteractionFlags(Qt.NoTextInteraction)

        super(QEngineeringTextItem, self).focusOutEvent(event)

    '''

        @brief      Double click event, Show QOcrResultDialog

        @author     Jeongwoo

        @date       18.04.23

        @history    18.06.20    Jeongwoo    Resize QRect added 1

    '''

    def mouseDoubleClickEvent(self, event):

        if event.buttons() == Qt.LeftButton:

            """

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

                self.setTextInteractionFlags(Qt.TextEditorInteraction)

                self.setFocus()

            """

            self.edit_text()

        super(QGraphicsTextItem, self).mouseDoubleClickEvent(event)

    '''

        @brief      rotate text

        @author     humkyung

        @date       2018.08.18

    '''

    def rotate(self):

        sx = 1

        sy = 1

        width = self.size[0]

        height = self.size[1]

        x = self.loc[0]

        y = self.loc[1]

        transform = QTransform()

        if (1.57 == self.angle) or (4.71 == self.angle):

            rect = self.text_size

            sx = width / rect.height()

            sy = height / rect.width()

            transform.translate(x, y)

            transform.translate(width * 0.5, height * 0.5)

            transform.scale(1, sy)

            transform.rotateRadians(-self.angle)

            transform.translate(-rect.width() * 0.5, -rect.height() * 0.5)

        elif 3.14 == self.angle:

            rect = self.text_size

            sx = width / rect.width()

            sy = height / rect.height()

            transform.translate(x, y - round((rect.height() - height) * 0.5))

            transform.scale(sx, 1)

            transform.rotateRadians(-self.angle)

            transform.translate(-width * 0.5, -height * 0.5)

        else:

            rect = self.text_size

            sx = width / rect.width()

            sy = height / rect.height()

            # if '\n' not in text:

            transform.translate(x, y - round((rect.height() - height) * 0.5))

            transform.scale(sx, 1)

        self.setTransform(transform)

        self.update()

    def text_width(self, font):

        """return text width"""

        text_width = 0

        for _text in self.text().split('\n'):

            """

            rect = QFontMetricsF(font).tightBoundingRect(_text)

            text_width = max(rect.width(), text_width)

            """

            text_width = max(QFontMetricsF(font).width(_text), text_width)

        return text_width

    def update_shape(self):

        """update text shape"""

        try:

            app_doc_data = AppDocData.instance()

            configs = app_doc_data.getConfigs('Text Style', 'Font Name')

            fontName = configs[0].value if configs else 'Arial'

            configs = app_doc_data.getConfigs('Text Style', 'Font Size')

            fontSize = int(configs[0].value) if configs else -1

            sx = 1

            sy = 1

            width = self.size[0]

            height = self.size[1]

            x = self.loc[0]

            y = self.loc[1]

            rect = None

            line_count = self.text().count('\n') if self.text().count('\n') is not 0 else 1

            allowed_error = 0.01

            if abs(self.angle - 1.57) < allowed_error:

                self.angle = 1.57

            elif abs(self.angle - 4.71) < allowed_error:

                self.angle = 4.71

            elif abs(self.angle - 3.14) < allowed_error:

                self.angle = 3.14

            else:

                self.angle = 0

            transform = QTransform()

            if abs(self.angle - 1.57) < allowed_error or abs(self.angle - 4.71) < allowed_error:

                font = QFont(fontName, width if fontSize == -1 else fontSize)

                font.setBold(True)

                x_factor = width / QFontMetricsF(font).height() #self.text()).height() / line_count)

                y_factor = height / self.text_width(font)

                factor = min(x_factor, y_factor)

                font.setPointSizeF(font.pointSizeF() * factor)

                self.setFont(font)

                rect = self.text_size

                sx = rect.height() / QFontMetricsF(font).tightBoundingRect(self.text()).height()

                sy = rect.width() / self.text_width(font)

                transform.translate(x + width * 0.5, y + height * 0.5)

                transform.rotateRadians(-self.angle)

                #transform.scale(1, sy)

                transform.translate(-rect.width() * 0.5, -rect.height() * 0.5)

            elif abs(self.angle - 3.14) < allowed_error:

                font = QFont(fontName, height if fontSize == -1 else fontSize)

                font.setBold(True)

                x_factor = width / self.text_width(font)

                y_factor = height / QFontMetricsF(font).height() #self.text()).height() / line_count)

                factor = min(x_factor, y_factor)

                font.setPointSizeF(font.pointSizeF() * factor)

                self.setFont(font)

                rect = self.text_size

                sx = width / self.text_width(font)

                sy = height / QFontMetricsF(font).tightBoundingRect(self.text()).height()

                transform.translate(x, y - round((rect.height() - height) * 0.5))

                #transform.scale(sx, 1)

                transform.rotateRadians(-self.angle)

                transform.translate(-width * 0.5, -height * 0.5)

            else:

                font = QFont(fontName, height if fontSize == -1 else fontSize)

                font.setBold(True)

                x_factor = width / self.text_width(font)

                y_factor = height / QFontMetricsF(font).height() #.boun(self.text()).height() / line_count)

                factor = min(x_factor, y_factor)

                font.setPointSizeF(font.pointSizeF() * factor)

                self.setFont(font)

                sx = width / self.text_width(font)

                sy = height / QFontMetricsF(font).tightBoundingRect(self.text()).height()

                transform.translate(x, y)

            self.setTransform(transform)

            self.document().setDocumentMargin(0)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}-{}) in {}:{}'.format(ex, self.text(),

                                                              sys.exc_info()[-1].tb_frame.f_code.co_filename,

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

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

    '''

        @brief      Put text on scene

        @author     Jeongwoo

        @date       18.04.23

        @history    humkyung 2018.06.30 apply font configuration

    '''

    def addTextItemToScene(self, scene):

        try:

            self.update_shape()

            """

            white_char_list = app_doc_data.getConfigs('Text Recognition', 'White Character List')

            self.highlighter = Highlighter(self.document())

            self.highlighter.white_char_list = '‘' #white_char_list[0].value if white_char_list else None

            """

            scene.addItem(self)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}-{}) in {}:{}'.format(ex, self.text(),

                                                              sys.exc_info()[-1].tb_frame.f_code.co_filename,

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

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

    '''

        @brief  get connected items

        @author humkyung

        @date   2018.04.23

        @history    2018.11.22      euisung     fix note road

    '''

    def getConnectedItems(self):

        visited = []

        try:

            if 1 == len(self.conns):

                # iterate connected items

                pool = []

                visited = []

                pool.append(self.conns[0])

                while len(pool) > 0:

                    it = pool.pop()

                    visited.append(it)

                    for conn in it.conns:

                        if (conn is not None) and (conn not in visited): pool.append(conn)

                # up to here

        except Exception as ex:

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

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

        return visited

    @staticmethod

    def from_database(component):

        """ get text item from database """

        import uuid

        from AppDocData import AppDocData

        from TextItemFactory import TextItemFactory

        from SymbolAttr import SymbolAttr

        item = None

        try:

            x = float(component['X'])

            y = float(component['Y'])

            width = float(component['Width']) if component['Width'] is not None else 0

            height = float(component['Height']) if component['Height'] is not None else 0

            if height < 10:

                height = 10

            if width < 10:

                width = 10

            angle = float(component['Rotation']) if component['Rotation'] is not None else 0

            text = component['Value']

            configs = AppDocData.instance().getConfigs('Data', 'Grid')

            grid = int(configs[0].value) if 1 == len(configs) else -1

            if grid == 1:

                x = round(x)

                y = round(y)

                width = round(width)

                height = round(height)

            textInfo = TextInfo(text, x, y, width, height, angle)

            connline = component['Connected'] if component['Connected'] is not None else None

            item = TextItemFactory.instance().createTextItem(textInfo)

            if item is not None:

                item.setVisible(False)

                item.uid = uuid.UUID(component['UID'])

                item.loc = [x, y]

                item.size = [width, height]

                item.angle = angle

                #item.setToolTip('<b>{}</b><br>LINE NO={}'.format(str(item.uid), text))

                if component['Owner'] and component['Owner'] != 'None':

                    item._owner = uuid.UUID(component['Owner'])

                # assign area

                if not component['Area']:

                    app_doc_data = AppDocData.instance()

                    for area in app_doc_data.getAreaList():

                        if area.contains([x, y]):

                            item.area = area.name

                            break

                else:

                    item.area = component['Area']

                ## up to here

                """ apply freeze value """

                # item.freeze_item.update_freeze(item.prop('Freeze'))

                if connline is not None:

                    item.conns.append(connline)

        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)

            return None

        return item

    '''

        @brief      parse xml code

        @author     humkyung

        @date       2018.09.15

    '''

    @staticmethod

    def fromXml(node):

        import uuid

        from TextItemFactory import TextItemFactory

        from AppDocData import AppDocData

        from EngineeringNoteItem import QEngineeringNoteItem

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        item = None

        try:

            location = node.find('LOCATION').text if node.find('LOCATION') is not None else '0,0'

            x = float(location.split(',')[0])

            y = float(location.split(',')[1])

            width = float(node.find('WIDTH').text) if node.find('WIDTH') is not None else 0

            height = float(node.find('HEIGHT').text) if node.find('HEIGHT') is not None else 0

            if height < 10:

                height = 10

            if width < 10:

                width = 10

            angle = float(node.find('ANGLE').text) if node.find('ANGLE') is not None else 0

            value = node.find('VALUE').text

            if not value or len(value.replace('\n', '').replace(' ', '')) == 0:

                return None

            # attributeValue = node.find('ATTRIBUTEVALUE')

            name = node.find('NAME').text

            configs = AppDocData.instance().getConfigs('Data', 'Grid')

            grid = int(configs[0].value) if 1 == len(configs) else -1

            if grid == 1:

                x = round(x)

                y = round(y)

                width = round(width)

                height = round(height)

            textInfo = TextInfo(value, x, y, width, height, angle)

            item = TextItemFactory.instance().createTextItem(textInfo)

            if item is not None:

                item.loc = [x, y]

                item.size = [width, height]

                item.angle = angle

            # set uid and owner of item

            if item is not None:

                item.uid = uuid.UUID(node.find('UID').text)

                item.setVisible(False)

                if node.find('OWNER') is not None and node.find('OWNER').text != 'None':

                    item._owner = uuid.UUID(node.find('OWNER').text)

            ## assign area

            if item is not None:

                if node.find('AREA') is None:

                    appDocData = AppDocData.instance()

                    for area in appDocData.getAreaList():

                        if area.contains([x, y]):

                            item.area = area.name

                            break

                else:

                    item.area = node.find('AREA').text

                    ## up to here

        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)

        return item

    '''

        @brief      generate xml code

        @author     humkyung

        @date       2018.04.23

        @history    humkyung 2018.04.27 move to QEngineeringLineNoTextItem

                    humkyung 2018.05.02 add name as parameter

                    Jeongwoo 2018.05.30 Change variable [owner] is nullable and Add/Modify attributes

    '''

    def toXml(self, owner=None):

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        try:

            node = Element('ATTRIBUTE')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            node.append(uidNode)

            # write owner's uid to xml

            ownerNode = Element('OWNER')

            if self.owner is not None:

                ownerNode.text = str(self.owner)

            else:

                ownerNode.text = 'None'

            node.append(ownerNode)

            # up to here

            attributeValueNode = Element('ATTRIBUTEVALUE')

            attributeValueNode.text = self.attribute

            node.append(attributeValueNode)

            nameNode = Element('NAME')

            nameNode.text = self.type

            node.append(nameNode)

            locNode = Element('LOCATION')

            locNode.text = '{},{}'.format(self.loc[0], self.loc[1])

            node.append(locNode)

            valueNode = Element('VALUE')

            valueNode.text = self.text()

            node.append(valueNode)

            angleNode = Element('ANGLE')

            angleNode.text = str(self.angle)

            node.append(angleNode)

            widthNode = Element('WIDTH')

            widthNode.text = str(self.size[0])

            node.append(widthNode)

            heightNode = Element('HEIGHT')

            heightNode.text = str(self.size[1])

            node.append(heightNode)

            areaNode = Element('AREA')

            areaNode.text = self.area

            node.append(areaNode)

            sceneNode = Element('SCENE')

            rect = self.sceneBoundingRect()

            sceneNode.text = '{},{},{},{}'.format(rect.x(), rect.y(), rect.width(), rect.height()) if self.scene() else \

                            '{},{},{},{}'.format(self.loc[0], self.loc[1], self.size[0], self.size[1])

            node.append(sceneNode)

        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)

            return None

        return node

    def to_svg(self, parent) -> list:

        """convert text item to svg"""

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        from App import App

        res = []

        try:

            node = None

            if parent is None or str(self.owner) == str(parent):

                app_doc_data = AppDocData.instance()

                prj = app_doc_data.getCurrentProject()

                node = Element('g')

                node.attrib['id'] = str(self.uid)

                node.attrib['font-family'] = self.font().family()

                node.attrib['font-size'] = str(self.boundingRect().height())  # str(self.font().pointSizeF())

                node.attrib['font-weight'] = str(self.font().weight())

                inverted = QTransform()

                if parent:

                    trans = parent.sceneTransform()

                    inverted, _ = trans.inverted()

                trans = self.sceneTransform()

                trans = trans*inverted

                node.attrib['transform'] = f"matrix(" \

                                           f"{trans.m11()},{trans.m12()}," \

                                           f"{trans.m21()},{trans.m22()}," \

                                           f"{trans.m31()},{trans.m32()}" \

                                           f")"

                text = Element('text')

                text.attrib['textLength'] = str(self.boundingRect().width())

                text.attrib['lengthAdjust'] = 'spacingAndGlyphs'

                text.text = self.toPlainText()

                text.attrib['alignment-baseline'] = 'hanging'  # align left-top corner

                node.append(text)

                res.append(node)

        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 findOwner(self, symbols, force=False):

        import math

        try:

            minDist = None

            selected = None

            configs = AppDocData.instance().getConfigs('Range', 'Detection Ratio')

            if not force:

                ratio = float(configs[0].value) if 1 == len(configs) else 1.5

            else:

                ratio = 50

            if len(self.text()) > 3:

                width = self.sceneBoundingRect().width()

            elif len(self.text()) == 3:

                width = self.sceneBoundingRect().width() * 4 / 3

            elif len(self.text()) == 2:

                width = self.sceneBoundingRect().width() * 2

            else:

                width = self.sceneBoundingRect().width() * 4

            dist = (self.sceneBoundingRect().height() + width) * ratio / 2

            center = self.sceneBoundingRect().center()

            target_symbols = []

            for symbol in symbols:

                attrs = symbol.getAttributes(findOwner=True)

                freeze = False

                for attr in attrs:

                    if attr.Freeze:

                        freeze = True

                        break

                if freeze and not force: continue

                for attr in attrs:

                    ret = attr.Codes.find_match_exactly(self.text())

                    if ret:

                        target_symbols.append(symbol)

                        break

            for symbol in target_symbols:

                if issubclass(type(symbol), SymbolSvgItem):

                    dx = symbol.origin[0] - center.x()

                    dy = symbol.origin[1] - center.y()

                    #offset = (symbol.sceneBoundingRect().width() + symbol.sceneBoundingRect().height()) / 4

                    length = math.sqrt(dx * dx + dy * dy)# - offset

                    if (length < dist) and (minDist is None or length < minDist):

                        minDist = length

                        selected = symbol

            if selected is not None:

                attrs = selected.getAttributes(findOwner=True)

                target_attrs = []

                for attr in attrs:

                    ret = attr.Codes.find_match_exactly(self.text())

                    if ret:

                        target_attrs.append(attr)