Verpacken von Schriftarten mit Anwendungen

Dieses Thema bietet eine Übersicht über das Verpacken von Schriftarten mit Windows Presentation Foundation (WPF)-Anwendung.

Einführung in das Verpacken von Schriftarten

Sie können Schriftarten problemlos als Ressourcen in WPF-Anwendungen verpacken, um den Text der Benutzeroberfläche und anderen textbasierten Inhalt anzuzeigen. Die Schriftarten können getrennt von den Assemblydateien oder eingebettet in die Assemblydateien der Anwendung vorkommen. Sie können auch eine Schriftartenbibliothek nur für Ressourcen erstellen, auf die die Anwendung verweisen kann.

OpenType- und TrueType®-Schriftarten enthalten das Typflag FsType, das die Lizenzierungsrechte für die Einbettung der Schriftart angibt. Dieses Typflag bezieht sich jedoch nur auf eingebettete Schriftarten, die in einem Dokument gespeichert sind, und nicht auf Schriftarten, die in eine Anwendung eingebettet sind. Sie können die Rechte für die Schriftarteinbettung für eine Schriftart abrufen, indem Sie ein GlyphTypeface-Objekt erstellen und auf seine EmbeddingRights-Eigenschaften verweisen. Verweisen Sie auf OS/2 und Windows-Metriken im Abschnitt OpenType-Spezifikation für mehr Informationen über den fsType flag.

Auf der Website Microsoft-Typografie finden Sie Kontaktinformationen, mit denen Sie einen Händler für eine bestimmte Schriftart oder einen Händler für benutzerdefinierte Schriftarten finden können.

Hinzufügen von Schriftarten als Inhaltselemente

Sie können Schriftarten als Projektinhaltselemente zu Ihrer Anwendung hinzufügen, die von den Assemblydateien der Anwendung getrennt sind. Dies bedeutet, dass Inhaltselemente nicht als Ressourcen in eine Assembly eingebettet werden. In der folgenden Beispielprojektdatei wird veranschaulicht, wie Inhaltselemente definiert werden.

<Project DefaultTargets="Build"  
                xmlns="http://schemas.microsoft.com/developer/msbuild/2003">  
  <!-- Other project build settings ... -->  
  
  <ItemGroup>  
    <Content Include="Peric.ttf" />  
    <Content Include="Pericl.ttf" />  
  </ItemGroup>  
</Project>  

Um sicherzustellen, dass die Anwendung die Schriftarten zur Laufzeit verwenden kann, müssen die Schriftarten im Bereitstellungsverzeichnis der Anwendung zugänglich sein. Mit dem <CopyToOutputDirectory>-Element in der Projektdatei der Anwendung können Sie die Schriftarten während des Erstellungsprozesses automatisch in das Bereitstellungsverzeichnis der Anwendung kopieren. In der folgenden Beispielprojektdatei wird veranschaulicht, wie Schriftarten in das Bereitstellungsverzeichnis kopiert werden.

<ItemGroup>  
  <Content Include="Peric.ttf">  
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>  
  </Content>  
  <Content Include="Pericl.ttf">  
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>  
  </Content>  
</ItemGroup>  

Im folgenden Codebeispiel wird veranschaulicht, wie auf die Schriftart der Anwendung als Inhaltselement verwiesen wird. Das Inhaltselement, auf das verwiesen wird, muss sich im selben Verzeichnis wie die Assemblydateien der Anwendung befinden.

<TextBlock FontFamily="./#Pericles Light">
  Aegean Sea
</TextBlock>

Hinzufügen von Schriftarten als Ressourcenelemente

Sie können Schriftarten als Projektressourcenelemente zu Ihrer Anwendung hinzufügen, die in die Assemblydateien der Anwendung eingebettet werden. Die Verwendung eines separaten Unterverzeichnisses für Ressourcen hilft beim Organisieren der Projektdateien der Anwendung. In der folgenden Beispielprojektdatei wird veranschaulicht, wie Schriftarten als Ressourcenelemente in einem separaten Unterverzeichnis definiert werden.

<Project DefaultTargets="Build"  
                xmlns="http://schemas.microsoft.com/developer/msbuild/2003">  
  <!-- Other project build settings ... -->  
  
  <ItemGroup>  
    <Resource Include="resources\Peric.ttf" />  
    <Resource Include="resources\Pericl.ttf" />  
  </ItemGroup>  
</Project>  

Im folgenden Markupbeispiel wird veranschaulicht, wie auf die Schriftartenressourcen der Anwendung verwiesen wird.

<TextBlock FontFamily="./resources/#Pericles Light">
  Aegean Sea
</TextBlock>

Verweisen auf Schriftartenressourcenelemente aus Code

Zum Verweisen auf Schriftartenressourcenelemente aus dem Code müssen Sie einen zweiteiligen Schriftartenressourcenverweis bereitstellen: den grundlegenden Ressourcenbezeichner (URI) und den Verweis auf den Speicherort der Schriftarten. Diese Werte werden als Parameter für die FontFamily-Methode verwendet. Im folgenden Codebeispiel wird veranschaulicht, wie auf die Schriftartenressourcen der Anwendung im Projektunterverzeichnis namens resources verwiesen wird.

// The font resource reference includes the base URI reference (application directory level),
// and a relative URI reference.
myTextBlock.FontFamily = new FontFamily(new Uri("pack://application:,,,/"), "./resources/#Pericles Light");

' The font resource reference includes the base URI reference (application directory level),
' and a relative URI reference.
myTextBlock.FontFamily = New FontFamily(New Uri("pack://application:,,,/"), "./resources/#Pericles Light")

Der grundlegende Ressourcenbezeichner (URI) kann das Unterverzeichnis der Anwendung beinhalten, in dem sich die Schriftartenressource befindet. In diesem Fall müsste der Verweis auf den Speicherort der Schriftarten kein Verzeichnis angeben, sondern müsste ein vorangestelltes „./“ enthalten, das angibt, dass sich die Schriftartenressource im selben Verzeichnis befindet, das vom grundlegenden Ressourcenbezeichner (URI) angegeben wird. Im folgenden Codebeispiel wird eine alternative Möglichkeit veranschaulicht, wie auf das Schriftartenressourcenelement verwiesen werden kann. Es entspricht dem vorherigen Codebeispiel.

// The base URI reference can include an application subdirectory.
myTextBlock.FontFamily = new FontFamily(new Uri("pack://application:,,,/resources/"), "./#Pericles Light");

' The base URI reference can include an application subdirectory.
myTextBlock.FontFamily = New FontFamily(New Uri("pack://application:,,,/resources/"), "./#Pericles Light")

Verweisen auf Schriftarten aus dem gleichen Anwendungsunterverzeichnis

Sie können Anwendungsinhalt und Ressourcendateien im selben benutzerdefinierten Unterverzeichnis Ihres Anwendungsprojekts platzieren. In der folgenden Beispielprojektdatei wird veranschaulicht, wie eine Inhaltsseite und Schriftartenressourcen im selben Unterverzeichnis definiert werden.

<ItemGroup>  
  <Page Include="pages\HomePage.xaml" />  
</ItemGroup>  
<ItemGroup>  
  <Resource Include="pages\Peric.ttf" />  
  <Resource Include="pages\Pericl.ttf" />  
</ItemGroup>  

Da sich Anwendungsinhalt und Schriftart im selben Unterverzeichnis befinden, ist der Schriftartenverweis relativ zum Anwendungsinhalt. In den folgenden Beispielen wird veranschaulicht, wie auf die Schriftartenressource der Anwendung verwiesen werden kann, wenn sich die Schriftart im selben Verzeichnis wie die Anwendung befindet.

<TextBlock FontFamily="./#Pericles Light">
  Aegean Sea
</TextBlock>

// The font resource reference includes the base Uri (application directory level),
// and the file resource location, which is relative to the base Uri.
myTextBlock.FontFamily = new FontFamily(new Uri("pack://application:,,,/"), "/pages/#Pericles Light");

' The font resource reference includes the base Uri (application directory level),
' and the file resource location, which is relative to the base Uri.
myTextBlock.FontFamily = New FontFamily(New Uri("pack://application:,,,/"), "/pages/#Pericles Light")

Auflisten von Schriftarten in einer Anwendung

Zum Enumerieren von Schriftzeichenelementen in Ihrer Anwendung verwenden Sie entweder die GetFontFamilies oder GetTypefaces-Methode. Das folgende Beispiel zeigt, wie man die GetFontFamilies-Methode verwendet, um die Auflistung des FontFamily-Objekts des Schriftzeichenspeicherorts der Anwendung zurückzubringen. In diesem Fall enthält die Anwendung ein Unterverzeichnis mit dem Namen „Ressourcen“.

foreach (FontFamily fontFamily in Fonts.GetFontFamilies(new Uri("pack://application:,,,/"), "./resources/"))
{
    // Perform action.
}

For Each fontFamily As FontFamily In Fonts.GetFontFamilies(New Uri("pack://application:,,,/"), "./resources/")
    ' Perform action.
