ltk

text_pango.c (11307B)

---

 /*
  * Copyright (c) 2021-2023 lumidify <nobody@lumidify.org>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdarg.h>
 
 #include <X11/Xos.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include <pango/pangoxft.h>
 #include <pango/pango-utils.h> /* for PANGO_VERSION_CHECK */
 
 #include "xlib_shared.h"
 #include "memory.h"
 #include "color.h"
 #include "rect.h"
 #include "widget.h"
 #include "ltk.h"
 #include "util.h"
 #include "text.h"
 
 struct ltk_text_line {
 	ltk_text_context *ctx;
 	char *text;
 	size_t len;
 	PangoLayout *layout;
 	uint16_t font_size;
 	PangoAttrList *attrs;
 };
 
 struct ltk_text_context {
 	ltk_renderdata *data;
 	PangoFontMap *fontmap;
 	PangoContext *context;
 	char *default_font;
 };
 
 ltk_text_context *
 ltk_text_context_create(ltk_renderdata *data, char *default_font) {
 	ltk_text_context *ctx = ltk_malloc(sizeof(ltk_text_context));
 	ctx->data = data;
 	ctx->fontmap = pango_xft_get_font_map(data->dpy, data->screen);
 	ctx->context = pango_font_map_create_context(ctx->fontmap);
 	ctx->default_font = ltk_strdup(default_font);
 	return ctx;
 }
 
 void
 ltk_text_context_destroy(ltk_text_context *ctx) {
 	ltk_free(ctx->default_font);
 	/* FIXME: if both are unref'd, there is a segfault - what is
 	   the normal thing to do here? */
 	g_object_unref(ctx->fontmap);
 	/*g_object_unref(ctx->context);*/
 	ltk_free(ctx);
 }
 
 void
 ltk_text_line_set_width(ltk_text_line *tl, int width) {
 	if (width <= 0)
 		pango_layout_set_width(tl->layout, -1);
 	else
 		pango_layout_set_width(tl->layout, width * PANGO_SCALE);
 }
 
 void
 ltk_text_line_set_text(ltk_text_line *tl, char *text, int take_over_text) {
 	if (tl->text)
 		free(tl->text);
 	if (take_over_text)
 		tl->text = text;
 	else
 		tl->text = ltk_strdup(text);
 	tl->len = strlen(tl->text);
 	pango_layout_set_text(tl->layout, tl->text, tl->len);
 }
 
 ltk_text_line *
 ltk_text_line_create(ltk_text_context *ctx, uint16_t font_size, char *text, int take_over_text, int width) {
 	ltk_text_line *tl = ltk_malloc(sizeof(ltk_text_line));
 	if (take_over_text)
 		tl->text = text;
 	else
 		tl->text = ltk_strdup(text);
 	tl->len = strlen(tl->text);
 	tl->font_size = font_size;
 	/* FIXME: does this ever return NULL? */
 	tl->layout = pango_layout_new(ctx->context);
 
 	PangoFontDescription *desc = pango_font_description_from_string(ctx->default_font);
 	pango_font_description_set_size(desc, font_size * PANGO_SCALE);
 	pango_layout_set_font_description(tl->layout, desc);
 	pango_font_description_free(desc);
 	tl->ctx = ctx;
 	pango_layout_set_wrap(tl->layout, PANGO_WRAP_WORD_CHAR);
 	pango_layout_set_text(tl->layout, text, -1);
 	if (width > 0)
 		ltk_text_line_set_width(tl, width * PANGO_SCALE);
 	tl->attrs = NULL;
 	ltk_text_line_clear_attrs(tl);
 
 	return tl;
 }
 
 void
 ltk_text_line_draw(ltk_text_line *tl, ltk_surface *s, ltk_color *color, int x, int y) {
 	XftDraw *d = ltk_surface_get_xft_draw(s);
 	pango_xft_render_layout(d, &color->xftcolor, tl->layout, x * PANGO_SCALE, y * PANGO_SCALE);
 }
 
 void
 ltk_text_line_draw_clipped(ltk_text_line *tl, ltk_surface *s, ltk_color *color, int x, int y, ltk_rect clip) {
 	XftDraw *d = ltk_surface_get_xft_draw(s);
 	/* FIXME: check for integer overflow */
 	XPoint points[] = {
 	    {clip.x, clip.y},
 	    {clip.x + clip.w, clip.y},
 	    {clip.x + clip.w, clip.y + clip.h},
 	    {clip.x, clip.y + clip.h}
 	};
 	Region r = XPolygonRegion(points, 4, EvenOddRule);
 	/* FIXME: error checking */
 	XftDrawSetClip(d, r);
 	ltk_text_line_draw(tl, s, color, x, y);
 	XDestroyRegion(r);
 	XftDrawSetClip(d, NULL);
 }
 
 void
 ltk_text_line_get_size(ltk_text_line *tl, int *w, int *h) {
 	pango_layout_get_pixel_size(tl->layout, w, h);
 }
 
 void
 ltk_text_line_clear_attrs(ltk_text_line *tl) {
 	PangoAttrList *attrs = pango_attr_list_new();
 	#if PANGO_VERSION_CHECK(1, 44, 0)
 	PangoAttribute *no_hyphens = pango_attr_insert_hyphens_new(FALSE);
 	pango_attr_list_insert(attrs, no_hyphens);
 	#endif
 	pango_layout_set_attributes(tl->layout, attrs);
 	if (tl->attrs)
 		pango_attr_list_unref(tl->attrs);
 	tl->attrs = attrs;
 }
 
 void
 ltk_text_line_add_attr_bg(ltk_text_line *tl, size_t start, size_t end, ltk_color *color) {
 	XRenderColor c = color->xftcolor.color;
 	PangoAttribute *attr = pango_attr_background_new(c.red, c.green, c.blue);
 	attr->start_index = start;
 	attr->end_index = end;
 	/* FIXME: this is sketchy - if add_attr_bg/fg is called multiple times,
 	   pango_layout_set_attributes will probably ref the same AttrList multiple times */
 	pango_attr_list_insert(tl->attrs, attr);
 	pango_layout_set_attributes(tl->layout, tl->attrs);
 }
 
 void
 ltk_text_line_add_attr_fg(ltk_text_line *tl, size_t start, size_t end, ltk_color *color) {
 	XRenderColor c = color->xftcolor.color;
 	PangoAttribute *attr = pango_attr_foreground_new(c.red, c.green, c.blue);
 	attr->start_index = start;
 	attr->end_index = end;
 	pango_attr_list_insert(tl->attrs, attr);
 	pango_layout_set_attributes(tl->layout, tl->attrs);
 }
 
 ltk_text_direction
 ltk_text_line_get_softline_direction(ltk_text_line *tl, size_t line) {
 	int num_softlines = pango_layout_get_line_count(tl->layout);
 	if ((int)line >= num_softlines)
 		return LTK_TEXT_LTR;
 	PangoLayoutLine *sl = pango_layout_get_line_readonly(tl->layout, (int)line);
 	if (!sl)
 		return LTK_TEXT_LTR;
 	return sl->resolved_dir == PANGO_DIRECTION_RTL || sl->resolved_dir == PANGO_DIRECTION_WEAK_RTL ? LTK_TEXT_RTL : LTK_TEXT_LTR;
 }
 
 ltk_text_direction
 ltk_text_line_get_byte_direction(ltk_text_line *tl, size_t byte) {
 	/* FIXME: check if index out of range first? */
 	PangoDirection dir = pango_layout_get_direction(tl->layout, (int)byte);
 	return dir == PANGO_DIRECTION_RTL || dir == PANGO_DIRECTION_WEAK_RTL ? LTK_TEXT_RTL : LTK_TEXT_LTR;
 }
 
 size_t
 ltk_text_line_get_num_softlines(ltk_text_line *tl) {
 	return (size_t)pango_layout_get_line_count(tl->layout);
 }
 
 size_t
 ltk_text_line_xy_to_pos(ltk_text_line *tl, int x, int y, int snap_nearest) {
 	int index, trailing;
 	pango_layout_xy_to_index(
 	    tl->layout,
 	    x * PANGO_SCALE, y * PANGO_SCALE,
 	    &index, & trailing
 	);
 	if (snap_nearest) {
 		while (trailing > 0) {
 			trailing--;
 			/* FIXME: proper string type with length */
 			// FIXME: next_utf8 should be size_t
 			index = next_utf8(tl->text, tl->len, index);
 		}
 	}
 	return (size_t)index;
 }
 
 /* FIXME: get_nearest_legal_pos */
 /* FIXME: factor out common text code from ltk and ledit */
 
 /* WARNING: width can be negative - https://docs.gtk.org/Pango/method.Layout.index_to_pos.html */
 void
 ltk_text_line_pos_to_rect(ltk_text_line *tl, size_t pos, int *x_ret, int *y_ret, int *w_ret, int *h_ret) {
 	PangoRectangle rect;
 	pango_layout_index_to_pos(tl->layout, (int)pos, &rect);
 	*x_ret = rect.x / PANGO_SCALE;
 	*y_ret = rect.y / PANGO_SCALE;
 	*w_ret = rect.width / PANGO_SCALE;
 	*h_ret = rect.height / PANGO_SCALE;
 }
 
 /* FIXME: a lot more error checking, including integer overflows */
 size_t
 ltk_text_line_x_softline_to_pos(ltk_text_line *tl, int x, size_t softline, int snap_nearest) {
 	int trailing = 0;
 	int x_relative = x * PANGO_SCALE;
 	PangoLayoutLine *pango_line = pango_layout_get_line_readonly(tl->layout, softline);
 	int tlw, tlh;
 	pango_layout_get_size(tl->layout, &tlw, &tlh);
 	/* x is absolute, so the margin at the left needs to be subtracted */
 	if (pango_line->resolved_dir == PANGO_DIRECTION_RTL) {
 		PangoRectangle rect;
 		pango_layout_line_get_extents(pango_line, NULL, &rect);
 		x_relative -= (tlw - rect.width);
 	}
 	int tmp_pos;
 	pango_layout_line_x_to_index(
 	    pango_line, x_relative, &tmp_pos, &trailing
 	);
 	size_t pos = (size_t)tmp_pos;
 	/* snap to the nearest border between graphemes */
 	if (snap_nearest) {
 		while (trailing > 0) {
 			trailing--;
 			pos = next_utf8(tl->text, tl->len, pos);
 		}
 	}
 	return pos;
 }
 
 void
 ltk_text_line_pos_to_x_softline(ltk_text_line *tl, size_t pos, int middle, int *x_ret, size_t *softline_ret) {
 	/*
 	if (pos > INT_MAX)
 		err_overflow();
 	*/
 	int sl_tmp;
 	pango_layout_index_to_line_x(tl->layout, (int)pos, 0, &sl_tmp, x_ret);
 	*softline_ret = sl_tmp;
 	PangoLayoutLine *pango_line = pango_layout_get_line_readonly(tl->layout, *softline_ret);
 	int tlw, tlh;
 	pango_layout_get_size(tl->layout, &tlw, &tlh);
 	/* FIXME: wouldn't it be easier to just use pango_layout_index_to_pos for everything here? */
 	/* add left margin to x position if line is aligned right */
 	if (pango_line->resolved_dir == PANGO_DIRECTION_RTL) {
 		PangoRectangle rect;
 		pango_layout_line_get_extents(pango_line, NULL, &rect);
 		*x_ret += (tlw - rect.width);
 	}
 	if (middle) {
 		PangoRectangle rect;
 		pango_layout_index_to_pos(tl->layout, (int)pos, &rect);
 		*x_ret += rect.width / 2;
 	}
 	*x_ret /= PANGO_SCALE; /* FIXME: PANGO_PIXELS, etc. */
 }
 
 /* prev_index_ret is used instead of just calling get_legal_normal_pos
    because weird things happen otherwise
    -> in certain cases, this is still weird because prev_index_ret sometimes
       is not at the end of the line, but this is the best I could come up
       with for now */
 size_t
 ltk_text_line_move_cursor_visually(ltk_text_line *tl, size_t pos, int movement, size_t *prev_index_ret) {
 	/* FIXME
 	if (pos > INT_MAX)
 		err_overflow();
 	*/
 	/* FIXME: trailing */
 	int trailing = 0;
 	int tmp_index;
 	int new_index = (int)pos, last_index = (int)pos;
 	int dir = 1;
 	int num = movement;
 	if (movement < 0) {
 		dir = -1;
 		num = -movement;
 	}
 	/* FIXME: This is stupid. Anything outside the range of int won't work
 	   anyways because of pango (and because everything else would break
 	   anyways with such long lines), so it's stupid to do all this weird
 	   casting. */
 	/*
 	if (cur_line->len > INT_MAX)
 		err_overflow();
 	*/
 	while (num > 0) {
 		tmp_index = new_index;
 		pango_layout_move_cursor_visually(
 		    tl->layout, TRUE,
 		    new_index, trailing, dir,
 		    &new_index, &trailing
 		);
 		/* for some reason, this is necessary */
 		if (new_index < 0)
 			new_index = 0;
 		else if (new_index > (int)tl->len)
 			new_index = (int)tl->len;
 		num--;
 		if (tmp_index != new_index)
 			last_index = tmp_index;
 	}
 	/* FIXME: Allow cursor to be at end of soft line */
 	/* we don't currently support a difference between the cursor being at
 	   the end of a soft line and the beginning of the next line */
 	/* FIXME: spaces at end of softlines are weird in normal mode */
 	while (trailing > 0) {
 		trailing--;
 		new_index = next_utf8(tl->text, tl->len, new_index);
 	}
 	if (new_index < 0)
 		new_index = 0;
 	if (prev_index_ret)
 		*prev_index_ret = (size_t)last_index;
 	return (size_t)new_index;
 }
 
 void
 ltk_text_line_destroy(ltk_text_line *tl) {
 	if (tl->attrs)
 		pango_attr_list_unref(tl->attrs);
 	g_object_unref(tl->layout);
 	ltk_free(tl->text);
 	ltk_free(tl);
 }