ClassicTemplate¶

def add_basic_watermark_snow_effects(self, wm: ArtLayer):
    """Adds optional snow effects for 'Snow' Basic Land watermarks.

    Args:
        wm: ArtLayer containing the Basic Land Watermark.
    """
    pass

def basic_text_layers(self) -> None:
    """Add essential text layers: Mana cost, Card name, Typeline."""
    self.text.extend([
        FormattedTextField(
            layer=self.text_layer_mana,
            contents=self.layout.mana_cost
        ),
        ScaledTextField(
            layer=self.text_layer_name,
            contents=self.layout.name,
            reference=self.name_reference
        ),
        ScaledTextField(
            layer=self.text_layer_type,
            contents=self.layout.type_line,
            reference=self.type_reference
        )])

def check_photoshop(self) -> None:
    """Check if Photoshop is responsive to automation."""
    # Ensure the Photoshop Application is responsive
    check = self.app.refresh_app()
    if not isinstance(check, OSError):
        return

    # Connection with Photoshop couldn't be established, try again?
    if not self.console.await_choice(
            self.event, get_photoshop_error_message(check),
            end="Hit Continue to try again, or Cancel to end the operation.\n\n"
    ):
        # Cancel the operation
        raise OSError(check)
    self.check_photoshop()

def collector_info(self) -> None:
    """Format and add the collector info at the bottom."""

    # Which collector info mode?
    if CFG.collector_mode in [
        CollectorMode.Default, CollectorMode.Modern
    ] and self.layout.collector_data:
        layers = self.collector_info_authentic()
    elif CFG.collector_mode == CollectorMode.ArtistOnly:
        layers = self.collector_info_artist_only()
    else:
        layers = self.collector_info_basic()

    # Shift collector text
    if self.is_align_collector_left:
        [psd.align_left(n, ref=self.collector_reference.dims) for n in layers]

def collector_info_artist_only(self) -> list[ArtLayer]:
    """Called to generate 'Artist Only' collector info."""

    # Collector layers
    artist = psd.getLayer(LAYERS.ARTIST, self.legal_group)
    psd.getLayer(LAYERS.SET, self.legal_group).visible = False

    # Apply the collector info
    psd.replace_text(artist, "Artist", self.layout.artist)
    return [artist]

def collector_info_authentic(self) -> list[ArtLayer]:
    """Classic presents authentic collector info differently."""

    # Hide basic 'Set' layer
    psd.getLayer(LAYERS.SET, self.legal_group).visible = False

    # Get artist and info layers, reveal info layer
    artist = psd.getLayer(LAYERS.ARTIST, self.legal_group)
    info = psd.getLayer(LAYERS.COLLECTOR, self.legal_group)
    info.visible = True

    # Fill optional promo star
    if self.is_collector_promo:
        psd.replace_text(info, "•", MagicIcons.COLLECTOR_STAR)

    # Apply the collector info
    psd.replace_text(artist, 'Artist', self.layout.artist)
    psd.replace_text(info, 'SET', self.layout.set)
    psd.replace_text(info, 'NUM', self.layout.collector_data)
    return [artist, info]

def collector_info_basic(self) -> list[ArtLayer]:
    """Called to generate basic collector info."""

    # Get artist and info layers
    artist = psd.getLayer(LAYERS.ARTIST, self.legal_group)
    info = psd.getLayer(LAYERS.SET, self.legal_group)

    # Fill optional promo star
    if self.is_collector_promo:
        psd.replace_text(info, "•", MagicIcons.COLLECTOR_STAR)

    # Apply the collector info
    if self.layout.lang != 'en':
        psd.replace_text(info, 'EN', self.layout.lang.upper())
    psd.replace_text(artist, "Artist", self.layout.artist)
    psd.replace_text(info, 'SET', self.layout.set)
    return [artist, info]

@try_photoshop
def color_border(self) -> None:
    """Color this card's border based on given setting."""
    if self.border_color != BorderColor.Black:
        psd.apply_fx(self.border_group, [EffectColorOverlay(color=psd.get_color(self.border_color))])

