Incrustar fuentes en presentaciones en Python vía Java

Introducción

Incrustar fuentes almacena los datos de la fuente dentro de una presentación de PowerPoint. Cuando un visor admite fuentes incrustadas, puede mostrar el texto utilizando esas fuentes aunque no estén instaladas en el sistema de destino. Esto ayuda a conservar los saltos de línea, el espaciado del texto y el diseño de las diapositivas.

Aspose.Slides for Python via Java le permite recuperar, añadir y eliminar fuentes incrustadas a través de la clase FontsManager devuelta por Presentation.getFontsManager. También puede reducir el tamaño de los datos de fuentes incrustadas eliminando los caracteres que la presentación no utiliza.

Los ejemplos a continuación funcionan con archivos PPTX. Antes de incrustar una fuente, asegúrese de que sus datos estén disponibles para Aspose.Slides y de que su licencia permita la incrustación.

Obtener y eliminar fuentes incrustadas

Utilice getEmbeddedFonts para enumerar las fuentes almacenadas en una presentación. Para eliminar una, pase una fuente de esa lista a removeEmbeddedFont y, a continuación, guarde la presentación.

El siguiente ejemplo enumera las fuentes incrustadas en EmbeddedFonts.pptx y elimina Calibri si está presente:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, SaveFormat

presentation = Presentation("EmbeddedFonts.pptx")
try:
    fonts_manager = presentation.getFontsManager()
    embedded_fonts = fonts_manager.getEmbeddedFonts()

    for font in embedded_fonts:
        print(font.getFontName())

    font_to_remove = None
    for font in embedded_fonts:
        if str(font.getFontName()).casefold() == "calibri":
            font_to_remove = font
            break

    if font_to_remove is not None:
        fonts_manager.removeEmbeddedFont(font_to_remove)
        presentation.save("WithoutEmbeddedCalibri.pptx", SaveFormat.Pptx)
    else:
        print("Calibri is not embedded. No output file was created.")
finally:
    presentation.dispose()

Eliminar una fuente incrustada elimina sus datos almacenados; no cambia la fuente asignada al texto. Si la fuente está instalada en el sistema de destino, el texto puede seguir utilizándola. De lo contrario, el renderizado puede requerir sustitución de fuentes, lo que puede afectar el diseño.

Inspeccionar datos de fuentes y permisos de incrustación

Utilice la clase FontsManager para inspeccionar las fuentes antes de incrustarlas. Llame a FontsManager.getFonts para obtener las fuentes utilizadas en la presentación. Para cada fuente, pase un objeto FontData y el valor requerido de FontStyleType a FontsManager.getFontBytes. El método devuelve los datos binarios de ese estilo de fuente, o None cuando la fuente o el estilo solicitados no están disponibles. No pase un resultado None a FontsManager.getFontEmbeddingLevel, porque ese método requiere una matriz de bytes.

EmbeddingLevel es una enumeración de indicadores que informa de las restricciones de incrustación almacenadas en la fuente:

  • Installable permite la incrustación y la instalación permanente en otro sistema, sujeto a la licencia de la fuente.
  • Restricted prohíbe la incrustación a menos que se obtenga permiso del propietario legal de la fuente cuando es el único indicador de permiso de uso.
  • PreviewPrint permite el uso temporal para visualización e impresión; un documento que contenga la fuente debe ser de solo lectura.
  • Editable permite el uso temporal y permite que el documento se edite y guarde.
  • NoSubsetting es una restricción adicional que prohíbe incrustar solo un subconjunto de glifos. Incruste todos los caracteres cuando este indicador está presente.
  • BitmapOnly es una restricción adicional que permite incrustar solo versiones bitmap, no datos de contorno. Si la fuente no tiene versiones bitmap, no puede ser incrustada.

