mirror
/
inkstitch
kopia lustrzana https://github.com/inkstitch/inkstitch
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Extracted Base.descendants into a util function

capellan/fix-cloning-hidden-elements
CapellanCitizen 2024-08-26 03:59:01 -04:00
rodzic e95d222c1d
commit fccf302406
4 zmienionych plików z 96 dodań i 94 usunięć

20
lib/elements/clone.py
Wyświetl plik

@ -17,7 +17,8 @@ from ..i18n import _
from ..svg.svg import copy_no_children
from ..svg.path import get_node_transform
from ..svg.tags import (EMBROIDERABLE_TAGS, INKSTITCH_ATTRIBS, SVG_USE_TAG,
XLINK_HREF, CONNECTION_START, CONNECTION_END)
XLINK_HREF, CONNECTION_START, CONNECTION_END,
SVG_GROUP_TAG)
from ..utils import cache
from .element import EmbroideryElement, param
from .validation import ValidationWarning
@ -71,9 +72,16 @@ class Clone(EmbroideryElement):
source_elements = self.clone_to_elements(source_node)
return [element.get_cache_key(previous_stitch) for element in source_elements]
def clone_to_elements(self, node):
from .utils import node_and_children_to_elements
return node_and_children_to_elements(node, True)
def clone_to_elements(self, node) -> List[EmbroideryElement]:
# Only used in get_cache_key_data, actual embroidery uses nodes_to_elements+iterate_nodes
from .utils import node_to_elements
elements = []
if node.tag in EMBROIDERABLE_TAGS:
elements = node_to_elements(node, True)
elif node.tag == SVG_GROUP_TAG:
for child in node.iterdescendants():
elements.extend(node_to_elements(child, True))
return elements
def to_stitch_groups(self, last_stitch_group=None) -> List[StitchGroup]:
if not self.clone:
@ -100,11 +108,13 @@ class Clone(EmbroideryElement):
Could possibly be refactored into just a generator - being a context manager is mainly to control the lifecycle of the elements
that are cloned (again, for testing convenience primarily)
"""
from .utils import nodes_to_elements, iterate_nodes
cloned_nodes = self.resolve_clone()
try:
# In a try block so we can ensure that the cloned_node is removed from the tree in the event of an exception.
# Otherwise, it might be left around on the document if we throw for some reason.
yield self.clone_to_elements(cloned_nodes[0])
yield nodes_to_elements(iterate_nodes(cloned_nodes[0]))
finally:
# Remove the "manually cloned" tree.
for cloned_node in cloned_nodes:

91
lib/elements/utils.py
Wyświetl plik

@ -3,9 +3,15 @@
# Copyright (c) 2010 Authors
# Licensed under the GNU GPL version 3.0 or later. See the file LICENSE for details.
from ..commands import is_command
from lxml.etree import Comment
from typing import List, Optional
from inkex import BaseElement
from ..commands import is_command, layer_commands
from ..marker import has_marker
from ..svg.tags import EMBROIDERABLE_TAGS, SVG_IMAGE_TAG, SVG_TEXT_TAG
from ..svg.tags import (CONNECTOR_TYPE, EMBROIDERABLE_TAGS, INKSCAPE_GROUPMODE,
NOT_EMBROIDERABLE_TAGS, SVG_CLIPPATH_TAG, SVG_DEFS_TAG,
SVG_GROUP_TAG, SVG_MASK_TAG, SVG_IMAGE_TAG, SVG_TEXT_TAG)
from .clone import Clone, is_clone
from .element import EmbroideryElement
from .empty_d_object import EmptyDObject
@ -15,8 +21,6 @@ from .marker import MarkerObject
from .satin_column import SatinColumn
from .stroke import Stroke
from .text import TextObject
from typing import List
from inkex import BaseElement
def node_to_elements(node, clone_to_element=False) -> List[EmbroideryElement]: # noqa: C901
@ -55,31 +59,66 @@ def node_to_elements(node, clone_to_element=False) -> List[EmbroideryElement]:
return []
def node_and_children_to_elements(node: BaseElement, clone_to_element=False) -> List[EmbroideryElement]:
"""
Iterate through a node and its children, and return all applicable EmbroideryElements.
Notably, does not return EmbroideryElements for hidden elements or children of hidden elements,
similar to `Base.descendants`.
"""
elements: List[EmbroideryElement] = []
def walk(node: BaseElement):
if node.get_computed_style('display') == 'none':
return
elements.extend(node_to_elements(node, clone_to_element))
for child in node:
walk(child)
walk(node)
return elements
def nodes_to_elements(nodes):
elements = []
for node in nodes:
elements.extend(node_to_elements(node))
return elements
def iterate_nodes(node: BaseElement, # noqa: C901
selection: Optional[List[BaseElement]] = None,
troubleshoot=False) -> List[BaseElement]:
# Postorder traversal of selected nodes and their descendants.
# Returns all nodes if there is no selection.
def walk(node: BaseElement, selected: bool) -> List[BaseElement]:
nodes = []
if node.tag == Comment:
return []
element = EmbroideryElement(node)
if element.has_command('ignore_object'):
return []
if node.tag == SVG_GROUP_TAG and node.get(INKSCAPE_GROUPMODE) == "layer":
if len(list(layer_commands(node, "ignore_layer"))):
return []
if (node.tag in EMBROIDERABLE_TAGS or node.tag == SVG_GROUP_TAG) and element.get_style('display', 'inline') is None:
return []
# defs, masks and clippaths can contain embroiderable elements
# but should never be rendered directly.
if node.tag in [SVG_DEFS_TAG, SVG_MASK_TAG, SVG_CLIPPATH_TAG]:
return []
# command connectors with a fill color set, will glitch into the elements list
if is_command(node) or node.get(CONNECTOR_TYPE):
return []
if not selected:
if selection:
if node in selection:
selected = True
else:
# if the user didn't select anything that means we process everything
selected = True
for child in node:
nodes.extend(walk(child, selected))
if selected:
if node.tag == SVG_GROUP_TAG:
pass
elif (node.tag in EMBROIDERABLE_TAGS or is_clone(node)) and not has_marker(node):
nodes.append(node)
# add images, text and elements with a marker for the troubleshoot extension
elif troubleshoot and (node.tag in NOT_EMBROIDERABLE_TAGS or has_marker(node)):
nodes.append(node)
return nodes
return walk(node, False)

65
lib/extensions/base.py
Wyświetl plik

@ -6,18 +6,12 @@
import os
import inkex
from lxml.etree import Comment
from ..commands import is_command, layer_commands
from ..elements import EmbroideryElement, nodes_to_elements
from ..elements.clone import is_clone
from ..i18n import _
from ..marker import has_marker
from ..metadata import InkStitchMetadata
from ..svg import generate_unique_id
from ..svg.tags import (CONNECTOR_TYPE, EMBROIDERABLE_TAGS, INKSCAPE_GROUPMODE,
NOT_EMBROIDERABLE_TAGS, SVG_CLIPPATH_TAG, SVG_DEFS_TAG,
SVG_GROUP_TAG, SVG_MASK_TAG)
from ..svg.tags import INKSCAPE_GROUPMODE, SVG_GROUP_TAG
from ..elements.utils import iterate_nodes, nodes_to_elements
from ..update import update_inkstitch_document
@ -62,58 +56,15 @@ class InkstitchExtension(inkex.EffectExtension):
inkex.errormsg(_("Tip: Run Extensions > Ink/Stitch > Troubleshoot > Troubleshoot Objects") + "\n")
def descendants(self, node, selected=False, troubleshoot=False): # noqa: C901
nodes = []
if node.tag == Comment:
return []
element = EmbroideryElement(node)
if element.has_command('ignore_object'):
return []
if node.tag == SVG_GROUP_TAG and node.get(INKSCAPE_GROUPMODE) == "layer":
if len(list(layer_commands(node, "ignore_layer"))):
return []
if (node.tag in EMBROIDERABLE_TAGS or node.tag == SVG_GROUP_TAG) and element.get_style('display', 'inline') is None:
return []
# defs, masks and clippaths can contain embroiderable elements
# but should never be rendered directly.
if node.tag in [SVG_DEFS_TAG, SVG_MASK_TAG, SVG_CLIPPATH_TAG]:
return []
# command connectors with a fill color set, will glitch into the elements list
if is_command(node) or node.get(CONNECTOR_TYPE):
return []
if self.svg.selection:
if node in list(self.svg.selection):
selected = True
else:
# if the user didn't select anything that means we process everything
selected = True
for child in node:
nodes.extend(self.descendants(child, selected, troubleshoot))
if selected:
if node.tag == SVG_GROUP_TAG:
pass
elif (node.tag in EMBROIDERABLE_TAGS or is_clone(node)) and not has_marker(node):
nodes.append(node)
# add images, text and elements with a marker for the troubleshoot extension
elif troubleshoot and (node.tag in NOT_EMBROIDERABLE_TAGS or has_marker(node)):
nodes.append(node)
return nodes
def get_nodes(self, troubleshoot=False):
# Postorder traversal of selected nodes and their descendants.
# Returns all nodes if there is no selection.
return self.descendants(self.document.getroot(), troubleshoot=troubleshoot)
if self.svg.selection:
selection = list(self.svg.selection)
else:
selection = None
return iterate_nodes(self.document.getroot(), selection=selection, troubleshoot=troubleshoot)
def get_elements(self, troubleshoot=False):
self.elements = nodes_to_elements(self.get_nodes(troubleshoot))

14
tests/test_elements_utils.py
Wyświetl plik

@ -5,7 +5,9 @@ from inkex.tester.svg import svg
class ElementsUtilsTest(TestCase):
def test_node_and_children_to_elements(self):
# These tests test two functions at once, but they're sort of complimentary.
# Might suggest that they could be combined in a later refactor?
def test_iterate_nodes_to_elements(self):
root = svg()
g = root.add(Group())
rect = g.add(Rectangle(attrib={
@ -25,20 +27,20 @@ class ElementsUtilsTest(TestCase):
"height": "10",
}))
elements = utils.node_and_children_to_elements(g)
elements = utils.nodes_to_elements(utils.iterate_nodes(g))
self.assertEqual(len(elements), 1)
self.assertEqual(type(elements[0]), FillStitch)
self.assertEqual(elements[0].node, rect)
def test_node_and_children_to_elements_root_embroiderable(self):
""" Test node_and_children_to_elements where the the node passed is directly embroiderable """
def test_iterate_nodes_to_elements_root_embroiderable(self):
""" Case where the root node is directly embroiderable """
root = svg()
rect = root.add(Rectangle(attrib={
"width": "10",
"height": "10"
}))
elements = utils.node_and_children_to_elements(rect)
elements = utils.nodes_to_elements(utils.iterate_nodes(rect))
self.assertEqual(len(elements), 1)
self.assertEqual(type(elements[0]), FillStitch)
self.assertEqual(elements[0].node, rect)
@ -46,5 +48,5 @@ class ElementsUtilsTest(TestCase):
# Now make the element hidden: It shouldn't return an element
rect.style = rect.style + Style({"display": "none"})
elements = utils.node_and_children_to_elements(rect)
elements = utils.nodes_to_elements(utils.iterate_nodes(rect))
self.assertEqual(len(elements), 0)