ore.models.node.Node.to_tikz()

Complexity

Conditions

13

Size

Total Lines	71
Code Lines	39

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

from . import xml_fuzztree
    def to_tikz(self, x_offset=0, y_offset=0, parent_kind=None):
        """
        Serializes this node and all its children into a TiKZ representation.
        A positive x offset shifts the resulting tree accordingly to the right.
        Negative offsets are allowed.

        We are intentionally do not use the TiKZ tree rendering capabilities, since this
        would ignore all user formatting of the tree from the editor.

        TikZ starts the coordinate system in the upper left corner, while we start in the lower left corner.
        This demands some coordinate mangling on the Y axis.

        Returns:
         {str} the node and its children in LaTex representation
        """
        # Optional nodes are dashed
        if self.get_property("optional", False):
            nodeStyle = "shapeStyleDashed"
        else:
            nodeStyle = "shapeStyle"
        # If this is a child node, we need to check if the parent wants to hide
        # some child property
        hiddenProps = []
        if parent_kind:
            nodeConfig = notations.by_kind[
                self.graph.kind]['nodes'][parent_kind]
            if 'childProperties' in nodeConfig:
                for childPropName in nodeConfig['childProperties']:
                    for childPropSettingName, childPropSettingVal in nodeConfig[
                            'childProperties'][childPropName].iteritems():
                        if childPropSettingName == "hidden" and childPropSettingVal is True:
                            hiddenProps.append(childPropName)
        # Create Tikz snippet for tree node, we start with the TiKZ node for the graph icon
        # Y coordinates are stretched a little bit, for optics
        result = "\\node [shape=%s, %s] at (%u, -%f) (%u) {};\n" % (
            self.kind, nodeStyle, self.x + x_offset, (self.y + y_offset) * 1.2, self.pk)
        # Determine the mirror text based on all properties
        # Text width is exactly the double width of the icons
        mirrorText = unicode()

The variable unicode does not seem to be defined.

        for index, propvalue in enumerate(
                self.get_all_mirror_properties(hiddenProps)):
            propvalue = propvalue.replace(
                "#",
                "\\#")    # consider special LaTex character in mirror text
            if index == 0:
                # Make the first property bigger, since it is supposed to be
                # the name
                propvalue = "\\baselineskip=0.8\\baselineskip\\textbf{{\\footnotesize %s}}" % propvalue
            else:
                propvalue = "{\\it\\scriptsize %s}" % propvalue
            propvalue = propvalue.decode('utf-8')
            mirrorText += propvalue + "\\\\"
        # Create child nodes and their edges
        for edge in self.outgoing.filter(deleted=False):
            # Add child node rendering
            result += edge.target.to_tikz(x_offset, y_offset, self.kind)
            # Add connector from this node to the added child, consider if
            # dashed line is needed
            if 'dashstyle' in notations.by_kind[self.graph.kind][
                    'nodes'][self.kind]['connector']:
                result += "\path[fork edge, dashed] (%s.south) edge (%u.north);\n" % (
                    self.pk, edge.target.pk)
            else:
                result += "\path[fork edge] (%s.south) edge (%u.north);\n" % (
                    self.pk, edge.target.pk)
        # Add the mirror text as separate text node, which makes formatting
        # more precise
        if mirrorText != "":
            result += "\\node [mirrorStyle] at (%u.south) (text%u) {%s};\n" % (
                self.pk, self.pk, mirrorText)
        return result