Los cuatro primeros valores describen el permiso de uso, mientras que NoSubsetting y BitmapOnly pueden combinarse con ellos. Verifique los modificadores con operaciones bit a bit. Dado que Installable es cero, enmascare los bits de permiso de uso y compare el resultado con Installable en lugar de comprobarlo como un indicador. Las fuentes actuales deben establecer como máximo un bit de permiso de uso. Para compatibilidad con fuentes antiguas que establecen más de uno, el asistente siguiente selecciona el permiso menos restrictivo: Editable, luego PreviewPrint, luego Restricted.

El siguiente ejemplo registra los datos normales, negrita, cursiva y negrita‑cursiva disponibles para cada fuente devuelta por getFonts. Omite los estilos no disponibles, fuentes restringidas, fuentes solo bitmap, fuentes limitadas a vista previa e impresión porque la salida sigue siendo editable, y fuentes que ya están incrustadas. Si algún estilo disponible tiene NoSubsetting, incrusta todos los caracteres de esa familia de fuentes.

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import EmbedFontCharacters, EmbeddingLevel, FontStyleType, Presentation, SaveFormat

def get_usage_permission(level):
    permission_mask = EmbeddingLevel.Restricted | EmbeddingLevel.PreviewPrint | EmbeddingLevel.Editable
    permissions = level & permission_mask

    if permissions & EmbeddingLevel.Editable:
        return EmbeddingLevel.Editable

    if permissions & EmbeddingLevel.PreviewPrint:
        return EmbeddingLevel.PreviewPrint

    if permissions & EmbeddingLevel.Restricted:
        return EmbeddingLevel.Restricted

    return EmbeddingLevel.Installable

presentation = Presentation("Fonts.pptx")
try:
    fonts_manager = presentation.getFontsManager()
    font_styles = [
        FontStyleType.Regular,
        FontStyleType.Bold,
        FontStyleType.Italic,
        FontStyleType.Bold | FontStyleType.Italic,
    ]

    embedded_font_names = {str(embedded_font.getFontName()).casefold() for embedded_font in fonts_manager.getEmbeddedFonts()}

    fonts_to_embed = []
    embedding_rules = []
    for font in fonts_manager.getFonts():
        font_name = str(font.getFontName())
        if font_name.casefold() in embedded_font_names:
            print(f"{font_name}: already embedded.")
            continue

        has_available_data = False
        all_available_styles_can_be_embedded = True
        preview_print_only = False
        requires_full_font = False

        for font_style in font_styles:
            font_bytes = fonts_manager.getFontBytes(font, font_style)
            if font_bytes is None:
                print(f"{font_name} ({font_style}): font data is unavailable.")
                continue

            has_available_data = True
            embedding_level = fonts_manager.getFontEmbeddingLevel(font_bytes, font.getFontName())
            usage_permission = get_usage_permission(embedding_level)
            no_subsetting = bool(embedding_level & EmbeddingLevel.NoSubsetting)
            bitmap_only = bool(embedding_level & EmbeddingLevel.BitmapOnly)

            requires_full_font = requires_full_font or no_subsetting
            preview_print_only = preview_print_only or usage_permission == EmbeddingLevel.PreviewPrint
            usage_permits_embedding = usage_permission != EmbeddingLevel.Restricted and not bitmap_only
            all_available_styles_can_be_embedded = all_available_styles_can_be_embedded and usage_permits_embedding

            print(f"{font_name} ({font_style}): {embedding_level}.")

        if not has_available_data:
            print(f"{font_name}: skipped because no requested style is available.")
        elif not all_available_styles_can_be_embedded:
            print(f"{font_name}: skipped because at least one available style does not permit outline embedding.")
        elif preview_print_only:
            print(f"{font_name}: skipped because this example produces an editable presentation.")
        else:
            rule = EmbedFontCharacters.All if requires_full_font else EmbedFontCharacters.OnlyUsed
            fonts_to_embed.append(font)
            embedding_rules.append(rule)

    for font, rule in zip(fonts_to_embed, embedding_rules):
        fonts_manager.addEmbeddedFont(font, rule)

    presentation.save("WithAuditedFonts.pptx", SaveFormat.Pptx)
