Fonts und Schriften für Annotationen

Bei den klassischen Annotationsformaten (ContentManager 7 / 8, FileNet IS / P8, jadice XML, Wang) werden Textinhalte mittels referenzierten Schriftarten (im weiteren als Font bzw. Fonts bezeichnet) dargestellt.

Bei textbasierten Annotationen sind Fonts durch einen Namen und den Stilinformationen (hier: bold / fett, italic / kursiv, plain / einfach) definiert. Anhand diesen Informationen muss ein passender Font für die Anzeige der Annotation ermittelt werden.

Repräsentation von Fonts

Ein Font wird als Datenstrom / Datenobjekt zur Verfügung gestellt, der via Klasse FontSource repräsentiert wird, siehe hierzu„Repräsentation von Fonts“.

Die FontSource-Instanzen müssen in einer FontManager-Implementation registiert werden, damit sie von der Font-Engine zur Darstellung von Annotationen gefunden und verwendet werden können (siehe auch„Bereitstellen der verfügbaren Fonts“).

Eigenschaften von Fonts

Ein Font wird durch Eigenschaften (Attribute) definiert, welche via Klasse FontAttributeSet repräsentiert werden, die von der FontSource Klasse abgefragt werden können. Siehe hierzu„Eigenschaften von Fonts“. Die Definition der Eigenschaften wird bei einer Font-Abfrage berücksichtigt.

Substitution / Suche von Fonts für Annotationen

Fonts für Annotationen werden anhand von AnnotationFontFactory-Implementationen für die Darstellung / das Rendering zur Verfügung gestellt. AnnotationFontFactory-Implementationen können im Annotationsprofil definiert und einem bestimmten Annotationstyp zugeordnet oder zentral in der Annotations-Klasse via setDefaultAnnotationFontFactory-Methode registriert werden. Definitionen im Annotationsprofil haben immer Vorrang. Wenn keine Definition vorhanden ist, wird auf die Annotations-Klasse zurückgegriffen. Es muss letztendlich immer eine AnnotationFontFactory-Implementation mit einer Fallback-FontSource wie Beispielsweise AnnotationBasicFontFactory oder SwingAnnotationBasicFontFactory definiert werden. Kann der Font nicht bestimmt werden, werden Fehler im Programmcode ausgelöst, der Anzeigevorgang wird nicht korrekt ausgeführt und die weitere Verarbeitung wird unterbrochen.

Definitionsmöglichkeiten von AnnotationFontFactory-Implementationen:

  • Annotationstyp spezifische Definition im Annotationsprofil (Klasse muss einen Standardkonstruktor besitzen): 

        <annotation-type name="BaseText" archetype="BaseText" class="com.levigo.jadice.annotation.TextAnnotation">
        ...
        <font-factory class="com.levigo.jadice.demo.font.annotation.SwingAnnotationProfileLogicalFontFactory"/>
        <font-factory class="com.levigo.jadice.demo.font.annotation.SwingAnnotationProfileStandard14FontFactory"/>
        <font-factory class="com.levigo.jadice.demo.font.annotation.SwingAnnotationProfileSystemFontFactory"/>
        <font-factory class="com.levigo.jadice.demo.font.annotation.SwingAnnotationProfileBasicFontFactory"/>
        ...
    </annotation-type>

    Die AnnotationFontFactory-Implementationen können auch in einer ChainedAnnotationFontFactory-Implementation zusammengefasst (siehe Beispiel weiter unten) und mit nur einem Eintrag definiert werden. Änderungen (zum Beispiel Reihenfolge anpassen oder Deaktivieren von Definitionen) müssen dann jedoch im Quelltext vorgenommen werden.

  • Registrierung in der Annotations-Klasse: 

        FontManagerFuture fontManagerFuture = ...
    Annotations.setDefaultAnnotationFontFactory(
        new SwingAnnotationStandard14FontFactory(fontManagerFuture));

AnnotationFontFactory-Implementationen können auch mit Hilfe der ChainedAnnotationFontFactory-Klasse verkettet / zusammengefasst werden, siehe auchBeispiel 7.16, „Verwendung der ChainedFontFactory“. Die AnnotationFontFactory-Implementationen werden in definierter Reihenfolge abgefragt. Bei einer erfolgreichen Suche wird die gefundene Font-Instanz zurückgegeben und der Abfragevorgang wird beendet. Wird nichts gefunden wird null zurückgegeben.

  • Registrierung in der Annotations-Klasse via ChainedAnnotationFontFactory-Klasse: 

        FontManagerFuture fontManagerFuture = ...
    Annotations.setDefaultAnnotationFontFactory(//
        new ChainedSwingAnnotationFontFactory(//
            new SwingAnnotationLogicalFontFactory(fontManagerFuture), //
            new SwingAnnotationStandard14FontFactory(fontManagerFuture), //
            new SwingAnnotationSystemFontFactory(fontManagerFuture) //
        )//
    );

Aufbau und Funktion einer Fontabfrage

Die AnnotationFontFactory-Implementationen werden mit einer FontAttributeSet-Klasse abgefragt, die die entsprechenden Attribute / Werte des Fonts beinhalten. Folgende Attribute werden von textbasierten Annotationen (siehe Klasse TextAnnotation) verwendet und entsprechend in der FontAttributeSet-Abfrage abgelegt:

Attribut FontName, ermittelt aus getFontFace()
Attribut Bold, wird nur definiert wenn Rückgabewert isBold() == true
Attribut Italic, wird nur definiert wenn Rückgabewert isItalic() == true
Attribut Plain, wird nur definiert wenn Rückgabewert isBold() == false und isItalic() == false

Weitere Attribute werden nicht definiert / berücksichtigt; Gross-/Kleinschreibung bei der Fontnamensdefinition wird bei der Abfrage nicht beachtet.

Als weiterer Parameter wird eine Map-Instanz mit der AnnotationType-Instanz der aktuellen Textannotation zur Verfügung gestellt. Anhand der AnnotationType-Instanz kann die Annotation identifiziert werden, zum Beispiel die Klasse der Annotation (siehe auch Klassen Scopes und AnnotationType): 

     public Font create(FontAttributeSet fontAttributeSet, Map<String, Object> scope) {
        Object scopeObject = scope.get(Scopes.SOURCE);
        if (scopeObject != null && scopeObject instanceof AnnotationType) {
          AnnotationType type = (AnnotationType) scopeObject;
          System.out.println(type.getAnnotationClass());
        }
        ...
    }

Funktion / Übersicht von AnnotationFontFactory-Implementationen

AnnotationFontFactory erweitert das FontFactory-Interface um die Methode getAvailableFontAttributeSets(), die eine Collection mit FontAttributeSet-Definitionen zurückgibt, die für eigene Zwecke (z.B. Informationen über Fonts) verwendet werden kann. Die aktuellen Implementationen liefern über diese Methode verfügbare Fonts. Es werden alle Fonts mit identischer FamilyName-Definition zusammengefasst und in einer vereinfachten FontAttributeSet-Definition bereitgestellt:

Beispiel: Die Fontdefinitionen

werden zu folgender Definition zusammengefasst:

Werden schriftbezogene GUI-Annotationseditorkomponenten (Schriftauswahl, Editieren des Textes) verwendet, muss die Methode gewünschte / verfügbare Fontdefinitionen liefern, ansonsten kann die getAvailableFontAttributeSets()-Methode null oder eine leere Collection zurückgeben. Auf die Darstellung / Rendering der Annotationen hat diese Methode keinen Einfluss.

Basis-/Fallback-Implementation im Paket com.levigo.jadice.annotation.font im jadice document platform 5 Core-Annotation-Modul:

  • AnnotationBasicFontFactory

    Diese Klasse liefert eine vektorbasierte Font-Basisimplementation mit einem eingeschränkten Zeichensatz (a-z, A-Z, 0-9, Leerzeichen), es sind keine Sonderzeichen vorhanden. Diese Implementation benötigt keine FontManager-Instanz und ist in der Annotations-Klasse als Standard AnnotationFontFactory registriert. Die getAvailableFontAttributeSets()-Methode gibt eine leere Collection zurück.

Die Implementationen im Paket com.levigo.jadice.appbase.font.factory.annotation im jadice document platform 5 Core-Appbase-Modul benötigen im Konstruktor eine FontManagerFuture-Instanz und können daher nicht im Annotationsprofil verwendet werden. Bei erfolgreicher Suche in der entsprechenden FontManager-Instanz wird ein Font-Objekt zurückgegeben. Diese Klassen stehen auch als Quellcode zur Verfügung.

Die Implementationen im Paket com.levigo.jadice.demo.font.annotation im jadice document platform 5 Core-Demo-Modul besitzen einen Standardkonstruktor und können somit im Annotationsprofil verwendet werden, hier wird intern eine FontManagerFuture-Instanz mit Standard-14 / System-Fonts verwendet. Diese Klassen befinden sich in einem Demo-Modul, stehen als Quellcode zur Verfügung und sollten bei Verwendung kopiert und entsprechend angepasst werden, da sich der Quelltext der Klassen in Zukunft ändern kann.

Funktion / Übersicht von SwingAnnotationFontFactory-Implementationen

