Font Struct Reference

TrueType fonts. More...

#include <Font.h>

Inheritance diagram for Font:

Public Member Functions
Class *	_Font (void)
	The Font archetype.
void	cacheFont (Data *data, const char *family)
void	clearCache (void)
	Clears the Font cache.
Font *	defaultFont (void)
Font *	defaultMonospaceFont (void)
Font *	fontWithAttributes (const FontAttributes *attributes, float pixelDensity)
	Resolves a new Font with the given attributes from the cached font Data.
Font *	fontWithName (const char *name, float pixelDensity)
	Resolves a Font from a name in the format produced by Font::name.
Font *	initWithData (Font *self, Data *data, const FontAttributes *attributes, float pixelDensity)
	Initializes this Font with the given TTF Data and attributes.
String *	name (const Font *self)
String *	nameWithAttributes (const FontAttributes *attributes)
void	renderBitmapCharacters (Font *self, const Renderer *renderer, const char *chars, SDL_Color color, int wrapWidth, const SDL_Point *origin, const ImageAtlas *icons)
	Records one quad per glyph of the given characters from this Font's bitmap.
void	renderCharacters (const Font *self, const char *chars, SDL_Color color, int wrapWidth)
	Renders the given characters in this Font.
void	renderDeviceWillReset (Font *self)
	Releases this Font's bitmap Texture, if any, ahead of a render device reset. It is recreated on the next draw.
void	sizeBitmapCharacters (const Font *self, const char *chars, int wrapWidth, const ImageAtlas *icons, int *w, int *h)
	Measures the given characters against this Font's bitmap.
void	sizeCharacters (const Font *self, const char *chars, int *w, int *h)
	Measures the given characters in this Font.

Data Fields
FontBitmap	bitmap
	The glyphs of a fixed-width Font, baked into one sheet; bitmap.surface is NULL for a proportional Font.
Data *	data
	The raw font data.
char *	family
	The family name.
TTF_Font *	font
	The backing font.
Object	object
	The superclass.
float	pixelDensity
	The display pixel density scale, greater than 1.0 on high-density displays.
int	renderSize
	The render size, adjusted for pixel density.
int	size
	The point size.
int	style
	The style.

Static Public Attributes
void(*	cacheFont )(Data *data, const char *family)
	Caches the specified font Data.

Protected Attributes
FontInterface *	interface [0]
	The interface type.

Detailed Description

TrueType fonts.

Definition at line 88 of file Font.h.

Member Function Documentation

_Font()

Class * _Font

(

void

)

The Font archetype.

Returns

The Font Class.

Definition at line 464 of file Font.c.

                   {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "Font",
      .superclass = _Object(),
      .instanceSize = sizeof(Font),
      .interfaceSize = sizeof(FontInterface),
      .initialize = initialize,
      .destroy = destroy,
    });
  });
 
  return clazz;
}

cacheFont()

void cacheFont	(	Data *	data,
		const char *	family
	)

Definition at line 122 of file Font.c.

                                                      {
  $(_cache, setObjectForKeyPath, data, family);
}

clearCache()

void clearCache

(

void

)

Clears the Font cache.

Definition at line 149 of file Font.c.

                             {
  $(_cache, removeAllObjects);
}

defaultFont()

Font * defaultFont

(

void

)

Returns

The default Font, at a pixel density of 1.0.

Remarks

This is the fallback for Views that are not yet attached to a window; on attachment, style application re-resolves Fonts through the window's cache.

Definition at line 159 of file Font.c.

                               {
  static Once once;
  
  const FontAttributes attrs = {
    DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FONT_STYLE
  };
 
  do_once(&once, {
    _defaultFont = $$(Font, fontWithAttributes, &attrs, 1.f);
    assert(_defaultFont);
  });
 
  return _defaultFont;
}

defaultMonospaceFont()

Font * defaultMonospaceFont

(

void

)

Returns

The default monospaced Font, at a pixel density of 1.0.

Remarks

Bundled so that a bitmap font is always available; this is the fallback for Views that are not yet attached to a window, mirroring Font::defaultFont.

