Fix text formatting and positioning issues in Borderless Showcase template

Author: pappnu

py/borderless_showcase.py

@@ -8,10 +8,6 @@
 from photoshop.api._layerSet import LayerSet
 from photoshop.api.enumerations import ElementPlacement
 
-from plugins.proxy_stuff.py.utils.colors import (
-    create_gradient_config,
-    create_gradient_location_map,
-)
 from src import CFG
 from src.cards import strip_reminder_text
 from src.enums.layers import LAYERS
@@ -71,6 +67,10 @@
     is_color_identity,
     parse_hex_color_list,
 )
+from .utils.colors import (
+    create_gradient_config,
+    create_gradient_location_map,
+)
 from .utils.layer import get_layer_dimensions_via_rasterization
 from .utils.layer_fx import get_stroke_details
 from .utils.path import check_layer_overlap_with_shape, create_shape_layer
@@ -600,6 +600,51 @@ def pt_reference(self) -> ReferenceLayer | None:
         ):
             refs.append(layer)
 
+            # Reserve space for flipide PT text
+            if self.text_layer_flipside_pt:
+                # Format flipside PT text
+                for idx, txt in enumerate(reversed(self.text)):
+                    if txt.layer is self.text_layer_flipside_pt:
+                        self.text.pop(idx)
+                        if txt.validate():
+                            txt.execute()
+
+                # Create a shape that encompasses flipside PT text
+                flipside_ref_dims = get_layer_dimensions(layer)
+                flipside_pt_dims = get_layer_dimensions_via_rasterization(
+                    self.text_layer_flipside_pt
+                )
+                rules_stroke_size = (
+                    (get_stroke_details(self.text_layer_rules_base) or {}).get(
+                        "size", 0
+                    )
+                    if self.text_layer_rules_base
+                    else 0
+                )
+                padded_left = flipside_pt_dims["left"] - rules_stroke_size
+                padded_top = flipside_pt_dims["top"] - rules_stroke_size
+                refs.append(
+                    create_shape_layer(
+                        (
+                            {
+                                "x": padded_left,
+                                "y": padded_top,
+                            },
+                            {"x": flipside_ref_dims["right"], "y": padded_top},
+                            {
+                                "x": flipside_ref_dims["right"],
+                                "y": flipside_ref_dims["bottom"],
+                            },
+                            {
+                                "x": padded_left,
+                                "y": flipside_ref_dims["bottom"],
+                            },
+                        ),
+                        relative_layer=layer,
+                        placement=ElementPlacement.PlaceAfter,
+                    )
+                )
+
         if refs:
             if len(refs) > 1:
                 merged = merge_shapes(*refs, operation=ShapeOperation.Unite)
@@ -881,6 +926,10 @@ def textbox_reference_adventure(self) -> ArtLayer | None:
                 )
             )
 
+    @cached_property
+    def textless_bottom_reference_layer(self) -> ReferenceLayer | None:
+        return get_reference_layer(LAYERS.TEXTLESS, self.textbox_reference_group)
+
     # endregion Reference Layers
 
     # region Shapes
