esc

Externally Scriptable Editor

git clone git://mccd.space/esc

renderer.c (8274B)

 #include "renderer.h"
 #include <SDL3/SDL.h>
 #include <SDL3_ttf/SDL_ttf.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 
 static float col_to_screen_x(const RenderCtx *ctx, int col)
 {
 	return ctx->margin + col * ctx->char_width - ctx->scroll_x;
 }
 
 static float row_to_screen_y(const RenderCtx *ctx, int row)
 {
 	return ctx->margin + row * ctx->line_height - ctx->scroll_y;
 }
 
 static bool is_row_visible(const RenderCtx *ctx, int row)
 {
 	float y = row_to_screen_y(ctx, row);
 	return y + ctx->line_height > 0 && y < ctx->render_h;
 }
 
 static void render_selection_rect(const RenderCtx *ctx, VisualPos pos,
 				  int col_width)
 {
 	SDL_FRect rect = {col_to_screen_x(ctx, pos.col),
 			  row_to_screen_y(ctx, pos.row),
 			  (float)(col_width * ctx->char_width),
 			  ctx->cursor_height};
 	SDL_RenderFillRect(ctx->renderer, &rect);
 }
 
 static void render_selection(const RenderCtx *ctx, const Editor *ed)
 {
 	if (ed->cursor_idx == ed->selection_anchor)
 		return;
 
 	int sel_min = ed->cursor_idx < ed->selection_anchor
 			  ? ed->cursor_idx
 			  : ed->selection_anchor;
 	int sel_max = ed->cursor_idx > ed->selection_anchor
 			  ? ed->cursor_idx
 			  : ed->selection_anchor;
 
 	SDL_SetRenderDrawColor(ctx->renderer, 200, 220, 255, 255);
 
 	VisualPos cur = {0, 0};
 	const char *p = ed->text.data;
 	while (p < ed->text.data + ed->text.len) {
 		int start_of_char_idx = (int)(p - ed->text.data);
 
 		EditorRange *r =
 		    editor_get_range_at((Editor *)ed, start_of_char_idx);
 		if (r && r->type == RANGE_REPLACEMENT) {
 			if (start_of_char_idx >= sel_min &&
 			    start_of_char_idx < sel_max)
 				render_selection_rect(
 				    ctx, cur,
 				    r->data.replacement.visual_cols);
 			cur.col += r->data.replacement.visual_cols;
 			p = ed->text.data + r->end_byte;
 			if ((int)(p - ed->text.data) >= sel_max)
 				break;
 			continue;
 		}
 
 		Uint32 cp = SDL_StepUTF8(&p, NULL);
 		int cols_for_char = 1;
 		if (cp == '\t')
 			cols_for_char = TAB_SIZE - (cur.col % TAB_SIZE);
 
 		if (start_of_char_idx >= sel_min &&
 		    start_of_char_idx < sel_max)
 			render_selection_rect(ctx, cur, cols_for_char);
 
 		if (cp == '\n') {
 			cur.row++;
 			cur.col = 0;
 		} else {
 			cur.col += cols_for_char;
 		}
 
 		if ((int)(p - ed->text.data) >= sel_max)
 			break;
 	}
 }
 
 /*
  * Expand tabs to spaces in src[0..len), writing into out (which must be at
  * least len*TAB_SIZE+1 bytes).  vis_col_in is the visual column at the start
  * of the chunk.  Returns the number of bytes written (not counting the NUL).
  */
 static int expand_tabs(const char *src, size_t len, char *out, int vis_col_in)
 {
 	int vis_col = vis_col_in;
 	int out_idx = 0;
 	for (size_t j = 0; j < len; j++) {
 		if (src[j] == '\t') {
 			int spaces = TAB_SIZE - (vis_col % TAB_SIZE);
 			for (int s = 0; s < spaces; s++)
 				out[out_idx++] = ' ';
 			vis_col += spaces;
 		} else {
 			if ((src[j] & 0xC0) != 0x80)
 				vis_col++;
 			out[out_idx++] = src[j];
 		}
 	}
 	out[out_idx] = '\0';
 	return out_idx;
 }
 
 /*
  * Scan forward from rel_start within a line to where the format or a
  * replacement range begins.  Returns the exclusive end index (relative to
  * line_start).
  */
 static size_t find_chunk_end(const Editor *ed, const char *line_start,
 			     size_t rel_start, size_t line_len,
 			     RangeFormat fmt)
 {
 	size_t chunk_end = rel_start + 1;
 	while (chunk_end < line_len) {
 		size_t next_abs =
 		    (size_t)(line_start - ed->text.data) + chunk_end;
 		if (editor_get_replacement_at((Editor *)ed, (int)next_abs))
 			break;
 		RangeFormat next_fmt =
 		    editor_get_format_at((Editor *)ed, (int)next_abs);
 		if (next_fmt.bold != fmt.bold || next_fmt.italic != fmt.italic)
 			break;
 		chunk_end++;
 	}
 	return chunk_end;
 }
 
 /*
  * Blit one format-uniform run of already-expanded text.  Returns the new x
  * position (x + pixels rendered).
  */
 static float render_chunk(const RenderCtx *ctx, const char *expanded,
 			  int expanded_len, TTF_Font *font, float x, float y)
 {
 	if (expanded_len <= 0)
 		return x;
 	SDL_Color black = {0, 0, 0, 255};
 	SDL_Surface *surf =
 	    TTF_RenderText_Blended(font, expanded, expanded_len, black);
 	if (!surf)
 		return x;
 	SDL_Texture *tex = SDL_CreateTextureFromSurface(ctx->renderer, surf);
 	SDL_FRect dst = {x, y, (float)surf->w, (float)surf->h};
 	SDL_RenderTexture(ctx->renderer, tex, NULL, &dst);
 	float new_x = x + surf->w;
 	SDL_DestroyTexture(tex);
 	SDL_DestroySurface(surf);
 	return new_x;
 }
 
 /*
  * Render one line of text, splitting it into format-uniform chunks and
  * skipping over replacement ranges.
  */
 static void render_line(const RenderCtx *ctx, const Editor *ed,
 			const char *line_start, size_t line_len, float x,
 			float y)
 {
 	int vis_col = 0;
 	size_t i = 0;
 	while (i < line_len) {
 		size_t abs_idx = (size_t)(line_start - ed->text.data) + i;
 
 		EditorRange *rep =
 		    editor_get_replacement_at((Editor *)ed, (int)abs_idx);
 		if (rep) {
 			size_t range_rel_end =
 			    (size_t)(rep->end_byte -
 				     (int)(line_start - ed->text.data));
 			size_t chunk_end =
 			    range_rel_end < line_len ? range_rel_end : line_len;
 			int spaces = rep->data.replacement.visual_cols;
 			x += spaces * ctx->char_width;
 			vis_col += spaces;
 			i = chunk_end;
 			continue;
 		}
 
 		RangeFormat fmt =
 		    editor_get_format_at((Editor *)ed, (int)abs_idx);
 		size_t chunk_end =
 		    find_chunk_end(ed, line_start, i, line_len, fmt);
 		TTF_Font *active_font = fmt.bold ? ctx->bold_font : ctx->font;
 
 		size_t raw_len = chunk_end - i;
 		char *buf = malloc(raw_len * TAB_SIZE + 1);
 		int expanded_len =
 		    expand_tabs(line_start + i, raw_len, buf, vis_col);
 
 		/* Advance vis_col past this chunk. */
 		for (size_t j = i; j < chunk_end; j++) {
 			if (line_start[j] == '\t')
 				vis_col += TAB_SIZE - (vis_col % TAB_SIZE);
 			else if ((line_start[j] & 0xC0) != 0x80)
 				vis_col++;
 		}
 
 		x = render_chunk(ctx, buf, expanded_len, active_font, x, y);
 		free(buf);
 		i = chunk_end;
 	}
 }
 
 static void render_text(const RenderCtx *ctx, const Editor *ed)
 {
 	if (!ctx->font || ed->text.len == 0)
 		return;
 
 	int row = 0;
 	float current_y = ctx->margin - ctx->scroll_y;
 	const char *line_start = ed->text.data;
 	while (line_start != NULL && *line_start != '\0') {
 		const char *line_end = strchr(line_start, '\n');
 		size_t line_len = line_end ? (size_t)(line_end - line_start)
 					   : strlen(line_start);
 
 		if (is_row_visible(ctx, row)) {
 			float x = ctx->margin - ctx->scroll_x;
 			render_line(ctx, ed, line_start, line_len, x,
 				    current_y);
 		}
 
 		current_y += ctx->line_height;
 		row++;
 		line_start = line_end ? line_end + 1 : NULL;
 	}
 }
 
 static void render_cursor(const RenderCtx *ctx, const Editor *ed)
 {
 	VisualPos pos = editor_byte_to_visual_pos(ed, ed->cursor_idx);
 	float cx = col_to_screen_x(ctx, pos.col);
 	float cy = row_to_screen_y(ctx, pos.row);
 	if (cy + ctx->line_height > 0 && cy < ctx->render_h) {
 		SDL_FRect cursor_rect = {cx, cy, 2.0f, ctx->cursor_height};
 		SDL_SetRenderDrawColor(ctx->renderer, 0, 0, 0, 255);
 		SDL_RenderFillRect(ctx->renderer, &cursor_rect);
 	}
 }
 
 void render_ctx_init(RenderCtx *ctx, SDL_Renderer *renderer, TTF_Font *font,
 		     TTF_Font *bold_font, int char_width, float line_height,
 		     float cursor_height)
 {
 	ctx->renderer = renderer;
 	ctx->font = font;
 	ctx->bold_font = bold_font;
 	ctx->char_width = char_width;
 	ctx->line_height = line_height;
 	ctx->cursor_height = cursor_height;
 	ctx->scroll_x = 0.0f;
 	ctx->scroll_y = 0.0f;
 	ctx->render_w = 0;
 	ctx->render_h = 0;
 	ctx->margin = 20.0f;
 }
 
 static void render_separators(RenderCtx *ctx, const Editor *ed)
 {
 	for (int i = 0; i < ed->files_count - 1; i++) {
 		int boundary_byte = ed->files[i].buf_end;
 		VisualPos vp = editor_byte_to_visual_pos(ed, boundary_byte);
 		float y = ctx->margin + vp.row * ctx->line_height
 			  - ctx->scroll_y;
 		if (y >= 0 && y < (float)ctx->render_h) {
 			SDL_SetRenderDrawColor(ctx->renderer, 80, 80, 80, 255);
 			SDL_RenderLine(ctx->renderer, 0, y,
 				       (float)ctx->render_w, y);
 		}
 	}
 }
 
 void render_editor(RenderCtx *ctx, const Editor *ed)
 {
 	SDL_GetRenderOutputSize(ctx->renderer, &ctx->render_w, &ctx->render_h);
 	SDL_SetRenderDrawColor(ctx->renderer, 255, 255, 255, 255);
 	SDL_RenderClear(ctx->renderer);
 	render_selection(ctx, ed);
 	render_separators(ctx, ed);
 	render_text(ctx, ed);
 	render_cursor(ctx, ed);
 	SDL_RenderPresent(ctx->renderer);
 }