HYTOS

# coding: utf-8

"""

This is Engineering Error Item module

"""

import sys

import os

import math

from PyQt5.QtGui import *

from PyQt5.QtCore import *

from PyQt5.QtSvg import *

from PyQt5.QtWidgets import *

from SymbolSvgItem import SymbolSvgItem

from SymbolAttr import SymbolAttr

class QEngineeringEndBreakItem(SymbolSvgItem):

    """

    This is Engineering Error Item class

    """

    clicked = pyqtSignal(QGraphicsSvgItem)

    '''

    '''

    ZVALUE = 8

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

        from SymbolAttr import SymbolProp

        from EngineeringFreezeItem import QEngineeringFreezeItem

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

        self.setZValue(QEngineeringEndBreakItem.ZVALUE)

        #self.connected_lines = []

        #attr = SymbolAttr()

        #attr.Attribute = 'Connected Line'

        #attr.AttributeType = 'Comp Item'

        #self.attrs[attr] = None

        self._properties = \

            {\

                SymbolProp(None, 'Connected Item', 'Comp Item'):None, SymbolProp(None, 'Freeze', 'Boolean'):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)

    '''

    def setPosition(self, loc, origin):

        transform = QTransform()

        transform.translate(loc[0] - origin[0], loc[1] - origin[1])

        self.origin = origin

        self.loc = loc

        self.setTransform(transform)

    def getAttributes(self):

        """

            attributes MUST have Connected Line attribute

        """

        return self.attrs

    def keyPressEvent(self, event): 

        if self.isSelected() and event.key() == Qt.Key_Delete:

            self.scene().removeItem(self)

    '''

    '''

    @staticmethod 

    def fromXml(node):

        import uuid

        from AppDocData import AppDocData

        end_break = None

        try:

            docdata = AppDocData.instance()

            dataPath = docdata.getErrorItemSvgPath()

            uidNode = node.find('UID')

            uid = uidNode.text if uidNode is not None else uuid.uuid4() # generate UUID

            pt = [float(x) for x in node.find('LOCATION').text.split(',')]

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

            origin = [float(x) for x in node.find('ORIGINALPOINT').text.split(',')]

            areaNode = node.find('AREA').text

            connectedLineNode = [uid for uid in node.find('CONNECTED_LINE').text.split(',')]

            end_break = SymbolSvgItem.createItem('End Break', dataPath)

            end_break.setPosition(pt, origin)

            end_break.connected_lines = [connectedLineNode[0], connectedLineNode[1]]

            end_break.setToolTip(str(end_break.connected_lines))

            end_break.area = areaNode

            end_break.name = name

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

        return end_break

    def toXml(self):

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

        try:

            node = Element('END_BREAK')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            node.append(uidNode)

            nameNode = Element('NAME')

            nameNode.text = self.name

            node.append(nameNode)

            areaNode = Element('AREA')

            areaNode.text = self.area

            node.append(areaNode)

            locNode = Element('LOCATION')

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

            node.append(locNode)

            originNode = Element('ORIGINALPOINT')

            originNode.text = '{},{}'.format(self.origin[0], self.origin[1])

            node.append(originNode)

            connectedLineNode = Element('CONNECTED_LINE')

            connectedLineNode.text = '{},{}'.format(self.connected_lines[0], self.connected_lines[1])

            node.append(connectedLineNode)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

            return None

        return node

    '''