Especifique la ubicación de las fuentes TrueType

En este tema se describe el comportamiento predeterminado de Aspose.Words cuando busca fuentes TrueType, incluidas las diferencias específicas del sistema operativo, y se muestra cómo especificar fuentes de fuentes de usuario.

La clase FontSourceBase se usa para especificar varias fuentes de fuentes. Hay varias implementaciones de la clase FontSourceBase:

Los detalles de implementación de algunas clases se explican a continuación.

Cargar fuentes desde System

Hay una clase especial SystemFontSource que siempre se usa de forma predeterminada. Representa todas las TrueType fuentes instaladas en el sistema. Por lo tanto, es posible crear una lista de fuentes con SystemFontSource y cualquier otra fuente requerida:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
FontSettings.getDefaultInstance().setFontsSources(
new FontSourceBase[] { new SystemFontSource(), new FolderFontSource("C:\\MyFonts\\", true) });
Document doc = new Document(dataDir + "Rendering.doc");
dataDir = dataDir + "Rendering.SetFontsFolders_out.pdf";
doc.save(dataDir);

Una sola instancia de la clase SystemFontSource se define de forma predeterminada en FontSettings. En diferentes sistemas operativos, las fuentes pueden ubicarse en lugares diferentes. Sin embargo, usar una instancia FontSettings para cada documento no es una solución óptima. En la mayoría de los casos, usar DefaultInstance debería ser suficiente.

Las instancias por documento son necesarias solo si se requiere usar diferentes fuentes para diferentes documentos, lo cual es un caso raro. El uso de varias instancias FontSettings disminuye el rendimiento porque no comparten la caché.

Donde Aspose.Words Busca TrueType Fuentes en Windows

En la mayoría de los casos, los usuarios de Windows no enfrentan problemas significativos con fuentes omitidas o diseños incorrectos. Normalmente, Aspose.Words recorre un documento y, cuando encuentra el enlace de una fuente, recupera correctamente los datos de la fuente de la carpeta del sistema.

En Windows, Aspose.Words primero toma todas las fuentes disponibles de la carpeta _%windir%\Fonts. Esta configuración funcionará para usted la mayor parte del tiempo. Solo especifica sus propias carpetas de fuentes si es necesario. Aspose.Words también busca fuentes adicionales registradas en la clave de registro HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts. Además, Windows 10 habilita la instalación de fuentes para el usuario actual. Las fuentes se colocan en la carpeta %userprofile%\AppData\Local\Microsoft\Windows\Fonts y también se especifican en el registro HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\Fonts, donde Aspose.Words buscará estas fuentes.

Si un documento contiene fuentes incrustadas, Aspose.Words puede leer los datos de fuentes relevantes del documento y usarlos para crear el diseño del documento. Los documentos también pueden contener enlaces a fuentes que no están en las carpetas del sistema, en cuyo caso funcionan los siguientes escenarios:

  • Los usuarios pueden configurar nuevas fuentes de fuentes a través de la clase FontSettings
  • Aspose.Words puede intentar reemplazar la fuente perdida por una similar

Fuentes en Sistemas que no sonWindows

Aspose.Words buscará las fuentes en las carpetas de fuentes del sistema. Se puede ver una lista de estas carpetas mediante el método GetSystemFontFolders. Si no se encuentran fuentes compatibles, Aspose.Words utilizará la fuente predeterminada incorporada Fanwood.ttf.

Dado que las métricas de fuente de Windows y noWindows OS son diferentes, Aspose.Words hace todo lo posible para encontrar una fuente similar y crear un diseño similar al original. Sin embargo, esto no siempre es posible. En estos casos, la clase FontSettings debe usarse para agregar fuentes personalizadas o reglas de sustitución.

Donde Aspose.Words Busca TrueType Fuentes en Linux

Diferentes distribuciones Linux pueden almacenar fuentes en carpetas diferentes. Aspose.Words busca fuentes en varias ubicaciones. De forma predeterminada, Aspose.Words busca las fuentes en todas las ubicaciones siguientes: /usr/share/fonts, /usr/local/share/fonts, /usr/X11R6/lib/X11/fonts. Este comportamiento predeterminado funcionará para la mayoría de las distribuciones Linux, pero no se garantiza que funcione todo el tiempo, en cuyo caso es posible que deba especificar explícitamente la ubicación de las fuentes true type. Para hacer esto, necesita saber dónde están instaladas las fuentes TrueType en su distribución Linux.

Donde Aspose.Words Busca TrueType Fuentes en Mac OS X

Aspose.Words busca fuentes en la carpeta /Library/Fonts, que es la ubicación estándar para TrueType fuentes en Mac OS X. Si bien esta configuración funcionará para usted la mayor parte del tiempo, es posible que deba especificar sus propias carpetas de fuentes en el caso de que lo necesite.

TrueType Fuentes en Android

En Android, el flujo de trabajo de fuentes se encapsula en la clase Typeface. Hay cinco tipos de tipos de letra, cada tipo de letra representa un grupo de familias de fuentes similares:

  • DEFAULT
  • DEFAULT_BOLD
  • MONOSPACE
  • SANS_SERIF
  • SERIF

Por ejemplo, de acuerdo con Android’s fonts.xml archivo de configuración, “times” pertenece a la familia" serif " so NotoSerif - Regular.ttf se utilizará cuando se solicite" times":

Fonts.xml

<family name="serif">
        <font weight="400" style="normal">NotoSerif-Regular.ttf</font>
        <font weight="700" style="normal">NotoSerif-Bold.ttf</font>
        <font weight="400" style="italic">NotoSerif-Italic.ttf</font>
        <font weight="700" style="italic">NotoSerif-BoldItalic.ttf</font>
</family>
<alias name="times" to="serif" />
<alias name="times new roman" to="serif" />

Para buscar fuentes similares, se utilizan las estrategias descritas anteriormente.

Además de ellos, Aspose.Words tiene su propia lista de reemplazos para la plataforma Android.

Digamos que el documento contiene la fuente PMingLiU-ExtB, en primer lugar, Aspose.Words está buscando la fuente requerida dentro de las fuentes del sistema.

La lista predeterminada de carpetas de fuentes Android es:

  • / sistema / fuentes
  • / sistema / fuente
  • / datos / fuentes

Aspose.Words busca en fuentes definidas por el usuario que se configuraron con el método:

Java

fontSettings.setFontsFolder("/home/user/MyFonts", true);

En caso de que se haya especificado un reemplazo explícito, Aspose.Words reemplaza la fuente faltante con la sugerencia del usuario:

Java

fontSettings.getSubstitutionSettings().getTableSubstitution().setSubstitutes("PMingLiU-ExtB", "Liberation Serif");

Si ninguna de las reglas funcionó, Aspose.Words verifique la tabla de reemplazo interno. Si la tabla contiene información sobre un buen ajuste, se reemplaza la fuente. En nuestro caso Aspose.Words seleccionará Typeface.SERIF. Pero si la tabla no sabe nada sobre la fuente solicitada, Aspose.Words elige una fuente basada en reglas especiales de MS Palabras o la distancia más cercana en el espacio Panose.

TrueType Fuentes en .NET Core y Xamarin

Para .NET Core y Xamarin se aplica la misma regla que para Aspose.Words para la versión Java. De forma predeterminada, todas las fuentes del sistema de la plataforma en la que se ejecuta la aplicación están disponibles. La lista de carpetas donde se realizará la búsqueda se puede encontrar llamando al método:

Java

SystemFontSource().getAvailableFonts()

Cargar fuentes desde la carpeta

Si el documento que se está procesando contiene enlaces a fuentes que no están en el sistema, o no desea agregarlas a la carpeta del sistema, o carece de permisos, entonces la mejor solución sería agregar una carpeta con sus propias fuentes usando el método SetFontsSources. Esto permitirá reemplazar la fuente del sistema con una fuente de usuario. Aspose.Words ya no buscará fuentes en el registro o en la carpeta Windows\Font y, en su lugar, solo buscará fuentes dentro de las carpetas especificadas. El método GetFontSources devolverá los valores correspondientes.

