HYTOS

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

import symbol

import SymbolBase

import TextInfo as ti

import math

import os

import sys

from AppDocData import AppDocData

ROOT_NODE_NAME = "DWG"

ROOT_DWGNAME_NODE_NAME = "DWGNAME"

ROOT_SIZE_NODE_NAME = "SIZE"

SYMBOL_LIST_NODE_NAME = "SYMBOLS"

TEXT_INFO_LIST_NODE_NAME = "TEXTINFOS"

IMG_LINE_LIST_NODE_NAME = "IMGLINES"

NOTE_TEXT_INFO_LIST_NOTE_NAME = "NOTES"

SCATEGORY_NODE_NAME = "SYMBOL"

SNAME_NODE_NAME = "NAME"

STYPE_NOTE_NAME = "TYPE"

SCLASS_NODE_NAME = "CLASS"

SITEM_NODE_NAME = "ITEM"

SSUB_TEXT = "TEXT"

SSUB_ORIGINAL_POINT = "ORIGINALPOINT"

SSUB_CONNECTION_POINT = "CONNECTIONPOINT"

SSUB_PARENT = "PARENT"

SSUB_CHILD = "CHILD"

SSUB_ANGLE = "ANGLE"

SSUB_START_POINT = "STARTPOINT"

SSUB_SIZE = "SIZE"

LINE_NO_LIST_NODE_NAME = "LINE_NOS"

TEXT_INFO_NODE_NAME = "TEXTINFO"

TTEXT_NODE_NAME = "TEXT"

TTEXT_X_NODE_NAME = "X"

TTEXT_Y_NODE_NAME = "Y"

TTEXT_WIDTH_NODE_NAME = "WIDTH"

TTEXT_HEIGHT_NODE_NAME = "HEIGHT"

TTEXT_ANGLE_NODE_NAME = "ANGLE"

IMG_LINE_NODE_NAME = "IMGLINE"

ISP_NODE_NAME = "START"

IEP_NODE_NAME = "END"

NOTE_TEXT_INFO_NOTE_NAME = "NOTE"

TNOTE_TEXT_NODE_NAME = "TEXT"

TNOTE_TEXT_X_NODE_NAME = "X"

TNOTE_TEXT_Y_NODE_NAME = "Y"

TNOTE_TEXT_WIDTH_NODE_NAME = "WIDTH"

TNOTE_TEXT_HEIGHT_NODE_NAME = "HEIGHT"

TNOTE_TEXT_ANGLE_NODE_NAME = "ANGLE"

LINE_INFOS_NODE_NAME = "LINEINFOS"

LLINE_INFO_NODE_NAME = "LINEINFO"

LLINE_UUID = "UUID"

LLINE_START_POINT_NODE_NAME = "STARTPOINT"

LLINE_END_POINT_NODE_NAME = "ENDPOINT"

LINE_NOS_NODE_NAME = "LINENOS"

TRIM_LINE_NOS_NODE_NAME = "TRIMLINENOS"

UNKNOWNS_NODE_NAME = "UNKNOWNS"

'''

    @brief  

    @author 

    @date   

    @history    2018.05.25  Jeongwoo    Remove parameter 'imgLineList'

'''

def writeXml(pidName, pidWidth, pidHeight, searchedSymbolList, textInfoList, noteTextInfoList):

    path = os.path.join(AppDocData.instance().getCurrentProject().getTempPath(), pidName + '.xml')

    try:

        xmlData = generateXml(pidName, pidWidth, pidHeight, searchedSymbolList, textInfoList, noteTextInfoList)

        ElementTree(xmlData).write(path)

    except Exception as ex:

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

    return path

'''

    @brief  write output xml

    @author humkyung

    @date   2018.04.23

'''

def writeOutputXml(pidName, pidWidth, pidHeight):

    try:

        path = os.path.join(AppDocData.instance().getCurrentProject().getOutputPath(), pidName + '.xml')

        xmlData = generateOutputXml(pidName, pidWidth, pidHeight)

        ElementTree(xmlData).write(path)

    except Exception as ex:

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

    return path

