HYTOS

# coding: utf-8

""" This is Drawing module """

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

from PyQt5.QtWidgets import *

from .Extent import Extent

from .Presentation import Presentation

class Drawing:

    def __init__(self):

        pass

    @staticmethod

    def to_xml(name: str, scene: QGraphicsScene) -> Element:

        """return element for drawing"""

        node = Element('Drawing')

        node.attrib['Name'] = name

        node.attrib['Type'] = 'PID'

        node.attrib['Title'] = ''

        Presentation.to_xml(node)

        Extent.to_xml(node, scene=scene)

        return node

# coding: utf-8

""" This is Equipment module """

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

from PyQt5.QtWidgets import *

from .Extent import Extent

from .Presentation import Presentation

class Equipment:

    def __init__(self):

        pass

    @staticmethod

    def to_xml(item) -> Element:

        """return element for equipment"""

        node = Element('Equipment')

        node.attrib['ID'] = str(item.uid)

        node.attrib['TagName'] = item.tag_no if item.tag_no else ''

        node.attrib['ComponentClass'] = ''

        node.attrib['ComponentName'] = ''

        node.attrib['ComponentType'] = ''

        node.attrib['Status'] = 'Current'

        Presentation.to_xml(node, layer='0', color='0', line_type='0', line_weight=0.1, r=0, g=0, b=0)

        Extent.to_xml(node, item=item)

        return node

class Nozzle:

    def __init__(self):

        pass

    @staticmethod

    def to_xml(item) -> Element:

        """return element for nozzle"""

        node = Element('Nozzle')

        node.attrib['ID'] = ''

        node.attrib['TagName'] = ''

        node.attrib['ComponentClass'] = 'Nozzle'

        node.attrib['ComponentName'] = ''

        node.attrib['ComponentType'] = ''

        node.attrib['Status'] = 'Current'

        Presentation.to_xml(node, layer='30', color='0', line_type='0', line_weight=0.1, r=0, g=0, b=0)

        return node

# coding: utf-8

""" This is Extent module """

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

from PyQt5.QtWidgets import *

from SymbolSvgItem import SymbolSvgItem

class Extent:

    def __init__(self):

        pass

    @staticmethod

    def to_xml(parent: Element, item: SymbolSvgItem = None, scene: QGraphicsScene = None) -> Element:

        """return element for extent"""

        _node = SubElement(parent, 'Extent')

        rect = None

        if item:

            rect = item.boundingRect()

        elif scene:

            rect = scene.itemsBoundingRect()

        _min = SubElement(_node, 'Min')

        _min.attrib['X'] = str(int(rect.left()))

        _min.attrib['Y'] = str(int(rect.top()))

        _min.attrib['Z'] = '0'

        _max = SubElement(_node, 'Max')

        _max.attrib['X'] = str(int(rect.right()))

        _max.attrib['Y'] = str(int(rect.bottom()))

        _max.attrib['Z'] = '0'

        return _node

# coding: utf-8

""" This is Presentation module """

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

from PyQt5.QtWidgets import *

from .Extent import Extent

class Presentation:

    def __init__(self):

        pass

    @staticmethod

    def to_xml(parent: Element, layer: str = '', color: str = '16777215', line_type: str = '', line_weight: float = 1,

               r: float = 1, g: float = 1, b: float = 1) -> Element:

        """return element for Presentation"""

        node = SubElement(parent, 'Presentation')

        node.attrib['Layer'] = f"{layer}"

        node.attrib['Color'] = f"{color}"

        node.attrib['LineType'] = f"{line_type}"

        node.attrib['LineWeight'] = f"{line_weight}"

        node.attrib['R'] = f"{r}"

        node.attrib['G'] = f"{g}"

        node.attrib['B'] = f"{b}"

        return node

from .Presentation import Presentation

class Point:

    def __init__(self):

        pass

    @staticmethod

    def to_xml(name: str, x: float, y: float, z: float = 0) -> Element:

        """return element for control point"""

        node = Element(name)

        node.attrib['X'] = f"{x}"

        node.attrib['Y'] = f"{y}"

        node.attrib['Z'] = f"{z}"

        return node

        node = Element('Line')

        Presentation.to_xml(node, layer='125', color='0', line_type='1', line_weight=0.35, r=0, g=0, b=0)

        extent_node = SubElement(node, 'Extent')

        coordinate_node = SubElement(node, 'Coordinate')

        coordinate_node = SubElement(node, 'Coordinate')

        return node