Especifique Una o Varias Carpetas de Fuentes

Los métodos SetFontsFolder y SetFontsFolders son accesos directos al método SetFontSources con una o varias instancias FolderFontSource. Estos métodos se utilizan para indicar dónde Aspose.Words debe buscar las fuentes. Si una carpeta no existe o no es accesible, Aspose.Words simplemente la ignora. Si se ignoraron todas las carpetas, incluidas las fuentes para la sustitución de fuentes, Aspose.Words usará la fuente Fanwood como predeterminada.

El siguiente ejemplo demuestra cómo configurar la carpeta o el origen, que Aspose.Words utilizará posteriormente para buscar fuentes TrueType durante la representación o incrustación de fuentes:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
// For complete examples and data files, please go to
// https://github.com/aspose-words/Aspose.Words-for-Java
Document doc = new Document(dataDir + "Rendering.doc");
FontSettings FontSettings = new FontSettings();
// Note that this setting will override any default font sources that are being
// searched by default. Now only these folders will be searched for
// Fonts when rendering or embedding fonts. To add an extra font source while
// keeping system font sources then use both FontSettings.GetFontSources and
// FontSettings.SetFontSources instead.
FontSettings.setFontsFolder("C:\\MyFonts\\", false);
// Set font settings
doc.setFontSettings(FontSettings);
doc.save(dataDir + "Rendering.SetFontsFolder_out.pdf");

Un parámetro booleano adicional controla si las fuentes se escanean recursivamente en todas las carpetas, por lo tanto, escanean todas las carpetas secundarias de una carpeta específica. El siguiente ejemplo demuestra cómo configurar Aspose.Words para que busque fuentes TrueType en varias carpetas al representar o incrustar fuentes:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
// For complete examples and data files, please go to
// https://github.com/aspose-words/Aspose.Words-for-.NET
// Open a Document
Document doc = new Document(dataDir + "Rendering.doc");
FontSettings FontSettings = new FontSettings();
// Note that this setting will override any default font sources that are being
// searched by default. Now only these folders will be searched for
// Fonts when rendering or embedding fonts. To add an extra font source while
// keeping system font sources then use both FontSettings.GetFontSources and
// FontSettings.SetFontSources instead.
FontSettings.setFontsFolders(new String[] { "C:\\MyFonts\\", "D:\\Misc\\Fonts\\" }, true);
// Set font settings
doc.setFontSettings(FontSettings);
doc.save(dataDir + "Rendering.SetFontsFolders_out.pdf");

Puede descargar el archivo de plantilla de este ejemplo desde Aspose.Words GitHub.

Si no desea utilizar fuentes del sistema en absoluto, Aspose.Words le permite ignorarlas y usar solo sus propias fuentes:

Java

FontSettings.getDefaultInstance().setFontsFolder("C:\\MyFonts\\", true);

Propiedad Prioritaria

La propiedad Priority se usa cuando hay fuentes con el mismo apellido y estilo en diferentes fuentes de fuentes. En este caso, Aspose.Words selecciona la fuente del origen con el valor de prioridad más alto. Por ejemplo, hay una versión anterior de la fuente en la carpeta del sistema y el cliente agregó una nueva versión de la misma fuente en una carpeta personalizada.

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
FontSettings.getDefaultInstance().setFontsSources(
new FontSourceBase[] { new SystemFontSource(), new FolderFontSource("C:\\MyFonts\\", true, 1) });

Cargar fuentes desde Stream

