Text.c File Reference

#include <assert.h>
#include <math.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "Colors.h"
#include "Text.h"
#include "Theme.h"

Go to the source code of this file.

Data Structures
struct	LayoutBuffer
	A growable string for MVC_LayoutText. More...

Macros
#define	_Class   _Text
#define	_GNU_SOURCE

Functions
Class *	_Text (void)
static void	append (LayoutBuffer *buffer, const char *chars, size_t length)
static void	appendRuns (Text *self, TTF_Text *layout, const TextSpan *span, int surfaceWidth)
	Appends the runs for one TextSpan of layout: one color run per line the span touches, or a single icon run positioned by the span's first line.
static void	appendSpan (TextSpan **spans, size_t *count, TextSpan span)
static void	applyStyle (View *self, const Style *style)
static void	applyTransform (Text *self)
	Rebuilds transformed from text and transform. Color escapes pass through without counting as letters, and icon escapes that resolve against the window's Theme are copied verbatim, since icon names are case sensitive.
static void	awakeWithDictionary (View *self, const Dictionary *dictionary)
static void	buildRuns (Text *self, const char *layoutText, const TextSpan *spans, size_t count, int wrapWidth, int surfaceWidth)
	Builds this Text's runs for its rendered texture: the texture is rendered from the layout string in white, so each color run is a region of it drawn in the color in effect for those characters, and each icon run is the placeholder region an icon is drawn over. The layout is SDL_ttf's own, so the regions are exact glyph clusters, including where wrapping broke the lines.
static void	checkIcons (Text *self)
	Invalidates this Text if the icon atlas it was prepared against has changed: a Theme swap, attaching to a window, or an icon registered since. Sets needsLayout when it does, since the natural size may have changed.
static size_t	colorEscapeLength (const char *chars)
	Length of the color escape at chars, or 0 if there is none: ^N selects a color, ^^ is a literal caret.
static void	dealloc (Object *self)
static String *	description (const Object *self)
static void	didMoveToWindow (View *self, SDL_Window *window)
static const char *	displayText (const Text *self)
static bool	hasEscapes (const char *text)
static const char *	iconPlaceholder (const Font *font)
	The placeholder an icon occupies in font's layout: a codepoint that is not a line-break opportunity, repeated until it is at least a line height wide. Resolved once per Font, on first use.
static ImageAtlas *	iconsFor (const Text *self)
static View *	init (View *self)
static void	initialize (Class *clazz)
static Text *	initWithText (Text *self, const char *text, Font *font)
static void	invalidate (Text *self)
	Releases this Text's rendered texture and runs, and invalidates its cached size.
bool	MVC_HasColorEscapes (const char *text)
size_t	MVC_IconEscapeLength (const char *chars, const ImageAtlas *icons, AtlasImage **image)
	Parses an icon escape at the start of chars: :name:, where name is one or more of [A-Za-z0-9_-] and under 64 bytes, and is registered in icons. An unregistered name is not an escape, so 12:30:45 stays literal unless someone registers an icon called 30.
char *	MVC_LayoutText (const Font *font, const char *text, SDL_Color color, const ImageAtlas *icons, TextSpan **spans, size_t *count)
	Resolves the escapes in text into the string to lay out and the spans to draw it as.
char *	MVC_StripColorEscapes (const char *text)
	Strips color escape sequences from the given text: ^0 through ^9 are removed, and ^^ collapses to ^.
static SDL_Size	naturalSize (const Text *self)
static void	refreshFont (Text *self)
	Re-resolves this Text's Font at the current window's pixel density. Shared by didMoveToWindow and renderDeviceDidReset, rather than the latter dispatching through the public didMoveToWindow, which would re-trigger View's own attachment side effects.
static void	render (View *self, Renderer *renderer)
static void	renderDeviceDidReset (View *self)
static void	renderDeviceWillReset (View *self)
static void	resolveFont (Text *self, const FontAttributes *attributes)
	Resolves and applies the Font with the given attributes: through the window's Theme when attached, which supplies the window's pixel density, or at a density of 1.0 otherwise, to be re-resolved on attachment via View::didMoveToWindow. The cache's reference is retained to mirror the owned reference the fallback returns.
static void	setFont (Text *self, Font *font)
static void	setText (Text *self, const char *text)
static void	setTextWithFormat (Text *self, const char *fmt,...)
static void	setTransform (Text *self, TextTransform transform)
static SDL_Size	sizeText (const Text *self, const char *text)
static SDL_Size	sizeThatFits (const View *self)

Variables
SDL_Color	TextEscapeColors []
const EnumName	TextTransformNames []

Macro Definition Documentation

_Class

#define _Class   _Text

Definition at line 37 of file Text.c.

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 24 of file Text.c.