def create_basic_watermark(self) -> None:
    """Builds a basic land watermark."""

    # Generate the watermark
    wm = psd.import_svg(
        path=self.layout.watermark_basic,
        ref=self.text_group,
        placement=ElementPlacement.PlaceAfter,
        docref=self.docref)
    psd.frame_layer_by_height(
        layer=wm,
        ref=self.textbox_reference.dims,
        scale=75)

    # Add effects
    psd.apply_fx(wm, self.basic_watermark_fx)

    # Add snow effects
    if self.is_snow:
        self.add_basic_watermark_snow_effects(wm)

    # Remove rules text step
    self.rules_text_and_pt_layers = lambda: None
    self.layout.oracle_text = ''
    self.layout.flavor_text = ''

def create_blended_layer(
        self,
        group: LayerSet,
        colors: Union[None, str, list[str]] = None,
        masks: Optional[list[ArtLayer]] = None,
        **kwargs
):
    """Either enable a single frame layer or create a multicolor layer using a gradient mask.

    Args:
        group: Group to look for the color layers within.
        colors: Color layers to look for.
        masks: Masks to use for blending the layers.
    """
    # Ensure masks is a list
    masks = masks or []

    # Establish our colors
    colors = colors or self.identity or self.pinlines
    if isinstance(colors, str) and not is_multicolor_string(colors):
        # Received a color string that isn't a frame color combination
        colors = [colors]
    elif len(colors) >= self.color_limit:
        # Received too big a color combination, revert to pinlines
        colors = [self.pinlines]
    elif isinstance(colors, str):
        # Convert string of colors to list
        colors = list(colors)

    # Single layer
    if len(colors) == 1:
        layer = psd.getLayer(colors[0], group)
        layer.visible = True
        return

    # Enable each layer color
    layers: list[ArtLayer] = []
    for i, color in enumerate(colors):

        # Make layer visible
        layer = psd.getLayer(color, group)
        if 'blend_mode' in kwargs:
            layer.blendMode = kwargs['blend_mode']
        layer.visible = True

        # Position the new layer and add a mask to previous, if previous layer exists
        if layers and len(masks) >= i:
            layer.move(layers[i - 1], ElementPlacement.PlaceAfter)
            psd.copy_layer_mask(masks[i - 1], layers[i - 1])

        # Add to the layer list
        layers.append(layer)

@staticmethod
def create_blended_solid_color(
        group: LayerSet,
        colors: list[ColorObject],
        masks: Optional[list[Union[ArtLayer, LayerSet]]] = None,
        **kwargs
) -> None:
    """Either enable a single frame layer or create a multicolor layer using a gradient mask.

    Args:
        group: Group to look for the color layers within.
        colors: Color layers to look for.
        masks: Masks to use for blending the layers.

    Keyword Args:
        blend_mode (BlendMode): Sets the blend mode of the generated solid color layers.
    """
    # Ensure masks is a list
    masks = masks or []

    # Enable each layer color
    layers: list[ArtLayer] = []
    for i, color in enumerate(colors):
        layer = psd.smart_layer(psd.create_color_layer(color, group))
        if 'blend_mode' in kwargs:
            layer.blendMode = kwargs['blend_mode']

        # Position the new layer and add a mask to previous, if previous layer exists
        if layers and len(masks) >= i:
            layer.move(layers[i - 1], ElementPlacement.PlaceAfter)
            psd.copy_layer_mask(masks[i - 1], layers[i - 1])
        layers.append(layer)

def create_watermark(self) -> None:
    """Builds the watermark."""
    # Required values to generate a Watermark
    if not all([
        self.layout.watermark_svg,
        self.layout.watermark,
        self.textbox_reference,
        self.watermark_colors,
        self.text_group
    ]):
        return

    # Get watermark custom settings if available
    wm_details = CON.watermarks.get(self.layout.watermark, {})

    # Import and frame the watermark
    wm = psd.import_svg(
        path=self.layout.watermark_svg,
        ref=self.text_group,
        placement=ElementPlacement.PlaceAfter,
        docref=self.docref)
    psd.frame_layer(
        layer=wm,
        ref=self.textbox_reference.dims,
        smallest=True,
        scale=wm_details.get('scale', 80))

    # Apply opacity, blending, and effects
    wm.opacity = wm_details.get('opacity', CFG.watermark_opacity)
    wm.blendMode = self.watermark_blend_mode
    psd.apply_fx(wm, self.watermark_fx)

