Rendu du texte à l’aide de glyphes

Solution d’API C++. pour afficher le texte avec la police souhaitée.

 

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

  Nuget   Pricing Buy
 

Aspose.Font API Solution offre de riches fonctionnalités pour travailler avec les polices, y compris la conversion, la manipulation des glyphes, la détection des symboles latins, etc. Certaines des fonctionnalités sont liées à la manipulation des glyphes, telles que le rendu du texte.

Un glyphe est une conception unique d’un caractère dans une police de caractères ou une représentation graphique d’un symbole ou d’un caractère. Pour mieux comprendre cette unité de police, lisez l’article Introduction to Glyph .

Cette page explique comment afficher le texte à l’aide de glyphes, mais une explication complète de la fonctionnalité est fournie dans l’article Using Glyph objects . Vous y trouverez d’autres exemples de code C++ et découvrirez les capacités d’Aspose.Font pour travailler spécifiquement avec les glyphes et les objets Glyph. Vous pouvez également apprendre des exemples complets et des fichiers de données sur Aspose Github Project .

Pour taper des textes avec des glyphes, nous avons besoin de :

  • Aspose.Font pour l'API C++ qui est une API de manipulation et de conversion de documents riche en fonctionnalités, puissante et facile à utiliser.

  • Ouvrez le gestionnaire de packages NuGet, recherchez Aspose.Font et installez-le. Vous pouvez également utiliser la commande suivante à partir de la console du gestionnaire de packages.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Rendu du texte avec des glyphes à l'aide de C++

Les étapes suivantes sont généralement nécessaires pour rendre le texte avec les glyphes :

  1. Chargez le fichier de police en mémoire. Ici, vous devez créer un objet de police, tel qu’un objet Type1Font, et le transmettre dans le chemin du fichier de police.
  2. Décodez le texte dans ses ID de glyphe correspondants. Pour cela, passez chaque caractère du texte à travers l’objet d’encodage de la police et décodez-le en son ID de glyphe correspondant.
  3. Obtenez le contour de chaque glyphe. Le contour est un tracé qui définit la forme du personnage. Ceci peut être réalisé en utilisant la méthode GetGlyphOutline() de l’objet Font .
  4. Dessinez les contours de chaque glyphe à l’aide d’un objet graphique, tel qu’un objet GraphicsPath. Créez simplement un objet qui implémente l’interface IGlyphOutlinePainter, qui est responsable du dessin des contours des glyphes.
  5. Affichez le texte en utilisant un objet graphique pour dessiner les contours de chaque glyphe. Cela peut être fait en utilisant la méthode DrawPath() de l’objet graphique.

Code C++ pour afficher du texte

    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. Comment la police est-elle rendue via Aspose.Font ?

Pour restituer les polices à l’aide de cette solution API, vous aurez besoin des entités de Aspose.Font.Rendering et Aspose.Font.Renderers . Tout d’abord, implémentez les méthodes IGlyphOutlinePainter. Créez ensuite la méthode DrawText(). Créez la méthode utilitaire pour calculer la largeur de la police et appelez la fonctionnalité de rendu du texte.

2. À quels facteurs devez-vous prêter attention lors du rendu de texte avec des glyphes ?

Lors du rendu de texte avec des glyphes, plusieurs facteurs importants doivent être pris en compte pour garantir des résultats précis et visuellement attrayants, tels que la sélection de la police, les indications, le crénage et le suivi, les mesures des glyphes, la couleur et le contraste, etc.

3. Qu’est-ce que l’indication de police ?

Les indices peuvent aider à maintenir la clarté et la lisibilité du texte, en particulier dans des tailles plus petites ou sur des écrans à faible résolution.