HYTOS

# coding: utf-8

""" This is engineering line no text item module """

import os.path

import sys

import copy

from EngineeringFromMarkItem import EngineeringFromMarkItem

from EngineeringToMarkItem import EngineeringToMarkItem

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, QRect

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

    except ImportError:

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

#from UserInputAttribute import UserInputAttribute

from OcrResultDialog import QOcrResultDialog

from AppDocData import AppDocData

from EngineeringTextItem import QEngineeringTextItem

from TextInfo import TextInfo

lineColumnList = ['UID', 'LINE_SIZE', 'LINE_SYMBOL', 'LINE_NO', 'LINE_CLASS', 'LINE_ROUTING_FROM', 'LINE_ROUTING_TO',

                  'SERVICE_FLUID', 'SERVICE_DENSITY', 'SERVICE_STATE', 'OPERATION_CONDITION_TEMP',

                  'OPERATION_CONDITION_PRESS', 'DESIGN_CONDITION_TEMP', 'DESIGN_CONDITION_PRESS', 'TEST_CONDITION_TEMP',

                  'TEST_CONDITION_PRESS', 'INSUL_CODE', 'PAINT_CODE', 'NDE_CODE', 'PWHT', 'PNID_NO']

class QEngineeringLineNoTextItem(QEngineeringTextItem):

    '''

        @history    18.05.14    Jeongwoo    Add variable self.runs

                    humkyung 2018.07.09 add stream no

    '''

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

        from SymbolAttr import SymbolProp

        from EngineeringFreezeItem import QEngineeringFreezeItem

        QEngineeringTextItem.__init__(self, uid, parent)

        self._properties = { SymbolProp(None, 'From', 'Comp Item'): None, \

                                SymbolProp(None, 'To', 'Comp Item'): None, \

                                SymbolProp(None, 'Config', 'String'): None }  # , SymbolProp(None, 'Freeze', 'Boolean'):False}

        self._runs = []

        self.lineNoFromToIndicator = []

        self.lineNoFromToIndicatorShowFlag = False

        """ create freeze control """

        # self.freeze_item = QEngineeringFreezeItem(-QEngineeringFreezeItem.FREEZE_SIZE*0.5, -QEngineeringFreezeItem.FREEZE_SIZE*0.5, QEngineeringFreezeItem.FREEZE_SIZE, QEngineeringFreezeItem.FREEZE_SIZE)

        # self.freeze_item.setParentItem(self)

        # self.freeze_item.setZValue(self.zValue() + 1)

        # self.freeze_item.setPen(Qt.black)

    @property

    def Size(self):

        """ return line no's size """

        attrs = self.getAttributes()

        matches = [value for attr, value in attrs.items() if attr.Attribute.upper() == 'NOMINALDIAMETER']

        return matches[0] if matches else ''

    def empty(self):

        """ return True if run is empty else return False """

        return False if self._runs else True

    #def setVisible(self, visible):

    #    """ override visible value """

    #    super(QEngineeringTextItem, self).setVisible(visible)

    #    for run in self.runs:

    #        run.visible = visible

    @property

    def connected_line(self):

        """return connected line"""

        if self.conns:

            if type(self.conns[0]) is str:

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

                if matches:

                    self.conns[0] = matches[0]

            return self.conns[0]

        return None

    '''

        @brief  getter of runs

        @author humkyung

        @date   2018.05.11

    '''

    @property

    def runs(self):

        return self._runs

    '''

        @brief  setter of runs

        @author humkyung

        @date   2018.05.11

    '''

    @runs.setter

    def runs(self, value):

        self._runs = value

    def hoverEnterEvent(self, event):

        """ highlight line no text and run's item """

        from App import App

        try:

            self.hover = True

            self.update()

            for run in self.runs:

                for item in run.items:

                    item.hoverEnterEvent(event, True)

                    # display from / to indicator

                    if not self.lineNoFromToIndicatorShowFlag:

                        if not self.lineNoFromToIndicator or len(self.lineNoFromToIndicator) < 2:

                            if run is self.runs[0] and (item is run.items[0] or item is run.items[-1]):

                                _label = EngineeringFromMarkItem(10, color=self._color) \

                                    if not self.lineNoFromToIndicator else EngineeringToMarkItem(10, color=self._color)

                                _label.setZValue(500)

                                self.scene().addItem(_label)

                                #_label.setParentItem(self)

                                _label.setPos(QPointF(item.origin[0], item.origin[1]))

                                self.lineNoFromToIndicator.append(_label)

                        elif self.lineNoFromToIndicator:

                            if run is self.runs[0] and (item is run.items[0]):

                                self.lineNoFromToIndicator[0].setPos(QPointF(item.origin[0], item.origin[1]))

                                self.lineNoFromToIndicator[0].setVisible(True)

                            elif run is self.runs[0] and (item is run.items[-1]):

                                self.lineNoFromToIndicator[1].setPos(QPointF(item.origin[0], item.origin[1]))

                                self.lineNoFromToIndicator[1].setVisible(True)

            if not self.runs:

                _from = self.prop('From')

                _to = self.prop('To')

                if _from and _to:

                    for item in [_from, _to]:

                    # display from / to indicator

                        if not self.lineNoFromToIndicator or len(self.lineNoFromToIndicator) < 2:

                            _label = EngineeringFromMarkItem(10, color=self._color) \

                                if not self.lineNoFromToIndicator else EngineeringToMarkItem(10, color=self._color)

                            _label.setZValue(500)

                            self.scene().addItem(_label)

                            _label.setPos(QPointF(item.origin[0], item.origin[1]))

                            self.lineNoFromToIndicator.append(_label)

                        elif self.lineNoFromToIndicator:

                            if item is _from:

                                self.lineNoFromToIndicator[0].setPos(QPointF(item.origin[0], item.origin[1]))

                                self.lineNoFromToIndicator[0].setVisible(True)

                            elif item is _to:

                                self.lineNoFromToIndicator[1].setPos(QPointF(item.origin[0], item.origin[1]))

                                self.lineNoFromToIndicator[1].setVisible(True)

        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 contextMenuEvent(self, event):

        items = self.scene().selectedItems()

        menu = QMenu()

        if len(items) == 1 and self in items:

            '''

            explodeAction = QAction('Explode', None)

            explodeAction.triggered.connect(self.contextExplode)

            menu.addAction(explodeAction)

            explodeKeepAction = QAction('Explode(keep from, to)', None)

            explodeKeepAction.triggered.connect(self.contextExplodeKeep)

            menu.addAction(explodeKeepAction)

            '''

            explodeAction = QAction('Explode', None)

            explodeAction.triggered.connect(self.contextExplode)

            menu.addAction(explodeAction)

            explodeKeepAction = QAction('Explode(keep from, to)', None)

            explodeKeepAction.triggered.connect(self.contextExplodeKeep)

            menu.addAction(explodeKeepAction)

            fromAction = QAction('Set From(S)', None)

            fromAction.triggered.connect(self.contextFrom)

            menu.addAction(fromAction)

            toAction = QAction('Set To(D)', None)

            toAction.triggered.connect(self.contextTo)

            menu.addAction(toAction)

            showAction = QAction('Show From, To(H)', None) if not self.lineNoFromToIndicatorShowFlag else QAction('Hide From, To(H)', None)

            showAction.triggered.connect(self.contextShow)

            menu.addAction(showAction)

            allAction = QAction('Select All in View(A)', None)

            allAction.triggered.connect(self.contextSelectAll)

            menu.addAction(allAction)

            searchAction = QAction('Search All Duplicate Line No', None)

            searchAction.triggered.connect(self.contextSearch)

            menu.addAction(searchAction)

            highlightAction = QAction('Highlight', None)

            highlightAction.triggered.connect(lambda: self.contextHighlight(self))

            menu.addAction(highlightAction)

            actions = []

            for index in range(len(self.runs)):

                actions.append(QAction('Highlight Run ' + str(index + 1), None))

            binding = [lambda index=index: actions[index].triggered.connect(lambda: self.contextHighlight(self.runs[index])) for index in range(len(self.runs))]

            for index in range(len(actions)):

                binding[index]()

                menu.addAction(actions[index])

            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)

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

            deleteAction.triggered.connect(self.contextDelete)

            menu.addAction(deleteAction)

        else:

            alignAction = QAction('Resize Selected Texts with This ', None)

            alignAction.triggered.connect(self.contextResizeText)

            menu.addAction(alignAction)

        menu.exec_(event.screenPos())

    def contextResizeText(self):

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

        allowed_error = 0.01

        for text in textItems:

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

                dx = round(self.size[0] - text.size[0])

                dy = round(self.size[1] - text.size[1])

            else:

                dx = round(self.size[1] - text.size[0])

                dy = round(self.size[0] - text.size[1])

            text.size[1] = text.size[1] + dy

            if abs(text.angle - 1.57) < allowed_error or abs(text.angle - 3.14) < allowed_error:

                text.loc[1] = text.loc[1] - dy

            text.size[0] = text.size[0] + dx

            if abs(text.angle - 4.71) < allowed_error or abs(text.angle - 4.71) < allowed_error or abs(text.angle - 3.14) < allowed_error:

                text.loc[0] = text.loc[0] - dx

            text.update_font()

            text.update()

    def contextSearch(self):

        from App import App

        from TextItemEditDialog import QTextItemEditDialog

        dlgTextItemEdit = QTextItemEditDialog(App.mainWnd(), 'Line No')

        dlgTextItemEdit.show()

        dlgTextItemEdit.exec_()

    def contextSelectAll(self):

        from App import App

        rect = App.mainWnd().graphicsView.viewport().rect()

        view_rect = App.mainWnd().graphicsView.mapToScene(rect).boundingRect()

        lineNos = [item for item in self.scene().items() if type(item) is QEngineeringLineNoTextItem and view_rect.contains(item.sceneBoundingRect().center())]

        for lineNo in lineNos:

            lineNo.setSelected(True)

    def contextShow(self):

        self.lineNoFromToIndicatorShowFlag = not self.lineNoFromToIndicatorShowFlag

        if self.lineNoFromToIndicatorShowFlag:

            if self.runs and self.runs[0].items:

                for item in [self.runs[0].items[0], self.runs[0].items[-1]]:

                    # display from / to indicator

                    if not self.lineNoFromToIndicator or len(self.lineNoFromToIndicator) < 2:

                        _label = EngineeringFromMarkItem(10, color=self._color) \

                            if not self.lineNoFromToIndicator else EngineeringToMarkItem(10, color=self._color)

                        _label.setZValue(500)

                        self.scene().addItem(_label)

                        _label.setPos(QPointF(item.origin[0], item.origin[1]))

                        self.lineNoFromToIndicator.append(_label)

                    elif self.lineNoFromToIndicator:

                        if item is self.runs[0].items[0]:

                            self.lineNoFromToIndicator[0].setPos(QPointF(item.origin[0], item.origin[1]))

                            self.lineNoFromToIndicator[0].setVisible(True)

                        elif item is self.runs[0].items[-1]:

                            self.lineNoFromToIndicator[1].setPos(QPointF(item.origin[0], item.origin[1]))

                            self.lineNoFromToIndicator[1].setVisible(True)

            elif not self.runs:

                _from = self.prop('From')

                _to = self.prop('To')

                if _from and _to:

                    for item in [_from, _to]:

                    # display from / to indicator

                        if not self.lineNoFromToIndicator or len(self.lineNoFromToIndicator) < 2:

                            _label = EngineeringFromMarkItem(10, color=self._color) \

                                if not self.lineNoFromToIndicator else EngineeringToMarkItem(10, color=self._color)

                            _label.setZValue(500)

                            self.scene().addItem(_label)

                            _label.setPos(QPointF(item.origin[0], item.origin[1]))

                            self.lineNoFromToIndicator.append(_label)

                        elif self.lineNoFromToIndicator:

                            if item is _from:

                                self.lineNoFromToIndicator[0].setPos(QPointF(item.origin[0], item.origin[1]))

                                self.lineNoFromToIndicator[0].setVisible(True)

                            elif item is _to:

                                self.lineNoFromToIndicator[1].setPos(QPointF(item.origin[0], item.origin[1]))

                                self.lineNoFromToIndicator[1].setVisible(True)

        else:

            if self.lineNoFromToIndicator:

                for _label in self.lineNoFromToIndicator:

                    _label.setVisible(False)            

    def contextFrom(self):

        from App import App

        import SelectAttributeCommand

        _from = None

        for prop, value in self.properties.items():

            if prop.Attribute == 'From':

                _from = prop

                break

        cmd = SelectAttributeCommand.SelectAttributeCommand(self, _from, App.mainWnd().graphicsView)

        cmd.onSuccess.connect(App.mainWnd().resultPropertyTableWidget.onSuccessSelectAttribute)

        App.mainWnd().graphicsView.command = cmd

    def contextTo(self):

        from App import App

        import SelectAttributeCommand

        _to = None

        for prop, value in self.properties.items():

            if prop.Attribute == 'To':

                _to = prop

                break

        cmd = SelectAttributeCommand.SelectAttributeCommand(self, _to, App.mainWnd().graphicsView)

        cmd.onSuccess.connect(App.mainWnd().resultPropertyTableWidget.onSuccessSelectAttribute)

        App.mainWnd().graphicsView.command = cmd

    def contextHighlight(self, item):

        from App import App

        from HighlightCommand import HighlightCommand

        HighlightCommand(App.mainWnd().graphicsView).execute(item)

    def contextExplode(self):

        from App import App

        App.mainWnd().itemTreeWidget.explode_line_no_from_context(self)

    def contextExplodeKeep(self):

        from App import App

        App.mainWnd().itemTreeWidget.explode_line_no_from_context(self, True)

    def contextReverse(self):

        self.reverse()

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

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

        self.keyPressEvent(event)

    def hoverLeaveEvent(self, event):

        """ unhighlight line no text and run's item """

        try:

            self.hover = False

            self.update()

            for run in self.runs:

                for item in run.items:

                    item.hoverLeaveEvent(event, True)

            if not self.lineNoFromToIndicatorShowFlag:

                if self.lineNoFromToIndicator:

                    for _label in self.lineNoFromToIndicator:

                        _label.setVisible(False)

        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 keyPressEvent(self, event):

        """ reverse line routine when user press 'C' key """

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

            self.reverse()

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

            self.contextFrom()

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

            self.contextTo()

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

            self.contextShow()

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

            self.contextSelectAll()

        QEngineeringTextItem.keyPressEvent(self, event)

    def update_flow_mark(self, position, minLength):

        """ update line flow mark """

        import math

        from EngineeringLineItem import QEngineeringLineItem

        allowed_error_radian = 0.09

        try:

            for run in self.runs:

                pre = None

                preRadian = None

                for item in run.items:

                    if pre is None and type(item) is QEngineeringLineItem and item.is_piping(True) and item.length() > minLength:

                        pre = item

                        start = item.line().p1()

                        end = item.line().p2()

                        _dir = [(end.x() - start.x()) / item.length(), (end.y() - start.y()) / item.length()]

                        radian = math.atan2(_dir[1], _dir[0]) - math.pi / 2

                        preRadian = radian if radian >= 0 else radian + 2 * math.pi

                        preRadian = abs(preRadian - math.pi)

                    elif pre and type(pre) is QEngineeringLineItem and type(item) is QEngineeringLineItem and item.is_piping(True):

                        start = item.line().p1()

                        end = item.line().p2()

                        _dir = [(end.x() - start.x()) / item.length(), (end.y() - start.y()) / item.length()]

                        radian = math.atan2(_dir[1], _dir[0]) - math.pi / 2

                        currRadian = radian if radian >= 0 else radian + 2 * math.pi

                        currRadian = abs(currRadian - math.pi)

                        if abs(currRadian - preRadian) > allowed_error_radian:

                            # insert flow mark at pre line

                            if pre.length() > minLength:

                                # if str(pre.uid) == '62edfbe5-29fd-49af-840b-6dce051e04d1':

                                # print(math.atan2(preDir[0], preDir[1]) - math.pi / 2)

                                # print(currRadian)

                                # print(preRadian)

                                pre.flowMark = position

                                pre.update_arrow()

                            pre = item

                            preRadian = currRadian

                if pre and type(item) is QEngineeringLineItem and item.is_piping(True) and item.length() > minLength:

                    pre.flowMark = position

                    pre.update_arrow()

        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 paint(self, painter, options=None, widget=None):

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

        if self.freeze_item is None:

            from EngineeringFreezeItem import QEngineeringFreezeItem

            self.freeze_item = QEngineeringFreezeItem(0, 0, QEngineeringFreezeItem.FREEZE_SIZE, QEngineeringFreezeItem.FREEZE_SIZE)

            self.freeze_item.setParentItem(self)

            self.freeze_item.setZValue(self.zValue() + 1)

            self.freeze_item.setPen(Qt.black)

    """

    def reverse(self):

        """ reverse line routine """

        if self.runs:

            self.runs[0].reverse()

            _from = self.prop('From')

            _to = self.prop('To')

            self.set_property('From', _to)

            self.set_property('To', _from)

    def getLongestTwoPoints(self, pts):

        import math

        res = [None, None]

        maxDistance = None

        for i in range(len(pts)):

            for j in range(i + 1, len(pts)):

                dx = pts[i][0] - pts[j][0]

                dy = pts[i][1] - pts[j][1]

                dist = math.sqrt(dx * dx + dy * dy)

                if (maxDistance is None) or (maxDistance < dist):

                    maxDistance = dist

                    res[0] = pts[i]

                    res[1] = pts[j]

        return res

    '''

        @brief      set attribute

        @author     humkyung

        @date       2018.07.20

    '''

    def set_attrib(self, attrib, value):

        matches = [attr for attr in self.attrs if attr.UID == attrib.UID]

        if len(matches) == 1:

            self.attrs[matches[0]] = value

        else:

            self.attrs[attrib] = value

    def removeSelfAttr(self, attributeName):

        pass

    '''

        @brief      get attribute

        @author     kyouho

        @date       2018.09.06

    '''

    def getLineNoAttributes(self, _attrs=None):

        from SymbolAttr import SymbolAttr

        from Configs import LineNoConfig

        import csv

        if _attrs is None:

            _attrs = {}

        try:

            docData = AppDocData.instance()

            line_no_configs = LineNoConfig.instance()

            config = None

            if line_no_configs:

                for line_no_config in line_no_configs:

                    item = line_no_config.parse(self.text())

                    if item[0]:

                        config = line_no_config

                        break

            else:

                item = (False,)

            if item[0]:

                # Line No 부분

                attr = SymbolAttr()

                attr.Attribute = 'LINE NO'

                attr.DisplayAttribute = 'Line No'

                attr.AttributeType = 'String'

                attr.IsProp = 5

                attr.Index = -1

                _attrs[attr] = self.text()

                result = item[1]

                configs = list(csv.reader([config.value], delimiter=self.delimiter, escapechar='^'))[0]

                props = docData.getLineProperties()

                for prop in props:

                    if prop.UID in configs:

                        for i in range(len(configs)):

                            if prop.UID == configs[i]:

                                _attrs[prop] = result[i]

                                break

                    else:

                        matches = [attr for attr in self.attrs if attr.UID == prop.UID]

                        if len(matches) == 1:

                            _attrs[matches[0]] = self.attrs[matches[0]]

                        # else:

                        #    _attrs[prop] = ''

        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 _attrs

    @staticmethod

    def from_database(component):

        """ get line no 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

            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)

                for key in item._properties.keys():

                    if key.Attribute != 'Config':

                        item._properties[key] = key.parse_value(component[key.Attribute])

                app_doc_data = AppDocData.instance()

                # get associations 

                associations = app_doc_data.get_component_associations(component['UID'])

                if associations:

                    for assoc in associations:

                        _attrType = assoc['Type']

                        if not _attrType in item._associations:

                            item._associations[_attrType] = []

                        item._associations[_attrType].append(

                            uuid.UUID(assoc['Association']) if assoc['Association'] != 'None' else None)

                # up to here

                '''

                # get associations 

                associations = app_doc_data.get_component_associations(component['UID'])

                if associations:

                    for assoc in associations:

                        _attrType = assoc['Type']

                        if not _attrType in item._associations:

                            item._associations[_attrType] = []

                        item._associations[_attrType].append(

                            uuid.UUID(assoc['Association']) if assoc['Association'] != 'None' else None)

                # up to here

                '''

                attrs = app_doc_data.get_component_attributes(component['UID'])

                for _attr in attrs:

                    attr = SymbolAttr.from_record(_attr)

                    item.attrs[attr] = _attr['Value']

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

                """ 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

    @staticmethod

    def fromXml(node):

        """ generate EngineeringLineNoTextItem from xml node """

        import uuid

        from TextItemFactory import TextItemFactory

        from SymbolAttr import SymbolAttr

        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

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

            text = node.find('TEXT').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(text, x, y, width, height, angle)

            connline = node.find('CONNLINE').text if node.find('CONNLINE') is not None else None

            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)

            matches = [prop_node for prop_node in node.iter('PROPERTY') if prop_node.attrib['Attribute'] == 'Config']

            if matches:

                item = TextItemFactory.instance().createTextItem(textInfo, matches[0].text)

            else:

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

            if item is not None:

                item.setVisible(False)

                for prop_node in node.iter('PROPERTY'):

                    matches = [prop for prop in item._properties.keys() if

                               prop.Attribute == prop_node.attrib['Attribute'] and prop.Attribute != 'Config']

                    if matches:

                        item._properties[matches[0]] = matches[0].parse_value(prop_node.text)

                for attr_node in node.iterfind('ATTRIBUTE'):

                    attr = SymbolAttr.fromXml(attr_node)

                    item.attrs[attr] = attr_node.text

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

                item.loc = [x, y]

                item.size = [width, height]

                item.angle = angle

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

                # get associations 

                attributeValue = node.find('ASSOCIATIONS')

                if attributeValue is not None:

                    for assoc in attributeValue.iter('ASSOCIATION'):

                        _attrType = assoc.attrib['TYPE']

                        if not _attrType in item._associations:

                            item._associations[_attrType] = []

                        item._associations[_attrType].append(uuid.UUID(assoc.text) if assoc.text != 'None' else None)

                # 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      generate xml code

        @author     humkyung

        @date       2018.04.23

        @history    humkyung 2018.05.02 write symbol's attribute

                    humkyung 2018.05.16 write run information to xml

    '''

    def toXml(self):

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

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        try:

            #docData = AppDocData.instance()

            #configs = docData.getConfigs('Line No', 'Delimiter')

            #delimiter = configs[0].value if 1 == len(configs) else '-'

            #lineNoconfigs = docData.getConfigs('Line No', 'Configuration')

            node = Element('LINE_NO')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            node.append(uidNode)

            textNode = Element('TEXT')

            textNode.text = self.text()

            node.append(textNode)

            locNode = Element('LOCATION')

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

            node.append(locNode)

            widthNode = Element('WIDTH')

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

            node.append(widthNode)

            heightNode = Element('HEIGHT')

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

            node.append(heightNode)

            angleNode = Element('ANGLE')

            angleNode.text = str(self.angle)

            node.append(angleNode)

            areaNode = Element('AREA')

            areaNode.text = self.area

            node.append(areaNode)

            for run in self.runs:

                if run and run.items:

                    node.append(run.toXml())

            attributeValueNode = Element('ASSOCIATIONS')

            for key, value in self._associations.items():

                for assoc in value:

                    assoc_node = Element('ASSOCIATION')

                    assoc_node.attrib['TYPE'] = str(key)

                    assoc_node.text = str(assoc)

                    attributeValueNode.append(assoc_node)

            node.append(attributeValueNode)

            properties_node = Element('PROPERTIES')

            for prop, value in self.properties.items():

                prop_node = prop.toXml()

                prop_node.text = str(value) if value else ''

                properties_node.append(prop_node)

            node.append(properties_node)

            _attrs = self.getAttributes()

            for key in _attrs.keys():

                if key.UID is not None:

                    attrNode = key.toXml()

                    attrNode.text = str(_attrs[key])

                    node.append(attrNode)

            if self.conns:

                connNode = Element('CONNLINE')

                connNode.text = str(self.conns[0].uid) if hasattr(self.conns[0], 'uid') else str(self.conns[0])

                node.append(connNode)

            sceneNode = Element('SCENE')

            sceneNode.text = str(self.sceneBoundingRect()).replace('PyQt5.QtCore.QRectF(', '').replace(' ', '').replace(

                ')', '') 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 line no item to svg"""

        import re

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

        from App import App

        res = []

        try:

            app_doc_data = AppDocData.instance()

            prj = app_doc_data.getCurrentProject()

            node = Element('g')

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

            node.attrib['class'] = 'Pipe'

            node.attrib['data-tag-name'] = self.toPlainText()

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

            except_pattern = re.compile('[^a-zA-Z0-9-_]')

            for attr, value in self.getAttributes().items():

                node.attrib[re.sub(except_pattern, '_', attr.Attribute)] = value if value else ''

            trans = self.sceneTransform()

            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.text = self.toPlainText()

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

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

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

            node.append(text)

            connected_line = self.connected_line

            if connected_line:

                conn_node = connected_line.to_svg(self)

                if conn_node:

                    node.extend(conn_node)

            res.append(node)

        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 res

    def end_break(self):

        '''

            @brief  end break check

            @author euisung

            @date   2019.05.07

            @history    2019.05.19  euisung    can cover at both end that contact other line's middle

                        2019.05.19  euisung    no more used integrated with linetracer

        '''

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        from AppDocData import AppDocData

        end_breaks = []

        try:

            docdata = AppDocData.instance()

            line_from = self.prop('From')

            line_to = self.prop('To')

            end_break_names = docdata.getSymbolListByType('type', 'End Break')

            if len(end_break_names) is 0:

                return end_breaks

            svgFileName = end_break_names[0].sName

            symbol = AppDocData.instance().getSymbolByQuery('name', svgFileName)

            svgFilePath = os.path.join(AppDocData.instance().getCurrentProject().getSvgFilePath(), symbol.getType(),

                                       svgFileName + '.svg')

            for line_end in [line_from, line_to]:

                for connector in line_end.connectors:

                    if connector.connectedItem is not None and connector.connectedItem.owner is not self:

                        end_break = SymbolSvgItem.createItem(symbol.getType(), None, svgFilePath)

                        pt = [connector.center()[0] - float(symbol.getOriginalPoint().split(',')[0]),

                              connector.center()[1] - float(symbol.getOriginalPoint().split(',')[1])]

                        origin = [0, 0]

                        if 2 == len(symbol.getOriginalPoint().split(',')):

                            tokens = symbol.getOriginalPoint().split(',')

                            origin = [pt[0] + float(tokens[0]), pt[1] + float(tokens[1])]

                        end_break.buildItem(svgFileName, symbol.getType(), 5.7, pt,

                                            [end_break.boundingRect().width(), end_break.boundingRect().height()],

                                            origin, [], symbol.getBaseSymbol(), symbol.getAdditionalSymbol(),

                                            symbol.getHasInstrumentLabel())

                        end_break.set_property('Connected Item', connector.connectedItem)

                        end_break.setToolTip('owner : ' + str(line_end))

                        end_break.area = 'Drawing'

                        end_break.owner = line_end

                        end_breaks.append(end_break)

        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 end_breaks

    '''

        @Override (QEngineeringTextItem)

        @brief  get connected items

        @author Jeongwoo

        @date   2018.05.15

    '''

    def getConnectedItems(self):

        visited = []

        try:

            for run in self.runs:

                visited.extend(run.items)

        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 visited

    def explode(self, remainFromTo=False):

        """ explode line no """

        # if False == self.prop('Freeze'):

        try:

            for index in reversed(range(len(self.runs))):

                self.runs[index].explode()

        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) + ' Item UID : ' + str(self.uid)

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

        finally:

            self.runs.clear()

            if not remainFromTo:

                self.set_property('From', None)

                self.set_property('To', None)

            if hasattr(self, 'lineNoFromToIndicator') and self.lineNoFromToIndicator:

                self.lineNoFromToIndicatorShowFlag = False

                if self.scene():

                    self.lineNoFromToIndicator[0].setVisible(False)

                    if len(self.lineNoFromToIndicator) == 2:

                        self.lineNoFromToIndicator[1].setVisible(False)

    '''

        @brief      generate sql phrase to save to database(Notice: Line No's symbol is is 1)

        @author     humkyung

        @date       2018.08.14

    '''

    def toSql_return_separately(self):

        import uuid

        from EngineeringAbstractItem import QEngineeringAbstractItem

        res = []

        resLater = []

        app_doc_data = AppDocData.instance()

        cols = ['UID', 'Drawings_UID', 'Symbol_UID', 'X', 'Y', 'Width', 'Height', 'Rotation', 'Value', 'Connected',

                '[From]', '[To]']

        if type(self) is QEngineeringLineNoTextItem:

            values = ['?', '?', "(select UID from Symbol where Name='Line NO' and SymbolType_UID=-1)", '?', '?', '?',

                      '?', '?', '?', '?', '?', '?']

        else: