Verpacken von Schriftarten mit Anwendungen

Artikel
08/10/2011

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

Hinweis
Wie die meisten Arten von Software werden Schriftartdateien eher lizenziert als verkauft.Lizenzen, die die Verwendung von Schriftarten steuern, sind von Anbieter zu Anbieter unterschiedlich. Im Allgemeinen lassen es die meisten Lizenzen, darunter auch die für die von Microsoft in Anwendungen und Windows bereitgestellten Schriftarten, nicht zu, dass die Schriftarten in Anwendungen eingebettet oder anders verbreitet werden.Deshalb liegt es in Ihrer Verantwortung als Entwickler sicherzustellen, dass Sie über die erforderlichen Lizenzrechte für alle Schriftarten verfügen, die Sie in eine Anwendung einbetten oder anders verteilen.

Wie die meisten Arten von Software werden Schriftartdateien eher lizenziert als verkauft.Lizenzen, die die Verwendung von Schriftarten steuern, sind von Anbieter zu Anbieter unterschiedlich. Im Allgemeinen lassen es die meisten Lizenzen, darunter auch die für die von Microsoft in Anwendungen und Windows bereitgestellten Schriftarten, nicht zu, dass die Schriftarten in Anwendungen eingebettet oder anders verbreitet werden.Deshalb liegt es in Ihrer Verantwortung als Entwickler sicherzustellen, dass Sie über die erforderlichen Lizenzrechte für alle Schriftarten verfügen, die Sie in eine Anwendung einbetten oder anders verteilen.

Dieses Thema enthält folgende Abschnitte.

Einführung in das Verpacken von Schriftarten
Hinzufügen von Schriftarten als Inhaltselemente
Hinzufügen von Schriftarten als Ressourcenelemente
Erstellen einer Schriftartressourcen-Bibliothek
Einschränkungen der Schriftartverwendung
Verwandte Abschnitte

Einführung in das Verpacken von Schriftarten

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

OpenType- und TrueType®-Schriftarten enthalten ein Typflag, fsType, mit dem für die Schriftart die Lizenzierungsrechte zur Einbettung der Schriftart angegeben werden. Dieses Typflag bezieht sich jedoch nur auf eingebettete Schriftarten, die in einem Dokument gespeichert sind. Es bezieht sich nicht auf Schriftarten, die in eine Anwendung eingebettet sind. Sie können die Rechte für die Schriftarteneinbettung für eine Schriftart abrufen, indem Sie ein GlyphTypeface-Objekt erstellen und auf dessen EmbeddingRights-Eigenschaft verweisen. Weitere Informationen zum fsType-Flag finden Sie im Abschnitt "OS/2 and Windows Metrics" der OpenType-Spezifikation.

Die Website Microsoft-Typografie enthält Kontaktinformationen, damit Sie einen bestimmten Schriftartanbieter leichter finden können oder damit Sie einen Schriftartanbieter für benutzerdefinierte Schriftarten finden können.

Hinzufügen von Schriftarten als Inhaltselemente

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

<Project DefaultTargets="Build" xmlns="https://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, muss ein Zugriff auf die Schriftarten über das Bereitstellungsverzeichnis der Anwendung möglich sein. Mit dem <CopyToOutputDirectory>-Element in der Projektdatei der Anwendung können Sie die Schriftarten automatisch während des Buildprozesses in das Bereitstellungsverzeichnis der Anwendung kopieren. Im folgenden Projektdateibeispiel wird gezeigt, wie Schriftarten ins Bereitstellungsverzeichnis kopiert werden.

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

Mit dem folgenden Codebeispiel wird gezeigt, wie auf die Schriftart einer Anwendung als Inhaltselement verwiesen wird (das Inhaltselement, auf das verwiesen wird, muss sich im gleichen Verzeichnis befinden wie die Assemblydateien der Anwendung).

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

Hinzufügen von Schriftarten als Ressourcenelemente

Sie können Ihrer Anwendung Schriftarten als Projektressourcenelemente hinzufügen, die in die Assemblydateien der Anwendung eingebettet sind. Die Verwendung eines separaten Unterverzeichnisses für Ressourcen hilft bei der Strukturierung der Projektdateien der Anwendung. Im folgenden Projektdateibeispiel wird gezeigt, wie Schriftarten als Ressourcenelemente in einem separaten Unterverzeichnis definiert werden.

<Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  <!-- Other project build settings ... -->

  <ItemGroup>
    <Resource Include="resources\Peric.ttf" />
    <Resource Include="resources\Pericl.ttf" />
  </ItemGroup>
</Project>

Hinweis
Wenn Sie der Anwendung Schriftarten als Ressourcen hinzufügen, stellen Sie sicher, dass Sie das <Resource>-Element festlegen, und nicht das <EmbeddedResource>-Element in der Projektdatei der Anwendung.Das <EmbeddedResource>-Element für den Buildvorgang wird nicht unterstützt.

Im folgenden Markupbeispiel wird gezeigt, wie auf die Schriftartressourcen der Anwendung verwiesen wird.

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

Verweisen auf Schriftartressourcen-Elemente über Code

