343 lines
10 KiB
C
343 lines
10 KiB
C
/* SPDX-License-Identifier: MIT */
|
|
/* Copyright (c) 2026 Oleksandr Zhylin */
|
|
#include <ncursesw/ncurses.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <wchar.h>
|
|
#include <widget.h>
|
|
#include <widget_core.h>
|
|
#include <core/app.h>
|
|
|
|
static void (*active_callback_backup)(w_cb_args_t *) = NULL;
|
|
|
|
static void incr_active_id(w_dialogue_t *d) {
|
|
w_g_el_t *active_el = NULL;
|
|
while (true) {
|
|
for (int i = d->active_el->id + 1;
|
|
active_el == NULL && d->id_map.length > i; i++) {
|
|
active_el = d->id_map.arr[i];
|
|
}
|
|
d->active_el = active_el;
|
|
if (d->active_el == NULL) {
|
|
d->active_el = d->id_map.fist_el;
|
|
break;
|
|
} else if (d->active_el->type != w_box && d->active_el->type != w_group) {
|
|
break;
|
|
}
|
|
active_el = NULL;
|
|
}
|
|
}
|
|
|
|
static void decr_active_id(w_dialogue_t *d) {
|
|
w_g_el_t *active_el = NULL;
|
|
while (true) {
|
|
for (int i = d->active_el->id - 1; active_el == NULL && i > 0; i--) {
|
|
active_el = d->id_map.arr[i];
|
|
}
|
|
d->active_el = active_el;
|
|
if (d->active_el == NULL) {
|
|
d->active_el = d->id_map.last_el;
|
|
break;
|
|
} else if (d->active_el->type != w_box && d->active_el->type != w_group) {
|
|
break;
|
|
}
|
|
active_el = NULL;
|
|
}
|
|
}
|
|
|
|
#define CH_GROUP(d, current, next) \
|
|
{ \
|
|
if (d->active.type == current) { \
|
|
d->active.type = next; \
|
|
diff = d->active.id - d->current->first_id; \
|
|
if (diff > d->next->last_id - d->next->first_id) { \
|
|
d->active.id = d->next->last_id; \
|
|
} else { \
|
|
d->active.id = d->next->first_id + diff; \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
static void case_callback(w_cb_args_t *args, w_cb_args_t *new_args) {
|
|
w_dialogue_t *d = args->element;
|
|
/* run callback function */
|
|
if (d->active_el->g_type == g_content) {
|
|
new_args->element = d->g_content;
|
|
} else {
|
|
new_args->element = d->g_action;
|
|
}
|
|
w_group_cb_default(new_args);
|
|
/* copy new result to the parental structure */
|
|
mempcpy(&(args->resp_data), &(new_args->resp_data),
|
|
sizeof(new_args->resp_data));
|
|
}
|
|
|
|
void w_dialogue_callback_default(w_cb_args_t *args) {
|
|
w_dialogue_t *d = args->element;
|
|
int32_t key = *((int32_t *)args->data);
|
|
w_cb_args_t new_args;
|
|
memcpy(&new_args, args, sizeof(w_cb_args_t));
|
|
new_args.active_el = d->active_el;
|
|
int32_t diff;
|
|
d->needs_update = true;
|
|
w_input_t *input;
|
|
w_t *widget;
|
|
switch (key) {
|
|
case '\t':
|
|
incr_active_id(d);
|
|
args->resp_data.code = cbrc_none;
|
|
break;
|
|
case '\33': /* Esc key */
|
|
args->resp_data.code = cbrp_val;
|
|
args->resp_data.val.val.num = -2;
|
|
break;
|
|
case KEY_RIGHT:
|
|
if (d->active_el->type == w_input) {
|
|
case_callback(args, &new_args);
|
|
break;
|
|
}
|
|
incr_active_id(d);
|
|
args->resp_data.code = cbrc_none;
|
|
break;
|
|
case KEY_LEFT:
|
|
if (d->active_el->type == w_input) {
|
|
case_callback(args, &new_args);
|
|
break;
|
|
}
|
|
decr_active_id(d);
|
|
args->resp_data.code = cbrc_none;
|
|
break;
|
|
case '\n':
|
|
widget = (w_t *)d->active_el->element;
|
|
if (widget->callback != NULL) { /* Existing callback case */
|
|
new_args.element = widget;
|
|
widget->callback(&new_args);
|
|
memcpy(&(args->resp_data), &(new_args.resp_data), sizeof(w_cbrp_data));
|
|
break;
|
|
} /* Default cases */
|
|
if (d->active_el->g_type == g_action) {
|
|
new_args.element = d->g_action;
|
|
w_group_cb_default(&new_args);
|
|
mempcpy(&(args->resp_data), &(new_args.resp_data),
|
|
sizeof(new_args.resp_data));
|
|
} else if (d->g_action != NULL) {
|
|
for (int i = 0; i < d->g_action->count; i++) {
|
|
if (d->g_action->elements[i].is_default) {
|
|
args->resp_data.code = cbrp_val;
|
|
args->resp_data.val.val.num = i;
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
args->resp_data.code = cbrp_val;
|
|
args->resp_data.val.val.num = d->active_el->idx;
|
|
return;
|
|
}
|
|
break;
|
|
case KEY_UP:
|
|
decr_active_id(d);
|
|
args->resp_data.code = cbrc_none;
|
|
break;
|
|
case KEY_DOWN:
|
|
incr_active_id(d);
|
|
args->resp_data.code = cbrc_none;
|
|
break;
|
|
default:
|
|
/* run callback function */
|
|
case_callback(args, &new_args);
|
|
}
|
|
}
|
|
|
|
void w_dialogue_init(w_dialogue_t *dialogue, const char title[],
|
|
const char text[], coordinates_t *p_coordinates) {
|
|
int32_t t_size = 0;
|
|
dialogue->win = 0;
|
|
dialogue->g_content = NULL;
|
|
dialogue->w.sz.x = 0;
|
|
dialogue->w.sz.y = 0;
|
|
dialogue->p_coordinates = p_coordinates;
|
|
dialogue->w.callback = w_dialogue_callback_default;
|
|
dialogue->is_initiated = true;
|
|
dialogue->needs_update = true;
|
|
dialogue->needs_destroy = false;
|
|
dialogue->color_scheme = dc_normal;
|
|
strcpy(dialogue->w.title, title);
|
|
t_size = strlen(text);
|
|
strcpy(dialogue->text, text);
|
|
u_d_arr_ptr_init(&(dialogue->id_map), MAX_IDS);
|
|
/* trim the last new line symbol */
|
|
if (t_size && dialogue->text[t_size - 1] == '\n')
|
|
dialogue->text[t_size - 1] = '\0';
|
|
}
|
|
|
|
/* variadic */
|
|
void w_dialogue_vinit(w_dialogue_t *dialogue, const char title[],
|
|
coordinates_t *p_coordinates, const char fmt[],
|
|
va_list *v_args) {
|
|
char f_text[DIALOGUE_TEXT];
|
|
vsprintf(f_text, fmt, *v_args);
|
|
w_dialogue_init(dialogue, title, f_text, p_coordinates);
|
|
}
|
|
|
|
int group_init_active_id(w_group_t *g, w_dialogue_t *d) {
|
|
enum w_type wt;
|
|
|
|
for (int i = 0; i < g->count; i++) {
|
|
wt = g->elements[i].type;
|
|
if (wt == w_button || wt == w_input ||
|
|
wt == w_checkbox) { /* Add here new types */
|
|
d->active_el = g->elements + i;
|
|
return 1;
|
|
} else if (wt == w_group) {
|
|
w_group_t *child_g = g->elements[i].element;
|
|
return group_init_active_id(child_g, d);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void w_dialogue_init_active_id(w_dialogue_t *dialogue) {
|
|
if (dialogue->g_content != NULL) {
|
|
if (group_init_active_id(dialogue->g_content, dialogue)) {
|
|
return;
|
|
}
|
|
}
|
|
if (dialogue->g_action != NULL) {
|
|
if (group_init_active_id(dialogue->g_action, dialogue)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
#define DETECT_GROUP_SIZE(group, line_max_len, y, x) \
|
|
if (group) { \
|
|
group->w.ps.y = y; \
|
|
if (line_max_len < group->w.sz.x) { \
|
|
line_max_len = group->w.sz.x; \
|
|
group->w.ps.x = 0; \
|
|
} else { \
|
|
group->w.ps.x = (line_max_len - group->w.sz.x) / 2; \
|
|
} \
|
|
y += group->w.sz.y; \
|
|
}
|
|
|
|
int32_t w_dialogue_draw(w_dialogue_t *d) {
|
|
if (!d->is_initiated)
|
|
return -1;
|
|
else if (!d->needs_update) {
|
|
return 0;
|
|
}
|
|
|
|
w_g_el_t *ae_ptr = NULL; /* active element */
|
|
/* count dimensions */
|
|
int32_t x = 1; /* when uses box */
|
|
int32_t y = 1; /* when uses box */
|
|
|
|
/* analyze text content */
|
|
int32_t line_count = 0;
|
|
int32_t line_max_len = 0;
|
|
wchar_t *main_text_wide = malloc(sizeof(wchar_t) * strlen(d->text));
|
|
size_t mwt_len;
|
|
u_utf8_convert_to_wide(d->text, &main_text_wide, &mwt_len);
|
|
line_count = w_text_divide_by_lines(
|
|
main_text_wide, mwt_len, d->p_coordinates->max_x * 0.77, &line_max_len);
|
|
y += line_count;
|
|
y += 2; /* margin for text */
|
|
|
|
/* analyze groups */
|
|
DETECT_GROUP_SIZE(d->g_content, line_max_len, y, x);
|
|
DETECT_GROUP_SIZE(d->g_action, line_max_len, y, x);
|
|
x += line_max_len;
|
|
|
|
x += 2; /* when uses box */
|
|
y += 2; /* when uses box */
|
|
|
|
d->w.sz.x = x;
|
|
d->w.sz.y = y;
|
|
d->w.ps.y = (d->p_coordinates->max_y - y) / 2;
|
|
d->w.ps.x = (d->p_coordinates->max_x - x) / 2;
|
|
|
|
/* render window */
|
|
if (d->win == NULL) {
|
|
d->win = newwin(y, x, d->w.ps.y, d->w.ps.x);
|
|
}
|
|
|
|
switch (d->color_scheme) {
|
|
case dc_normal:
|
|
wattrset(d->win, COLOR_PAIR(0) | A_REVERSE);
|
|
break;
|
|
case dc_alert:
|
|
wattrset(d->win, COLOR_PAIR(4) | A_REVERSE);
|
|
break;
|
|
}
|
|
|
|
/* background */
|
|
for (int yp = 1; yp < d->w.sz.y - 1; yp++) {
|
|
mvwprintw(d->win, yp, 1, "%*s", (int)d->w.sz.x, "");
|
|
}
|
|
|
|
/* title */
|
|
const int32_t title_mx_pos = (d->w.sz.x - strlen(d->w.title)) / 2;
|
|
box(d->win, 0, 0);
|
|
mvwprintw(d->win, 0, title_mx_pos - 1, " ");
|
|
mvwprintw(d->win, 0, title_mx_pos, "%s", d->w.title);
|
|
mvwprintw(d->win, 0, title_mx_pos + strlen(d->w.title), " ");
|
|
|
|
/* text */
|
|
wattroff(d->win, A_BOLD);
|
|
/* mvwhline(d->win, d->w.sz.y - 3, 1, 0, d->w.sz.x - 2); */
|
|
w_print_multiline_text_wide(d->win, main_text_wide, mwt_len, line_max_len,
|
|
d->w.sz.x, 2, 0, PMT_ALIGN_CENTER);
|
|
wattroff(d->win, A_REVERSE);
|
|
|
|
if (d->g_content != NULL) {
|
|
w_group_draw(d->win, d->g_content, d->active_el->id);
|
|
}
|
|
if (d->g_action != NULL) {
|
|
w_group_draw(d->win, d->g_action, d->active_el->id);
|
|
}
|
|
|
|
/* move cursor */
|
|
if (d->active_el != NULL &&
|
|
(d->active_el->type == w_input || d->active_el->type == w_checkbox)) {
|
|
w_t *w = d->active_el->element;
|
|
d->w.cur.y = w->cur.y;
|
|
d->w.cur.x = w->cur.x;
|
|
if (d->w.cur.y || d->w.cur.x) {
|
|
wmove(d->win, d->w.cur.y, d->w.cur.x);
|
|
curs_set(true);
|
|
}
|
|
|
|
} else {
|
|
curs_set(false);
|
|
}
|
|
|
|
d->needs_update = false;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void w_dialogue_destroy(w_dialogue_t *d, void *_app) {
|
|
app_t *app = (app_t *)_app;
|
|
if (d->g_content) {
|
|
w_group_destroy(d->g_content);
|
|
}
|
|
if (d->g_action) {
|
|
w_group_destroy(d->g_action);
|
|
}
|
|
delwin(d->win);
|
|
d->win = NULL;
|
|
d->is_initiated = false;
|
|
d->needs_destroy = false;
|
|
d->needs_update = false;
|
|
app->active_callback = (w_cb_t)app->main_ui.cb_b_press;
|
|
app->query_args->active_dialogue = NULL;
|
|
u_d_arr_ptr_free(&(d->id_map));
|
|
curs_set(false);
|
|
app_refresh(app);
|
|
} |