@@ -1268,7 +1317,7 @@ def format_temp_rules_text(
         text_field = FormattedTextField(
             layer=layer,
             contents=oracle_text,
-            flavor=flavor_text or "",
+            flavor=flavor_text,
             divider=divider_layer,
         )
         if not text_field.validate():
@@ -1316,6 +1365,12 @@ def adjust_textbox_for_font_size(
         vertical_padding: tuple[float | int, float | int] | None = None,
     ) -> tuple[ArtLayer, ReferenceLayer] | None:
         """Calculates the required size for rules textbox when the rules text has a fixed font size."""
+        if not oracle_text + (flavor_text or ""):
+            return (
+                base_text_layer,
+                self.textless_bottom_reference_layer or base_textbox_reference,
+            )
+
         min_top = min_top if min_top is not None else self.doc_height
         vertical_padding = (
             vertical_padding
@@ -1485,7 +1540,7 @@ def adjust_textbox_for_font_size(
                         shaped_text
                     )
 
-                    top = dims_text_ref_shape["top"] - delta - vertical_padding[1]
+                    top = dims_text_ref_shape["top"] + delta - vertical_padding[1]
 
                     shaped_text.remove()
                     shaped_text = self.create_offset_text_shape(
@@ -1601,8 +1656,12 @@ def adjust_textboxes_for_font_size(
         # First pass of sizing
         for idx, arg in enumerate(textbox_args_sorted):
             height_padding = arg.get("height_padding", 0) or 0
+            arg["base_text_layer"].visible = False
+            base_text_layer_copy = arg["base_text_layer"].duplicate(
+                arg["base_text_layer"], ElementPlacement.PlaceBefore
+            )
             sized = self.adjust_textbox_for_font_size(
-                base_text_layer=arg["base_text_layer"],
+                base_text_layer=base_text_layer_copy,
                 base_textbox_reference=arg["base_textbox_reference"],
                 base_text_wrap_reference=arg["base_text_wrap_reference"],
                 divider_layer=arg["divider_layer"],
@@ -1619,6 +1678,7 @@ def adjust_textboxes_for_font_size(
             # other layer seems to fix it without causing side effects.
             if self.art_layer:
                 select_layer(self.art_layer)
+            base_text_layer_copy.remove()
             if sized:
                 sizes.append(sized)
                 if (
@@ -1646,8 +1706,11 @@ def adjust_textboxes_for_font_size(
             layer.remove()
             ref.remove()
             min_top = tallest_top + height_padding
+            base_text_layer_copy = arg["base_text_layer"].duplicate(
+                arg["base_text_layer"], ElementPlacement.PlaceBefore
+            )
             sized = self.adjust_textbox_for_font_size(
-                base_text_layer=arg["base_text_layer"],
+                base_text_layer=base_text_layer_copy,
                 base_textbox_reference=arg["base_textbox_reference"],
                 base_text_wrap_reference=arg["base_text_wrap_reference"],
                 divider_layer=arg["divider_layer"],
@@ -1656,6 +1719,10 @@ def adjust_textboxes_for_font_size(
                 min_top=min_top,
                 align_to=min_top + (tallest_height - height_padding) / 2,
             )
+            # Same reference layer turning visible bug as above.
+            if self.art_layer:
+                select_layer(self.art_layer)
+            base_text_layer_copy.remove()
             if sized:
                 sizes[orig_idx] = sized
             else:
@@ -1672,15 +1739,20 @@ def disable_text_area_scaling(self, text_area: FormattedTextArea) -> None:
         text_area.fix_overflow_width = False
 
     def rules_text_and_pt_layers(self) -> None:
-        if self.is_split and self.rules_text_font_size:
-            # Split cards don't have PT text and rules text is already adjusted elsewhere
-            return
+        if self.is_split:
+            if self.rules_text_font_size:
+                # Split cards don't have PT text and rules text is already adjusted elsewhere
+                return
+            return super().rules_text_and_pt_layers()
 
         if self.is_planeswalker:
             if self.text_layer_rules_base:
                 self.text_layer_rules_base.visible = False
             return
 
+        # Ensure that sizing logic associated with fixed font size runs before
+        # accessing the rules text layer
+        self.textbox_reference
         super(BorderlessVectorTemplate, self).rules_text_and_pt_layers()
 
         if self.supports_dynamic_textbox_height:
@@ -1741,7 +1813,7 @@ def textbox_positioning(self) -> None:
                 ref.dims["top"] -= self.rules_text_padding / 2
             else:
                 ref = (
-                    get_reference_layer(LAYERS.TEXTLESS, self.textbox_reference_group)
+                    self.textless_bottom_reference_layer
                     if self.is_vertical_layout
                     else self.textbox_reference
                 )
@@ -1923,7 +1995,9 @@ def match_adventure_font_sizes(self) -> None:
                         },
                     )
                     if text_area.validate():
-                        text_area.execute()
+                        # It's enough to reposition the text since it's already formatted.
+                        # Reformatting actually breaks the styling of the text.
+                        text_area.position_within_reference()
                     break
 
     # endregion Adventure

py/utils/layer.py

@@ -1,3 +1,6 @@
+from contextlib import AbstractContextManager
+from types import TracebackType
+
 from photoshop.api import ElementPlacement, RasterizeType
 from photoshop.api._artlayer import ArtLayer
 from photoshop.api._layerSet import LayerSet
@@ -24,3 +27,21 @@ def get_layer_dimensions_via_rasterization(
     dims = get_layer_dimensions(layer_copy)
     layer_copy.remove()
     return dims
+
+
+class LayerVisibleContext(AbstractContextManager[None]):
+    def __init__(self, layer: ArtLayer | LayerSet) -> None:
+        self._layer = layer
+        self._initial_visibility: bool
+
+    def __enter__(self) -> None:
+        self._initial_visibility = self._layer.visible
+        self._layer.visible = False
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self._layer.visible = self._initial_visibility

py/utils/layer_fx.py

@@ -6,30 +6,33 @@
 
 from src import APP
 
+from .layer import LayerVisibleContext
+
 
 class StrokeDetails(TypedDict):
     size: int
 
 
 def get_stroke_details(layer: ArtLayer | LayerSet) -> StrokeDetails | None:
-    APP.instance.activeDocument.activeLayer = layer
+    with LayerVisibleContext(layer):
+        APP.instance.activeDocument.activeLayer = layer
 
-    ref = ActionReference()
-    ref.putEnumerated(
-        APP.instance.cID("Lyr "), APP.instance.cID("Ordn"), APP.instance.cID("Trgt")
-    )
-    desc: ActionDescriptor = APP.instance.executeActionGet(ref)
+        ref = ActionReference()
+        ref.putEnumerated(
+            APP.instance.cID("Lyr "), APP.instance.cID("Ordn"), APP.instance.cID("Trgt")
+        )
+        desc: ActionDescriptor = APP.instance.executeActionGet(ref)
 
-    layer_effects_id = APP.instance.sID("layerEffects")
-    if not desc.hasKey(layer_effects_id):
-        return
+        layer_effects_id = APP.instance.sID("layerEffects")
+        if not desc.hasKey(layer_effects_id):
+            return
 
-    layer_effects: ActionDescriptor = desc.getObjectValue(layer_effects_id)
+        layer_effects: ActionDescriptor = desc.getObjectValue(layer_effects_id)
 
-    frame_fx_id = APP.instance.sID("frameFX")
-    if not layer_effects.hasKey(frame_fx_id):
-        return
+        frame_fx_id = APP.instance.sID("frameFX")
+        if not layer_effects.hasKey(frame_fx_id):
+            return
 
-    frame_fx: ActionDescriptor = layer_effects.getObjectValue(frame_fx_id)
+        frame_fx: ActionDescriptor = layer_effects.getObjectValue(frame_fx_id)
 
-    return {"size": frame_fx.getInteger(APP.instance.sID("size"))}
+        return {"size": frame_fx.getInteger(APP.instance.sID("size"))}

py/utils/path.py

@@ -12,13 +12,12 @@
 from src.helpers.layers import select_layer, select_layers
 from src.helpers.selection import (
     check_selection_bounds,
-    select_bounds,
+    select_layer_pixels,
     select_overlapping,
 )
 from src.schema.colors import ColorObject
 
 from ..uxp.path import PathPointConf, create_path
-from .layer_fx import get_stroke_details
 
 
 def get_layer_path(layer: ArtLayer) -> tuple[Any, bool]:
@@ -156,17 +155,11 @@ def subtract_front_shape(shape_1: ArtLayer, shape_2: ArtLayer) -> ArtLayer:
     return active_layer
 
 
-def check_layer_overlap_with_shape(layer: ArtLayer, ref: ArtLayer):
+def check_layer_overlap_with_shape(layer: ArtLayer, ref: ArtLayer) -> float:
     selection = APP.instance.activeDocument.selection
-    dims = get_shape_dimensions(ref)
-    ref_bounds = (dims["left"], dims["top"], dims["right"], dims["bottom"])
-    select_bounds(ref_bounds, selection=selection)
-
-    if details := get_stroke_details(layer):
-        selection.expand(details["size"])
-
+    select_layer_pixels(ref)
     select_overlapping(layer)
     if bounds := check_selection_bounds(selection):
         selection.deselect()
-        return ref_bounds[1] - bounds[3]
+        return get_shape_dimensions(ref)["top"] - bounds[3]
     return 0

py/uxp/text.py

@@ -219,6 +219,16 @@ def create_text_layer_with_path(
     color = kwargs.get("color", ref_text.color)
     size = kwargs.get("size", ref_text.size)
     leading = kwargs.get("leading", ref_text.leading)
+    try:
+        space_after = ref_text.spaceAfter
+        space_before = ref_text.spaceBefore
+    except COMError:
+        # Hacky workaround to a value retrieval issue with an unknown cause.
+        # This was observed on a duplicated text layer when accessing spaceAfter.
+        # https://community.adobe.com/t5/photoshop-ecosystem-discussions/textitem-color-returns-quot-general-photoshop-error-quot/m-p/10900372#M303432
+        ref_text.contents = ref_text.contents
+        space_after = ref_text.spaceAfter
+        space_before = ref_text.spaceBefore
     desc: MakeTextLayerActionDescriptor = {
         "_obj": "make",
         "_target": [{"_ref": "textLayer"}],
@@ -271,11 +281,11 @@ def create_text_layer_with_path(
                         "_obj": "paragraphStyle",
                         "spaceBefore": {
                             "_unit": "pointsUnit",
-                            "_value": float(ref_text.spaceBefore),
+                            "_value": float(space_before),
                         },
                         "spaceAfter": {
                             "_unit": "pointsUnit",
-                            "_value": float(ref_text.spaceAfter),
+                            "_value": float(space_after),
                         },
                     },
                 }