SwingAnnotationFontFactory erweitert das AnnotationFontFactory-Interface um die Methode createAWTFont(FontAttributeSet fontAttributeSet), die aus einer FontAttributeSet-Definition einen passenden Java AWT Font erstellen soll. SwingAnnotationFontFactory-Implementationen werden verwendet um dem Schriftauswahldialog und dem Texteditor (beide Java AWT basierend) passende AWT Font-Instanzen zur Verfügung zu stellen.

Funktionsweise / Ablauf:

In der folgenden Übersicht wird das Zusammenspiel / Verhalten der GUI-Schriftauswahl und der SwingAnnotationFontFactory-Definition erläutert:

Definition der verwendeten SwingAnnotationFontFactory-Implementationen im Annotationsprofil: 

    <annotation-type name="BaseText" archetype="BaseText" class="com.levigo.jadice.annotation.TextAnnotation">
        ...
        <font-factory class="com.levigo.jadice.demo.font.annotation.SwingAnnotationProfileLogicalFontFactory"/>
        <font-factory class="com.levigo.jadice.demo.font.annotation.SwingAnnotationProfileStandard14FontFactory"/>
        <font-factory class="com.levigo.jadice.demo.font.annotation.SwingAnnotationProfileBasicFontFactory"/>
        ...
    </annotation-type>

Entsprechende Verwendung der SwingAnnotationFontFactory-Implementationen via Annotations-Klasse: 

    FontManagerFuture fontManagerFuture = SwingFontEnvironment.getFontManagerFuture();
    Annotations.setDefaultAnnotationFontFactory(//
        new ChainedSwingAnnotationFontFactory(//
            new SwingAnnotationLogicalFontFactory(fontManagerFuture), //
            new SwingAnnotationStandard14FontFactory(fontManagerFuture), //
            new SwingAnnotationBasicFontFactory(fontManagerFuture) //
        )//
    );

Die Methode getAvailableFontAttributeSets() gibt folgende FamilyName-Attribute zurück:

Alle oben genannten Font-Family-Namen stehen dem Schriftauswahldialog und dem Texteditor zur Verfügung, d. h. die createAWTFont(FontAttributeSet fontAttributeSet)-Methode sollte auch entsprechende Java AWT Font-Instanzen erzeugen um eine korrekte Darstellung in den GUI-Editorkomponenten zu gewährleisten.

Schriftauswahldialog sieht wie folgt aus:

Arimo
Cousine
Dialog
DialogInput
Monospaced
SansSerif
Serif
Tinos

Die Fontauswahl kann im Annotationsprofil definiert / gefiltert werden:

  • Mit folgender Definition sind alle Fonts auswählbar:

        <annotation-type name="BaseText" archetype="BaseText" class="com.levigo.jadice.annotation.TextAnnotation">
        ...
        <unrestricted name="fontFace" propertyType="java.lang.String">
            <editor class="com.levigo.jadice.swing.internal.annotation.editors.FontFaceEditor" />
                <default>Sansserif</default>
        </unrestricted>
        ...
    </annotation-type>

  • Mit folgender Einstellung können Fonts gezielt ausgewählt werden: 

        <annotation-type name="BaseText" archetype="BaseText" class="com.levigo.jadice.annotation.TextAnnotation">
        ...
        <discrete name="fontFace" propertyType="java.lang.String">
    	    <editor class="com.levigo.jadice.swing.internal.annotation.editors.FontFaceEditor" />
            <default>Sansserif</default>
            <!-- Folgende Fonts sind auswählbar -->
            <allowed>Sansserif</allowed>
            <allowed>Serif</allowed>
            <allowed>Monospaced</allowed>
            <allowed>Arimo</allowed>
            <allowed>Cousine</allowed>
            <allowed>Tinos</allowed>
        </discrete>
        ...
    </annotation-type>

Hier werden nur die mit dem allowed-Element definierten Font-Family-Namen im Schriftauswahldialog angezeigt:

Arimo
Cousine
Monospaced
SansSerif
Serif
Tinos

Die Fontdefinitionen werden im Schriftauswahldialog sortiert (alphanumerisch aufsteigend) angezeigt, ist eine Fontdefinition in den SwingAnnotationFontFactory-Implementationen nicht verfügbar, wird sie im Auswahlmenü ausgeblendet.

Wird ein Fontname aus der Liste ausgewählt, wird dieser der entsprechenden TextAnnotation-Instanz via setFontFace(String fontFace)-Methode gesetzt, beim darauf folgenden Darstellungs- / Rendervorgang wird aus dem Fontnamen und den Stilinformationen erneut eine Fontabfrage erstellt und ausgeführt (siehe„Aufbau und Funktion einer Fontabfrage“).

