HYTOS

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringTextItem import QEngineeringTextItem

    def texts(self):

        """ return text type of associations """

        from EngineeringTextItem import QEngineeringTextItem

        res = []

        for text in [x for x in self.associations() if issubclass(type(x), QEngineeringTextItem)]:

            consumed = False

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

                if key.AssocItem and key.AssocItem is text:

                    consumed = True

            if not consumed:

                res.append(text)

        return res

            from EngineeringTextItem import QEngineeringTextItem

        from EngineeringTextItem import QEngineeringTextItem

# coding: utf-8

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

import os.path

import sys

import copy

try:

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

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

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

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 EngineeringPolylineItem import QEngineeringPolylineItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from UserInputAttribute import UserInputAttribute

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, 'Freeze', 'Boolean'):False}

        self._runs = []

        """ 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 properties(self):

        """ getter of properties """

        import uuid

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

            if prop.is_selectable and type(value) is uuid.UUID and self.scene():

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

                if matches: self._properties[prop] = matches[0]

        return self._properties

    @properties.setter

    def properties(self, value):

        """ setter of properties """

        self._properties = value

    def prop(self, property):

        """ return property with given value """

        matches = [prop for prop,_ in self.properties.items() if prop.Attribute == property]

        return self.properties[matches[0]] if matches else None

    def set_property(self, property, value):

        """ set property with given value """

        matches = [prop for prop,_ in self._properties.items() if prop.Attribute == property]

        if matches: self._properties[matches[0]] = value

    @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 None

    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

    '''

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

        self.hover = True

        self.update()

        for run in self.runs:

            for item in run.items:

                item.hoverEnterEvent(event)

    def hoverLeaveEvent(self, event):

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

        self.hover = False

        self.update()

        for run in self.runs:

            for item in run.items:

                item.hoverLeaveEvent(event)

    def keyPressEvent(self, event): 

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

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

            self.reverse()

    """

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

        from SymbolAttr import SymbolAttr

        from Configs import LineNoConfig

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

            # Line No 부분

            if item[0]:

                attr = SymbolAttr()

                attr.Attribute = 'LINE NO'

                attr.DisplayAttribute = 'Line No'

                attr.AttributeType = 'String'

                _attrs[attr] = self.text()

                result = item[1]

                configs = config.value.split(self.delimiter)

                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] = ''

#            attrs['CONN'] = self.conns[0].uid if self.conns else ''

        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

    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.getCategory(), 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())

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

            finally:

                self.runs.clear()

                if not remainFromTo:

                    self.set_property('From', None)

                    self.set_property('To', None)

    '''

        @brief      save Line Data

        @author     kyouho

        @date       2018.08.14

    '''

    def toSql(self):

        data = self.getLineDataList()

        sql = "insert or replace into LINE_DATA_LIST(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) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"

        param = tuple(data)

        return (sql, tuple(param))

    '''

        @brief      return Line Data List

        @author     kyouho

        @date       2018.08.14

    '''

    def getLineDataList(self):

        dataList = []

        try:

            import uuid

            global lineColumnList

            docData = AppDocData.instance()

            attrs = self.getAttributes()

            #attrs = attrs.items()

            for index in range(len(lineColumnList)):

                dataList.append('')

            dataList[20] = docData.imgName

            for key in attrs.keys():

                if type(key) is not UserInputAttribute:

                    lineProp = docData.getLinePropertiesByUID(key.UID)

                    if lineProp:

                        attrName = lineProp[0].Attribute.upper().replace(' ','')

                    else:

                        attrName = key.Attribute.upper().replace(' ','')

                    data = attrs[key]

                    if attrName == 'NOMINALDIAMETER':

                        dataList[1] = data

                    elif attrName == 'FLUIDCODE':

                        dataList[2] = data

                        dataList[7] = data

                    elif attrName == 'TAGSEQNO':

                        pass

                    elif attrName == 'INSULATIONPURPOSE':

                        dataList[16] = data

                    elif attrName == 'STREAMNO':

                        pass

                    elif attrName == 'LINENO' or attrName == 'LINE NO':

                        dataList[3] = data

                    elif attrName == 'PNIDNUMBER':

                        pass

                    elif attrName == 'PIPINGMATERIALSCLASS':

                        dataList[4] = data

                    elif attrName == '':

                        pass

                else:

                    typeUID = key.Attribute

                    value = key.text

                    lineAttr = docData.getLinePropertiesByUID(key.UD)

                    for index in range(len(lineColumnList)):

                        if lineColumnList[index] == lineAttr[0].Attribute:

                            dataList[index] = value

        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)

        if dataList[0] == '':

            dataList[0] = str(uuid.uuid4())

        return dataList

# coding: utf-8

import sys

import os

import math

from PyQt5.QtGui import *

from PyQt5.QtCore import *

from PyQt5.QtSvg import *

from PyQt5.QtWidgets import (QApplication, QGraphicsItem)

from SymbolSvgItem import SymbolSvgItem

from EngineeringConnectorItem import QEngineeringConnectorItem

