1. Produkte
  2.   Font
  3.   C++
  4.   Aspose.Font für C++

Aspose.Font für C++

 
 

C++ Schriftarten-API zum Lesen, Speichern & Konvertieren von Schriftarten

C++‑Bibliothek ermöglicht das Laden, Lesen, Speichern und Konvertieren verschiedener Schriftformate wie TrueType, WOFF, EOT, OpenType, CFF und Type1 in C++‑basierten Anwendungen.

Aspose.Font für C++ ist ein sehr leistungsstarkes Werkzeug, das die Schriftverarbeitung vereinfacht und ein umfangreiches Funktionsset für Softwareentwickler und Programmierer bietet. Es befähigt C++-Entwickler, mit verschiedenen Schriftformaten zu arbeiten und ein breites Spektrum an schriftenbezogenen Aufgaben auszuführen. Es ermöglicht Softwareentwicklern, Schriftdateien in verschiedenen Formaten zu laden, zu erzeugen, zu bearbeiten und zu konvertieren, wie z. B. TrueType (TTF), OpenType (OTF), PostScript Type 1 (PFB/PFA), WOFF, EOT und viele andere. Die API kann Ihre schriftenbezogenen Aufgaben auf die nächste Stufe heben, ohne externe Abhängigkeiten.

Aspose.Font für C++ ist eine funktionsreiche Bibliothek, die umfassende Schriftmanipulationsmöglichkeiten für C++‑Entwickler bietet. Die Bibliothek unterstützt ein breites Spektrum an Schriftoperationen, einschließlich dem Extrahieren von Schriftmetadaten, Laden von Schriftdateien von Festplatte oder Stream, Zugriff auf Glypheninformationen, Konvertieren von Schriften in verschiedene Formate, Lesen von Schriftinformationen, Aktualisieren von Schriftdateien und Speichern auf der Festplatte, Auslesen von Metrikinformationen aus Schriftdateien, Rendern von Text mithilfe von Schriftglyphen, Zusammenführen von TrueType-Schriften und vieles mehr. Sie unterstützt sowohl 32‑Bit‑ als auch 64‑Bit‑Betriebssysteme.

Aspose.Font für C++ bietet erweiterte typografische Funktionen, einschließlich der Handhabung von Ligaturen, kontextabhängigen und fakultativen Glyphenersetzungen sowie fortgeschrittenen Textlayout‑Optionen. Diese Funktionen sind besonders nützlich beim Arbeiten mit komplexen Schriften oder Sprachen, die eine anspruchsvolle Textformung und -darstellung erfordern. Die API ist plattformübergreifend und ermöglicht es Benutzern, sie nahtlos auf verschiedenen Betriebssystemen wie Windows, Linux und macOS zu nutzen. Wenn Sie die Schriftmanipulationsmöglichkeiten in Ihren C++‑Anwendungen erweitern möchten, ist Aspose.Font zweifellos eine Überlegung wert.

Previous Next

Erste Schritte mit Aspose.Font für C++

Die empfohlene Methode, Aspose.Font für C++ zu installieren, ist die Verwendung von NuGet. Bitte verwenden Sie den folgenden Befehl für eine reibungslose Installation.

Aspose.Font für C++ über NuGet-Befehl installieren

NuGet\Install-Package Aspose.Font.Cpp -Version 23.4.0

Sie können die Bibliothek direkt von der Aspose.Font für C++ Produktseite herunterladen

Schriftkonvertierung in unterstützte Dateiformate über die C++-API

Eine der bemerkenswerten Funktionen von Aspose.Font für C++ ist die Fähigkeit, Schriftarten zwischen verschiedenen unterstützten Dateiformaten zu konvertieren. Dies ist sehr praktisch, wenn Softwareentwickler Schriftarten in ein bestimmtes Format konvertieren müssen, das mit Ihrer Zielumgebung oder Plattform kompatibel ist. Die Bibliothek unterstützt nahtlose Konvertierungen zwischen TrueType-, OpenType-, CFF-, PostScript Type 1-Schriftarten und mehr, sodass Entwickler ein breites Anwendungsspektrum abdecken können. Das folgende Beispiel zeigt, wie man eine Schriftart aus einem der unterstützten Formate wie TTF lädt und sie mit C++-Befehlen in WOFF2 konvertiert.

TTF in WOFF2 mit C++-API konvertieren

using namespace System;
    using namespace Aspose::Font::Sources;
    using namespace Aspose::Font::Ttf;
    using namespace Aspose::Font;

    // Open TTF font
    SharedPtr fontFileDefinition = MakeObject(MakeObject(u"Montserrat-Regular.ttf"));
    SharedPtr fontDefinition = MakeObject(FontType::TTF, fontFileDefinition);
    SharedPtr font = Font::Open(fontDefinition);

    // WOFF2 output settings
    SharedPtr outStream = IO::File::Create(u"Montserrat-Regular.woff2");

    // Convert TTF to WOFF2
    font->SaveToFormat(outStream, FontSavingFormats::WOFF2);

Laden und Extrahieren von Type1-Schriften über die C++-API

Aspose.Font für C++ ermöglicht es Softwareentwicklern, Type1 sowie andere unterstützte Schriftformate aus verschiedenen Quellen zu laden, z. B. lokale Dateien, Streams oder URLs. Softwareentwickler können Schriftarten einzeln oder stapelweise laden, was die gleichzeitige Verarbeitung mehrerer Schriftarten erleichtert. Nach dem Laden können Entwickler die Eigenschaften der Schriftarten aktualisieren und sie wieder im gewünschten Format speichern oder mühelos in andere Formate exportieren. Das folgende Beispiel zeigt, wie man Type1‑Schriftarten in C++‑Anwendungen lädt und Daten daraus extrahiert.