Um über Code auf Schriftartressourcen-Elemente zu verweisen, müssen Sie einen zweiteiligen Schriftartressourcen-Verweis angeben: den grundlegenden uniform resource identifier (URI) und den Verweis auf den Speicherort der Schriftart. Diese Werte werden als Parameter für die FontFamily-Methode verwendet. Das folgende Codebeispiel veranschaulicht, wie auf die Schriftartressourcen 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 uniform resource identifier (URI) kann das Anwendungsunterverzeichnis einschließen, in dem sich die Schriftartressource befindet. In diesem Fall müsste der Verweis auf den Speicherort der Schriftart kein Verzeichnis angeben, sondern müsste ein führendes "./"-Zeichen aufweisen, mit dem gekennzeichnet wird, dass sich die Schriftartressource in dem Verzeichnis befindet, das vom grundlegenden uniform resource identifier (URI) angegeben wird. Das folgende Codebeispiel zeigt eine andere Möglichkeit, auf das Schriftartressourcen-Element zu verweisen. Es entspricht dem vorherigen Beispiel.

            ' 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 über das gleiche Anwendungsunterverzeichnis

Sie können den Anwendungsinhalt und die Ressourcendateien im gleichen benutzerdefinierten Unterverzeichnis Ihres Anwendungsprojekts platzieren. Das folgende Projektdateibeispiel zeigt eine Inhaltsseite und Schriftartressourcen an, die im gleichen Unterverzeichnis definiert werden.

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

Da sich der Anwendungsinhalt und die Schriftart im gleichen Unterverzeichnis befinden, ist der Schriftartverweis relativ zum Anwendungsinhalt. Das folgende Beispiel veranschaulicht, wie auf die Schriftartressourcen der Anwendung verwiesen wird, wenn sich die Schriftart im gleichen Verzeichnis befindet wie die Anwendung.

<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

Verwenden Sie zum Auflisten von Schriftarten als Ressourcenelemente in der Anwendung die GetFontFamilies-Methode oder die GetTypefaces-Methode. Im folgenden Beispiel wird veranschaulicht, wie Sie mit der GetFontFamilies-Methode die Auflistung von FontFamily-Objekten aus dem Schriftartspeicherort der Anwendung zurückgeben. In diesem Fall enthält die Anwendung ein Unterverzeichnis mit dem Namen "resources".

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

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

Im folgenden Beispiel wird veranschaulicht, wie Sie mit der GetTypefaces-Methode die Auflistung von Typeface-Objekten aus dem Schriftartspeicherort der Anwendung zurückgeben. In diesem Fall enthält die Anwendung ein Unterverzeichnis mit dem Namen "resources".

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

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

Erstellen einer Schriftartressourcen-Bibliothek

Sie können eine reine Ressourcenbibliothek erstellen, die ausschließlich Schriftarten enthält. Code ist nicht Bestandteil eines solchen Bibliothekprojekts. Das Erstellen einer reinen Ressourcenbibliothek ist eine verbreitete Technik für das Entkoppeln von Ressourcen vom Anwendungscode, in dem sie verwendet werden. Dadurch ist es auch möglich, dass die Bibliotheksassembly in mehrere Anwendungsprojekte aufgenommen werden kann. Im folgenden Projektdateibeispiel werden die Hauptbestandteile eines reinen Ressourcenbibliotheksprojekts veranschaulicht.

<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 über die Anwendung auf eine Schriftart in einer Ressourcenbibliothek zu verweisen, müssen Sie dem Schriftartverweis den Namen der Bibliotheksassembly voranstellen. In diesem Fall ist die Schriftartressourcen-Assembly "FontLibrary". Um den Assemblynamen innerhalb der Assembly vom Verweis zu trennen, verwenden Sie ein ";"-Zeichen. Durch Hinzufügen des Schlüsselworts "Component" gefolgt vom Verweis auf den Schriftartnamen wird der Verweis auf die Ressource der Schriftartbibliothek vervollständigt. Im folgenden Codebeispiel wird gezeigt, wie auf eine Schriftart in einer Ressourcenbibliotheksassembly verwiesen wird.

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

Hinweis
Dieses SDK enthält einen Satz von Beispielen für OpenType-Schriftarten, die Sie in WPF-Anwendungen verwenden können.Die Schriftarten werden in einer reinen Ressourcenbibliothek definiert.Weitere Informationen finden Sie unter OpenType-Beispielschriftartenpaket.

Einschränkungen der Schriftartverwendung

In der folgenden Liste werden mehrere Einschränkungen des Verpackens und Verwendens von Schriftarten in WPF-Anwendungen beschrieben:

Berechtigungsbits für die Schriftarteinbettung: Mit WPF-Anwendungen werden Berechtigungsbits für die Schriftarteinbettung nicht überprüft oder durchgesetzt. Weitere Informationen finden Sie unter Einführung in das Verpacken von Schriftarten.
Site der Ursprungsschriftarten: WPF-Anwendungen lassen keine Schriftartenverweise auf einen http- oder ftp-uniform resource identifier (URI) zu.
Absoluter URI mit der pack:-Notation: Mit WPF-Anwendungen können Sie programmgesteuert kein FontFamily-Objekt mit "pack:" als Bestandteil des absoluten uniform resource identifier (URI)-Verweises auf eine Schriftart erstellen. Beispielsweise ist "pack://application:,,,/resources/#Pericles Light" ein ungültiger Schriftartverweis.
Automatische Schriftarteinbettung: Zur Entwurfszeit erfolgt keine Unterstützung für die Suche der Schriftartverwendung einer Anwendung und für das automatische Einbetten der Schriftarten in die Ressourcen der Anwendung.
Schriftartteilmengen: WPF-Anwendungen unterstützen die Erstellung von Schriftartteilmengen für nicht einheitlich dargestellte Dokumente nicht.
Bei einem falschen Verweis greift die Anwendung wieder auf die Verwendung einer verfügbaren Schriftart zurück.

Siehe auch

Freigeben über