Definition at line 180 of file Font.c.

                                        {
  static Once once;
  
  const FontAttributes attrs = {
    DEFAULT_MONOSPACE_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FONT_STYLE
  };
 
  do_once(&once, {
    _defaultMonospaceFont = $$(Font, fontWithAttributes, &attrs, 1.f);
    assert(_defaultMonospaceFont);
  });
 
  return _defaultMonospaceFont;
}

fontWithAttributes()

Font * fontWithAttributes	(	const FontAttributes *	attributes,
		float	pixelDensity
	)

Resolves a new Font with the given attributes from the cached font Data.

"Cached" refers to the font Data registered via Font::cacheFont; the returned instance itself is newly created. Instance caching is provided by Theme::font, which callers with a Theme SHOULD prefer, since it supplies the pixel density implicitly and avoids re-opening the same Font repeatedly. Attributes are normalized to their defaults exactly as Font::nameWithAttributes normalizes them.

Parameters

attributes	The FontAttributes.
pixelDensity	The pixel density.

Returns

The Font, or the default Font if attributes->family is not registered. The caller owns the returned Font, and MUST release it.

Definition at line 199 of file Font.c.

                                                                                      {
 
  FontAttributes normalized = *attributes;
  normalizeAttributes(&normalized);
 
  if (pixelDensity < 1.f) {
    pixelDensity = 1.f;
  }
 
  Data *data = $((Dictionary *) _cache, objectForKeyPath, normalized.family);
  if (data) {
    Font *font = $(alloc(Font), initWithData, data, &normalized, pixelDensity);
    assert(font);
 
    return font;
  }
 
  MVC_LogWarn("%s-%d-%d not found\n", normalized.family, normalized.size, normalized.style);
  return retain($$(Font, defaultFont));
}

fontWithName()

Font * fontWithName	(	const char *	name,
		float	pixelDensity
	)

Resolves a Font from a name in the format produced by Font::name.

The name is parsed from the right, so families MAY contain -: the final token is the style, the preceding token the point size, and the remainder the family.

Parameters

name	The name, e.g. "Coda-16-regular".
pixelDensity	The pixel density.

Returns

The Font, or the default Font if name is not parseable or not registered. The caller owns the returned Font, and MUST release it.

Definition at line 224 of file Font.c.

                                                                {
 
  assert(name);
 
  char *chars = strdup(name);
  assert(chars);
 
  Font *font = NULL;
 
  char *styleToken = strrchr(chars, '-');
  if (styleToken) {
    *styleToken++ = '\0';
 
    char *sizeToken = strrchr(chars, '-');
    if (sizeToken) {
      *sizeToken++ = '\0';
 
      const FontAttributes attributes = {
        chars, (int) strtol(sizeToken, NULL, 10), valueof(FontStyleNames, styleToken)
      };
 
      font = $$(Font, fontWithAttributes, &attributes, pixelDensity);
    }
  }
 
  free(chars);
 
  if (font == NULL) {
    MVC_LogWarn("%s is not a valid Font name\n", name);
    font = retain($$(Font, defaultFont));
  }
 
  return font;
}

initWithData()

Font * initWithData	(	Font *	self,
		Data *	data,
		const FontAttributes *	attributes,
		float	pixelDensity
	)

Initializes this Font with the given TTF Data and attributes.

Fonts are immutable: the backing TTF_Font is opened here at size * pixelDensity and never re-opened. A pixel density change MUST be handled by resolving a new instance (see Theme::font).

Parameters

self	The Font.
data	The Data.
attributes	The FontAttributes.
pixelDensity	The pixel density.

Returns

The initialized Font, or NULL on error.