Wie man Daten aus Type1-Schriften mit der C++-API lädt und extrahiert?

System::String fileName = dataDir + u"courier.pfb";
//Font file name with full path
    
System::SharedPtr fd = System::MakeObject(Aspose::Font::FontType::Type1, System::MakeObject(u"pfb", System::MakeObject(fileName)));
System::SharedPtr font = System::DynamicCast_noexcept(Aspose::Font::Font::Open(fd));

Unterstützung für Schriftmetriken und Glyphen

Aspose.Font für C++ ist eine sehr funktionsreiche Bibliothek, die Zugriff auf eine Fülle von Schriftmetriken bietet, darunter Aufstieg, Abstieg, Zeilenabstand und verschiedene weitere wichtige Messwerte. Softwareentwickler können Glypheninformationen wie Unicode‑Werte, Begrenzungsrahmen, Vorwärtsbreiten und mehr abrufen. Diese Funktionen ermöglichen es den Benutzern, Text in Ihren Anwendungen genau zu positionieren und zu rendern. Das folgende Beispiel zeigt, wie Softwareentwickler Text mit den Glyphen mithilfe von C++‑Befehlen rendern können.

Wie rendert man Text mit den Glyphen in C++-Anwendungen?

 using Aspose::Font::Glyphs;
using Aspose::Font::Rendering;
using Aspose::Font::RenderingPath;

class GlyphOutlinePainter: IGlyphOutlinePainter
    RenderingText::GlyphOutlinePainter::GlyphOutlinePainter(System::SharedPtr path)
    {
        _path = path;
    }
    void RenderingText::GlyphOutlinePainter::MoveTo(System::SharedPtr moveTo)
    {
        _path->CloseFigure();
        _currentPoint.set_X((float)moveTo->get_X());
        _currentPoint.set_Y((float)moveTo->get_Y());
    }

    void RenderingText::GlyphOutlinePainter::LineTo(System::SharedPtr lineTo)
    {
        float x = (float)lineTo->get_X();
        float y = (float)lineTo->get_Y();
        _path->AddLine(_currentPoint.get_X(), _currentPoint.get_Y(), x, y);
        _currentPoint.set_X(x);
        _currentPoint.set_Y(y);
    }

    void RenderingText::GlyphOutlinePainter::CurveTo(System::SharedPtr curveTo)
    {
        float x3 = (float)curveTo->get_X3();
        float y3 = (float)curveTo->get_Y3();
    
        _path->AddBezier(_currentPoint.get_X(), _currentPoint.get_Y(), (float)curveTo->get_X1(), (float)curveTo->get_Y1(), (float)curveTo->get_X2(), (float)curveTo->get_Y2(), x3, y3);
    
        _currentPoint.set_X(x3);
        _currentPoint.set_Y(y3);
    }

    void RenderingText::GlyphOutlinePainter::ClosePath()
    {
        _path->CloseFigure();
    }

    System::Object::shared_members_type Aspose::Font::Examples::WorkingWithTrueTypeAndOpenTypeFonts::RenderingText::GlyphOutlinePainter::GetSharedMembers()
    {
        auto result = System::Object::GetSharedMembers();
    
        result.Add("Aspose::Font::Examples::WorkingWithTrueTypeAndOpenTypeFonts::RenderingText::GlyphOutlinePainter::_path", this->_path);      result.Add("Aspose::Font::Examples::WorkingWithTrueTypeAndOpenTypeFonts::RenderingText::GlyphOutlinePainter::_currentPoint", this->_currentPoint);
    
        return result;
    }

Schriftmanipulation & -bearbeitung über die C++-API

Aspose.Font für C++ ermöglicht es Softwareentwicklern, Type1 sowie andere unterstützte Schriftformate aus verschiedenen Quellen zu laden, z. B. lokale Dateien, Streams oder URLs. Softwareentwickler können Schriftarten einzeln oder stapelweise laden, was die gleichzeitige Verarbeitung mehrerer Schriftarten erleichtert. Nach dem Laden können Entwickler die Eigenschaften der Schriftarten aktualisieren und sie wieder im gewünschten Format speichern oder mühelos in andere Formate exportieren. Das folgende Beispiel zeigt, wie man Type1‑Schriftarten in C++‑Anwendungen lädt und Daten daraus extrahiert.

Schriftmetrikinformationen aus Type1-Schriften in C++-Apps lesen

System::String fileName = dataDir + u"courier.pfb";
//Font file name with full path
    
System::SharedPtr fd = System::MakeObject(Aspose::Font::FontType::Type1, System::MakeObject(u"pfb", System::MakeObject(fileName)));
System::SharedPtr font = System::DynamicCast_noexcept(Aspose::Font::Font::Open(fd));
    
System::String name = font->get_FontName();
System::Console::WriteLine(System::String(u"Font name: ") + name);
System::Console::WriteLine(System::String(u"Glyph count: ") + font->get_NumGlyphs());
System::String metrics = System::String::Format(u"Font metrics: ascender - {0}, descender - {1}, typo ascender = {2}, typo descender = {3}, UnitsPerEm = {4}", font->get_Metrics()->get_Ascender(), font->get_Metrics()->get_Descender(), font->get_Metrics()->get_TypoAscender(), font->get_Metrics()->get_TypoDescender(), font->get_Metrics()->get_UnitsPerEM());
    
System::Console::WriteLine(metrics);
 Deutsch