class QEngineeringNozzleItem(SymbolSvgItem):

    ZVALUE = 20

    clicked = pyqtSignal(QGraphicsSvgItem)

    '''

    '''

    def __init__(self, path, uid=None, flip=0):

        SymbolSvgItem.__init__(self, path, uid, flip=flip)

        self._props = [['Name', None], ['Size', None]]

        self.setZValue(QEngineeringNozzleItem.ZVALUE)

    '''

        @brief      getter of property

        @author     humkyung

        @date       2018.07.29

    '''

    @property

    def props(self):

        return self._props

    '''

        @brief  connect attribute

        @author humkyung

        @date   2018.07.19

    '''

    def connectAttribute(self, attributes, clear=True):

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        super(QEngineeringNozzleItem, self).connectAttribute(attributes, clear)

        rect = self.sceneBoundingRect()

        attrs = [attr for attr in attributes if type(attr) is QEngineeringTagNoTextItem]

        # check if text locates inside equipment

        for attr in attrs:

            if rect.contains(attr.center()):

                self.attrs.append(attr)

                attrs.remove(attr)

                break

        if not self.attrs:

            minDist = None

            selected = None

            # get nearest text from nozzle 

            for attr in attrs:

                dx = attr.center().x() - rect.center().x()

                dy = attr.center().y() - rect.center().y()

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

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

                    minDist = dist

                    selected = attr

            if selected is not None:

                self.attrs.append(selected)

                selected.onwer = self

# coding: utf-8

import os.path

import sys

import copy

try:

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

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

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

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 AppDocData import AppDocData

from EngineeringTextItem import QEngineeringTextItem

class QEngineeringNozzleNameItem(QEngineeringTextItem):

    '''

    '''

    def __init__(self, parent=None):

        QEngineeringTextItem.__init__(self, parent)

        self._runs = []

        appDocData = AppDocData.instance()

        attributes = appDocData.getSymbolAttribute('Nozzle')

        self._attrs = [[attr, None] for attr in attributes]

    '''

        @brief      getter of attributes

        @author     humkyung

        @date       2018.07.29

    '''

    @property

    def attrs(self):

        return self._attrs

# coding: utf-8

""" This is engineering reserved word text item module """

import os.path

import sys

import copy

try:

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

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

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

        QGraphicsTextItem

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 AppDocData import AppDocData, MessageType

from EngineeringTextItem import QEngineeringTextItem

class QEngineeringReservedWordTextItem(QEngineeringTextItem):

    """ This is engineering reserved words text item class """

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

        QEngineeringTextItem.__init__(self, uid, parent)

        self.type = 'Reserved Word'

# coding: utf-8

""" This is engineering run item moduel """

import sys

import os.path

import copy

try:

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

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

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

except ImportError:

    try:

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

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

    except ImportError:

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

from EngineeringAbstractItem import QEngineeringAbstractItem

class QEngineeringRunItem(QEngineeringAbstractItem):

    """ This is engineering run item class """

    def __init__(self):

        import uuid

        QEngineeringAbstractItem.__init__(self)

        self.uid = uuid.uuid4() # generate UUID

        self._items = []

        self._visible = False

        self.owner = None

    @property

    def Type(self):

        """ return type of run(Drain/Process) """

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringLineItem import QEngineeringLineItem

        if len(self._items) == 2:

            if 1 == len([item for item in self._items if type(item) is QEngineeringLineItem]) and\

            1 == len([item for item in self._items if type(item) is SymbolSvgItem]): return 'Drain'

        return 'Process'

    @property

    def visible(self):

        """ return visible """

        return self._visible

    @visible.setter

    def visible(self, value):

        """ set visible value """

        self._visible = value

        for item in self.items:

            if issubclass(type(item), QGraphicsItem):

                item.setVisible(value)

    '''

        @brief  getter of items

        @author humkyung

        @date   2018.05.15

    '''

    @property

    def items(self):

        return self._items

    '''

        @brief  setter of items

        @author humkyung

        @date   2018.05.15

    '''

    @items.setter

    def items(self, value):

        self._items = value

    def explode(self):

        """ explode run and subtract it from line no """

        try:

            for item in self.items:

                item.owner = None

        finally:

            self.items.clear()

            if self.owner: self.owner.runs.remove(self)

    '''

        @brief  get two points which's length is max

        @author humkyung

        @date   2018.05.23

    '''

    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

    def arrange_flow_direction(self):

        """ arrange flow direction of line """

        from EngineeringLineItem import QEngineeringLineItem

        for at in range(len(self.items)):

            if type(self.items[at]) is QEngineeringLineItem and at > 0:

                self.items[at].arrange_flow_direction(self.items[at-1])

            elif type(self.items[at]) is QEngineeringLineItem and len(self.items) > 1:

                self.items[at].arrange_flow_direction(self.items[at+1])

                self.items[at].reverse()

    def reverse(self):

        """ reverse line's flow direction """

        from EngineeringLineItem import QEngineeringLineItem

        self.items.reverse()

        for at in range(len(self.items)):

            if type(self.items[at]) is QEngineeringLineItem:

                self.items[at].reverse()

    '''

        @brief  add flow mark

        @author humkyung

        @date   2018.06.17

    '''

    def addFlowMark(self):

        from EngineeringLineItem import QEngineeringLineItem

        try:

            connectedLines = [item for item in self.items if type(item) is QEngineeringLineItem]

            maxLength = None

            maxLengthItem = None

            for line in connectedLines:

                length = line.length()

                if maxLength is None or maxLength < length:

                    maxLength = length

                    maxLengthItem = line

            if maxLengthItem is not None: maxLengthItem.addFlowArrow()

        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)

    '''

        @brief  write to xml

        @author humkyung

        @date   2018.05.16

        @history    Jeongwoo 2018.05.24 Add math.fabs() on sublist's if-statement

                                        Change toler(1 → 5) and Modify Longest Line's coords // Make comments Test Code

                    humkyung 2018.06.22 sort lines before writing to xml

                    kyouho  2018.08.09 Line 묶기

    '''

    def toXml(self):

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

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        try:

            node = Element('RUN')

            node.attrib['TYPE'] = self.Type

            for item in self.items:

                # skip line item which's connected items are same

                if (type(item) is QEngineeringLineItem) and item.connectors[0].connectedItem is not None and (item.connectors[0].connectedItem is item.connectors[1].connectedItem):

                    continue

                # up to here

                node.append(item.toXml())

        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