Definition at line 263 of file Font.c.

                                                                                                        {
 
  self = (Font *) super(Object, self, init);
  if (self) {
 
    self->data = retain(data);
    assert(self->data);
 
    self->family = strdup(attributes->family);
    assert(self->family);
 
    self->size = attributes->size;
    assert(self->size);
 
    self->style = attributes->style;
 
    self->pixelDensity = pixelDensity;
    self->renderSize = self->size * self->pixelDensity;
 
    SDL_IOStream *buffer = SDL_IOFromConstMem(self->data->bytes, (int) self->data->length);
    assert(buffer);
 
    self->font = TTF_OpenFontIO(buffer, 1, self->renderSize);
    assert(self->font);
 
    TTF_SetFontStyle(self->font, self->style);
    TTF_SetFontHinting(self->font, TTF_HINTING_LIGHT_SUBPIXEL);
 
    if (TTF_FontIsFixedWidth(self->font)) {
      initBitmap(&self->bitmap, self);
    }
  }
 
  return self;
}

name()

String * name

(

const Font *

self

)

Returns

This Font's name, in the format family-size-style, e.g. "Coda-16-regular".

Remarks

The format is stable and MAY be parsed by Font::fontWithName; it is also the key under which Theme caches Font instances. Pixel density is deliberately absent: it is implied by the window whose cache is consulted.

Definition at line 303 of file Font.c.

                                      {
  const FontAttributes attributes = { self->family, self->size, self->style };
  return $$(Font, nameWithAttributes, &attributes);
}

nameWithAttributes()

String * nameWithAttributes

(

const FontAttributes *

attributes

)

Returns

The Font name for the given attributes, in the format of Font::name.

Definition at line 312 of file Font.c.

                                                                    {
 
  FontAttributes normalized = *attributes;
  normalizeAttributes(&normalized);
 
  for (const EnumName *en = FontStyleNames; en->name; en++) {
    if (en->value == normalized.style) {
      return str("%s-%d-%s", normalized.family, normalized.size, en->alias ?: en->name);
    }
  }
 
  return str("%s-%d-%d", normalized.family, normalized.size, normalized.style);
}

renderBitmapCharacters()

void renderBitmapCharacters	(	Font *	self,
		const Renderer *	renderer,
		const char *	chars,
		SDL_Color	color,
		int	wrapWidth,
		const SDL_Point *	origin,
		const ImageAtlas *	icons
	)

Records one quad per glyph of the given characters from this Font's bitmap.

Parameters

self	The Font, which MUST have a bitmap.
renderer	The Renderer.
chars	The null-terminated UTF-8 encoded C string to render.
color	The color; ^0 through ^9 in chars select from TextEscapeColors, and ^^ is a literal ^.
wrapWidth	The maximum line width, in logical pixels, or 0 for no wrapping.
origin	The top-left corner of the first line, in logical pixels.
icons	The ImageAtlas resolving :icon: escapes, or NULL for none.

renderCharacters()

SDL_Surface * renderCharacters	(	const Font *	self,
		const char *	chars,
		SDL_Color	color,
		int	wrapWidth
	)

Renders the given characters in this Font.

Parameters

self	The Font.
chars	The null-terminated UTF-8 encoded C string to render.
color	The color.
wrapWidth	The maximum line width, in logical pixels, where wrapping should occur.

Returns

The rendered surface, or NULL on error.

Definition at line 330 of file Font.c.

                                                                                                          {
 
  // Always the wrapping renderer: with a width of 0 it breaks on newlines only, which is what
  // Font::sizeCharacters and the TTF_Text layout Text builds its color runs from both assume,
  // whereas TTF_RenderText_Blended draws a newline as a missing glyph on a single line
  SDL_Surface *surface = TTF_RenderText_Blended_Wrapped(self->font, chars, 0, color, wrapWidth * self->pixelDensity);
 
  SDL_Surface *converted = NULL;
  if (surface) {
    converted = SDL_ConvertSurface(surface, SDL_PIXELFORMAT_RGBA32);
    SDL_DestroySurface(surface);
  } else {
    MVC_LogError("%s\n", SDL_GetError());
  }
 
  return converted;
}

renderDeviceWillReset()

void renderDeviceWillReset

(

Font *

self

)

Releases this Font's bitmap Texture, if any, ahead of a render device reset. It is recreated on the next draw.

