Introduce a statusline buffer.

A buffer is introduced for the statusline which will only be copied to the actual statusline
once an entire statusline is parsed. This avoids a race condition where incompletely parsed
statuslines were rendered, causing only some status blocks to be rendered which is visible to
the user as a flickering.

fixes #1480
This commit is contained in:
Ingo Bürk 2015-02-18 20:11:42 +01:00
parent 9ff230c375
commit 296fbdde12

View File

@ -54,25 +54,40 @@ typedef struct parser_ctx {
parser_ctx parser_context;
/* The buffer statusline points to */
struct statusline_head statusline_head = TAILQ_HEAD_INITIALIZER(statusline_head);
/* Used temporarily while reading a statusline */
struct statusline_head statusline_buffer = TAILQ_HEAD_INITIALIZER(statusline_buffer);
int child_stdin;
/*
* Clears all blocks from the statusline structure in memory and frees their
* associated resources.
* Remove all blocks from the given statusline.
* If free_resources is set, the fields of each status block will be free'd.
*/
static void clear_status_blocks() {
static void clear_statusline(struct statusline_head *head, bool free_resources) {
struct status_block *first;
while (!TAILQ_EMPTY(&statusline_head)) {
first = TAILQ_FIRST(&statusline_head);
I3STRING_FREE(first->full_text);
TAILQ_REMOVE(&statusline_head, first, blocks);
while (!TAILQ_EMPTY(head)) {
first = TAILQ_FIRST(head);
if (free_resources) {
I3STRING_FREE(first->full_text);
FREE(first->color);
FREE(first->name);
}
TAILQ_REMOVE(head, first, blocks);
free(first);
}
}
static void copy_statusline(struct statusline_head *from, struct statusline_head *to) {
struct status_block *current;
TAILQ_FOREACH (current, from, blocks) {
struct status_block *new_block = smalloc(sizeof(struct status_block));
memcpy(new_block, current, sizeof(struct status_block));
TAILQ_INSERT_TAIL(to, new_block, blocks);
}
}
/*
* Replaces the statusline in memory with an error message. Pass a format
* string and format parameters as you would in `printf'. The next time
@ -80,7 +95,7 @@ static void clear_status_blocks() {
* the space allocated for the statusline.
*/
__attribute__((format(printf, 1, 2))) static void set_statusline_error(const char *format, ...) {
clear_status_blocks();
clear_statusline(&statusline_head, true);
char *message;
va_list args;
@ -126,20 +141,12 @@ void cleanup(void) {
/*
* The start of a new array is the start of a new status line, so we clear all
* previous entries.
*
* previous entries from the buffer.
*/
static int stdin_start_array(void *context) {
struct status_block *first;
while (!TAILQ_EMPTY(&statusline_head)) {
first = TAILQ_FIRST(&statusline_head);
I3STRING_FREE(first->full_text);
FREE(first->color);
FREE(first->name);
FREE(first->instance);
TAILQ_REMOVE(&statusline_head, first, blocks);
free(first);
}
// the blocks are still used by statusline_head, so we won't free the
// resources here.
clear_statusline(&statusline_buffer, false);
return 1;
}
@ -222,6 +229,10 @@ static int stdin_integer(void *context, long long val) {
return 1;
}
/*
* When a map is finished, we have an entire status block.
* Move it from the parser's context to the statusline buffer.
*/
static int stdin_end_map(void *context) {
parser_ctx *ctx = context;
struct status_block *new_block = smalloc(sizeof(struct status_block));
@ -232,11 +243,19 @@ static int stdin_end_map(void *context) {
new_block->full_text = i3string_from_utf8("SPEC VIOLATION: full_text is NULL!");
if (new_block->urgent)
ctx->has_urgent = true;
TAILQ_INSERT_TAIL(&statusline_head, new_block, blocks);
TAILQ_INSERT_TAIL(&statusline_buffer, new_block, blocks);
return 1;
}
/*
* When an array is finished, we have an entire statusline.
* Copy it from the buffer to the actual statusline.
*/
static int stdin_end_array(void *context) {
DLOG("copying statusline_buffer to statusline_head\n");
clear_statusline(&statusline_head, true);
copy_statusline(&statusline_buffer, &statusline_head);
DLOG("dumping statusline:\n");
struct status_block *current;
TAILQ_FOREACH(current, &statusline_head, blocks) {