Function Documentation

_Text()

Class * _Text

(

void

)

Definition at line 988 of file Text.c.

                   {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "Text",
      .superclass = _View(),
      .instanceSize = sizeof(Text),
      .interfaceSize = sizeof(TextInterface),
      .initialize = initialize,
    });
  });
 
  return clazz;
}

append()

static void append ( LayoutBuffer *  buffer, const char *  chars, size_t  length  )

static

Definition at line 150 of file Text.c.

                                                                           {
 
  if (buffer->length + length + 1 > buffer->capacity) {
    buffer->capacity = max(buffer->capacity * 2, buffer->length + length + 1);
    buffer->chars = realloc(buffer->chars, buffer->capacity);
    assert(buffer->chars);
  }
 
  memcpy(buffer->chars + buffer->length, chars, length);
  buffer->length += length;
  buffer->chars[buffer->length] = '\0';
}

appendRuns()

static void appendRuns ( Text *  self, TTF_Text *  layout, const TextSpan *  span, int  surfaceWidth  )

static

Appends the runs for one TextSpan of layout: one color run per line the span touches, or a single icon run positioned by the span's first line.

Definition at line 400 of file Text.c.

                                                                                             {
 
  int count = 0;
  TTF_SubString **substrings = TTF_GetTextSubStringsForRange(layout, span->offset, span->length, &count);
  assert(substrings);
 
  if (count == 0) {
    SDL_free(substrings);
    return;
  }
 
  TextRun *runs = realloc(self->runs, (self->runCount + count) * sizeof(TextRun));
  assert(runs);
  self->runs = runs;
 
  if (span->icon) {
    // The placeholder is one word, so it only splits when the wrap width is narrower than a
    // line height; the icon stays where the escape is, in the first fragment, and is clamped
    // to it when drawn
    self->runs[self->runCount++] = (TextRun) { substrings[0]->rect, Colors.White, retain(span->icon) };
    SDL_free(substrings);
    return;
  }
 
  for (int i = 0; i < count; i++) {
    SDL_Rect rect = substrings[i]->rect;
 
    // A cluster's rect is its advance box; the last glyph on a line can ink past it, and the
    // surface is sized to include that, so let the line's last run reach the surface's edge
    if (substrings[i]->flags & TTF_SUBSTRING_LINE_END) {
      rect.w = surfaceWidth - rect.x;
    }
 
    self->runs[self->runCount++] = (TextRun) { rect, span->color, NULL };
  }
 
  SDL_free(substrings);
}

appendSpan()

static void appendSpan ( TextSpan **  spans, size_t *  count, TextSpan  span  )

static

Definition at line 207 of file Text.c.

                                                                       {
 
  if (spans == NULL) {
    return;
  }
 
  TextSpan *grown = realloc(*spans, (*count + 1) * sizeof(TextSpan));
  assert(grown);
 
  *spans = grown;
  (*spans)[(*count)++] = span;
}

applyStyle()

static void applyStyle ( View *  self, const Style *  style  )

static

See also

View::applyStyle(View *, const Style *)

Definition at line 534 of file Text.c.

                                                       {
 
  super(View, self, applyStyle, style);
 
  Text *this = (Text *) self;
 
  const Inlet colorInlets[] = MakeInlets(
    MakeInlet("color", InletTypeColor, &this->color, NULL)
  );
 
  if ($(self, bind, colorInlets, style->attributes)) {
    invalidate(this);
  }
 
  int transform = -1;
 
  const Inlet transformInlets[] = MakeInlets(
    MakeInlet("text-transform", InletTypeEnum, &transform, (ident) TextTransformNames)
  );
 
  $(self, bind, transformInlets, style->attributes);
 
  $(this, setTransform, transform < 0 ? TextTransformNone : (TextTransform) transform);
 
  char *fontFamily = NULL;
  int fontSize = -1, fontStyle = -1;
 
  const Inlet fontInlets[] = MakeInlets(
    MakeInlet("font-family", InletTypeCharacters, &fontFamily, NULL),
    MakeInlet("font-size", InletTypeInteger, &fontSize, NULL),
    MakeInlet("font-style", InletTypeEnum, &fontStyle, (ident) FontStyleNames)
  );
 
  if ($(self, bind, fontInlets, style->attributes)) {
 
    const FontAttributes attributes = { fontFamily, fontSize, fontStyle };
    resolveFont(this, &attributes);
 
    if (fontFamily) {
      free(fontFamily);
    }
  }
}

applyTransform()

static void applyTransform ( Text *  self )

static

Rebuilds transformed from text and transform. Color escapes pass through without counting as letters, and icon escapes that resolve against the window's Theme are copied verbatim, since icon names are case sensitive.