Parameters

self

The Font.

sizeBitmapCharacters()

void sizeBitmapCharacters	(	const Font *	self,
		const char *	chars,
		int	wrapWidth,
		const ImageAtlas *	icons,
		int *	w,
		int *	h
	)

Measures the given characters against this Font's bitmap.

Parameters

self	The Font, which MUST have a bitmap.
chars	The null-terminated UTF-8 encoded C string to size.
wrapWidth	The maximum line width, in logical pixels, or 0 for no wrapping.
icons	The ImageAtlas resolving :icon: escapes, or NULL for none.
w	The width to return, in logical pixels.
h	The height to return, in logical pixels.

sizeCharacters()

void sizeCharacters	(	const Font *	self,
		const char *	chars,
		int *	w,
		int *	h
	)

Measures the given characters in this Font.

Parameters

self	The Font.
chars	The null-terminated UTF-8 encoded C string to size.
w	The width to return.
h	The height to return.

Returns

The size of the rendered characters in logical pixels.

Definition at line 352 of file Font.c.

                                                                                {
 
  if (w) {
    *w = 0;
  }
  if (h) {
    *h = 0;
  }
 
  if (chars) {
    char *lines = strdup(chars);
 
    const int font_h = TTF_GetFontHeight(self->font);
 
    for (char *line = strtok(lines, "\n\r"); line; line = strtok(NULL, "\n\r")) {
 
      if (w) {
 
        int lineWidth;
        TTF_GetStringSize(self->font, line, 0, &lineWidth, NULL);
 
        // TTF_GetStringSize sums glyph advances, but the final glyph's ink can extend past its
        // own advance (common with bold or large faces). Check the final glyph's bounds and
        // ensure we take the larger value.
        const char *end = line + strlen(line);
        const Uint32 ch = SDL_StepBackUTF8(line, &end);
        if (ch) {
          int maxX, advance;
          if (TTF_GetGlyphMetrics(self->font, ch, NULL, &maxX, NULL, NULL, &advance)) {
            if (maxX > advance) {
              lineWidth += maxX - advance;
            }
          }
        }
 
        *w = max(*w, lineWidth);
      }
      if (h) {
        *h += font_h;
      }
    }
    free(lines);
 
    if (w) {
      *w = ceilf(*w / self->pixelDensity);
    }
    if (h) {
      *h = ceilf(*h / self->pixelDensity);
    }
  }
}

Field Documentation

bitmap

FontBitmap Font::bitmap

The glyphs of a fixed-width Font, baked into one sheet; bitmap.surface is NULL for a proportional Font.

Monospaced Fonts are bitmap fonts: Text draws a Font with a bitmap as one quad per glyph from the sheet, with no opt-in.

Definition at line 107 of file Font.h.

cacheFont

void(* cacheFont) (Data *data, const char *family)

static

Caches the specified font Data.

Parameters

data	The TTF Data.
family	The family.

Definition at line 169 of file Font.h.

data

Data* Font::data

The raw font data.

Definition at line 112 of file Font.h.

family

char* Font::family

The family name.

Definition at line 117 of file Font.h.

font

TTF_Font* Font::font

The backing font.

Definition at line 122 of file Font.h.

interface

FontInterface* Font::interface[0]

protected

The interface type.

Definition at line 99 of file Font.h.

object

Object Font::object

The superclass.

Definition at line 93 of file Font.h.

pixelDensity

float Font::pixelDensity

The display pixel density scale, greater than 1.0 on high-density displays.

Definition at line 134 of file Font.h.

renderSize

int Font::renderSize

The render size, adjusted for pixel density.

Definition at line 139 of file Font.h.

size

int Font::size

The point size.

Definition at line 144 of file Font.h.

style

int Font::style

The style.

Definition at line 149 of file Font.h.

---

The documentation for this struct was generated from the following files:

• Sources/ObjectivelyMVC/Font.h
• Sources/ObjectivelyMVC/Font+Bitmap.c
• Sources/ObjectivelyMVC/Font.c