# coding: utf-8

import os.path

import sys

import copy

try:

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

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

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

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 EngineeringPolylineItem import QEngineeringPolylineItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from AppDocData import AppDocData, MessageType

from EngineeringTextItem import QEngineeringTextItem

from SymbolSvgItem import SymbolSvgItem

class QEngineeringSizeTextItem(QEngineeringTextItem):

    def __init__(self, parent=None):

        import uuid

        QEngineeringTextItem.__init__(self, parent)

        self.type = 'SIZE'

    def findOwner(self, symbols):

        import math

        try:

            minDist = None

            selected = None

            configs = AppDocData.instance().getConfigs('Size', 'Delimiter')

            delimiter = configs[0].value.upper() if configs else 'X'

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

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

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

            center = self.sceneBoundingRect().center()

            for symbol in symbols:

                if delimiter in self.text().upper() and type(symbol) is QEngineeringReducerItem:

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

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

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

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

                        minDist = length

                        selected = symbol

                elif not delimiter in self.text().upper() and type(symbol) is SymbolSvgItem:

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

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

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

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

                        minDist = length

                        selected = symbol

            if selected is not None:                

                if selected.add_assoc_item(self):

                    self.owner = selected

        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)

# coding: utf-8

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

import os.path

import sys

import copy

try:

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

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

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

        QGraphicsTextItem

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 AppDocData import AppDocData, MessageType

from EngineeringTextItem import QEngineeringTextItem

class QEngineeringTagNoTextItem(QEngineeringTextItem):

    """ This is engineering tag no text item class """

    def __init__(self, parent=None):

        import uuid

        QEngineeringTextItem.__init__(self, parent)

        self.type = 'TAG NO'

    def findOwner(self, symbols):

        import math

        try:

            minDist = None

            selected = None

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

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

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

            center = self.sceneBoundingRect().center()

            for symbol in symbols:

                if type(symbol) is QEngineeringEquipmentItem:

                    if symbol.includes([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()]):

                        selected = symbol

                        break

            if selected is None:

                for symbol in symbols:

                    if type(symbol) is QEngineeringEquipmentItem:

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

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

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

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

                            minDist = length

                            selected = symbol

            if selected is not None:

                if selected.add_assoc_item(self):

                    self.owner = selected

        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)

                #self.resetTransform()

                #self.setPos(change.topLeft())

    '''

        @brief  change cursor to CrossCursor if mouse point is close to connection point

        @author humkyung

        @date   2018.04.28

    '''

    def hoverMoveEvent(self, event):

        pass

            toler = 10

            self._selected_idx = None

            for idx, corner in enumerate(self.corners):

                dx = corner.x() - pos.x()

                dy = corner.y() - pos.y()

                if math.sqrt(dx * dx + dy * dy) < toler:

                    self._selected_idx = idx

                    break

            if self._selected_idx is None:

                self.clicked.emit(self)

        #super(SymbolSvgItem, self).mousePressEvent(event)

        self.focuspen = QPen(Qt.DotLine)

        self.focuspen.setColor(Qt.black)

        self.focuspen.setWidthF(1.5)

        painter.setPen(self.focuspen)

        painter.drawRect(self.boundingRect())

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from EngineeringTextItem import QEngineeringTextItem

        """

        for attr in self.attrs:

            if issubclass(type(attr), QEngineeringTextItem):

                color = QEngineeringAbstractItem.HOVER_COLOR if self.hover else (

                    self._owner._color if self._owner else QEngineeringAbstractItem.DEFAULT_COLOR)

                attr.setColor(color)

            elif issubclass(type(attr), SymbolSvgItem):

                attr.setColor(self.getColor())

                attr.update()

        """