def enable_crown(self) -> None:
    """Enable layers which make-up the Legendary crown."""

    # Enable crown and legendary border
    self.crown_layer.visible = True
    if self.border_group and isinstance(self.border_group, LayerContainer):
        psd.getLayer(LAYERS.NORMAL_BORDER, self.border_group).visible = False
        psd.getLayer(LAYERS.LEGENDARY_BORDER, self.border_group).visible = True

    # Call hollow crown step
    if self.is_hollow_crown:
        self.enable_hollow_crown(
            psd.getLayer(LAYERS.SHADOWS))

def enable_frame_layers(self):
    """Enable layers which create the frame of the card. Simplified, does not support Legendary Crown."""

    # Resize expansion symbol
    if self.expansion_symbol_layer:
        self.expansion_symbol_layer.resize(90, 90, AnchorPosition.MiddleCenter)
        if self.is_land:
            self.expansion_symbol_layer.translate(0, 8)

    # Simple one image background
    self.pinlines_layer.visible = True

    # Add the promo star
    if self.is_promo_star:
        psd.getLayerSet("Promo Star", LAYERS.TEXT_AND_ICONS).visible = True

    # Make Extended Art modifications
    if self.is_extended:
        # Copy extended mask to Border
        psd.copy_layer_mask(self.border_mask, self.border_group)

        # Enable extended mask on Pinlines
        psd.enable_mask(self.pinlines_layer.parent)
        psd.enable_vector_mask(self.pinlines_layer.parent)

def enable_hollow_crown(self, shadows: Optional[ArtLayer] = None) -> None:
    """Enable the hollow legendary crown."""
    if shadows:
        psd.enable_mask(shadows)
    psd.enable_mask(self.crown_layer.parent)
    psd.enable_mask(self.pinlines_layer.parent)
    self.crown_shadow_layer.visible = True

def execute(self) -> bool:
    """Perform actions to render the card using this template.

    Notes:
        - Each action is wrapped in an exception check and breakpoint to cancel the thread
            if a cancellation signal was sent by the user.
        - Never override this method!
    """
    # Preliminary Photoshop check
    if not self.run_tasks(
        funcs=[self.check_photoshop],
        message="Unable to reach Photoshop!"
    ):
        return False

    # Pre-process layout data
    if not self.run_tasks(
        funcs=self.pre_render_methods,
        message="Pre-processing layout data failed!"
    ):
        return False

    # Load in the PSD template
    if not self.run_tasks(
        funcs=[self.app.load],
        message="PSD template failed to load!",
        args=[str(self.layout.template_file)]
    ):
        return False

    # Load in artwork and frame it
    if not self.run_tasks(
        funcs=[self.load_artwork],
        message="Unable to load artwork!"
    ):
        return False

    # Load in Scryfall scan and frame it
    if CFG.import_scryfall_scan:
        self.run_tasks(
            funcs=[self.paste_scryfall_scan],
            message="Couldn't import Scryfall scan, continuing without it!",
            warning=True)

    # Add expansion symbol
    self.run_tasks(
        funcs=[self.load_expansion_symbol],
        message="Unable to generate expansion symbol!",
        warning=True)

    # Add watermark
    if CFG.enable_basic_watermark and self.is_basic_land:
        # Basic land watermark
        if not self.run_tasks(
            funcs=[self.create_basic_watermark],
            message="Unable to generate basic land watermark!"
        ):
            return False
    elif CFG.watermark_mode is not WatermarkMode.Disabled:
        # Normal watermark
        if not self.run_tasks(
            funcs=[self.create_watermark],
            message="Unable to generate watermark!"
        ):
            return False

    # Enable layers to build our frame
    if not self.run_tasks(
        funcs=self.frame_layer_methods,
        message="Enabling layers failed!"
    ):
        return False

    # Format text layers
    if not self.run_tasks(
        funcs=[
            *self.text_layer_methods,
            self.format_text_layers,
            *self.post_text_methods
        ],
        message="Formatting text layers failed!"
    ):
        return False

    # Specific hooks
    if not self.run_tasks(
        funcs=self.hooks,
        message="Encountered an error during triggered hooks step!"
    ):
        return False

    # Manual edit step?
    if CFG.exit_early and not ENV.TEST_MODE:
        self.console.await_choice(self.event)

    # Save the document
    if not self.run_tasks(
        funcs=[self.save_mode],
        message="Error during file save process!",
        kwargs={'path': self.output_file_name, 'docref': self.docref}
    ):
        return False

    # Post save methods
    if not self.run_tasks(
        funcs=self.post_save_methods,
        message="Image saved, but an error was encountered during the post-save step!"
    ):
        return False

    # Reset document, return success
    if not ENV.TEST_MODE:
        self.console.update(f"[b]{self.output_file_name.stem}[/b] rendered successfully!")
    self.reset()
    return True