Aspose.Words proporciona la clase StreamFontSource, que permite cargar fuentes desde la secuencia. Para usar el origen de la fuente stream, un usuario debe crear una clase derivada de StreamFontSource y proporcionar una implementación del método OpenFontDataStream. El método OpenFontDataStream podría llamarse varias veces. Por primera vez, se llamará cuando Aspose.Words escanee las fuentes de fuentes proporcionadas para obtener una lista de las fuentes disponibles. Más tarde se puede llamar si la fuente se usa en el documento para analizar los datos de la fuente e incrustar los datos de la fuente en algunos formatos de salida. StreamFontSource puede ser útil porque permite cargar los datos de la fuente solo cuando es necesario y no almacenarlos en la memoria durante la vida útil de FontSettings.

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
public void streamFontSourceFileRendering() throws Exception {
FontSettings fontSettings = new FontSettings();
fontSettings.setFontsSources(new FontSourceBase[]{new StreamFontSourceFile()});
DocumentBuilder builder = new DocumentBuilder();
builder.getDocument().setFontSettings(fontSettings);
builder.getFont().setName("Kreon-Regular");
builder.writeln("Test aspose text when saving to PDF.");
builder.getDocument().save(dataDir + "FontSettings.StreamFontSourceFileRendering.pdf");
}
/// <summary>
/// Load the font data only when required instead of storing it in the memory for the entire lifetime of the "FontSettings" object.
/// </summary>
private static class StreamFontSourceFile extends StreamFontSource {
public FileInputStream openFontDataStream() throws Exception {
return new FileInputStream(dataDir + "Kreon-Regular.ttf");
}
}

StreamFontSource

Guardar y Cargar una Caché de Búsqueda de Fuentes

Al buscar una fuente por primera vez, Aspose.Words itera sobre las fuentes especificadas por el usuario y forma una caché de búsqueda de fuentes en función de los datos de estas fuentes. Por lo tanto, el caché recopilará información sobre las fuentes disponibles: familia de fuentes, estilo, nombre completo de la fuente y otros. En llamadas posteriores, Aspose.Words busca información sobre la fuente deseada por su nombre en la caché de búsqueda de fuentes, después de lo cual analiza los archivos especificados para usar la fuente.

El procedimiento para analizar todos los archivos de fuentes disponibles para inicializar la caché requiere bastante tiempo. Aspose.Words le permite guardar y cargar la caché utilizando el método FontSettings.SaveSearchCache para resolver el problema de rendimiento. Es decir, el usuario puede cargar un caché guardado previamente desde un archivo y omitir el paso de analizar todos los archivos de fuentes disponibles.

Obtener una Lista de Fuentes Disponibles

Si desea obtener la lista de fuentes disponibles, que, por ejemplo, se pueden usar para representar un documento PDF, puede usar el método GetAvailableFonts, como se muestra en el siguiente ejemplo de código. La clase PhysicalFontInfo especifica información sobre la fuente física disponible para el motor de fuentes Aspose.Words.:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
// Get available system fonts
for (PhysicalFontInfo fontInfo : (Iterable<PhysicalFontInfo>) new SystemFontSource().getAvailableFonts()) {
System.out.println("FontFamilyName : " + fontInfo.getFontFamilyName());
System.out.println("FullFontName : " + fontInfo.getFullFontName());
System.out.println("Version : " + fontInfo.getVersion());
System.out.println("FilePath : " + fontInfo.getFilePath());
}
// Get available fonts in folder
for (PhysicalFontInfo fontInfo : (Iterable<PhysicalFontInfo>) new FolderFontSource(dataDir, true)
.getAvailableFonts()) {
System.out.println("FontFamilyName : " + fontInfo.getFontFamilyName());
System.out.println("FullFontName : " + fontInfo.getFullFontName());
System.out.println("Version : " + fontInfo.getVersion());
System.out.println("FilePath : " + fontInfo.getFilePath());
}
// Get available fonts from FontSettings
ArrayList<FolderFontSource> fontSources = new ArrayList(
Arrays.asList(FontSettings.getDefaultInstance().getFontsSources()));
// Convert the Arraylist of source back into a primitive array of FontSource
// objects.
FontSourceBase[] updatedFontSources = (FontSourceBase[]) fontSources
.toArray(new FontSourceBase[fontSources.size()]);
for (PhysicalFontInfo fontInfo : (Iterable<PhysicalFontInfo>) updatedFontSources[0].getAvailableFonts()) {
System.out.println("FontFamilyName : " + fontInfo.getFontFamilyName());
System.out.println("FullFontName : " + fontInfo.getFullFontName());
System.out.println("Version : " + fontInfo.getVersion());
System.out.println("FilePath : " + fontInfo.getFilePath());
}