'''

    @brief      generate output xml for converter

    @author     humkyung

    @date       2018.04.23

    @history    humkyung 2018.05.02 write equipment node

                humkyung 2018.05.10 write orphan lines

                humkyung 2018.05.16 remove code to write orphan lines and symbols

                humkyung 2018.09.06 write text to xml

'''

def generateOutputXml(pidName, pidWidth, pidHeight):

    appDocData = AppDocData.instance()

    try:

        xml = Element(ROOT_NODE_NAME) # Root Node

        SubElement(xml, ROOT_DWGNAME_NODE_NAME).text = pidName

        SubElement(xml, ROOT_SIZE_NODE_NAME).text = str(pidWidth) + "," + str(pidHeight)

        SubElement(xml, 'UNIT').text = appDocData.getCurrentProject().unit()

        for equipment in appDocData.equipments:

            equipmentNode = Element('EQUIPMENT')

            equipmentNode.append(equipment.toXml())

            xml.append(equipmentNode)

        sortedList = sorted(appDocData.lineNos, key=lambda param:param.text())

        for lineno in sortedList:

            xml.append(lineno.toXml())

        for text in appDocData.texts:

            xml.append(text.toXml())

    except Exception as ex:

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

    return xml

'''

    @history    2018.04.30  Jeongwoo    noteTextInfoList None Check

                2018.05.25  Jeongwoo    Remove parameter 'imgLineList' and Check if variable is None or not

'''

def generateXml(pidName, pidWidth, pidHeight, searchedSymbolList, textInfoList, noteTextInfoList):

    xml = Element(ROOT_NODE_NAME) # Root Node

    SubElement(xml, ROOT_DWGNAME_NODE_NAME).text = pidName

    SubElement(xml, ROOT_SIZE_NODE_NAME).text = str(pidWidth) + "," + str(pidHeight)

    try:

        if searchedSymbolList is not None:

            symbolListNode = Element(SYMBOL_LIST_NODE_NAME) # Symbol List Node

            sortedList = sorted(searchedSymbolList, key=lambda sym:sym.getName())

            for symbol in sortedList:

                node = getSymbolInfoNode(symbol)

                symbolListNode.append(node)

            xml.append(symbolListNode)

        if textInfoList is not None:

            textInfoListNode = Element(TEXT_INFO_LIST_NODE_NAME) # Text Info List Node

            for textInfo in textInfoList:

                node = getTextInfoNode(textInfo)

                textInfoListNode.append(node)

            xml.append(textInfoListNode)

        noteTextInfoListNode = Element(NOTE_TEXT_INFO_LIST_NOTE_NAME)

        if noteTextInfoList is not None:

            for noteTextInfo in noteTextInfoList:

                node = getNoteTextInfoNode(noteTextInfo)

                noteTextInfoListNode.append(node)

        xml.append(noteTextInfoListNode)

    except Exception as ex:

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

    return xml

