Rendern Sie Text mit Glyphen

C++ API-Lösung. um Text mit der gewünschten Schriftart anzuzeigen.

 

Aspose.Font for C++ Aspose.Font for C++

  Nuget   Pricing Buy
 

Die Aspose.Font API-Lösung bietet umfangreiche Funktionen für die Arbeit mit Schriftarten, einschließlich Konvertierung, Bearbeitung von Glyphen, Erkennung lateinischer Symbole und mehr. Einige der Funktionen beziehen sich auf die Glyphenmanipulation, wie z. B. das Rendern von Text.

Eine Glyphe ist ein einzigartiges Design eines Zeichens in einer Schriftart oder eine grafische Darstellung eines Symbols oder Zeichens. Lesen Sie den Artikel Introduction to Glyph für ein tieferes Verständnis dieser Schrifteinheit.

Auf dieser Seite wird erläutert, wie der Text mithilfe von Glyphen angezeigt wird, aber eine umfassende Erläuterung der Funktionalität finden Sie im Artikel Using Glyph objects . Dort finden Sie weitere C++-Codebeispiele und erfahren mehr über die Funktionen von Aspose.Font für die Arbeit mit Glyphen und Glyph-Objekten speziell. Vollständige Beispiele und Datendateien finden Sie auch unter Aspose Github Project .

Um Texte mit Glyphen auszugeben, benötigen wir:

  • Aspose.Font für C++ API, eine funktionsreiche, leistungsstarke und benutzerfreundliche API zur Dokumentenbearbeitung und -konvertierung.

  • Öffnen Sie den NuGet-Paket-Manager, suchen Sie nach Aspose.Font und installieren Sie es. Sie können auch den folgenden Befehl in der Paket-Manager-Konsole verwenden.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Rendern Sie Text mit Glyphen mit C++

Die nächsten Schritte sind normalerweise erforderlich, um Text mit den Glyphen zu rendern:

  1. Laden Sie die Schriftartdatei in den Speicher. Hier müssen Sie ein Schriftartobjekt erstellen, z. B. ein Type1Font-Objekt, und es im Schriftartdateipfad übergeben.
  2. Decodieren Sie den Text in seine entsprechenden Glyphen-IDs. Leiten Sie dazu jedes Zeichen des Textes durch das Codierungsobjekt der Schriftart und decodieren Sie es in seine entsprechende Glyphen-ID.
  3. Holen Sie sich den Umriss jeder Glyphe. Der Umriss ist ein Pfad, der die Form des Zeichens definiert. Dies kann mit der Methode GetGlyphOutline() des Objekts Font erreicht werden.
  4. Zeichnen Sie die Umrisse jeder Glyphe mithilfe eines Grafikobjekts, z. B. eines GraphicsPath-Objekts. Erstellen Sie einfach ein Objekt, das die Schnittstelle IGlyphOutlinePainter implementiert, die für das Zeichnen der Umrisse der Glyphen verantwortlich ist.
  5. Zeigen Sie den Text an, indem Sie ein Grafikobjekt verwenden, um die Umrisse jeder Glyphe zu zeichnen. Dies kann mit der Methode DrawPath() des Grafikobjekts erfolgen.

C++-Code zum Rendern von Text

    using Aspose::Font::Glyphs;
    using Aspose::Font::Rendering;
    using Aspose::Font::RenderingPath;
    class GlyphOutlinePainter: IGlyphOutlinePainter
    RenderingText::GlyphOutlinePainter::GlyphOutlinePainter(System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path)
    {
        _path = path;
    }

    void RenderingText::GlyphOutlinePainter::MoveTo(System::SharedPtr<Aspose::Font::RenderingPath::MoveTo> moveTo)
    {
        _path->CloseFigure();
        _currentPoint.set_X((float)moveTo->get_X());
        _currentPoint.set_Y((float)moveTo->get_Y());
    }

    void RenderingText::GlyphOutlinePainter::LineTo(System::SharedPtr<Aspose::Font::RenderingPath::LineTo> 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<Aspose::Font::RenderingPath::CurveTo> 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;
    }



FAQ

1. Wie wird die Schriftart über Aspose.Font gerendert?

Um Schriftarten mit dieser API-Lösung zu rendern, benötigen Sie die Entitäten Aspose.Font.Rendering und Aspose.Font.Renderers Namespaces. Implementieren Sie zunächst die IGlyphOutlinePainter-Methoden. Erstellen Sie dann die DrawText()-Methode. Erstellen Sie die Dienstprogrammmethode zum Berechnen der Schriftbreite und rufen Sie die Funktionalität zum Rendern von Text auf.

2. Auf welche Faktoren sollten Sie beim Rendern von Text mit Glyphen achten?

Beim Rendern von Text mit Glyphen müssen mehrere wichtige Faktoren berücksichtigt werden, um genaue und optisch ansprechende Ergebnisse zu gewährleisten, wie z. B. Schriftartauswahl, Hinting, Kerning und Tracking, Glyphenmetriken, Farbe und Kontrast usw.

3. Was ist Schrifthinweis?

Hinweise können dazu beitragen, die Klarheit und Lesbarkeit von Text zu erhalten, insbesondere bei kleineren Größen oder auf Bildschirmen mit niedriger Auflösung.