Die Implementationen im Paket com.levigo.jadice.appbase.annotation.font im jadice document platform 5 Swing-Appbase-Modul benötigen im Konstruktor eine FontManagerFuture-Instanz und können daher nicht im Annotationsprofil verwendet werden. Bei erfolgreicher Suche in der entsprechenden FontManager-Instanz wird ein Font-Objekt zurückgegeben. Diese Klassen stehen auch als Quellcode zur Verfügung. Die Implementationen werden aktuell in der SwingFontEnvironments-Klasse im Swing-Demo-Client-Modul verwendet.

  • SwingAnnotationBasicFontFactory

    Diese Klasse liefert eine vektorbasierte Font-Basisimplementation mit einem eingeschränkten Zeichensatz (a-z, A-Z, 0-9, Leerzeichen), es sind keine Sonderzeichen vorhanden. Die getAvailableFontAttributeSets()-Methode gibt eine leere Collection zurück. Die FontManagerFuture-Instanz muss die Standard-14 Fonts registriert haben, damit die createAWTFont(FontAttributeSet fontAttributeSet)-Methode eine passende Java AWT Font-Instanz erzeugen kann, hier wird immer der Standard-14-Font 'Arimo' zurückgegeben, ist ein anderer Font gewünscht, muss eine eigene Implementation erstellt werden.

  • SwingAnnotationLogicalFontFactory

    Diese Implementation löst logische Fontnamen nach jadice Standard-14 Fonts auf (siehe LogicalFontIdentifier, LogicalFontFactory), die getAvailableFontAttributeSets()-Methode stellt alle logische Fontdefinitionen zur Verfügung. Die benötigte FontManagerFuture-Instanz muss die Standard-14 Fonts registriert haben, die createAWTFont(FontAttributeSet fontAttributeSet)-Methode erstellt aus dem Standard-14 Fontdatenstrom eine Java AWT Font-Instanz.

  • SwingAnnotationStandard14FontFactory

    Diese Implementation löst alle jadice Standard-14 Fontnamen auf (siehe Standard14Substitute, Standard14FontFactory), die getAvailableFontAttributeSets()-Methode stellt alle Standard-14 Fontdefinitionen zur Verfügung. Die benötigte FontManagerFuture-Instanz muss die Standard-14 Fonts registriert haben, die createAWTFont(FontAttributeSet fontAttributeSet)-Methode erstellt aus dem Standard-14 Fontdatenstrom eine Java AWT Font-Instanz.

  • SwingAnnotationSystemFontFactory

    Diese Implementation versucht Fontnamen nach Systemfonts aufzulösen, die getAvailableFontAttributeSets()-Methode stellt alle System-Fontdefinitionen zur Verfügung. Die benötigte FontManagerFuture-Instanz muss System-Fonts registriert haben, die createAWTFont(FontAttributeSet fontAttributeSet)-Methode erstellt aus dem Font-Family-Namen eine passende Java AWT Font-Instanz.

  • SwingAnnotationGenericStylesSystemFontFactory

    Funktionsweise entspricht der SwingAnnotationSystemFontFactory-Implementation, die getAvailableFontAttributeSets()-Methode stellt nur System-Fontdefinitionen zur Verfügung, die die Stilarten plain / normal, bold / fett, italic / kursiv und bold-italic / fett-kursiv erfüllen.

  • ChainedSwingAnnotationFontFactory

    Diese Implementation fasst mehrere SwingAnnotationFontFactory-Instanzen zusammen, die getAvailableFontAttributeSets()-Methode stellt die Fontdefinitionen aus allen registrierten AnnotationFontFactory-Instanz zur Verfügung. Die createAWTFont(FontAttributeSet fontAttributeSet)-Methode gibt den ersten Treffer von den registrierten Instanzen zurück.

Die Implementationen im Paket com.levigo.jadice.demo.font.annotation im jadice document platform 5 Swing-Demo-Client-Modul besitzen einen Standardkonstruktor und können somit im Annotationsprofil verwendet werden, hier wird intern eine FontManagerFuture-Instanz mit Standard-14 / System-Fonts verwendet. Diese Klassen befinden sich in einem Demo-Modul, stehen als Quellcode zur Verfügung und sollten bei Verwendung kopiert und entsprechend angepasst werden, da sich der Quelltext der Klassen in Zukunft ändern kann.

[jadice viewer Version 6.2.33: Dokumentation für Entwickler. Veröffentlicht: 2025-08-08]
Zurück  Nach oben  Weiter
  Zum Anfang