def getSymbolInfoNode(symbol):

    sName = symbol.getName()

    sSp = symbol.getSp()

    sAngle = symbol.getRotatedAngle()

    sType = symbol.getType()

    sText = symbol.getText()

    sOriginalPoint = symbol.getOriginalPoint()

    sConnectionPoint = symbol.getConnectionPoint()

    sWidth = symbol.getWidth()

    sHeight = symbol.getHeight()

    sBaseSymbol = symbol.getBaseSymbol()

    sAdditionalSymbol = symbol.getAdditionalSymbol()

    sCategoryNode = Element(SCATEGORY_NODE_NAME)

    sNameNode = Element(SNAME_NODE_NAME)

    sNameNode.text = sName

    sTypeNode = Element(STYPE_NOTE_NAME)

    sTypeNode.text = sType

    sOriginalPointNode = Element(SSUB_ORIGINAL_POINT)

    sOpX = sSp[0] + int(sOriginalPoint.split(',')[0])

    sOpY = sSp[1] + int(sOriginalPoint.split(',')[1])

    sOriginalPointNode.text = str(sOpX) + "," + str(sOpY)

    sConnectionPointNode = Element(SSUB_CONNECTION_POINT)

    convertedConnectionPoint = ""

    if sConnectionPoint:

        splitConnectionPoint = sConnectionPoint.split("/")

        for index in range(len(splitConnectionPoint)):

            if index != 0:

                convertedConnectionPoint = convertedConnectionPoint + "/"

            item = splitConnectionPoint[index]

            sCpX = sSp[0] + int(item.split(',')[0])

            sCpY = sSp[1] + int(item.split(',')[1])

            tempStr = str(sCpX) + "," + str(sCpY)

            convertedConnectionPoint = convertedConnectionPoint + tempStr

    sConnectionPointNode.text = convertedConnectionPoint

    sBaseSymbolNode = Element(SSUB_PARENT)

    sBaseSymbolNode.text = sBaseSymbol

    if sAdditionalSymbol is not None:

        sAdditionalSymbolNode = Element(SSUB_CHILD)

        sAdditionalSymbolNode.text = sAdditionalSymbol

        sCategoryNode.append(sAdditionalSymbolNode)

    sAngleNode = Element(SSUB_ANGLE)

    sAngleNode.text = str(round(math.radians(sAngle), 2))

    sTextNode = Element(SSUB_TEXT)

    sTextNode.text = sText

    sStartPointNode = Element(SSUB_START_POINT)

    sStartPointNode.text = str(sSp[0]) + "," + str(sSp[1])

    sSizeNode = Element(SSUB_SIZE)

    sSizeNode.text = str(sWidth) + "," + str(sHeight)

    sCategoryNode.append(sNameNode)

    sCategoryNode.append(sTypeNode)

    sCategoryNode.append(sOriginalPointNode)

    sCategoryNode.append(sConnectionPointNode)

    sCategoryNode.append(sBaseSymbolNode)

    sCategoryNode.append(sAngleNode)

    sCategoryNode.append(sTextNode)

    sCategoryNode.append(sStartPointNode)

    sCategoryNode.append(sSizeNode)

    return sCategoryNode

def getTextInfoNode(textInfo):

    text = textInfo.getText()

    x = textInfo.getX()

    y = textInfo.getY()

    w = textInfo.getW()

    h = textInfo.getH()

    angle = textInfo.getAngle()

    tInfoNode = Element(TEXT_INFO_NODE_NAME)

    textNode = Element(TTEXT_NODE_NAME)

    textNode.text = text

    xNode = Element(TTEXT_X_NODE_NAME)

    xNode.text = str(x)

    yNode = Element(TTEXT_Y_NODE_NAME)

    yNode.text = str(y)

    widthNode = Element(TTEXT_WIDTH_NODE_NAME)

    widthNode.text = str(w)

    heightNode = Element(TTEXT_HEIGHT_NODE_NAME)

    heightNode.text = str(h)

    angleNode = Element(TTEXT_ANGLE_NODE_NAME)

    angleNode.text = str(round(math.radians(angle), 2))

    tInfoNode.append(textNode)

    tInfoNode.append(xNode)

    tInfoNode.append(yNode)

    tInfoNode.append(widthNode)

    tInfoNode.append(heightNode)

    tInfoNode.append(angleNode)

    return tInfoNode