finally:
    presentation.dispose()

Esta inspección informa de las restricciones codificadas en cada archivo de fuente. No otorga una licencia, no demuestra que haya obtenido la fuente legalmente, ni sustituye la comprobación del acuerdo de licencia de la fuente antes de distribuir una copia incrustada.

Añadir fuentes incrustadas

Utilice addEmbeddedFont para incrustar una fuente. Sus sobrecargas aceptan ya sea un objeto FontData o una matriz de bytes que contiene los datos de la fuente. La enumeración EmbedFontCharacters controla qué caracteres se incluyen:

  • All incrusta todos los caracteres de la fuente. Use esta opción cuando los destinatarios necesiten editar la presentación e introducir texto nuevo.
  • OnlyUsed incrusta sólo los caracteres utilizados en la presentación para reducir el tamaño del archivo. Elija esta opción para una presentación final que se destine principalmente a la visualización.

El siguiente ejemplo utiliza getFonts para obtener las fuentes usadas en Fonts.pptx e incrusta aquellas que aún no están incrustadas. Las fuentes a añadir deben estar disponibles en la máquina que ejecuta el código. Las fuentes ya incrustadas conservan sus juegos de caracteres actuales.

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import EmbedFontCharacters, Presentation, SaveFormat

presentation = Presentation("Fonts.pptx")
try:
    fonts_manager = presentation.getFontsManager()
    all_fonts = fonts_manager.getFonts()
    embedded_fonts = fonts_manager.getEmbeddedFonts()
    embedded_font_names = {str(embedded_font.getFontName()).casefold() for embedded_font in embedded_fonts}

    for font in all_fonts:
        font_name = str(font.getFontName()).casefold()
        if font_name not in embedded_font_names:
            fonts_manager.addEmbeddedFont(font, EmbedFontCharacters.All)
            embedded_font_names.add(font_name)

    presentation.save("WithEmbeddedFonts.pptx", SaveFormat.Pptx)
finally:
    presentation.dispose()

Comprimir fuentes incrustadas

Compress.compressEmbeddedFonts reduce los datos de fuentes incrustadas eliminando los caracteres no usados. funciona sobre fuentes que ya están incrustadas, por lo que la reducción de tamaño depende de cuántos datos de fuente no utilizados contiene la presentación.

El siguiente ejemplo comprime las fuentes en EmbeddedFonts.pptx y guarda el resultado como un archivo separado:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Compress, Presentation, SaveFormat

presentation = Presentation("EmbeddedFonts.pptx")
try:
    Compress.compressEmbeddedFonts(presentation)
    presentation.save("CompressedEmbeddedFonts.pptx", SaveFormat.Pptx)
finally:
    presentation.dispose()

Conserve el archivo original si los destinatarios pueden necesitar añadir texto más tarde. Los caracteres eliminados durante la compresión ya no están disponibles en la fuente incrustada, incluso si originalmente incrustó todos los caracteres.

Preguntas frecuentes

¿Cómo puedo comprobar si una fuente incrustada seguirá siendo sustituida durante el renderizado?

Llame a getSubstitutions en el entorno donde renderice la presentación para ver qué fuentes reemplazará Aspose.Slides. También verifique la configuración de sustitución de fuentes y las reglas de respaldo de fuentes. El respaldo maneja los caracteres ausentes, por lo que incrustar una fuente no resuelve los caracteres que la propia fuente no contiene.

¿Debo incrustar fuentes comunes como Arial y Calibri?

Base la decisión en el entorno de destino. Si las fuentes requeridas están disponibles en cada máquina que abre o renderiza la presentación, incrustarlas puede añadir un tamaño de archivo innecesario. Si los destinatarios o servidores pueden no disponer de esas fuentes, incrustarlas puede ayudar a conservar la apariencia prevista, siempre que sus licencias lo permitan.

Especificar fuentes predeterminadas de la presentación en Python mediante Java Administrar fuentes de reserva para presentaciones en Python a través de Java