Renderizar texto usando glifos

Solución API C++. para mostrar el texto con la fuente deseada.

 

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

  Nuget   Pricing Buy
 

La solución API de Aspose.Font ofrece capacidades ricas para trabajar con fuentes, incluida la conversión, la manipulación de glifos, la detección de símbolos latinos y más. Algunas de las funciones están relacionadas con la manipulación de glifos, como la representación de texto.

Un glifo es un diseño único de un carácter en un tipo de letra o una representación gráfica de un símbolo o carácter. Para obtener una comprensión más profunda de esta unidad de fuente, lea el artículo Introducción a Glyph .

Esta página explica cómo mostrar el texto usando glifos, pero se proporciona una explicación completa de la funcionalidad en el artículo Uso de objetos Glyph . Allí encontrará más ejemplos de código C++ y aprenderá sobre las capacidades de Aspose.Font para trabajar con glifos y objetos Glyph específicamente. También puede aprender ejemplos completos y archivos de datos en Aspose Github Project .

Para escribir textos con glifos necesitamos:

  • Aspose.Font para la API de C++, que es una API de manipulación y conversión de documentos rica en funciones, potente y fácil de usar.

  • Abra el administrador de paquetes NuGet y busque Aspose.Font e instálelo. También puede usar el siguiente comando desde la Consola del administrador de paquetes.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Renderizar texto con glifos usando C++

Por lo general, se requieren los siguientes pasos para representar el texto con los glifos:

  1. Cargue el archivo de fuente en la memoria. Aquí debe crear un objeto de fuente, como un objeto Type1Font, y pasarlo a la ruta del archivo de fuente.
  2. Decodifique el texto en sus ID de glifo correspondientes. Para ello, pase cada carácter del texto por el objeto de codificación de la fuente y decodifique a su ID de glifo correspondiente.
  3. Obtenga el contorno de cada glifo. El contorno es un trazado que define la forma del personaje. Esto se puede lograr utilizando el método GetGlyphOutline() del objeto Font .
  4. Dibuje los contornos de cada glifo utilizando un objeto gráfico, como un objeto GraphicsPath. Simplemente cree un objeto que implemente la interfaz IGlyphOutlinePainter, que es responsable de dibujar los contornos de los glifos.
  5. Muestre el texto utilizando un objeto gráfico para dibujar los contornos de cada glifo. Esto se puede hacer usando el método DrawPath() del objeto gráfico.

Código C++ para renderizar texto

    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;
    }



Preguntas más frecuentes

1. ¿Cómo se representa la fuente mediante Aspose.Font?

Para representar fuentes usando esta solución API necesitarás las entidades de Aspose.Font.Rendering y Aspose.Font.Renderers espacios de nombres. Primero, implemente los métodos IGlyphOutlinePainter. Luego cree el método DrawText(). Cree el método de utilidad para calcular el ancho de fuente y llame a la funcionalidad de representación de texto.

2. ¿A qué factores debería prestar atención al representar texto con glifos?

Al representar texto con glifos, hay varios factores importantes a considerar para garantizar resultados precisos y visualmente atractivos, como selección de fuente, sugerencias, interletraje y seguimiento, métricas de glifos, color y contraste, etc.

3. ¿Qué es la sugerencia de fuente?

Las sugerencias pueden ayudar a mantener la claridad y legibilidad del texto, especialmente en tamaños más pequeños o en pantallas de baja resolución.