def getNoteTextInfoNode(noteTextInfo):

    text = noteTextInfo.getText()

    x = noteTextInfo.getX()

    y = noteTextInfo.getY()

    w = noteTextInfo.getW()

    h = noteTextInfo.getH()

    angle = noteTextInfo.getAngle()

    ntInfoNode = Element(NOTE_TEXT_INFO_NOTE_NAME)

    textNode = Element(TNOTE_TEXT_NODE_NAME)

    textNode.text = text

    xNode = Element(TNOTE_TEXT_X_NODE_NAME)

    xNode.text = str(x)

    yNode = Element(TNOTE_TEXT_Y_NODE_NAME)

    yNode.text = str(y)

    widthNode = Element(TNOTE_TEXT_WIDTH_NODE_NAME)

    widthNode.text = str(w)

    heightNode = Element(TNOTE_TEXT_HEIGHT_NODE_NAME)

    heightNode.text = str(h)

    angleNode = Element(TNOTE_TEXT_ANGLE_NODE_NAME)

    angleNode.text = str(round(math.radians(angle), 2))

    ntInfoNode.append(textNode)

    ntInfoNode.append(xNode)

    ntInfoNode.append(yNode)

    ntInfoNode.append(widthNode)

    ntInfoNode.append(heightNode)

    ntInfoNode.append(angleNode)

    return ntInfoNode

'''

    @brief      Append LineInfo Data

    @author     Jeongwoo

    @date       2018.05.28

'''

def appendLineInfo(xmlPath, lineInfo):

    tree = parse(xmlPath)

    root = tree.getroot()

    lineInfosNode = root.find(LINE_INFOS_NODE_NAME)

    if lineInfosNode is not None:

        lineInfosNode.clear()

    else:

        lineInfosNode = Element(LINE_INFOS_NODE_NAME)

        root.append(lineInfosNode)

    for line in lineInfo:

        lineInfoNode = Element(LLINE_INFO_NODE_NAME)

        #uuidNode = Element(LLINE_UUID)

        #uuidNode.text = line.uid

        startPointNode = Element(LLINE_START_POINT_NODE_NAME)

        startPointNode.text = str(line.startPoint()[0])+","+str(line.startPoint()[1])

        endPointNode = Element(LLINE_END_POINT_NODE_NAME)

        endPointNode.text = str(line.endPoint()[0])+","+str(line.endPoint()[1])

        #lineInfoNode.append(uuidNode)

        lineInfoNode.append(startPointNode)

        lineInfoNode.append(endPointNode)

        lineInfosNode.append(lineInfoNode)

    ElementTree(root).write(xmlPath)

'''

    @brief      Write xml data by scene

    @author     Jeongwoo

    @date       2018.05.30

    @history    2018.05.30  Jeongwoo    Create node by item object

                2018.06.12  Jeongwoo    Add if-statement for QEngineeringLineNoTextItem data node

                2018.06.14  Jeongwoo    Add if-statement for QEngineeringUnknownItem data node

                2018.11.26  euisung     remove scene dependency

'''