class BsplineCurve:

    def __init__(self):

        pass

    @staticmethod

    def to_xml(controls: list, _type: str, knots: list) -> Element:

        """return element for bspline curve"""

        node = Element('BsplineCurve')

        node.attrib['Degree'] = f"{len(controls) - 1}"

        node.attrib['CurveType'] = _type

        node.attrib['NumControlPoints'] = f"{len(controls)}"

        node.attrib['NumKnots'] = f"{len(knots)}"

        controls_node = SubElement(node, 'ControlPoints')

        for control in controls:

            controls_node.append(Point.to_xml('Coordinate', control.real, control.imag))

        knots_node = SubElement(node, 'Knots')

        for knot in knots:

            knot_node = SubElement(knots_node, 'Knot')

            knot_node.text = f"{knot}"

        weights_node = SubElement(node, 'WeightsData')

        for control in controls:

            weight_node = SubElement(weights_node, 'ControlPointWeight')

            weight_node.text = '1'

        return node

            location_node = Point.to_xml('Location', x=conn.center()[0], y=conn.center()[1], z=0)

            position_node.append(location_node)

            axis_node = Point.to_xml('Axis', x=0, y=0, z=1)

            position_node.append(axis_node)

            reference_node = Point.to_xml('Reference', x=1, y=0, z=0)

            position_node.append(reference_node)

        return xml

# coding: utf-8

""" This is ShapeCatalogue module """

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

from PyQt5.QtWidgets import *

from .Extent import Extent

from .Presentation import Presentation

class ShapeCatalogue:

    def __init__(self):

        pass

    @staticmethod

    def to_xml(scene: QGraphicsScene) -> Element:

        """return element for shape catalogue"""

        from SymbolSvgItem import SymbolSvgItem

        from svg.path import Path, Line, Arc, CubicBezier, QuadraticBezier, parse_path

        from svg.path.path import Move

        from .Shape import Line as DEXPI_Line, ConnectionPoints, GenericAttributes, BsplineCurve

        node = Element('ShapeCatalogue')

        node.attrib['Name'] = 'ShapeCatalogue'

        catalogue = set()

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

        for item in items:

            type_str = f"{item.type}/{item.name}"

            if type_str not in catalogue:

                shape_node = SubElement(node, 'Nozzle' if item.type == 'Nozzles' else 'Equipment')

                shape_node.attrib['ComponentClass'] = item.type

                shape_node.attrib['ComponentName'] = item.name

                shape_node.attrib['Status'] = 'Current'

                Presentation.to_xml(shape_node, layer='0', color='0', line_type='0', line_weight=0.1, r=0, g=0, b=0)

                generic_attributes = GenericAttributes(item)

                shape_node.append(generic_attributes.to_xml())

                svg = item.to_svg(parent=None)

                paths = svg[0].findall('path')

                for path in paths:

                    path_ele = parse_path(path.attrib['d'])

                    for idx, ele in enumerate(path_ele):

                        if type(ele) is Move:

                            continue

                        elif type(ele) is Line:

                            line = DEXPI_Line(ele.start, ele.end)

                            shape_node.append(line.to_xml())

                        elif type(ele) is Arc:

                            continue

                        elif type(ele) is CubicBezier:

                            bspline_curve_node = BsplineCurve.to_xml(controls=[ele.start, ele.control1,

                                                                               ele.control2, ele.end],

                                                                     _type='BsplineCurveWithKnots', knots=[])

                            shape_node.append(bspline_curve_node)

                        elif type(ele) is QuadraticBezier:

                            continue

                        else:

                            continue

                connection_points_node = ConnectionPoints(item.connectors)

                shape_node.append(connection_points_node.to_xml())

                catalogue.add(type_str)

        return node

from EngineeringEquipmentItem import QEngineeringEquipmentItem

from .Drawing import Drawing

from .Extent import Extent

from .ShapeCatalogue import ShapeCatalogue

from .Equipment import Equipment

        node.attrib['OriginatingSystem'] = 'ID2'

        extent = Extent.to_xml(xml, scene=scene)

        """drawing node"""

        drawing_node = Drawing.to_xml(name, scene)

        xml.append(drawing_node)

        """shape catalogue node"""

        shape_catalogue_node = ShapeCatalogue.to_xml(scene)

        xml.append(shape_catalogue_node)

        """equipment nodes"""

        equipments = [item for item in scene.items() if type(item) is QEngineeringEquipmentItem]

        for equipment in equipments:

            node = Equipment.to_xml(equipment)

            xml.append(node)

        """piping network system"""

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"