235 lines
6.7 KiB
C
235 lines
6.7 KiB
C
#include "group.h"
|
|
#include "button.h"
|
|
#include "d_array.h"
|
|
#include "fs_file_list.h"
|
|
#include "input.h"
|
|
#include "progress_bar.h"
|
|
#include "widget_core.h"
|
|
#include <ncurses.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <utils.h>
|
|
|
|
void group_default_callback(callback_args_t *args) {
|
|
group_t *g = (group_t *)args->element;
|
|
int32_t key = *((int32_t *)args->data);
|
|
int64_t response = args->resp_data.val.val.num;
|
|
input_t *input;
|
|
widget_t *widget;
|
|
group_el_t *element_ptr = args->active_el;
|
|
u_int32_t start_pos = 0;
|
|
callback_args_t new_args;
|
|
switch (key) {
|
|
case '\n': /* Enter */
|
|
args->resp_data.code = cbrp_val;
|
|
mempcpy(&(args->resp_data.val), &(element_ptr->val), sizeof(struct val_t));
|
|
break;
|
|
case KEY_BACKSPACE:
|
|
case KEY_DL:
|
|
if (element_ptr->type == w_input) {
|
|
input = (input_t *)element_ptr->element;
|
|
if (input->value_len) {
|
|
if (input->cur_pos > 0) {
|
|
start_pos = input->value_len-- - input->cur_pos;
|
|
memmove(input->value + start_pos - 1, input->value + start_pos,
|
|
input->value_len - start_pos + 2);
|
|
} else {
|
|
input->value[--input->value_len] = '\0';
|
|
}
|
|
}
|
|
}
|
|
args->resp_data.code = cbrc_none;
|
|
break;
|
|
default:
|
|
if (element_ptr->type == w_input) {
|
|
input = (input_t *)element_ptr->element;
|
|
if (input->max_len > input->value_len) {
|
|
if (input->cur_pos > 0) {
|
|
start_pos = input->value_len++ - input->cur_pos;
|
|
memmove(input->value + start_pos + 1, input->value + start_pos,
|
|
input->value_len - start_pos);
|
|
input->value[start_pos] = key;
|
|
} else {
|
|
input->value[input->value_len++] = key;
|
|
input->value[input->value_len] = '\0';
|
|
}
|
|
}
|
|
} else {
|
|
/* callback case */
|
|
widget = (widget_t *)element_ptr->element;
|
|
if (widget->callback != NULL) {
|
|
memccpy(&new_args, args, 1, sizeof(callback_args_t));
|
|
new_args.element = element_ptr->element;
|
|
widget->callback(&new_args);
|
|
break;
|
|
}
|
|
}
|
|
args->resp_data.code = cbrc_none;
|
|
break;
|
|
}
|
|
}
|
|
|
|
union current_element {
|
|
group_t *group;
|
|
enum w_type type;
|
|
};
|
|
|
|
group_t *init_group(WINDOW **win, widget_t *w_parent, group_el_init_t *children,
|
|
d_array_ptr_t *id_map, enum g_direction direction, enum g_type g_type) {
|
|
group_t *group = malloc(sizeof(group_t));
|
|
union current_element current;
|
|
group->parent_group = NULL;
|
|
current.type = w_end;
|
|
init_widget(&(group->w), w_parent, win, "");
|
|
/* count elements */
|
|
group->count = 0;
|
|
for (; children[group->count].type != w_end; group->count++)
|
|
;
|
|
group->w.w_parent = w_parent;
|
|
group->w.callback = group_default_callback;
|
|
if (group->count == 0) {
|
|
return group;
|
|
}
|
|
group->elements = calloc(group->count, sizeof(group_el_t));
|
|
group_el_t *elements = group->elements;
|
|
for (int32_t i = 0; i < group->count; i++) {
|
|
elements[i].type = children[i].type;
|
|
elements[i].is_default = children[i].is_default;
|
|
elements[i].g_type = g_type;
|
|
elements[i].idx = i;
|
|
elements[i].val.type = val_nul;
|
|
}
|
|
|
|
/* init child elements */
|
|
for (int32_t i = 0; i < group->count; i++) {
|
|
widget_t *w;
|
|
switch (elements[i].type) {
|
|
case w_button:
|
|
elements[i].element = init_button(win, &(group->w), children[i].label);
|
|
elements[i].val.type = val_num;
|
|
elements[i].val.val.num = children[i].val.num;
|
|
w = &(((button_t *)elements[i].element)->w);
|
|
break;
|
|
case w_box:
|
|
case w_end:
|
|
break;
|
|
case w_group:
|
|
elements[i].element = init_group(win, &(group->w), children[i].children,
|
|
id_map, children[i].direction, g_type);
|
|
w = &(((group_t *)elements[i].element)->w);
|
|
current.group = (group_t *)elements[i].element;
|
|
current.group->parent_group = group;
|
|
if (i == 0) {
|
|
group->first_id = current.group->first_id;
|
|
group->last_id = current.group->last_id;
|
|
} else {
|
|
group->last_id = current.group->last_id;
|
|
}
|
|
current.type = w_group;
|
|
break;
|
|
case w_input:
|
|
elements[i].element =
|
|
init_input(win, &(group->w), children[i].label, children[i].length,
|
|
children[i].is_hidden_value);
|
|
w = &(((input_t *)elements[i].element)->w);
|
|
break;
|
|
case w_progress:
|
|
elements[i].element = init_ui_progress_bar(win, &(group->w));
|
|
w = &(((ui_progress_bar_t *)elements[i].element)->w);
|
|
break;
|
|
case w_fs_file_list:
|
|
elements[i].element = init_fs_file_list(win, &(group->w));
|
|
w = &(((ui_progress_bar_t *)elements[i].element)->w);
|
|
break;
|
|
}
|
|
if (current.type != w_group) {
|
|
if (i == 0) {
|
|
group->first_id = w->id;
|
|
group->last_id = w->id;
|
|
} else {
|
|
group->last_id = w->id;
|
|
}
|
|
}
|
|
/* set dimensions */
|
|
elements[i].id = w->id;
|
|
add_d_arr_ptr(id_map, elements + i, w->id);
|
|
if (direction == horizontal) {
|
|
w->m_x = group->w.m_x + 1 + group->w.x;
|
|
w->m_y = group->w.m_y;
|
|
group->w.x += w->x + 1;
|
|
if (group->w.y < w->y)
|
|
group->w.y = w->y;
|
|
} else {
|
|
w->m_x = group->w.m_x;
|
|
w->m_y = group->w.m_y + group->w.y;
|
|
group->w.y += w->y;
|
|
if (group->w.x < w->x)
|
|
group->w.x = w->x;
|
|
}
|
|
}
|
|
|
|
if (direction == vertical)
|
|
group->w.y++;
|
|
|
|
return group;
|
|
}
|
|
|
|
void draw_group(WINDOW *win, group_t *group, int32_t active_id) {
|
|
group_el_t *children = group->elements;
|
|
for (int i = 0; i < group->count; i++) {
|
|
group_el_t *el = &children[i];
|
|
switch (el->type) {
|
|
case w_button:
|
|
draw_button((button_t *)el->element, active_id);
|
|
break;
|
|
case w_group:
|
|
draw_group(win, (group_t *)el->element, active_id);
|
|
break;
|
|
case w_box:
|
|
case w_end:
|
|
break;
|
|
case w_input:
|
|
draw_input((input_t *)el->element, active_id);
|
|
break;
|
|
case w_progress:
|
|
draw_ui_progress_bar((ui_progress_bar_t *)el->element);
|
|
break;
|
|
case w_fs_file_list:
|
|
draw_fs_file_list((ui_fs_file_list_t *)el->element);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void destroy_group(group_t *group) {
|
|
group_el_t *children = group->elements;
|
|
for (int i = 0; i < group->count; i++) {
|
|
group_el_t *el = &children[i];
|
|
switch (el->type) {
|
|
case w_button:
|
|
destroy_button(el->element);
|
|
break;
|
|
case w_group:
|
|
destroy_group(el->element);
|
|
break;
|
|
case w_box:
|
|
case w_end:
|
|
break;
|
|
case w_input:
|
|
destroy_input(el->element);
|
|
break;
|
|
case w_progress:
|
|
destroy_ui_progress_bar(el->element);
|
|
break;
|
|
case w_fs_file_list:
|
|
destroy_fs_file_list(el->element);
|
|
break;
|
|
}
|
|
}
|
|
if (group->elements != NULL) {
|
|
free(group->elements);
|
|
}
|
|
free(group);
|
|
} |