#include <cairomm/cairomm.h>
 
const double HEIGHT = 200.0;
const double WIDTH = 400.0;
const double FONT_SIZE = 64.0;
const double TEXT_ORIGIN_Y = (HEIGHT / 2.0) + (FONT_SIZE / 2.0);
const double TEXT_ORIGIN_X = 50.0;  
const double GLYPH_SPACING = 0.1;
 
struct GlyphBounds
{
  unsigned long glyph;
  double width;
  double height;
};
 
static const GlyphBounds glyphs[] =
{
  { 'c', 0.45, 0.5 },
  { 'a', 0.45, 0.5 },
  { 'i', 0.2, 0.75 },
  { 'r', 0.4, 0.5 },
  { 'o', 0.44, 0.5 },
  { 'm', 0.75, 0.5 },
  { '!', 0.2, 0.75 }
};
 
{
public:
  
  
  {
  }
 
  Cairo::ErrorStatus
  {
    for (unsigned int i = 0; i < sizeof (glyphs) / sizeof (GlyphBounds); ++i) {
      if (glyphs[i].width > 
max)
 
    }
    
    extents.max_x_advance = 
max;
    return CAIRO_STATUS_SUCCESS;
  }
 
  Cairo::ErrorStatus
                    unsigned long unicode, unsigned long& glyph) override
  {
    glyph = 0;
    
    
    for (unsigned int i = 0; i < sizeof (glyphs) / sizeof (GlyphBounds); ++i) {
      if (glyphs[i].glyph == unicode) {
        
        glyph = i+1;
        break;
      }
    }
    return CAIRO_STATUS_SUCCESS;
  }
 
  Cairo::ErrorStatus
               unsigned long glyph,
  {
    
    if (glyph >= 1 && glyph <= sizeof(glyphs)/sizeof(GlyphBounds)) {
      cr->set_line_width(0.05);
      
      
      cr->rectangle(0.0, 0.0, glyphs[glyph-1].width, -glyphs[glyph-1].height);
      cr->stroke();
      metrics.x_advance = glyphs[glyph-1].width + GLYPH_SPACING;
    }
    return CAIRO_STATUS_SUCCESS;
  }
 
protected:
  
  
  BoxFontFace() : UserFontFace() { }
};
 
int main(int, char**)
{
  auto surface =
  
  cr->set_source_rgb(1.0, 1.0, 1.0);
  cr->paint();
 
  
  cr->arc(TEXT_ORIGIN_X, TEXT_ORIGIN_Y, FONT_SIZE / 4.0, 0, 2*M_PI);
  cr->set_source_rgba(0.0, 1.0, 0.0, 0.5);
  cr->fill();
 
  
  cr->move_to(TEXT_ORIGIN_X, TEXT_ORIGIN_Y);
  cr->set_source_rgb(0.8, 0.2, 0.2);
  auto font = BoxFontFace::create();
  cr->set_font_face(font);
  cr->set_font_size(FONT_SIZE);
  cr->show_text("cairomm!");
 
  
  cr->move_to(TEXT_ORIGIN_X, TEXT_ORIGIN_Y);
  cr->set_source_rgba(0.2, 0.2, 0.2, 0.3);
  auto toy_font =
  cr->set_font_face(toy_font);
  cr->set_font_size(FONT_SIZE);
  cr->show_text("cairomm!");
 
  const char* filename = "user-font.png";
  try {
    surface->write_to_png(filename);
    return 0;
  {
    return 1;
  }
}
basic_ostream< _CharT, _Traits > & endl(basic_ostream< _CharT, _Traits > &__os)
static RefPtr< Context > create(const RefPtr< Surface > &target)
static RefPtr< ImageSurface > create(Format format, int width, int height)
Creates an image surface of the specified format and dimensions.
RefPtr<> is a reference-counting shared smartpointer.
Definition refptr.h:45
static RefPtr< ToyFontFace > create(const std::string &family, FontSlant slant, FontWeight weight)
Creates a font face from a triplet of family, slant, and weight.
Font support with font data provided by the user.
Definition fontface.h:208
virtual ErrorStatus render_glyph(const RefPtr< ScaledFont > &scaled_font, unsigned long glyph, const RefPtr< Context > &cr, TextExtents &metrics)=0
This function is called when a user scaled-font needs to render a glyph.
virtual ErrorStatus unicode_to_glyph(const RefPtr< ScaledFont > &scaled_font, unsigned long unicode, unsigned long &glyph)
This function is called to convert an input Unicode character to a single glyph.
virtual ErrorStatus init(const RefPtr< ScaledFont > &scaled_font, const RefPtr< Context > &cr, FontExtents &extents)
This function is called when a scaled-font needs to be created for a user font-face.
@ FONT_SLANT_NORMAL
Upright font style.
Definition enums.h:246
@ FORMAT_ARGB32
Each pixel is a 32-bit quantity, with alpha in the upper 8 bits, then red, then green,...
Definition enums.h:349
@ FONT_WEIGHT_BOLD
Bold font weight.
Definition enums.h:272