Definition at line 311 of file Text.c.

                                       {
 
  free(self->transformed);
  self->transformed = NULL;
 
  if (self->transform == TextTransformNone || self->text == NULL) {
    return;
  }
 
  self->transformed = strdup(self->text);
  assert(self->transformed);
 
  const ImageAtlas *icons = iconsFor(self);
 
  bool wordStart = true;
  for (char *c = self->transformed; *c; c++) {
 
    if (colorEscapeLength(c)) {
      c++;
      continue;
    }
 
    if (*c == ':') {
      const size_t length = MVC_IconEscapeLength(c, icons, NULL);
      if (length) {
        c += length - 1;
        continue;
      }
    }
 
    const unsigned char uc = (unsigned char) *c;
 
    if ((uc & 0x80u) == 0) {
      switch (self->transform) {
        case TextTransformUppercase:
          *c = (char) SDL_toupper(uc);
          break;
        case TextTransformLowercase:
          *c = (char) SDL_tolower(uc);
          break;
        case TextTransformCapitalize:
          *c = (char) (wordStart ? SDL_toupper(uc) : SDL_tolower(uc));
          break;
        default:
          break;
      }
    }
 
    wordStart = SDL_isspace((unsigned char) *c) != 0;
  }
}

awakeWithDictionary()

static void awakeWithDictionary ( View *  self, const Dictionary *  dictionary  )

static

See also

View::awakeWithDictionary(View *, const Dictionary *)

Definition at line 581 of file Text.c.

                                                                          {
 
  super(View, self, awakeWithDictionary, dictionary);
 
  Text *this = (Text *) self;
 
  int transform = this->transform;
 
  const Inlet inlets[] = MakeInlets(
    MakeInlet("color", InletTypeColor, &this->color, NULL),
    MakeInlet("lineWrap", InletTypeBool, &this->lineWrap, NULL),
    MakeInlet("text", InletTypeCharacters, &this->text, NULL),
    MakeInlet("textTransform", InletTypeEnum, &transform, (ident) TextTransformNames)
  );
 
  $(self, bind, inlets, dictionary);
 
  this->transform = (TextTransform) transform;
 
  applyTransform(this);
  invalidate(this);
 
  $(self, sizeToFit);
}

buildRuns()

static void buildRuns ( Text *  self, const char *  layoutText, const TextSpan *  spans, size_t  count, int  wrapWidth, int  surfaceWidth  )

static

Builds this Text's runs for its rendered texture: the texture is rendered from the layout string in white, so each color run is a region of it drawn in the color in effect for those characters, and each icon run is the placeholder region an icon is drawn over. The layout is SDL_ttf's own, so the regions are exact glyph clusters, including where wrapping broke the lines.

Remarks

A cluster's rect is its advance box: ink that overhangs a run boundary within a line (italics, tight kerning) is clipped to whichever run owns that column.

Definition at line 448 of file Text.c.

                                                                                                                                {
 
  assert(self->runs == NULL);
 
  TTF_Text *layout = TTF_CreateText(NULL, self->font->font, layoutText, 0);
  assert(layout);
 
  TTF_SetTextWrapWidth(layout, (int) (wrapWidth * self->font->pixelDensity));
 
  for (size_t i = 0; i < count; i++) {
    appendRuns(self, layout, &spans[i], surfaceWidth);
  }
 
  TTF_DestroyText(layout);
}

checkIcons()

static void checkIcons ( Text *  self )

static

Invalidates this Text if the icon atlas it was prepared against has changed: a Theme swap, attaching to a window, or an icon registered since. Sets needsLayout when it does, since the natural size may have changed.

Definition at line 368 of file Text.c.

                                   {
 
  const ImageAtlas *icons = iconsFor(self);
  const unsigned generation = icons ? icons->generation : 0;
 
  if (icons != self->icons.atlas || generation != self->icons.generation) {
    invalidate(self);
    self->icons.atlas = icons;
    self->icons.generation = generation;
    applyTransform(self);
    $((View *) self, setNeedsLayout);
  }
}

colorEscapeLength()

static size_t colorEscapeLength ( const char *  chars )

static

Length of the color escape at chars, or 0 if there is none: ^N selects a color, ^^ is a literal caret.

