foot/render.h

#pragma once
#include <stdbool.h>

#include "terminal.h"
#include "fdm.h"
#include "wayland.h"

struct renderer;
struct renderer *render_init(struct fdm *fdm, struct wayland *wayl);
void render_destroy(struct renderer *renderer);

bool render_resize(struct terminal *term, int width, int height);
bool render_resize_force(struct terminal *term, int width, int height);

void render_set_title(struct terminal *term, const char *title);
void render_refresh(struct terminal *term);
bool render_xcursor_set(struct terminal *term);

void render_search_box(struct terminal *term);
void render_csd(struct terminal *term);

struct render_worker_context {
    int my_id;
    struct terminal *term;
};
int render_worker_thread(void *_ctx);
render: break out rendering functions to render.{c,h} 2019-07-05 10:16:56 +02:00			`#pragma once`
render: render_resize_*() returns a boolean indicating whether size changed. 2020-02-25 19:51:03 +01:00			`#include <stdbool.h>`
render: break out rendering functions to render.{c,h} 2019-07-05 10:16:56 +02:00
			`#include "terminal.h"`
render: trigger terminal refreshes in an FDM hook In some cases, we end up calling render_refresh() multiple times in the same FDM iteration. This means will render the first update immediately, and then set the 'pending' flag, causing the updated content to be rendered in the next frame. This can cause flicker, or flashes, since we're presenting one or more intermediate frames until the final content is shown. Not to mention that it is inefficient to render multiple frames like this. Fix by: * render_refresh() only sets a flag in the terminal * install an FDM hook; this hook loops all terminals and executes what render_refresh() _used_ to do (that is, render immediately if we're not waiting for a frame callback, otherwise set 'pending' flag). for all terminals that have the 'refresh_needed' flag set. 2020-01-04 19:49:26 +01:00			`#include "fdm.h"`
			`#include "wayland.h"`
render: break out rendering functions to render.{c,h} 2019-07-05 10:16:56 +02:00
render: trigger terminal refreshes in an FDM hook In some cases, we end up calling render_refresh() multiple times in the same FDM iteration. This means will render the first update immediately, and then set the 'pending' flag, causing the updated content to be rendered in the next frame. This can cause flicker, or flashes, since we're presenting one or more intermediate frames until the final content is shown. Not to mention that it is inefficient to render multiple frames like this. Fix by: * render_refresh() only sets a flag in the terminal * install an FDM hook; this hook loops all terminals and executes what render_refresh() _used_ to do (that is, render immediately if we're not waiting for a frame callback, otherwise set 'pending' flag). for all terminals that have the 'refresh_needed' flag set. 2020-01-04 19:49:26 +01:00			`struct renderer;`
			`struct renderer render_init(struct fdm fdm, struct wayland *wayl);`
			`void render_destroy(struct renderer *renderer);`
render: break out rendering functions to render.{c,h} 2019-07-05 10:16:56 +02:00
render: render_resize_*() returns a boolean indicating whether size changed. 2020-02-25 19:51:03 +01:00			`bool render_resize(struct terminal *term, int width, int height);`
			`bool render_resize_force(struct terminal *term, int width, int height);`
render: add render_resize_force() This forces a full resize operation, even though actual window size (or scale) hasn't changed. 2020-02-08 14:08:16 +01:00
render: break out rendering functions to render.{c,h} 2019-07-05 10:16:56 +02:00			`void render_set_title(struct terminal term, const char title);`
render: add render_refresh() 2019-07-24 20:09:49 +02:00			`void render_refresh(struct terminal *term);`
render: throttle xcursor updates With a bad behaving client (e.g. 'less' with mouse support enabled), we can end up with a lot of xcursor updates (so much, that we flooded the wayland socket before we implemented a blocking wayl_flush()). Since there's little point in updating the cursor more than once per frame interval, use frame callbacks to throttle the updates. This works more or lesslike normal terminal refreshes: render_xcursor_set() stores the last terminal (window) that had (and updated) the cursor. The renderer's FDM hook checks if we have such a pending terminal set, and if so, tries to refresh the cursor. This is done by first checking if we're already waiting for a callback from a previous cursor update, and if so we do nothing; the callback will update the cursor for the next frame. If we're not already waiting for a callback, we update the cursor immediately. 2020-01-04 22:01:19 +01:00			`bool render_xcursor_set(struct terminal *term);`
wip: initial multithreaded renderer 2019-07-29 20:13:26 +02:00
search: move render() function to the 'render' module 2019-08-29 20:18:06 +02:00			`void render_search_box(struct terminal *term);`
render: export render_csd() 2020-02-25 19:09:29 +01:00			`void render_csd(struct terminal *term);`
render: reload cursor theme when scale (may) have changed 2019-08-21 17:53:52 +02:00
wip: initial multithreaded renderer 2019-07-29 20:13:26 +02:00			`struct render_worker_context {`
			`int my_id;`
			`struct terminal *term;`
			`};`
			`int render_worker_thread(void *_ctx);`