Next fontFamily

Das folgende Beispiel zeigt, wie man die GetTypefaces-Methode verwendet, um die Auflistung des Typeface-Objekts des Schriftzeichenspeicherorts der Anwendung zurückzubringen. In diesem Fall enthält die Anwendung ein Unterverzeichnis mit dem Namen „Ressourcen“.

foreach (Typeface typeface in Fonts.GetTypefaces(new Uri("pack://application:,,,/"), "./resources/"))
{
    // Perform action.
}

For Each typeface As Typeface In Fonts.GetTypefaces(New Uri("pack://application:,,,/"), "./resources/")
    ' Perform action.
Next typeface

Erstellen einer Schriftartenressourcenbibliothek

Sie können eine Bibliothek nur für Ressourcen erstellen, die ausschließlich Schriftarten enthält. In dieser Art von Bibliothek ist kein Code enthalten. Das Erstellen einer Bibliothek nur für Ressourcen dient häufig dem Entkoppeln von Ressourcen vom Anwendungscode, der sie verwendet. Dies ermöglicht außerdem, dass die Bibliotheksassembly in mehreren Anwendungsprojekten enthalten sein kann. In der folgenden Beispielprojektdatei werden die Hauptbestandteile einer Bibliothek nur für Ressourcen gezeigt.

<PropertyGroup>  
  <AssemblyName>FontLibrary</AssemblyName>  
  <OutputType>library</OutputType>  
  ...  
</PropertyGroup>  
...
<ItemGroup>  
  <Resource Include="Kooten.ttf" />  
  <Resource Include="Pesca.ttf" />  
</ItemGroup  

Verweisen auf eine Schriftart in einer Ressourcenbibliothek

Um aus Ihrer Anwendung auf eine Schriftart in einer Ressourcenbibliothek zu verweisen, müssen Sie dem Verweis auf die Schriftart den Namen der Bibliotheksassembly voranstellen. In diesem Fall ist die Schriftartenressourcenassembly „FontLibrary“. Verwenden Sie ein Semikolon (;), um den Assemblynamen vom Verweis innerhalb der Assembly zu trennen. Durch Hinzufügen des Schlüsselworts „Component“ gefolgt vom Verweis auf den Namen der Schriftart wird der Verweis auf die Ressource der Schriftartenbibliothek vervollständigt. Im folgenden Codebeispiel wird veranschaulicht, wie auf eine Schriftart in einer Ressourcenbibliotheksassembly verwiesen wird.

<Run FontFamily="/FontLibrary;Component/#Kootenay" FontSize="36">
  ABCDEFGHIJKLMNOPQRSTUVWXYZ
</Run>

Einschränkungen der Verwendung von Schriftarten

In der folgenden Liste werden mehrere Einschränkungen für das Verpacken und die Verwendung von Schriftarten in WPF-Anwendungen beschrieben:

• Berechtigungsbits für die Schriftarteneinbettung: WPF-Anwendungen werden keine Berechtigungsbits für die Schriftarteneinbettung überprüft oder durchgesetzt. Weitere Informationen erhalten Sie im Abschnitt Einführung in das Verpacken von Schriftarten.

• Site der Ursprungsschriftarten: WPF-Anwendungen lassen keine Schriftartenverweise auf einen http- oder ftp-Ressourcenbezeichner (URI) zu.

• Absoluter URI mit Paketnotation: WPF-Anwendungen können Sie programmgesteuert kein FontFamily-Objekt mit „Paket:“ als Bestandteil des absoluten Verweises auf den Ressourcenbezeichner auf eine Schriftart erstellen. Zum Beispiel ist "pack://application:,,,/resources/#Pericles Light" ein ungültiger Schriftartenverweis.

• Automatische Schriftarteneinbettung: Zur Entwurfszeit werden die Suche nach der Schriftartenverwendung einer Anwendung und das automatische Einbetten der Schriftarten in die Ressourcen der Anwendung nicht unterstützt.

• Schriftartteilmengen: WPF-Anwendungen unterstützen keine Erstellung von Schriftartteilmengen für Dokumente ohne festes Format.

• Bei einem falschen Verweis greift die Anwendung auf eine verfügbare Schriftart zurück.

Weitere Informationen

• Typography
• FontFamily
• Microsoft Typography: Links, News, and Contacts (Microsoft-Typografie: Links, Neuigkeiten und Kontakte)
• OpenType-Spezifikation
• Features für OpenType-Schriftarten
• OpenType-Beispielschriftartenpaket