def writeXmlOnScene(pidName, pidWidth, pidHeight):

    from EngineeringNoteItem import QEngineeringNoteItem

    from EngineeringTextItem import QEngineeringTextItem

    from EngineeringLineItem import QEngineeringLineItem

    from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

    from EngineeringUnknownItem import QEngineeringUnknownItem

    from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

    from QEngineeringSizeTextItem import QEngineeringSizeTextItem

    from SymbolSvgItem import SymbolSvgItem

    appDocData = AppDocData.instance()

    items = []

    items = appDocData.allItems

    path = os.path.join(AppDocData.instance().getCurrentProject().getTempPath(), pidName + '.xml')

    xml = Element(ROOT_NODE_NAME) # Root Node

    SubElement(xml, ROOT_DWGNAME_NODE_NAME).text = pidName

    SubElement(xml, ROOT_SIZE_NODE_NAME).text = str(pidWidth) + "," + str(pidHeight)

    symbolListNode = Element(SYMBOL_LIST_NODE_NAME) # Symbol List Node

    textInfoListNode = Element(TEXT_INFO_LIST_NODE_NAME) # Text Info List Node

    noteTextInfoListNode = Element(NOTE_TEXT_INFO_LIST_NOTE_NAME)

    lineListNode = Element(LINE_INFOS_NODE_NAME)

    lineNoListNode = Element(LINE_NOS_NODE_NAME)

    unknownListNode = Element(UNKNOWNS_NODE_NAME)

    # trim line 추가

    trimLineNoListNode = Element(TRIM_LINE_NOS_NODE_NAME)

    try:

        resultDic = {}

        resultDic["Symbol Item"] = [0, []]

        resultDic["Line Item"] = [0, []]

        resultDic["Line No Text Item"] = [0, []]

        resultDic["Text Item"] = [0, []]

        resultDic["Note Item"] = [0, []]

        resultDic["Unknown Item"] = [0, []]

        resultDic["Trim Line Item"] = [0, []]

        resultDic["Size Item"] = [0, []]

        for item in items:

            if issubclass(type(item), SymbolSvgItem):

                symbolNode = item.toXml()

                if symbolNode is None: continue

                if type(symbolNode) is str:

                    resultDic["Symbol Item"][1].append(symbolNode)

                else:

                    resultDic["Symbol Item"][0] += 1

                    symbolListNode.append(symbolNode)

            elif type(item) is QEngineeringLineItem:

                lineNode = item.toXml()

                if type(lineNode) is str:

                    resultDic["Line Item"][1].append(lineNode)

                else:

                    resultDic["Line Item"][0] += 1

                    lineListNode.append(lineNode)

            elif type(item) is QEngineeringLineNoTextItem:

                lineNoNode = item.toXml()

                if type(lineNoNode) is str:

                    resultDic["Line No Text Item"][1].append(lineNoNode)

                else:

                    resultDic["Line No Text Item"][0] += 1

                    lineNoListNode.append(lineNoNode)

            elif type(item) is QEngineeringTextItem:

                textNode = item.toXml()

                if type(textNode) is str:

                    resultDic["Text Item"][1].append(textNode)

                else:

                    resultDic["Text Item"][0] += 1

                    textInfoListNode.append(textNode)

            elif type(item) is QEngineeringNoteItem:

                noteNode = item.toXml(name = 'NOTE')

                if type(noteNode) is str:

                    resultDic["Note Item"][1].append(noteNode)

                else:

                    resultDic["Note Item"][0] += 1

                    noteTextInfoListNode.append(noteNode)

            elif type(item) is QEngineeringUnknownItem:

                unknownNode = item.toXml()

                if type(unknownNode) is str:

                    resultDic["Unknown Item"][1].append(unknownNode)

                else:

                    resultDic["Unknown Item"][0] += 1

                    unknownListNode.append(unknownNode)

            elif type(item) is QEngineeringSizeTextItem:

                sizeNode = item.toXml(name='SIZE')

                if type(sizeNode) is str:

                    resultDic["Size Item"][1].append(sizeNode)

                else:

                    resultDic["Size Item"][0] += 1

                    textInfoListNode.append(sizeNode)

        for line in appDocData.tracerLineNos:

            if type(line) is QEngineeringTrimLineNoTextItem:

                trimNode = line.toXml()

                if type(trimNode) is str:

                    resultDic["Trim Line Item"][1].append(trimNode)

                else:

                    resultDic["Trim Line Item"][0] += 1

                    trimLineNoListNode.append(trimNode)

    except Exception as ex:

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

    finally:

        xml.append(symbolListNode)

        xml.append(textInfoListNode)

        xml.append(noteTextInfoListNode)

        xml.append(lineListNode)

        xml.append(lineNoListNode)

        xml.append(unknownListNode)

        xml.append(trimLineNoListNode)

        ElementTree(xml).write(path)

    return resultDic

def indent(elem, level=0):

    i = "\n" + level*"  "

    if len(elem):

        if not elem.text or not elem.text.strip():

            elem.text = i + "  "

        if not elem.tail or not elem.tail.strip():

            elem.tail = i

        for elem in elem:

            indent(elem, level+1)

        if not elem.tail or not elem.tail.strip():

            elem.tail = i

    else:

        if level and (not elem.tail or not elem.tail.strip()):

            elem.tail = i

    return elem