Definition at line 58 of file Text.c.

                                                   {
  if (chars[0] == '^' && ((chars[1] >= '0' && chars[1] <= '9') || chars[1] == '^')) {
    return 2;
  }
  return 0;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 495 of file Text.c.

                                  {
 
  Text *this = (Text *) self;
 
  invalidate(this);
 
  release(this->font);
 
  free(this->text);
  free(this->transformed);
 
  super(Object, self, dealloc);
}

description()

static String * description ( const Object *  self )

static

See also

Object::description(const Object *)

Definition at line 512 of file Text.c.

                                               {
 
  View *this = (View *) self;
  const SDL_Rect bounds = $(this, bounds);
 
  String *classNames = $((Object *) this->classNames, description);
  String *description = str("%s@%p \"%s\" %s [%d, %d, %d, %d]",
                this->identifier ?: classnameof(self),
                self,
                displayText((Text *) self) ?: "",
                classNames->chars,
                bounds.x, bounds.y, bounds.w, bounds.h);
 
  release(classNames);
  return description;
}

didMoveToWindow()

static void didMoveToWindow ( View *  self, SDL_Window *  window  )

static

See also

View::didMoveToWindow(View *, SDL_Window *)

Definition at line 624 of file Text.c.

                                                            {
 
  super(View, self, didMoveToWindow, window);
 
  // Nothing to resolve or size when detaching, and View::dealloc detaches after Text::dealloc has
  // already released the Font, so touching it here would be a use-after-free
  if (window) {
 
    refreshFont((Text *) self);
 
    // Icons resolve through the window's Theme; sizing re-prepares against it (see checkIcons)
    $(self, sizeToFit);
  }
}

displayText()

static const char * displayText ( const Text *  self )

static

Returns

The string this Text draws and measures: transformed when a transform is set.

Definition at line 385 of file Text.c.

                                                 {
  return self->transformed ?: self->text;
}

hasEscapes()

static bool hasEscapes ( const char *  text )

static

Returns

True if text contains anything MVC_LayoutText might resolve: a caret or a colon.

Definition at line 392 of file Text.c.

                                         {
  return MVC_HasColorEscapes(text) || strchr(text, ':') != NULL;
}

iconPlaceholder()

static const char * iconPlaceholder ( const Font *  font )

static

The placeholder an icon occupies in font's layout: a codepoint that is not a line-break opportunity, repeated until it is at least a line height wide. Resolved once per Font, on first use.

Measured with TTF_GetStringSize, the same engine that lays out and renders the text, rather than glyph metrics: Coda has no U+00A0, and shaping substitutes the space glyph for it at the space's advance, where the glyph metrics would report .notdef's.

Definition at line 171 of file Text.c.

                                                     {
 
  if (font->iconPlaceholder) {
    return font->iconPlaceholder;
  }
 
  static const Uint32 candidates[] = { 0x00A0, 0x2007, '_' };
 
  Uint32 codepoint = candidates[lengthof(candidates) - 1];
  for (size_t i = 0; i < lengthof(candidates); i++) {
    if (TTF_FontHasGlyph(font->font, candidates[i])) {
      codepoint = candidates[i];
      break;
    }
  }
 
  char utf8[5] = { 0 };
  SDL_UCS4ToUTF8(codepoint, utf8);
 
  const int lineHeight = TTF_GetFontHeight(font->font);
 
  LayoutBuffer placeholder = { 0 };
 
  for (int i = 0, width = 0; i < 16 && width < lineHeight; i++) {
    append(&placeholder, utf8, strlen(utf8));
    if (!TTF_GetStringSize(font->font, placeholder.chars, 0, &width, NULL)) {
      break;
    }
  }
 
  // A lazily resolved cache on an otherwise immutable Font, like its bitmap's Texture
  ((Font *) font)->iconPlaceholder = placeholder.chars;
 
  return font->iconPlaceholder;
}

iconsFor()

static ImageAtlas * iconsFor ( const Text *  self )

static

Returns

The icon ImageAtlas of this Text's window's Theme, or NULL when detached.

Definition at line 297 of file Text.c.

                                              {
 
  const View *view = (View *) self;
 
  Theme *theme = view->window ? $$(Theme, theme, view->window) : NULL;
 
  return theme ? $(theme, icons) : NULL;
}

init()

static View * init ( View *  self )

static

See also

View::init(View *)

Definition at line 642 of file Text.c.

                              {
  return (View *) $((Text *) self, initWithText, NULL, NULL);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 961 of file Text.c.

                                     {
 
  ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
  ((ObjectInterface *) clazz->interface)->description = description;
 
  ((ViewInterface *) clazz->interface)->applyStyle = applyStyle;
  ((ViewInterface *) clazz->interface)->awakeWithDictionary = awakeWithDictionary;
  ((ViewInterface *) clazz->interface)->didMoveToWindow = didMoveToWindow;
  ((ViewInterface *) clazz->interface)->init = init;
  ((ViewInterface *) clazz->interface)->render = render;
  ((ViewInterface *) clazz->interface)->renderDeviceDidReset = renderDeviceDidReset;
  ((ViewInterface *) clazz->interface)->renderDeviceWillReset = renderDeviceWillReset;
  ((ViewInterface *) clazz->interface)->sizeThatFits = sizeThatFits;
 
  ((TextInterface *) clazz->interface)->initWithText = initWithText;
  ((TextInterface *) clazz->interface)->naturalSize = naturalSize;
  ((TextInterface *) clazz->interface)->setFont = setFont;
  ((TextInterface *) clazz->interface)->setText = setText;
  ((TextInterface *) clazz->interface)->setTextWithFormat = setTextWithFormat;
  ((TextInterface *) clazz->interface)->setTransform = setTransform;
  ((TextInterface *) clazz->interface)->sizeText = sizeText;
}

initWithText()

static Text * initWithText ( Text *  self, const char *  text, Font *  font  )

static

Definition at line 808 of file Text.c.

                                                                    {
 
  self = (Text *) super(View, self, initWithFrame, NULL);
  if (self) {
    $(self, setFont, font);
    $(self, setText, text);
  }
 
  return self;
}

invalidate()

static void invalidate ( Text *  self )

static

Releases this Text's rendered texture and runs, and invalidates its cached size.

Definition at line 279 of file Text.c.

                                   {
 
  self->texture = release(self->texture);
 
  for (size_t i = 0; i < self->runCount; i++) {
    release(self->runs[i].icon);
  }
 
  free(self->runs);
  self->runs = NULL;
  self->runCount = 0;
 
  self->naturalSizeCache.isValid = false;
}

MVC_HasColorEscapes()

bool MVC_HasColorEscapes

(

const char *

text

)

Parameters

text	The text, or NULL.

Returns

True if text contains a color escape (^0 through ^9, or ^^).

Definition at line 65 of file Text.c.

                                           {
 
  for (const char *p = text ? strchr(text, '^') : NULL; p; p = strchr(p + 1, '^')) {
    if (colorEscapeLength(p)) {
      return true;
    }
  }
 
  return false;
}

MVC_IconEscapeLength()

size_t MVC_IconEscapeLength	(	const char *	chars,
		const ImageAtlas *	icons,
		AtlasImage **	image
	)

Parses an icon escape at the start of chars: :name:, where name is one or more of [A-Za-z0-9_-] and under 64 bytes, and is registered in icons. An unregistered name is not an escape, so 12:30:45 stays literal unless someone registers an icon called 30.

Parameters

chars	The text, positioned at a candidate :.
icons	The icon ImageAtlas, or NULL for none.
image	If not NULL, receives the icon, or NULL.

Returns

The byte length of the escape, or 0 if chars does not start with one.

Definition at line 104 of file Text.c.

                                                                                            {
 
  if (image) {
    *image = NULL;
  }
 
  if (chars == NULL || icons == NULL || chars[0] != ':') {
    return 0;
  }
 
  const char *q = chars + 1;
  while (SDL_isalnum((unsigned char) *q) || *q == '_' || *q == '-') {
    q++;
  }
 
  char name[64];
  const size_t len = q - chars - 1;
 
  if (*q != ':' || len == 0 || len >= sizeof(name)) {
    return 0;
  }
 
  memcpy(name, chars + 1, len);
  name[len] = '\0';
 
  AtlasImage *icon = $(icons, imageWithName, name);
  if (icon == NULL) {
    return 0;
  }
 
  if (image) {
    *image = icon;
  }
 
  return len + 2;
}

MVC_LayoutText()

char * MVC_LayoutText	(	const Font *	font,
		const char *	text,
		SDL_Color	color,
		const ImageAtlas *	icons,
		TextSpan **	spans,
		size_t *	count
	)

Resolves the escapes in text into the string to lay out and the spans to draw it as.

^N selects a color for what follows, ^^ becomes ^, and a registered :icon: becomes a run of placeholder characters at least a line height wide, for the icon to be drawn over. The placeholder is never a line-break opportunity, so an icon stays with its word. With no icons, and spans NULL, the result is that of MVC_StripColorEscapes.

Parameters

font	The Font the text will be laid out in.
text	The text.
color	The color in effect at the start of text.
icons	The icon ImageAtlas, or NULL for none.
spans	If not NULL, receives the spans, which the caller MUST free.
count	If not NULL, receives the number of spans; meaningful only with spans.

Returns

The layout string, which the caller MUST free.

Definition at line 220 of file Text.c.

                                                                                                                                    {
 
  assert(font);
  assert(text);
 
  LayoutBuffer layout = { 0 };
  append(&layout, "", 0);
 
  size_t n = 0;
  if (spans) {
    *spans = NULL;
  }
 
  size_t start = 0;
 
  for (const char *p = text; ; ) {
 
    const bool end = *p == '\0';
    const bool escape = !end && p[0] == '^' && p[1] >= '0' && p[1] <= '9';
 
    AtlasImage *icon = NULL;
    const size_t iconLength = (!end && *p == ':') ? MVC_IconEscapeLength(p, icons, &icon) : 0;
 
    if (end || escape || iconLength) {
      if (layout.length > start) {
        appendSpan(spans, &n, (TextSpan) { (int) start, (int) (layout.length - start), color, NULL });
      }
      if (end) {
        break;
      }
      if (escape) {
        color = TextEscapeColors[p[1] - '0'];
        p += 2;
      } else {
        const char *placeholder = iconPlaceholder(font);
        appendSpan(spans, &n, (TextSpan) { (int) layout.length, (int) strlen(placeholder), Colors.White, icon });
        append(&layout, placeholder, strlen(placeholder));
        p += iconLength;
      }
      start = layout.length;
    } else if (p[0] == '^' && p[1] == '^') {
      append(&layout, "^", 1);
      p += 2;
    } else {
      append(&layout, p, 1);
      p++;
    }
  }
 
  if (count) {
    *count = n;
  }
 
  return layout.chars;
}

MVC_StripColorEscapes()

char * MVC_StripColorEscapes

(

const char *

text

)

Strips color escape sequences from the given text: ^0 through ^9 are removed, and ^^ collapses to ^.

Parameters

text

The text.

Returns

A newly allocated copy of text without escape sequences. The caller must free it.

Definition at line 83 of file Text.c.

                                              {
 
  assert(text);
 
  char *stripped = malloc(strlen(text) + 1);
  size_t idx = 0;
 
  for (const char *p = text; *p; p++) {
    if (p[0] == '^' && p[1] >= '0' && p[1] <= '9') {
      p++;
    } else if (p[0] == '^' && p[1] == '^') {
      stripped[idx++] = *p++;
    } else {
      stripped[idx++] = *p;
    }
  }
 
  stripped[idx] = '\0';
  return stripped;
}

naturalSize()

static SDL_Size naturalSize ( const Text *  self )

static

Definition at line 823 of file Text.c.

                                              {
 
  Font *font = self->font;
  if (font == NULL) {
    return MakeSize(0, 0);
  }
 
  // Nominally const, but a changed icon atlas invalidates the texture and runs here. Safe only
  // because layout precedes drawing within a frame and the Renderer keeps unretained Textures.
  Text *this = (Text *) self;
 
  checkIcons(this);
 
  if (self->naturalSizeCache.isValid && font->pixelDensity == self->naturalSizeCache.pixelDensity) {
    return self->naturalSizeCache.size;
  }
 
  const SDL_Size size = $(self, sizeText, displayText(self) ?: "");
 
  this->naturalSizeCache.size = size;
  this->naturalSizeCache.pixelDensity = font->pixelDensity;
  this->naturalSizeCache.isValid = true;
 
  return size;
}

refreshFont()

static void refreshFont ( Text *  self )

static

Re-resolves this Text's Font at the current window's pixel density. Shared by didMoveToWindow and renderDeviceDidReset, rather than the latter dispatching through the public didMoveToWindow, which would re-trigger View's own attachment side effects.

Definition at line 611 of file Text.c.

                                    {
 
  const View *view = (View *) self;
 
  if (view->window && self->font) {
    const FontAttributes attributes = { self->font->family, self->font->size, self->font->style };
    resolveFont(self, &attributes);
  }
}

render()

static void render ( View *  self, Renderer *  renderer  )

static

See also

View::render(View *, Renderer *)

Definition at line 649 of file Text.c.

                                                   {
 
  super(View, self, render, renderer);
 
  Text *this = (Text *) self;
 
  assert(this->font);
 
  const float scale = this->font->pixelDensity;
 
  if (this->text) {
 
    checkIcons(this);
 
    const char *text = displayText(this);
 
    const SDL_Rect frame = $(self, renderFrame);
 
    const int wrapWidth = this->lineWrap ? frame.w : 0;
 
    if (this->font->bitmap.surface) {
      $(this->font, renderBitmapCharacters, renderer, text, this->color, wrapWidth,
        &(const SDL_Point) { frame.x, frame.y }, this->icons.atlas);
      return;
    }
 
    if (this->texture == NULL) {
      SDL_Surface *surface = NULL;
 
      if (hasEscapes(text)) {
        TextSpan *spans = NULL;
        size_t count = 0;
 
        char *layout = MVC_LayoutText(this->font, text, this->color, this->icons.atlas, &spans, &count);
 
        // A colon or caret that resolved to nothing -- "Health: 100", a URL -- is plain text,
        // and takes the single-quad path rather than a run per line
        bool plain = true;
        for (size_t i = 0; i < count && plain; i++) {
          plain = spans[i].icon == NULL && SDL_memcmp(&spans[i].color, &this->color, sizeof(SDL_Color)) == 0;
        }
 
        // Text that is nothing but escapes has nothing to draw
        if (*layout && plain) {
          surface = $(this->font, renderCharacters, layout, this->color, wrapWidth);
        } else if (*layout) {
          surface = $(this->font, renderCharacters, layout, Colors.White, wrapWidth);
          assert(surface);
          buildRuns(this, layout, spans, count, wrapWidth, surface->w);
        }
 
        free(spans);
        free(layout);
 
        if (surface == NULL) {
          return;
        }
      } else {
        surface = $(this->font, renderCharacters, text, this->color, wrapWidth);
      }
 
      assert(surface);
 
      const SDL_GPUTextureCreateInfo texInfo = {
        .type                 = SDL_GPU_TEXTURETYPE_2D,
        .format               = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM,
        .usage                = SDL_GPU_TEXTUREUSAGE_SAMPLER,
        .width                = (Uint32) surface->w,
        .height               = (Uint32) surface->h,
        .layer_count_or_depth = 1,
        .num_levels           = 1,
      };
 
      this->texture = $(renderer->device, createTexture, &texInfo, surface->pixels);
 
      SDL_DestroySurface(surface);
    }
 
    assert(this->texture);
 
    // The destination size must be the texture's exact native size divided by scale, not that
    // rounded to an integer: rounding it first, then having the renderer's projection
    // multiply back by scale to reach physical pixels, lands on a physical width that differs
    // from the texture's actual resolution -- stretching it by that (sub-)pixel remainder. Since
    // the remainder depends on the string's own pixel width, this stretch changes with every
    // keystroke, visibly shifting every glyph in the string, not just the one that was typed.
 
    if (this->runs) {
      const int lineHeight = TTF_GetFontHeight(this->font->font);
 
      for (size_t i = 0; i < this->runCount; i++) {
        const TextRun *run = &this->runs[i];
 
        if (run->icon) {
          // Drawn from the icon atlas, not this Text's texture, so an icon splits the Renderer's
          // merged draw; centered in its placeholder, which is at least a line height wide
          if (run->icon->atlas) {
            const int side = min(lineHeight, run->src.w);
            const SDL_FRect dest = {
              frame.x + (run->src.x + (run->src.w - side) / 2) / scale, frame.y + run->src.y / scale,
              side / scale, side / scale
            };
            Texture *texture = $(run->icon->atlas, texture, renderer->device);
            $(renderer, drawTextureRegion, texture, &run->icon->rect, &dest, &Colors.White);
          }
          continue;
        }
 
        const SDL_FRect dest = {
          frame.x + run->src.x / scale, frame.y + run->src.y / scale,
          run->src.w / scale, run->src.h / scale
        };
        $(renderer, drawTextureRegion, this->texture, &run->src, &dest, &run->color);
      }
    } else {
      const SDL_FRect dest = {
        (float) frame.x, (float) frame.y,
        this->texture->size.w / scale, this->texture->size.h / scale
      };
      $(renderer, drawTexture, this->texture, &dest, &Colors.White);
    }
  }
}

renderDeviceDidReset()

static void renderDeviceDidReset ( View *  self )

static

See also

View::renderDeviceDidReset(View *)

Definition at line 776 of file Text.c.

                                             {
 
  refreshFont((Text *) self);
 
  $(self, sizeToFit);
 
  super(View, self, renderDeviceDidReset);
}

renderDeviceWillReset()

static void renderDeviceWillReset ( View *  self )

static

See also

View::renderDeviceWillReset(View *)

Definition at line 788 of file Text.c.

                                              {
 
  invalidate((Text *) self);
 
  super(View, self, renderDeviceWillReset);
}

resolveFont()

static void resolveFont ( Text *  self, const FontAttributes *  attributes  )

static

Resolves and applies the Font with the given attributes: through the window's Theme when attached, which supplies the window's pixel density, or at a density of 1.0 otherwise, to be re-resolved on attachment via View::didMoveToWindow. The cache's reference is retained to mirror the owned reference the fallback returns.

Definition at line 470 of file Text.c.

                                                                      {
 
  View *view = (View *) self;
 
  Theme *theme = view->window ? $$(Theme, theme, view->window) : NULL;
 
  Font *font;
  if (theme) {
    const float pixelDensity = SDL_GetWindowPixelDensity(view->window);
    font = retain($(theme, font, attributes, pixelDensity));
  } else {
    font = $$(Font, fontWithAttributes, attributes, 1.f);
  }
 
  assert(font);
 
  $(self, setFont, font);
  release(font);
}

setFont()

static void setFont ( Text *  self, Font *  font  )

static

Definition at line 880 of file Text.c.

                                            {
 
  font = font ?: $$(Font, defaultFont);
 
  if (font != self->font) {
 
    release(self->font);
    self->font = retain(font);
 
    invalidate(self);
 
    $((View *) self, sizeToFit);
  }
}

setText()

static void setText ( Text *  self, const char *  text  )

static

Definition at line 899 of file Text.c.

                                                  {
 
  if (strcmp(self->text ?: "", text ?: "")) {
 
    free(self->text);
 
    if (text && strlen(text)) {
      self->text = strdup(text);
    } else {
      self->text = NULL;
    }
 
    applyTransform(self);
    invalidate(self);
 
    $((View *) self, sizeToFit);
  }
}

setTextWithFormat()

static void setTextWithFormat ( Text *  self, const char *  fmt,   ...  )

static

Definition at line 925 of file Text.c.

                                                                {
 
  va_list args;
  va_start(args, fmt);
 
  char *text;
  const int len = vasprintf(&text, fmt, args);
  if (len >= 0) {
    $(self, setText, text);
  }
 
  free(text);
  va_end(args);
}

setTransform()

static void setTransform ( Text *  self, TextTransform  transform  )

static

Definition at line 944 of file Text.c.

                                                              {
 
  if (transform != self->transform) {
    self->transform = transform;
 
    applyTransform(self);
    invalidate(self);
 
    $((View *) self, sizeToFit);
  }
}

sizeText()

static SDL_Size sizeText ( const Text *  self, const char *  text  )

static

Definition at line 853 of file Text.c.

                                                             {
 
  SDL_Size size = MakeSize(0, 0);
 
  if (self->font == NULL || text == NULL) {
    return size;
  }
 
  const ImageAtlas *icons = iconsFor(self);
 
  if (self->font->bitmap.surface) {
    $(self->font, sizeBitmapCharacters, text, 0, icons, &size.w, &size.h);
  } else if (hasEscapes(text)) {
    char *layout = MVC_LayoutText(self->font, text, self->color, icons, NULL, NULL);
    $(self->font, sizeCharacters, layout, &size.w, &size.h);
    free(layout);
  } else {
    $(self->font, sizeCharacters, text, &size.w, &size.h);
  }
 
  return size;
}

sizeThatFits()

static SDL_Size sizeThatFits ( const View *  self )

static

See also

View::sizeThatFits(View *)

Definition at line 798 of file Text.c.

                                               {
  return $((Text *) self, naturalSize);
}

Variable Documentation

TextEscapeColors

SDL_Color TextEscapeColors[]

Initial value:

= {
  { 0x00, 0x00, 0x00, 0xFF },  
  { 0xFF, 0x00, 0x00, 0xFF },  
  { 0x00, 0xFF, 0x00, 0xFF },  
  { 0xFF, 0xFF, 0x00, 0xFF },  
  { 0x00, 0x00, 0xFF, 0xFF },  
  { 0xFF, 0x00, 0xFF, 0xFF },  
  { 0x00, 0xFF, 0xFF, 0xFF },  
  { 0xFF, 0xFF, 0xFF, 0xFF },  
  { 0xFF, 0x80, 0x00, 0xFF },  
  { 0x80, 0x80, 0x80, 0xFF }   
}

Definition at line 41 of file Text.c.

                               {
  { 0x00, 0x00, 0x00, 0xFF },  // ^0 Black
  { 0xFF, 0x00, 0x00, 0xFF },  // ^1 Red
  { 0x00, 0xFF, 0x00, 0xFF },  // ^2 Green
  { 0xFF, 0xFF, 0x00, 0xFF },  // ^3 Yellow
  { 0x00, 0x00, 0xFF, 0xFF },  // ^4 Blue
  { 0xFF, 0x00, 0xFF, 0xFF },  // ^5 Magenta
  { 0x00, 0xFF, 0xFF, 0xFF },  // ^6 Cyan
  { 0xFF, 0xFF, 0xFF, 0xFF },  // ^7 White
  { 0xFF, 0x80, 0x00, 0xFF },  // ^8 Orange
  { 0x80, 0x80, 0x80, 0xFF }   // ^9 Grey
};

TextTransformNames

const EnumName TextTransformNames[]

Initial value:

= MakeEnumNames(
  MakeEnumAlias(TextTransformNone, none),
  MakeEnumAlias(TextTransformUppercase, uppercase),
  MakeEnumAlias(TextTransformLowercase, lowercase),
  MakeEnumAlias(TextTransformCapitalize, capitalize)
)

Definition at line 76 of file Text.c.