pjht/swaylock
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
cca2436ba5
swaylock/render.c

388 lines
13 KiB
C
Raw Normal View History

R E N D E R I N G
2018-04-03 14:04:31 -05:00
#include <math.h>
Import stdlib.h and define POSIX macro for rand()
2018-04-03 21:01:29 -05:00
#include <stdlib.h>
#include <wayland-client.h>
Add password buffer, refactor rendering/surfaces
2018-04-03 13:31:30 -05:00
#include "cairo.h"
#include "background-image.h"
Convert swaylock into standalone project
2019-01-13 20:15:32 -06:00
#include "swaylock.h"
Stop pooling background surface buffers The wl_buffers for the background surface only need to be updated when the output dimensions change. Using the fixed pool of two buffers to cache these buffers does not help, since if a new buffer is needed, it will have a different size than whatever buffers were cached. Furthermore, because the pool has fixed size, it is possible to run out of buffers if configure events arrive faster than pool buffers are marked not busy, which can lead to protocol errors when the background surface is committed after acknowledging a new size, but without attaching a buffer that matches that size.
2023-03-12 15:48:58 -05:00
#include "log.h"
Add password buffer, refactor rendering/surfaces
2018-04-03 13:31:30 -05:00
R E N D E R I N G
2018-04-03 14:04:31 -05:00
#define M_PI 3.14159265358979323846
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
const float TYPE_INDICATOR_RANGE = M_PI / 3.0f;
const float TYPE_INDICATOR_BORDER_THICKNESS = M_PI / 128.0f;
R E N D E R I N G
2018-04-03 14:04:31 -05:00
Implement swaylock customization flags
2018-07-10 20:29:15 -05:00
static void set_color_for_state(cairo_t *cairo, struct swaylock_state *state,
struct swaylock_colorset *colorset) {
Separate input and auth state This commit establishes separate state machines for auth state (whether the password submitted is being verified or is wrong) and input state (typing indicators and clear message -- things relevant to the state of the password being typed in, before it is submitted.) This makes it possible to display the auth state while updating the input state (for example, show that the previously submitted password is 'verifying' or 'wrong' while typing another.) The two state machines interact only when submitting a password. There is some interference with the rendering code -- a 'cleared' message from the input state machine supersedes verifying/wrong messages from the auth state machine; although since the 'clear' state has a shorter timeout than the auth 'invalid' state, this is unlikely to hide the 'wrong' message.
2023-05-02 20:00:41 -05:00
if (state->input_state == INPUT_STATE_CLEAR) {
cairo_set_source_u32(cairo, colorset->cleared);
} else if (state->auth_state == AUTH_STATE_VALIDATING) {
Implement swaylock customization flags
2018-07-10 20:29:15 -05:00
cairo_set_source_u32(cairo, colorset->verifying);
} else if (state->auth_state == AUTH_STATE_INVALID) {
cairo_set_source_u32(cairo, colorset->wrong);
} else {
Add caps lock state to indicator This implements customization for the indicator as proposed in sway#2788 with comments from sway#3367 in mind. The default behaviour does not change exept for the caps lock text color. Since these changes seem to be lost in the split I've remade them.
2019-01-14 09:51:04 -06:00
if (state->xkb.caps_lock && state->args.show_caps_lock_indicator) {
cairo_set_source_u32(cairo, colorset->caps_lock);
} else if (state->xkb.caps_lock && !state->args.show_caps_lock_indicator &&
state->args.show_caps_lock_text) {
uint32_t inputtextcolor = state->args.colors.text.input;
state->args.colors.text.input = state->args.colors.text.caps_lock;
cairo_set_source_u32(cairo, colorset->input);
state->args.colors.text.input = inputtextcolor;
} else {
cairo_set_source_u32(cairo, colorset->input);
}
Implement swaylock customization flags
2018-07-10 20:29:15 -05:00
}
}
Improve frame callback and commit handling The few places that required a surface commit relied on render_frame and render_frame_background to form it form them after they had set up frame callback events. This would fail if render_frame ran out of buffers and exited early, as the caller would still wait indefinitely on the frame callback. swaylock would quite consistently run out of buffers when rendering immediately after a configure event, such as when the keypress causing render also caused outputs to be enabled from idle. Restructure the render and commit handling slightly so that the whole frame callback and commit setup is handled by the render code, which now has a single render entrypoint. This both avoids stalls from lacking commits, but also fixes the case the configure path to respect frame callbacks so we do not run out of buffers in the first place.
2024-09-06 17:27:37 -05:00
static void surface_frame_handle_done(void *data, struct wl_callback *callback,
uint32_t time) {
struct swaylock_surface *surface = data;
wl_callback_destroy(callback);
surface->frame = NULL;
render(surface);
}
static const struct wl_callback_listener surface_frame_listener = {
.done = surface_frame_handle_done,
};
static bool render_frame(struct swaylock_surface *surface);
void render(struct swaylock_surface *surface) {
Add password buffer, refactor rendering/surfaces
2018-04-03 13:31:30 -05:00
struct swaylock_state *state = surface->state;
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
int buffer_width = surface->width * surface->scale;
int buffer_height = surface->height * surface->scale;
swaylock: don't try to render unconfigured surfaces
2018-05-23 16:55:57 -05:00
if (buffer_width == 0 || buffer_height == 0) {
return; // not yet configured
}
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
Improve frame callback and commit handling The few places that required a surface commit relied on render_frame and render_frame_background to form it form them after they had set up frame callback events. This would fail if render_frame ran out of buffers and exited early, as the caller would still wait indefinitely on the frame callback. swaylock would quite consistently run out of buffers when rendering immediately after a configure event, such as when the keypress causing render also caused outputs to be enabled from idle. Restructure the render and commit handling slightly so that the whole frame callback and commit setup is handled by the render code, which now has a single render entrypoint. This both avoids stalls from lacking commits, but also fixes the case the configure path to respect frame callbacks so we do not run out of buffers in the first place.
2024-09-06 17:27:37 -05:00
if (!surface->dirty || surface->frame) {
// Nothing to do or frame already pending
return;
}
bool need_destroy = false;
struct pool_buffer buffer;
Don't drop the buffer until after surface commit
2023-06-08 22:32:52 -05:00
Stop pooling background surface buffers The wl_buffers for the background surface only need to be updated when the output dimensions change. Using the fixed pool of two buffers to cache these buffers does not help, since if a new buffer is needed, it will have a different size than whatever buffers were cached. Furthermore, because the pool has fixed size, it is possible to run out of buffers if configure events arrive faster than pool buffers are marked not busy, which can lead to protocol errors when the background surface is committed after acknowledging a new size, but without attaching a buffer that matches that size.
2023-03-12 15:48:58 -05:00
if (buffer_width != surface->last_buffer_width ||
buffer_height != surface->last_buffer_height) {
Improve frame callback and commit handling The few places that required a surface commit relied on render_frame and render_frame_background to form it form them after they had set up frame callback events. This would fail if render_frame ran out of buffers and exited early, as the caller would still wait indefinitely on the frame callback. swaylock would quite consistently run out of buffers when rendering immediately after a configure event, such as when the keypress causing render also caused outputs to be enabled from idle. Restructure the render and commit handling slightly so that the whole frame callback and commit setup is handled by the render code, which now has a single render entrypoint. This both avoids stalls from lacking commits, but also fixes the case the configure path to respect frame callbacks so we do not run out of buffers in the first place.
2024-09-06 17:27:37 -05:00
need_destroy = true;
Stop pooling background surface buffers The wl_buffers for the background surface only need to be updated when the output dimensions change. Using the fixed pool of two buffers to cache these buffers does not help, since if a new buffer is needed, it will have a different size than whatever buffers were cached. Furthermore, because the pool has fixed size, it is possible to run out of buffers if configure events arrive faster than pool buffers are marked not busy, which can lead to protocol errors when the background surface is committed after acknowledging a new size, but without attaching a buffer that matches that size.
2023-03-12 15:48:58 -05:00
if (!create_buffer(state->shm, &buffer, buffer_width, buffer_height,
WL_SHM_FORMAT_ARGB8888)) {
swaylock_log(LOG_ERROR,
"Failed to create new buffer for frame background.");
return;
}
cairo_t *cairo = buffer.cairo;
cairo_set_antialias(cairo, CAIRO_ANTIALIAS_BEST);
cairo_save(cairo);
cairo_set_operator(cairo, CAIRO_OPERATOR_SOURCE);
cairo_set_source_u32(cairo, state->args.colors.background);
cairo_paint(cairo);
if (surface->image && state->args.mode != BACKGROUND_MODE_SOLID_COLOR) {
cairo_set_operator(cairo, CAIRO_OPERATOR_OVER);
render_background_image(cairo, surface->image,
state->args.mode, buffer_width, buffer_height);
}
cairo_restore(cairo);
cairo_identity_matrix(cairo);
swaylock: implement a proper render loop
2018-05-25 13:34:36 -05:00
Improve frame callback and commit handling The few places that required a surface commit relied on render_frame and render_frame_background to form it form them after they had set up frame callback events. This would fail if render_frame ran out of buffers and exited early, as the caller would still wait indefinitely on the frame callback. swaylock would quite consistently run out of buffers when rendering immediately after a configure event, such as when the keypress causing render also caused outputs to be enabled from idle. Restructure the render and commit handling slightly so that the whole frame callback and commit setup is handled by the render code, which now has a single render entrypoint. This both avoids stalls from lacking commits, but also fixes the case the configure path to respect frame callbacks so we do not run out of buffers in the first place.
2024-09-06 17:27:37 -05:00
wl_surface_set_buffer_scale(surface->surface, surface->scale);
Stop pooling background surface buffers The wl_buffers for the background surface only need to be updated when the output dimensions change. Using the fixed pool of two buffers to cache these buffers does not help, since if a new buffer is needed, it will have a different size than whatever buffers were cached. Furthermore, because the pool has fixed size, it is possible to run out of buffers if configure events arrive faster than pool buffers are marked not busy, which can lead to protocol errors when the background surface is committed after acknowledging a new size, but without attaching a buffer that matches that size.
2023-03-12 15:48:58 -05:00
wl_surface_attach(surface->surface, buffer.buffer, 0, 0);
wl_surface_damage_buffer(surface->surface, 0, 0, INT32_MAX, INT32_MAX);
Improve frame callback and commit handling The few places that required a surface commit relied on render_frame and render_frame_background to form it form them after they had set up frame callback events. This would fail if render_frame ran out of buffers and exited early, as the caller would still wait indefinitely on the frame callback. swaylock would quite consistently run out of buffers when rendering immediately after a configure event, such as when the keypress causing render also caused outputs to be enabled from idle. Restructure the render and commit handling slightly so that the whole frame callback and commit setup is handled by the render code, which now has a single render entrypoint. This both avoids stalls from lacking commits, but also fixes the case the configure path to respect frame callbacks so we do not run out of buffers in the first place.
2024-09-06 17:27:37 -05:00
need_destroy = true;
Add hidpi support to swaylock
2018-04-03 18:15:14 -05:00
Stop pooling background surface buffers The wl_buffers for the background surface only need to be updated when the output dimensions change. Using the fixed pool of two buffers to cache these buffers does not help, since if a new buffer is needed, it will have a different size than whatever buffers were cached. Furthermore, because the pool has fixed size, it is possible to run out of buffers if configure events arrive faster than pool buffers are marked not busy, which can lead to protocol errors when the background surface is committed after acknowledging a new size, but without attaching a buffer that matches that size.
2023-03-12 15:48:58 -05:00
surface->last_buffer_width = buffer_width;
surface->last_buffer_height = buffer_height;
Improve frame callback and commit handling The few places that required a surface commit relied on render_frame and render_frame_background to form it form them after they had set up frame callback events. This would fail if render_frame ran out of buffers and exited early, as the caller would still wait indefinitely on the frame callback. swaylock would quite consistently run out of buffers when rendering immediately after a configure event, such as when the keypress causing render also caused outputs to be enabled from idle. Restructure the render and commit handling slightly so that the whole frame callback and commit setup is handled by the render code, which now has a single render entrypoint. This both avoids stalls from lacking commits, but also fixes the case the configure path to respect frame callbacks so we do not run out of buffers in the first place.
2024-09-06 17:27:37 -05:00
}
render_frame(surface);
surface->dirty = false;
surface->frame = wl_surface_frame(surface->surface);
wl_callback_add_listener(surface->frame, &surface_frame_listener, surface);
wl_surface_commit(surface->surface);
if (need_destroy) {
destroy_buffer(&buffer);
R E N D E R I N G
2018-04-03 14:04:31 -05:00
}
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
}
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
static void configure_font_drawing(cairo_t *cairo, struct swaylock_state *state,
enum wl_output_subpixel subpixel, int arc_radius) {
cairo_font_options_t *fo = cairo_font_options_create();
cairo_font_options_set_hint_style(fo, CAIRO_HINT_STYLE_FULL);
cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_SUBPIXEL);
cairo_font_options_set_subpixel_order(fo, to_cairo_subpixel_order(subpixel));
cairo_set_font_options(cairo, fo);
cairo_select_font_face(cairo, state->args.font,
CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
if (state->args.font_size > 0) {
cairo_set_font_size(cairo, state->args.font_size);
} else {
cairo_set_font_size(cairo, arc_radius / 3.0f);
}
cairo_font_options_destroy(fo);
}
Improve frame callback and commit handling The few places that required a surface commit relied on render_frame and render_frame_background to form it form them after they had set up frame callback events. This would fail if render_frame ran out of buffers and exited early, as the caller would still wait indefinitely on the frame callback. swaylock would quite consistently run out of buffers when rendering immediately after a configure event, such as when the keypress causing render also caused outputs to be enabled from idle. Restructure the render and commit handling slightly so that the whole frame callback and commit setup is handled by the render code, which now has a single render entrypoint. This both avoids stalls from lacking commits, but also fixes the case the configure path to respect frame callbacks so we do not run out of buffers in the first place.
2024-09-06 17:27:37 -05:00
static bool render_frame(struct swaylock_surface *surface) {
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
struct swaylock_state *state = surface->state;
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
// First, compute the text that will be drawn, if any, since this
// determines the size/positioning of the surface
char attempts[4]; // like i3lock: count no more than 999
char *text = NULL;
const char *layout_text = NULL;
Separate input and auth state This commit establishes separate state machines for auth state (whether the password submitted is being verified or is wrong) and input state (typing indicators and clear message -- things relevant to the state of the password being typed in, before it is submitted.) This makes it possible to display the auth state while updating the input state (for example, show that the previously submitted password is 'verifying' or 'wrong' while typing another.) The two state machines interact only when submitting a password. There is some interference with the rendering code -- a 'cleared' message from the input state machine supersedes verifying/wrong messages from the auth state machine; although since the 'clear' state has a shorter timeout than the auth 'invalid' state, this is unlikely to hide the 'wrong' message.
2023-05-02 20:00:41 -05:00
bool draw_indicator = state->args.show_indicator &&
(state->auth_state != AUTH_STATE_IDLE ||
state->input_state != INPUT_STATE_IDLE ||
state->args.indicator_idle_visible);
if (draw_indicator) {
if (state->input_state == INPUT_STATE_CLEAR) {
// This message has highest priority
text = "Cleared";
} else if (state->auth_state == AUTH_STATE_VALIDATING) {
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
text = "Verifying";
Separate input and auth state This commit establishes separate state machines for auth state (whether the password submitted is being verified or is wrong) and input state (typing indicators and clear message -- things relevant to the state of the password being typed in, before it is submitted.) This makes it possible to display the auth state while updating the input state (for example, show that the previously submitted password is 'verifying' or 'wrong' while typing another.) The two state machines interact only when submitting a password. There is some interference with the rendering code -- a 'cleared' message from the input state machine supersedes verifying/wrong messages from the auth state machine; although since the 'clear' state has a shorter timeout than the auth 'invalid' state, this is unlikely to hide the 'wrong' message.
2023-05-02 20:00:41 -05:00
} else if (state->auth_state == AUTH_STATE_INVALID) {
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
text = "Wrong";
Separate input and auth state This commit establishes separate state machines for auth state (whether the password submitted is being verified or is wrong) and input state (typing indicators and clear message -- things relevant to the state of the password being typed in, before it is submitted.) This makes it possible to display the auth state while updating the input state (for example, show that the previously submitted password is 'verifying' or 'wrong' while typing another.) The two state machines interact only when submitting a password. There is some interference with the rendering code -- a 'cleared' message from the input state machine supersedes verifying/wrong messages from the auth state machine; although since the 'clear' state has a shorter timeout than the auth 'invalid' state, this is unlikely to hide the 'wrong' message.
2023-05-02 20:00:41 -05:00
} else {
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
// Caps Lock has higher priority
if (state->xkb.caps_lock && state->args.show_caps_lock_text) {
text = "Caps Lock";
} else if (state->args.show_failed_attempts &&
state->failed_attempts > 0) {
if (state->failed_attempts > 999) {
text = "999+";
} else {
snprintf(attempts, sizeof(attempts), "%d", state->failed_attempts);
text = attempts;
}
}
xkb_layout_index_t num_layout = xkb_keymap_num_layouts(state->xkb.keymap);
if (!state->args.hide_keyboard_layout &&
(state->args.show_keyboard_layout || num_layout > 1)) {
xkb_layout_index_t curr_layout = 0;
// advance to the first active layout (if any)
while (curr_layout < num_layout &&
xkb_state_layout_index_is_active(state->xkb.state,
curr_layout, XKB_STATE_LAYOUT_EFFECTIVE) != 1) {
++curr_layout;
}
// will handle invalid index if none are active
layout_text = xkb_keymap_layout_get_name(state->xkb.keymap, curr_layout);
}
}
}
// Compute the size of the buffer needed
Implement swaylock customization flags
2018-07-10 20:29:15 -05:00
int arc_radius = state->args.radius * surface->scale;
int arc_thickness = state->args.thickness * surface->scale;
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
int buffer_diameter = (arc_radius + arc_thickness) * 2;
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
int buffer_width = buffer_diameter;
int buffer_height = buffer_diameter;
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
if (text || layout_text) {
cairo_set_antialias(state->test_cairo, CAIRO_ANTIALIAS_BEST);
configure_font_drawing(state->test_cairo, state, surface->subpixel, arc_radius);
if (text) {
cairo_text_extents_t extents;
cairo_text_extents(state->test_cairo, text, &extents);
if (buffer_width < extents.width) {
buffer_width = extents.width;
}
}
if (layout_text) {
cairo_text_extents_t extents;
cairo_font_extents_t fe;
double box_padding = 4.0 * surface->scale;
cairo_text_extents(state->test_cairo, layout_text, &extents);
cairo_font_extents(state->test_cairo, &fe);
buffer_height += fe.height + 2 * box_padding;
if (buffer_width < extents.width + 2 * box_padding) {
buffer_width = extents.width + 2 * box_padding;
}
}
}
// Ensure buffer size is multiple of buffer scale - required by protocol
buffer_height += surface->scale - (buffer_height % surface->scale);
buffer_width += surface->scale - (buffer_width % surface->scale);
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
Added option to adjust ring position via CLI arguments and the config file
2019-11-27 18:43:16 -06:00
int subsurf_xpos;
int subsurf_ypos;
// Center the indicator unless overridden by the user
if (state->args.override_indicator_x_position) {
subsurf_xpos = state->args.indicator_x_position -
buffer_width / (2 * surface->scale) + 2 / surface->scale;
} else {
subsurf_xpos = surface->width / 2 -
buffer_width / (2 * surface->scale) + 2 / surface->scale;
}
if (state->args.override_indicator_y_position) {
subsurf_ypos = state->args.indicator_y_position -
(state->args.radius + state->args.thickness);
} else {
subsurf_ypos = surface->height / 2 -
(state->args.radius + state->args.thickness);
}
renderer: work with current buffer locally No need to store this globally accessible struct member.
2022-09-24 03:18:20 -05:00
struct pool_buffer *buffer = get_next_buffer(state->shm,
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
surface->indicator_buffers, buffer_width, buffer_height);
renderer: work with current buffer locally No need to store this globally accessible struct member.
2022-09-24 03:18:20 -05:00
if (buffer == NULL) {
Improve frame callback and commit handling The few places that required a surface commit relied on render_frame and render_frame_background to form it form them after they had set up frame callback events. This would fail if render_frame ran out of buffers and exited early, as the caller would still wait indefinitely on the frame callback. swaylock would quite consistently run out of buffers when rendering immediately after a configure event, such as when the keypress causing render also caused outputs to be enabled from idle. Restructure the render and commit handling slightly so that the whole frame callback and commit setup is handled by the render code, which now has a single render entrypoint. This both avoids stalls from lacking commits, but also fixes the case the configure path to respect frame callbacks so we do not run out of buffers in the first place.
2024-09-06 17:27:37 -05:00
swaylock_log(LOG_ERROR, "No buffer");
return false;
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
}
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
// Render the buffer
renderer: work with current buffer locally No need to store this globally accessible struct member.
2022-09-24 03:18:20 -05:00
cairo_t *cairo = buffer->cairo;
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
cairo_set_antialias(cairo, CAIRO_ANTIALIAS_BEST);
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
cairo_identity_matrix(cairo);
// Clear
cairo_save(cairo);
cairo_set_source_rgba(cairo, 0, 0, 0, 0);
cairo_set_operator(cairo, CAIRO_OPERATOR_SOURCE);
cairo_paint(cairo);
cairo_restore(cairo);
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
float type_indicator_border_thickness =
TYPE_INDICATOR_BORDER_THICKNESS * surface->scale;
Add hidpi support to swaylock
2018-04-03 18:15:14 -05:00
Separate input and auth state This commit establishes separate state machines for auth state (whether the password submitted is being verified or is wrong) and input state (typing indicators and clear message -- things relevant to the state of the password being typed in, before it is submitted.) This makes it possible to display the auth state while updating the input state (for example, show that the previously submitted password is 'verifying' or 'wrong' while typing another.) The two state machines interact only when submitting a password. There is some interference with the rendering code -- a 'cleared' message from the input state machine supersedes verifying/wrong messages from the auth state machine; although since the 'clear' state has a shorter timeout than the auth 'invalid' state, this is unlikely to hide the 'wrong' message.
2023-05-02 20:00:41 -05:00
if (draw_indicator) {
Draw ring and inner fill separately
2021-05-31 16:01:59 -05:00
// Fill inner circle
cairo_set_line_width(cairo, 0);
cairo_arc(cairo, buffer_width / 2, buffer_diameter / 2,
arc_radius - arc_thickness / 2, 0, 2 * M_PI);
set_color_for_state(cairo, state, &state->args.colors.inside);
cairo_fill_preserve(cairo);
cairo_stroke(cairo);
// Draw ring
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
cairo_set_line_width(cairo, arc_thickness);
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
cairo_arc(cairo, buffer_width / 2, buffer_diameter / 2, arc_radius,
Implement swaylock customization flags
2018-07-10 20:29:15 -05:00
0, 2 * M_PI);
set_color_for_state(cairo, state, &state->args.colors.ring);
cairo_stroke(cairo);
R E N D E R I N G
2018-04-03 14:04:31 -05:00
// Draw a message
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
configure_font_drawing(cairo, state, surface->subpixel, arc_radius);
Implement swaylock customization flags
2018-07-10 20:29:15 -05:00
set_color_for_state(cairo, state, &state->args.colors.text);
R E N D E R I N G
2018-04-03 14:04:31 -05:00
if (text) {
cairo_text_extents_t extents;
Fix vertical align of text inside the circle
2019-01-28 12:51:34 -06:00
cairo_font_extents_t fe;
R E N D E R I N G
2018-04-03 14:04:31 -05:00
double x, y;
cairo_text_extents(cairo, text, &extents);
Fix vertical align of text inside the circle
2019-01-28 12:51:34 -06:00
cairo_font_extents(cairo, &fe);
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
x = (buffer_width / 2) -
R E N D E R I N G
2018-04-03 14:04:31 -05:00
(extents.width / 2 + extents.x_bearing);
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
y = (buffer_diameter / 2) +
Fix vertical align of text inside the circle
2019-01-28 12:51:34 -06:00
(fe.height / 2 - fe.descent);
R E N D E R I N G
2018-04-03 14:04:31 -05:00
cairo_move_to(cairo, x, y);
cairo_show_text(cairo, text);
cairo_close_path(cairo);
cairo_new_sub_path(cairo);
}
// Typing indicator: Highlight random part on keypress
Separate input and auth state This commit establishes separate state machines for auth state (whether the password submitted is being verified or is wrong) and input state (typing indicators and clear message -- things relevant to the state of the password being typed in, before it is submitted.) This makes it possible to display the auth state while updating the input state (for example, show that the previously submitted password is 'verifying' or 'wrong' while typing another.) The two state machines interact only when submitting a password. There is some interference with the rendering code -- a 'cleared' message from the input state machine supersedes verifying/wrong messages from the auth state machine; although since the 'clear' state has a shorter timeout than the auth 'invalid' state, this is unlikely to hide the 'wrong' message.
2023-05-02 20:00:41 -05:00
if (state->input_state == INPUT_STATE_LETTER ||
state->input_state == INPUT_STATE_BACKSPACE) {
Synchronize highlight position between outputs This change has the additional benefit of ensuring that the position of the highlight only changes in reaction to a letter key or backspace being pressed, and not when the compositor sends a new configure event or the output needs to be redrawn for some other reason.
2023-03-28 18:42:19 -05:00
double highlight_start = state->highlight_start * (M_PI / 1024.0);
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
cairo_arc(cairo, buffer_width / 2, buffer_diameter / 2,
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
arc_radius, highlight_start,
R E N D E R I N G
2018-04-03 14:04:31 -05:00
highlight_start + TYPE_INDICATOR_RANGE);
Separate input and auth state This commit establishes separate state machines for auth state (whether the password submitted is being verified or is wrong) and input state (typing indicators and clear message -- things relevant to the state of the password being typed in, before it is submitted.) This makes it possible to display the auth state while updating the input state (for example, show that the previously submitted password is 'verifying' or 'wrong' while typing another.) The two state machines interact only when submitting a password. There is some interference with the rendering code -- a 'cleared' message from the input state machine supersedes verifying/wrong messages from the auth state machine; although since the 'clear' state has a shorter timeout than the auth 'invalid' state, this is unlikely to hide the 'wrong' message.
2023-05-02 20:00:41 -05:00
if (state->input_state == INPUT_STATE_LETTER) {
Add caps lock state to indicator This implements customization for the indicator as proposed in sway#2788 with comments from sway#3367 in mind. The default behaviour does not change exept for the caps lock text color. Since these changes seem to be lost in the split I've remade them.
2019-01-14 09:51:04 -06:00
if (state->xkb.caps_lock && state->args.show_caps_lock_indicator) {
cairo_set_source_u32(cairo, state->args.colors.caps_lock_key_highlight);
} else {
cairo_set_source_u32(cairo, state->args.colors.key_highlight);
}
R E N D E R I N G
2018-04-03 14:04:31 -05:00
} else {
Add caps lock state to indicator This implements customization for the indicator as proposed in sway#2788 with comments from sway#3367 in mind. The default behaviour does not change exept for the caps lock text color. Since these changes seem to be lost in the split I've remade them.
2019-01-14 09:51:04 -06:00
if (state->xkb.caps_lock && state->args.show_caps_lock_indicator) {
cairo_set_source_u32(cairo, state->args.colors.caps_lock_bs_highlight);
} else {
cairo_set_source_u32(cairo, state->args.colors.bs_highlight);
}
R E N D E R I N G
2018-04-03 14:04:31 -05:00
}
cairo_stroke(cairo);
// Draw borders
Implement swaylock customization flags
2018-07-10 20:29:15 -05:00
cairo_set_source_u32(cairo, state->args.colors.separator);
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
cairo_arc(cairo, buffer_width / 2, buffer_diameter / 2,
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
arc_radius, highlight_start,
highlight_start + type_indicator_border_thickness);
R E N D E R I N G
2018-04-03 14:04:31 -05:00
cairo_stroke(cairo);
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
cairo_arc(cairo, buffer_width / 2, buffer_diameter / 2,
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
arc_radius, highlight_start + TYPE_INDICATOR_RANGE,
R E N D E R I N G
2018-04-03 14:04:31 -05:00
highlight_start + TYPE_INDICATOR_RANGE +
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
type_indicator_border_thickness);
R E N D E R I N G
2018-04-03 14:04:31 -05:00
cairo_stroke(cairo);
}
// Draw inner + outer border of the circle
Implement swaylock customization flags
2018-07-10 20:29:15 -05:00
set_color_for_state(cairo, state, &state->args.colors.line);
Add hidpi support to swaylock
2018-04-03 18:15:14 -05:00
cairo_set_line_width(cairo, 2.0 * surface->scale);
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
cairo_arc(cairo, buffer_width / 2, buffer_diameter / 2,
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
arc_radius - arc_thickness / 2, 0, 2 * M_PI);
R E N D E R I N G
2018-04-03 14:04:31 -05:00
cairo_stroke(cairo);
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
cairo_arc(cairo, buffer_width / 2, buffer_diameter / 2,
Address review feedback from @emersion
2018-04-04 17:52:44 -05:00
arc_radius + arc_thickness / 2, 0, 2 * M_PI);
R E N D E R I N G
2018-04-03 14:04:31 -05:00
cairo_stroke(cairo);
Display xkb layout while typing Displays the current keyboard layout below the unlock indicator if more than one xkb layout is configured or the show-keyboard-layout option is given. The text is displayed with a background box. Adds commandline options for text color, background color and border color of the box as well.
2019-02-05 09:12:54 -06:00
Fix some typos Signed-off-by: Elyes HAOUAS <ehaouas@noos.fr>
2021-04-12 11:21:01 -05:00
// display layout text separately
Display xkb layout while typing Displays the current keyboard layout below the unlock indicator if more than one xkb layout is configured or the show-keyboard-layout option is given. The text is displayed with a background box. Adds commandline options for text color, background color and border color of the box as well.
2019-02-05 09:12:54 -06:00
if (layout_text) {
cairo_text_extents_t extents;
cairo_font_extents_t fe;
double x, y;
double box_padding = 4.0 * surface->scale;
cairo_text_extents(cairo, layout_text, &extents);
cairo_font_extents(cairo, &fe);
// upper left coordinates for box
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
x = (buffer_width / 2) - (extents.width / 2) - box_padding;
y = buffer_diameter;
Display xkb layout while typing Displays the current keyboard layout below the unlock indicator if more than one xkb layout is configured or the show-keyboard-layout option is given. The text is displayed with a background box. Adds commandline options for text color, background color and border color of the box as well.
2019-02-05 09:12:54 -06:00
// background box
cairo_rectangle(cairo, x, y,
extents.width + 2.0 * box_padding,
fe.height + 2.0 * box_padding);
cairo_set_source_u32(cairo, state->args.colors.layout_background);
cairo_fill_preserve(cairo);
// border
cairo_set_source_u32(cairo, state->args.colors.layout_border);
cairo_stroke(cairo);
// take font extents and padding into account
cairo_move_to(cairo,
x - extents.x_bearing + box_padding,
y + (fe.height - fe.descent) + box_padding);
cairo_set_source_u32(cairo, state->args.colors.layout_text);
cairo_show_text(cairo, layout_text);
cairo_new_sub_path(cairo);
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
}
Fix indicator buffer not resizing after display powers off
2021-06-27 22:46:01 -05:00
}
Resizable buffer size for the subsurface
2019-06-13 18:41:57 -05:00
Estimate buffer size in advance for render_frame The size of the surface used to draw the indicator depends on the extents of the text being drawn on and under the indicator. This commit refactors the `render_frame` function so that the surface size is computed before drawing; before, `render_frame` drew onto a buffer, estimated the size the buffer should have had, and recursively called itself to try again with the estimated size, if necessary. This was done because Cairo's methods to estimate font and text size require that a cairo_t context object and an associated cairo_surface already have been set up. Since the surface size depends on the text size, the natural way to use Cairo would have a circular dependency. In order to compute sizes _before_ the buffer is created, this commit adds a 1x1 surface and a matching `test_cairo` context which is set to the same font and drawing parameters as the buffer that will be created. Font/text extent measurements should give the same results as for the final buffer.
2023-01-14 13:51:47 -06:00
// Send Wayland requests
wl_subsurface_set_position(surface->subsurface, subsurf_xpos, subsurf_ypos);
R E N D E R I N G
2018-04-03 14:04:31 -05:00
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
wl_surface_set_buffer_scale(surface->child, surface->scale);
renderer: work with current buffer locally No need to store this globally accessible struct member.
2022-09-24 03:18:20 -05:00
wl_surface_attach(surface->child, buffer->buffer, 0, 0);
Use wl_surface.damage_buffer We incorrectly used the buffer size instead of the surface size. Let's not bother and just damage the maximum region.
2021-02-10 10:45:42 -06:00
wl_surface_damage_buffer(surface->child, 0, 0, INT32_MAX, INT32_MAX);
Decouple the drawing of the background from drawing the indicator. * Render background only once in main wl_surface * Render indicator on subsurface
2019-03-12 05:16:33 -05:00
wl_surface_commit(surface->child);
Improve frame callback and commit handling The few places that required a surface commit relied on render_frame and render_frame_background to form it form them after they had set up frame callback events. This would fail if render_frame ran out of buffers and exited early, as the caller would still wait indefinitely on the frame callback. swaylock would quite consistently run out of buffers when rendering immediately after a configure event, such as when the keypress causing render also caused outputs to be enabled from idle. Restructure the render and commit handling slightly so that the whole frame callback and commit setup is handled by the render code, which now has a single render entrypoint. This both avoids stalls from lacking commits, but also fixes the case the configure path to respect frame callbacks so we do not run out of buffers in the first place.
2024-09-06 17:27:37 -05:00
return true;
R E N D E R I N G
2018-04-03 14:04:31 -05:00
}
Reference in New Issue Copy Permalink