mirrors
/
Nuklear
mirror of https://github.com/Immediate-Mode-UI/Nuklear
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Nuklear/demo/demo.c

636 lines
23 KiB
C
Raw Blame History

#define MAX_BUFFER 64
#define MAX_MEMORY (64 * 1024)
struct settings_window {
struct gui_panel_hook hook;
/* brush tab */
gui_bool brush_tab;
gui_bool radius_u_active;
gui_bool radius_l_active;
gui_float radiusu;
gui_float radiusl;
gui_bool rotate_to_stroke;
/* color tab */
gui_bool color_tab;
struct gui_color color;
gui_float opacity;
gui_bool opacity_active;
/* floot tab */
gui_bool flood_tab;
struct gui_color flood_color;
gui_float flood_opacity;
gui_size flood_type;
/* paint tabs */
gui_bool paint_tab;
gui_size artisan_type;
gui_size effect_type;
gui_size brush_mode;
/* texture tab */
gui_bool texture_tab;
gui_size attribute;
gui_bool update_on_stroke;
gui_bool save_on_stroke;
gui_bool extend_seam_color;
};
struct show_window {
struct gui_panel_hook hook;
/* input buffer */
gui_char input_buffer[MAX_BUFFER];
gui_size input_length;
gui_bool input_active;
/* command buffer */
gui_char command_buffer[MAX_BUFFER];
gui_size command_length;
gui_bool command_active;
/* widgets state */
gui_bool checkbox;
gui_float slider;
gui_size progressbar;
gui_int spinner;
gui_bool spinner_active;
gui_size item_current;
gui_size shelf_selection;
gui_int combo_selection;
gui_bool toggle;
gui_int option;
/* tabs */
gui_bool combobox_tab;
gui_bool widget_tab;
gui_bool table_tab;
/* scrollbars */
gui_float shelf_scrollbar;
gui_float table_scrollbar;
};
struct control_window {
struct gui_panel_hook hook;
gui_flags show_flags;
/* tabs */
gui_bool flag_tab;
gui_bool style_tab;
gui_bool color_tab;
/* color picker */
gui_bool picker_active;
gui_bool spinner_r_active;
gui_bool spinner_g_active;
gui_bool spinner_b_active;
gui_bool spinner_a_active;
gui_size current_color;
struct gui_color color;
};
struct demo_gui {
struct show_window show;
struct control_window control;
struct settings_window settings;
struct gui_memory memory;
struct gui_command_buffer buffer;
struct gui_layout_config conf;
struct gui_panel_stack background;
struct gui_layout layout;
struct gui_panel_stack floating;
struct gui_panel_layout tab;
struct gui_config config;
struct gui_font font;
gui_size width, height;
};
static void
combobox_panel(struct gui_panel_layout *panel, struct show_window *demo)
{
gui_int i = 0;
static const char *options[] = {"easy", "normal", "hard", "hell", "doom", "godlike"};
gui_panel_row(panel, 30, 3);
for (i = 0; i < (gui_int)LEN(options); i++) {
if (gui_panel_option(panel, options[i], demo->combo_selection == i))
demo->combo_selection = i;
}
}
static void
widget_panel(struct gui_panel_layout *panel, struct show_window *demo)
{
char buffer[MAX_BUFFER];
const char *items[] = {"Fist", "Pistol", "Shotgun", "Railgun", "BFG"};
gui_panel_row(panel, 30, 1);
gui_panel_label(panel, "text left", GUI_TEXT_LEFT);
gui_panel_label(panel, "text center", GUI_TEXT_CENTERED);
gui_panel_label(panel, "text right", GUI_TEXT_RIGHT);
if (gui_panel_button_text(panel, "button", GUI_BUTTON_DEFAULT))
fprintf(stdout, "button pressed!\n");
demo->toggle = gui_panel_button_toggle(panel, "toggle", demo->toggle);
demo->checkbox = gui_panel_check(panel, "checkbox", demo->checkbox);
gui_panel_row(panel, 30, 2);
if (gui_panel_option(panel, "option 0", demo->option == 0)) demo->option = 0;
if (gui_panel_option(panel, "option 1", demo->option == 1)) demo->option = 1;
demo->slider = gui_panel_slider(panel, 0, demo->slider, 10, 1.0f);
sprintf(buffer, "%.2f", demo->slider);
gui_panel_label(panel, buffer, GUI_TEXT_LEFT);
demo->progressbar = gui_panel_progress(panel, demo->progressbar, 100, gui_true);
sprintf(buffer, "%lu", demo->progressbar);
gui_panel_label(panel, buffer, GUI_TEXT_LEFT);
gui_panel_row(panel, 30, 1);
demo->item_current = gui_panel_selector(panel, items, LEN(items), demo->item_current);
demo->spinner = gui_panel_spinner(panel, 0, demo->spinner, 250, 10, &demo->spinner_active);
if (gui_panel_shell(panel, demo->command_buffer, &demo->command_length, MAX_BUFFER, &demo->command_active))
demo->command_length = 0;
demo->input_length = gui_panel_edit(panel, demo->input_buffer, demo->input_length,
MAX_BUFFER, &demo->input_active, GUI_INPUT_DEFAULT);
}
static void
graph_panel(struct gui_panel_layout *panel, gui_size current)
{
enum {HISTO, PLOT};
static const gui_float values[] = {8.0f,15.0f,20.0f,12.0f,30.0f,12.0f,35.0f,40.0f,20.0f};
gui_panel_row(panel, 100, 1);
if (current == HISTO) {
gui_panel_graph(panel, GUI_GRAPH_HISTO, values, LEN(values));
} else {
gui_panel_graph(panel, GUI_GRAPH_LINES, values, LEN(values));
}
}
static void
table_panel(struct gui_panel_layout *panel)
{
static const struct gui_color header = {178, 122, 1, 255};
gui_panel_table_begin(panel, GUI_TABLE_HHEADER, 30, 2);
gui_panel_label_colored(panel, "MOVEMENT", GUI_TEXT_CENTERED, header);
gui_panel_label_colored(panel, "KEY/BUTTON", GUI_TEXT_CENTERED, header);
gui_panel_table_row(panel);
gui_panel_label(panel, "Move foward", GUI_TEXT_LEFT);
gui_panel_label(panel, "w", GUI_TEXT_CENTERED);
gui_panel_table_row(panel);
gui_panel_label(panel, "Move back", GUI_TEXT_LEFT);
gui_panel_label(panel, "s", GUI_TEXT_CENTERED);
gui_panel_table_row(panel);
gui_panel_label(panel, "Move left", GUI_TEXT_LEFT);
gui_panel_label(panel, "a", GUI_TEXT_CENTERED);
gui_panel_table_row(panel);
gui_panel_label(panel, "Move right", GUI_TEXT_LEFT);
gui_panel_label(panel, "d", GUI_TEXT_CENTERED);
gui_panel_table_row(panel);
gui_panel_label(panel, "Jump", GUI_TEXT_LEFT);
gui_panel_label(panel, "SPACE", GUI_TEXT_CENTERED);
gui_panel_table_row(panel);
gui_panel_label(panel, "Duck", GUI_TEXT_LEFT);
gui_panel_label(panel, "CTRL", GUI_TEXT_CENTERED);
gui_panel_table_end(panel);
}
static void
init_show(struct show_window *win, struct gui_config *config, struct gui_font *font,
struct gui_panel_stack *stack)
{
gui_panel_hook_init(&win->hook, 50, 50, 300, 500,
GUI_PANEL_BORDER|GUI_PANEL_MOVEABLE|
GUI_PANEL_CLOSEABLE|GUI_PANEL_SCALEABLE|
GUI_PANEL_MINIMIZABLE, config, font);
gui_stack_push(stack, &win->hook);
win->widget_tab = GUI_MINIMIZED;
win->combobox_tab = GUI_MINIMIZED;
win->slider = 5.0f;
win->progressbar = 50;
win->spinner = 100;
}
static void
update_show(struct show_window *show, struct gui_panel_stack *stack,
struct gui_input *in, struct gui_canvas *canvas)
{
struct gui_panel_layout layout;
struct gui_panel_layout tab;
static const char *shelfs[] = {"Histogram", "Lines"};
gui_panel_hook_begin_stacked(&layout, &show->hook, stack, "Show", canvas, in);
show->combobox_tab = gui_panel_tab_begin(&layout, &tab, "Combobox", show->combobox_tab);
combobox_panel(&tab, show);
gui_panel_tab_end(&layout, &tab);
show->widget_tab = gui_panel_tab_begin(&layout, &tab, "Widgets", show->widget_tab);
widget_panel(&tab, show);
gui_panel_tab_end(&layout, &tab);
gui_panel_row(&layout, 180, 1);
show->shelf_selection = gui_panel_shelf_begin(&layout, &tab, shelfs,
LEN(shelfs), show->shelf_selection, show->shelf_scrollbar);
graph_panel(&tab, show->shelf_selection);
show->shelf_scrollbar = gui_panel_shelf_end(&layout, &tab);
gui_panel_row(&layout, 180, 1);
gui_panel_group_begin(&layout, &tab, "Table", show->table_scrollbar);
table_panel(&tab);
show->table_scrollbar = gui_panel_group_end(&layout, &tab);
gui_panel_hook_end(&layout, &show->hook);
}
static void
update_flags(struct gui_panel_layout *panel, struct control_window *control)
{
gui_flags i = 0x01;
gui_size n = 0;
gui_flags res = 0;
const char *options[] = {"Hidden", "Border", "Minimizable", "Closeable", "Moveable", "Scaleable"};
gui_panel_row(panel, 30, 2);
do {
if (gui_panel_check(panel, options[n++], (control->show_flags & i) ? gui_true : gui_false))
res |= i;
i = i << 1;
} while (i <= GUI_PANEL_SCALEABLE);
control->show_flags = res;
}
static void
style_tab(struct gui_panel_layout *panel, struct gui_config *config)
{
gui_int tx, ty;
gui_panel_row(panel, 30, 2);
gui_panel_label(panel, "scrollbar width:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(panel, 0, (gui_int)config->scrollbar_width, 20, 1, NULL);
config->scrollbar_width = (float)tx;
gui_panel_row(panel, 30, 3);
gui_panel_label(panel, "padding:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(panel, 0, (gui_int)config->panel_padding.x, 20, 1, NULL);
ty = gui_panel_spinner(panel, 0, (gui_int)config->panel_padding.y, 20, 1, NULL);
config->panel_padding.x = (float)tx;
config->panel_padding.y = (float)ty;
gui_panel_label(panel, "item spacing:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(panel, 0, (gui_int)config->item_spacing.x, 20, 1, NULL);
ty = gui_panel_spinner(panel, 0, (gui_int)config->item_spacing.y, 20, 1, NULL);
config->item_spacing.x = (float)tx;
config->item_spacing.y = (float)ty;
gui_panel_label(panel, "item padding:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(panel, 0, (gui_int)config->item_padding.x, 20, 1, NULL);
ty = gui_panel_spinner(panel, 0, (gui_int)config->item_padding.y, 20, 1, NULL);
config->item_padding.x = (float)tx;
config->item_padding.y = (float)ty;
gui_panel_label(panel, "scaler size:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(panel, 0, (gui_int)config->scaler_size.x, 20, 1, NULL);
ty = gui_panel_spinner(panel, 0, (gui_int)config->scaler_size.y, 20, 1, NULL);
config->scaler_size.x = (float)tx;
config->scaler_size.y = (float)ty;
}
static struct gui_color
color_picker(struct gui_panel_layout *panel, struct control_window *control,
const char *name, struct gui_color color)
{
gui_float r, g, b, a;
gui_panel_row(panel, 30, 2);
gui_panel_label(panel, name, GUI_TEXT_LEFT);
gui_panel_button_color(panel, color, GUI_BUTTON_DEFAULT);
gui_panel_row(panel, 30, 2);
r = color.r; g = color.g; b = color.b; a = color.a;
r = gui_panel_slider(panel, 0, r, 255, 10);
color.r = (gui_byte)r;
color.r = (gui_byte)gui_panel_spinner(panel, 0, color.r, 255, 1, &control->spinner_r_active);
g = gui_panel_slider(panel, 0, g, 255, 10);
color.g = (gui_byte)g;
color.g = (gui_byte)gui_panel_spinner(panel, 0, color.g, 255, 1, &control->spinner_g_active);
b = gui_panel_slider(panel, 0, b, 255, 10);
color.b = (gui_byte)b;
color.b = (gui_byte)gui_panel_spinner(panel, 0,(gui_int)color.b, 255, 1, &control->spinner_b_active);
a = gui_panel_slider(panel, 0, a, 255, 10);
color.a = (gui_byte)a;
color.a = (gui_byte)gui_panel_spinner(panel, 0, (gui_int)color.a, 255, 1, &control->spinner_a_active);
return color;
}
static void
color_tab(struct gui_panel_layout *panel, struct control_window *control, struct gui_config *config)
{
gui_size i = 0;
static const char *labels[] = {"Text:", "Panel:", "Header:", "Border:", "Button:",
"Button Border:", "Button Hovering:", "Button Toggle:", "Button Hovering Text:",
"Check:", "Check BG:", "Check Active:", "Option:", "Option BG:", "Option Active:",
"Slider:", "Slider cursor:", "Progress:", "Progress Cursor:", "Editbox:", "Editbox cursor:",
"Editbox Border:", "Spinner:", "Spinner Border:", "Selector:", "Selector Border:",
"Histo:", "Histo Bars:", "Histo Negative:", "Histo Hovering:", "Plot:", "Plot Lines:",
"Plot Hightlight:", "Scrollbar:", "Scrollbar Cursor:", "Scrollbar Border:",
"Table lines:", "Shelf:", "Shelf Text:", "Shelf Active:", "Shelf Active Text:", "Scaler:"
};
if (control->picker_active) {
control->color = color_picker(panel,control,labels[control->current_color], control->color);
gui_panel_row(panel, 30, 3);
gui_panel_seperator(panel, 1);
if (gui_panel_button_text(panel, "ok", GUI_BUTTON_DEFAULT)) {
config->colors[control->current_color] = control->color;
control->picker_active = gui_false;
}
if (gui_panel_button_text(panel, "cancel", GUI_BUTTON_DEFAULT))
control->picker_active = gui_false;
} else {
gui_panel_row(panel, 30, 2);
for (i = 0; i < GUI_COLOR_COUNT; ++i) {
gui_panel_label(panel, labels[i], GUI_TEXT_LEFT);
if (gui_panel_button_color(panel, config->colors[i], GUI_BUTTON_DEFAULT)) {
if (!control->picker_active) {
control->picker_active = gui_true;
control->color = config->colors[i];
control->current_color = i;
} else continue;
}
}
}
}
static void
init_control(struct control_window *win, struct gui_config *config, struct gui_font *font,
struct gui_panel_stack *stack)
{
gui_panel_hook_init(&win->hook, 380, 50, 400, 350,
GUI_PANEL_BORDER|GUI_PANEL_MOVEABLE|GUI_PANEL_CLOSEABLE|GUI_PANEL_SCALEABLE, config, font);
gui_stack_push(stack, &win->hook);
win->show_flags = gui_hook_panel(&win->hook)->flags;
win->style_tab = GUI_MINIMIZED;
win->color_tab = GUI_MINIMIZED;
}
static gui_bool
update_control(struct control_window *control, struct gui_panel_stack *stack,
struct gui_input *in, struct gui_canvas *canvas, struct gui_config *config)
{
gui_bool running;
struct gui_panel_layout layout;
struct gui_panel_layout tab;
running = gui_panel_hook_begin_stacked(&layout, &control->hook, stack, "Control", canvas, in);
control->flag_tab = gui_panel_tab_begin(&layout, &tab, "Options", control->flag_tab);
update_flags(&tab, control);
gui_panel_tab_end(&layout, &tab);
control->style_tab = gui_panel_tab_begin(&layout, &tab, "Style", control->style_tab);
style_tab(&tab, config);
gui_panel_tab_end(&layout, &tab);
control->color_tab = gui_panel_tab_begin(&layout, &tab, "Color", control->color_tab);
color_tab(&tab, control, config);
gui_panel_tab_end(&layout, &tab);
gui_panel_hook_end(&layout, &control->hook);
return running;
}
static void
brush_tab(struct gui_panel_layout *panel, struct settings_window *win)
{
gui_panel_row(panel, 20, 2);
gui_panel_label(panel, "Radius (U):", GUI_TEXT_RIGHT);
win->radiusu = gui_panel_slider(panel, 0, win->radiusu, 20, 0.5);
gui_panel_label(panel, "Radius (L):", GUI_TEXT_RIGHT);
win->radiusl = gui_panel_slider(panel, 0, win->radiusl, 20, 0.5);
gui_panel_row(panel, 25, 3);
gui_panel_seperator(panel, 1);
win->rotate_to_stroke = gui_panel_check(panel, "Rotate to stroke", win->rotate_to_stroke);
}
static struct gui_color
scolor_tab(struct gui_panel_layout *panel, struct settings_window *win)
{
char buffer[256];
struct gui_color color = win->color;
gui_float c = color.r;
gui_panel_row(panel, 20, 3);
gui_panel_label(panel, "Color:", GUI_TEXT_RIGHT);
c = gui_panel_slider(panel, 0, c, 250, 10);
color.r = (gui_byte)c;
color.g = (gui_byte)c;
color.b = (gui_byte)c;
color.a = 255;
gui_panel_button_color(panel, color, GUI_BUTTON_DEFAULT);
gui_panel_label(panel, "Opacity:", GUI_TEXT_RIGHT);
win->flood_opacity = gui_panel_slider(panel, 0, win->flood_opacity, 250, 10);
sprintf(buffer, "%.2f", win->flood_opacity);
gui_panel_label(panel, buffer, GUI_TEXT_LEFT);
return color;
}
static struct gui_color
flood_tab(struct gui_panel_layout *panel, struct settings_window *win)
{
char buffer[256];
const char *flood_types[] = {"All", "Selected"};
struct gui_color color = win->flood_color;
gui_float c = color.r;
gui_panel_row(panel, 25, 3);
gui_panel_label(panel, "Color:", GUI_TEXT_RIGHT);
c = gui_panel_slider(panel, 0, c, 250, 10);
color.r = (gui_byte)c;
color.g = (gui_byte)c;
color.b = (gui_byte)c;
color.a = 255;
gui_panel_button_color(panel, color, GUI_BUTTON_DEFAULT);
gui_panel_label(panel, "Opacity:", GUI_TEXT_RIGHT);
win->opacity = gui_panel_slider(panel, 0, win->opacity, 250, 10);
sprintf(buffer, "%.2f", win->opacity);
gui_panel_label(panel, buffer, GUI_TEXT_LEFT);
gui_panel_row(panel, 25, 2);
if (gui_panel_button_text(panel, "Flood Paint", GUI_BUTTON_DEFAULT))
fprintf(stdout, "flood paint pressed!\n");
if (gui_panel_button_text(panel, "Flood Erease", GUI_BUTTON_DEFAULT))
fprintf(stdout, "flood erase pressed!\n");
gui_panel_row(panel, 25, LEN(flood_types) + 1);
gui_panel_label(panel, "Flood:", GUI_TEXT_RIGHT);
win->flood_type = gui_panel_option_group(panel, flood_types, LEN(flood_types), win->flood_type);
return color;
}
static void
paint_tab(struct gui_panel_layout *panel, struct settings_window *win)
{
const char *brush_mode[] = {"Dynamic", "Static"};
const char *artisan_types[] = {"Paint", "Erase", "Clone"};
const char *paint_effects[] = {"Paint", "Smear", "Blur"};
gui_panel_row(panel, 25, LEN(artisan_types) + 1);
gui_panel_label(panel, "Artisan:", GUI_TEXT_RIGHT);
win->artisan_type = gui_panel_option_group(panel, artisan_types, LEN(artisan_types), win->artisan_type);
gui_panel_row(panel, 25, LEN(paint_effects) + 1);
gui_panel_label(panel, "Effects:", GUI_TEXT_RIGHT);
win->effect_type = gui_panel_option_group(panel, paint_effects, LEN(paint_effects), win->effect_type);
gui_panel_row(panel, 25, 3);
gui_panel_seperator(panel, 1);
if (gui_panel_button_text(panel, "Erase", GUI_BUTTON_DEFAULT))
fprintf(stdout, "set erase image button pressed!\n");
gui_panel_row(panel, 25, 3);
gui_panel_seperator(panel, 1);
if (gui_panel_button_text(panel, "Reset", GUI_BUTTON_DEFAULT))
fprintf(stdout, "reset brushes button pressed!\n");
gui_panel_row(panel, 25, LEN(brush_mode) + 1);
gui_panel_label(panel, "Brush mode:", GUI_TEXT_RIGHT);
win->brush_mode = gui_panel_option_group(panel, brush_mode, LEN(brush_mode), win->brush_mode);
}
static void
texture_tab(struct gui_panel_layout *panel, struct settings_window *win)
{
const char *attributes[] = {"Color", "Normals", "Depth"};
gui_panel_row(panel, 25, 3);
gui_panel_label(panel, "Attribute:", GUI_TEXT_RIGHT);
win->attribute = gui_panel_selector(panel, attributes, LEN(attributes), win->attribute);
gui_panel_seperator(panel, 2);
if (gui_panel_button_text(panel, "Assign", GUI_BUTTON_DEFAULT))
fprintf(stdout, "assign/edit textures button pressed!\n");
gui_panel_seperator(panel, 2);
if (gui_panel_button_text(panel, "Save", GUI_BUTTON_DEFAULT))
fprintf(stdout, "save textures button pressed!\n");
gui_panel_seperator(panel, 2);
if (gui_panel_button_text(panel, "Reload", GUI_BUTTON_DEFAULT))
fprintf(stdout, "reload textures button pressed!\n");
gui_panel_seperator(panel, 2);
win->update_on_stroke = gui_panel_check(panel, "Update on stroke", win->update_on_stroke);
gui_panel_seperator(panel, 2);
win->save_on_stroke = gui_panel_check(panel, "Save texture on stroke", win->save_on_stroke);
gui_panel_seperator(panel, 2);
win->extend_seam_color = gui_panel_check(panel, "Extend seam color", win->extend_seam_color);
}
static void
update_settings(struct settings_window *win, struct gui_layout *layout,
struct gui_input *in, struct gui_canvas *canvas)
{
struct gui_panel_layout panel;
struct gui_panel_layout tab;
gui_panel_hook_begin_tiled(&panel, &win->hook, layout, GUI_SLOT_RIGHT, 0, "Tool Settings", canvas, in);
win->brush_tab = gui_panel_tab_begin(&panel, &tab, "Brush", win->brush_tab);
brush_tab(&tab, win);
gui_panel_tab_end(&panel, &tab);
win->color_tab = gui_panel_tab_begin(&panel, &tab, "Color", win->color_tab);
win->color = scolor_tab(&tab, win);
gui_panel_tab_end(&panel, &tab);
win->flood_tab = gui_panel_tab_begin(&panel, &tab, "Flood", win->flood_tab);
win->flood_color = flood_tab(&tab, win);
gui_panel_tab_end(&panel, &tab);
win->paint_tab = gui_panel_tab_begin(&panel, &tab, "Paint", win->paint_tab);
paint_tab(&tab, win);
gui_panel_tab_end(&panel, &tab);
win->texture_tab = gui_panel_tab_begin(&panel, &tab, "Textures", win->texture_tab);
texture_tab(&tab, win);
gui_panel_tab_end(&panel, &tab);
gui_panel_hook_end(&panel, &win->hook);
}
static void
init_demo(struct demo_gui *gui, struct gui_font *font)
{
struct gui_layout_config ratio;
struct gui_command_buffer *buffer = &gui->buffer;
struct gui_memory *memory = &gui->memory;
struct gui_config *config = &gui->config;
gui->font = *font;
memory->memory = calloc(MAX_MEMORY, 1);
memory->size = MAX_MEMORY;
gui_buffer_init_fixed(buffer, memory, GUI_BUFFER_CLIPPING);
gui_default_config(config);
ratio.left = 0.05f;
ratio.right = 0.35f;
ratio.centerv = 0.9f;
ratio.centerh = 0.6f;
ratio.bottom = 0.05f;
ratio.top = 0.05f;
gui_layout_init(&gui->layout, &ratio);
gui_panel_hook_init(&gui->settings.hook, 0, 0, 0, 0, GUI_PANEL_BORDER, config, font);
gui_stack_clear(&gui->floating);
init_show(&gui->show, config, font, &gui->floating);
init_control(&gui->control, config, font, &gui->floating);
}
static void
background_demo(struct demo_gui *gui, struct gui_input *input, struct gui_command_buffer *buffer,
gui_bool active)
{
struct gui_command_buffer sub;
struct gui_canvas canvas;
struct settings_window *settings = &gui->settings;
gui_layout_begin(&gui->layout, gui->width, gui->height, active);
gui_layout_slot(&gui->layout, GUI_SLOT_RIGHT, GUI_LAYOUT_VERTICAL, 1);
gui_buffer_lock(&canvas, buffer, &sub, 0, gui->width, gui->height);
update_settings(&gui->settings, &gui->layout, input, &canvas);
gui_buffer_unlock(gui_hook_output(&settings->hook), buffer, &sub, &canvas, NULL);
gui_layout_end(&gui->background, &gui->layout);
}
static gui_bool
floating_demo(struct demo_gui *gui, struct gui_input *input, struct gui_command_buffer *buffer)
{
gui_bool running;
struct show_window *show = &gui->show;
struct control_window *control = &gui->control;
struct gui_command_buffer sub;
struct gui_canvas canvas;
/* Show window */
gui_buffer_lock(&canvas, buffer, &sub, 0, gui->width, gui->height);
running = update_control(control, &gui->floating, input, &canvas, &gui->config);
gui_buffer_unlock(gui_hook_output(&control->hook), buffer, &sub, &canvas, NULL);
/* control window */
gui_hook_panel(&show->hook)->flags = control->show_flags;
gui_buffer_lock(&canvas, buffer, &sub, 0, gui->width, gui->height);
update_show(show, &gui->floating, input, &canvas);
if (gui_hook_panel(&show->hook)->flags & GUI_PANEL_HIDDEN)
control->show_flags |= GUI_PANEL_HIDDEN;
gui_buffer_unlock(gui_hook_output(&show->hook), buffer, &sub, &canvas, NULL);
return running;
}
static gui_bool
run_demo(struct demo_gui *gui, struct gui_input *input)
{
gui_bool running;
struct gui_command_buffer *buffer = &gui->buffer;
gui_buffer_begin(NULL, buffer, gui->width, gui->height);
background_demo(gui, input, buffer, gui->control.show_flags & GUI_PANEL_HIDDEN);
running = floating_demo(gui, input, buffer);
gui_buffer_end(NULL, buffer, NULL, NULL);
return running;
}
Reference in New Issue View Git Blame Copy Permalink