def format_text_layers(self) -> None:
    """Validate and execute each formatted text layer."""
    for t in self.text:
        # Check for cancelled thread each iteration
        if self.event.is_set():
            return
        # Validate and execute
        if t and t.validate():
            t.execute()

def generate_layer(
        self, group: Union[ArtLayer, LayerSet],
        colors: Union[str, ColorObject, list[ColorObject], list[dict]],
        masks: Optional[list[ArtLayer]] = None,
        **kwargs
) -> Optional[ArtLayer]:
    """Takes information about a frame layer group and routes it to the correct
    generation function which blends rasterized layers, blends solid color layers, or
    generates a solid color/gradient adjustment layer.

    Notes:
        The result for a given 'colors' schema:
        - str: Enable and/or blend one or more texture layers, unless string is a hex color, in which
            case create a solid color adjustment layer.
        - list[str]: Blend multiple texture layers.
        - list[int]: Create a solid color adjustment layer.
        - list[dict]: Create a gradient adjustment layer.
        - list[list[int]]: Blend multiple solid color adjustment layers.
        - list[SolidColor]: Blend multiple solid color adjustment layers.

    Args:
        group: Layer or group containing layers.
        colors: Color definition for this frame layer generation.
        masks: Masks used to blend this generated layer.
    """
    # Assign a generator task based on colors value
    if isinstance(colors, str):
        # Example: '#FFFFFF'
        # Single adjustment layer
        if colors.startswith('#'):
            return psd.create_color_layer(
                color=colors,
                layer=group,
                docref=self.docref,
                **kwargs)
        # Example: 'Land'
        # Single or blended texture layers
        return self.create_blended_layer(
            group=group,
            colors=colors,
            masks=masks,
            **kwargs)
    elif isinstance(colors, SolidColor):
        # Example: SolidColor
        # Single adjustment layer
        return psd.create_color_layer(
            color=colors,
            layer=group,
            docref=self.docref,
            **kwargs
        )
    elif isinstance(colors, list):
        if all(isinstance(c, str) for c in colors):
            # Example: ['#000000', '#FFFFFF', ...]
            # Blended RGB/CMYK adjustment layers
            if colors[0].startswith('#'):  # noqa
                return self.create_blended_solid_color(
                    group=group,
                    colors=colors,
                    masks=masks,
                    **kwargs)
            # Example: ['W', 'U']
            # Blended texture layers
            return self.create_blended_layer(
                group=group,
                colors=colors,
                masks=masks,
                **kwargs)
        elif all(isinstance(c, int) for c in colors):
            # Example: [r, g, b]
            # RGB/CMYK adjustment layer
            return psd.create_color_layer(
                color=colors,
                layer=group,
                docref=self.docref,
                **kwargs)
        elif all(isinstance(c, dict) for c in colors):
            # Example: [GradientColor, GradientColor, ...]
            # Gradient adjustment layer
            return psd.create_gradient_layer(
                colors=colors,
                layer=group,
                docref=self.docref,
                **kwargs)
        elif all(isinstance(c, (list, SolidColor)) for c in colors):
            # Example 1: [[r, g, b], [r, g, b], ...]
            # Example 2: [SolidColor, SolidColor, ...]
            # Blended RGB/CMYK adjustment layers
            return self.create_blended_solid_color(
                group=group,
                colors=colors,
                masks=masks,
                **kwargs)

    # Failed to match a recognized color notation
    if group:
        self.log(f"Couldn't generate frame element: '{group.name}'")