Text mit Glyphen rendern

C++ API-Lösung zur Anzeige von Text mit der gewünschten Schriftart.

 

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

  Nuget   Pricing Buy
 

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

Ein Glyph ist ein einzigartiges Design eines Zeichens in einer Schriftart oder eine grafische Darstellung eines Symbols oder Zeichens. Um ein tieferes Verständnis dieser Schriftarteinheit zu erlangen, lesen Sie den Artikel Einführung in Glyphen .

Diese Seite erklärt, wie man Text mit Glyphen anzeigt, aber eine umfassende Erklärung der Funktionalität finden Sie im Artikel Verwendung von Glyph-Objekten . Dort finden Sie weitere C++ Codebeispiele und erfahren mehr über die Möglichkeiten von Aspose.Font im Umgang mit Glyphen und Glyph-Objekten. Vollständige Beispiele und Datendateien finden Sie außerdem im Aspose Github-Projekt .

Um Texte mit Glyphen einzugeben, benötigen wir:

  • Aspose.Font für C++ API, die eine funktionsreiche, leistungsstarke und einfach zu nutzende API für Dokumentenmanipulation und -konvertierung ist.

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

Package Manager Console Command


    PM> Install-Package Aspose.Font

Text mit Glyphen mit C++ rendern

Die folgenden Schritte sind normalerweise erforderlich, um Text mit Glyphen zu rendern:

  1. Laden Sie die Schriftdatei in den Speicher. Hier müssen Sie ein Schriftobjekt erstellen, z. B. ein Type1Font Objekt, und den Pfad zur Schriftdatei angeben.
  2. Dekodieren Sie den Text in die entsprechenden Glyphen-IDs. Dazu übergeben Sie jedes Zeichen des Textes an das Zeichencodierungsobjekt der Schrift und dekodieren es zu seiner entsprechenden Glyphen-ID.
  3. Holen Sie die Kontur jedes Glyphen. Die Kontur ist ein Pfad, der die Form des Zeichens definiert. Dies kann mithilfe der GetGlyphOutline()‑Methode des Font ‑Objekts erreicht werden.
  4. Zeichnen Sie die Konturen jedes Glyphen mit einem Grafikobjekt, z. B. einem GraphicsPath‑Objekt. Erstellen Sie einfach ein Objekt, das das IGlyphOutlinePainter-Interface implementiert, welches für das Zeichnen der Glyphen‑Konturen verantwortlich ist.
  5. Zeigen Sie den Text an, indem Sie ein Grafikobjekt verwenden, um die Konturen jedes Glyphen zu zeichnen. Dies kann mit der DrawPath()‑Methode 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.