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

348 lines
14 KiB
C
Raw Blame History

#define MAX_BUFFER 64
#define MAX_MEMORY (32 * 1024)
struct show_window {
struct gui_panel_hook hook;
gui_char in_buf[MAX_BUFFER];
gui_size in_len;
gui_bool in_act;
gui_char cmd_buf[MAX_BUFFER];
gui_size cmd_len;
gui_bool cmd_act;
gui_bool check;
gui_float slider;
gui_size prog;
gui_int spinner;
gui_bool spin_act;
gui_size item_cur;
gui_size cur;
gui_bool diff_min;
gui_bool wid_min;
gui_bool tbl_min;
gui_float shelf_off;
gui_float tbl_off;
gui_int combo_sel;
gui_bool toggle;
gui_int option;
};
struct control_window {
struct gui_panel_hook hook;
gui_flags show_flags;
gui_bool flag_min;
gui_bool style_min;
gui_bool color_min;
gui_bool picker_act;
gui_bool col_r_act;
gui_bool col_g_act;
gui_bool col_b_act;
gui_bool col_a_act;
gui_size current;
struct gui_color color;
};
static void
table_panel(struct gui_panel_layout *panel, struct show_window *demo)
{
struct gui_panel_layout tab;
static const struct gui_color header = {178, 122, 1, 255};
gui_panel_row(panel, 250, 1);
gui_panel_group_begin(panel, &tab, "Table", demo->tbl_off);
gui_panel_table_begin(&tab, GUI_TABLE_HHEADER, 30, 2);
gui_panel_label_colored(&tab, "MOVEMENT", GUI_TEXT_CENTERED, header);
gui_panel_label_colored(&tab, "KEY/BUTTON", GUI_TEXT_CENTERED, header);
gui_panel_table_row(&tab);
gui_panel_label(&tab, "Move foward", GUI_TEXT_LEFT);
gui_panel_label(&tab, "w", GUI_TEXT_CENTERED);
gui_panel_table_row(&tab);
gui_panel_label(&tab, "Move back", GUI_TEXT_LEFT);
gui_panel_label(&tab, "s", GUI_TEXT_CENTERED);
gui_panel_table_row(&tab);
gui_panel_label(&tab, "Move left", GUI_TEXT_LEFT);
gui_panel_label(&tab, "a", GUI_TEXT_CENTERED);
gui_panel_table_row(&tab);
gui_panel_label(&tab, "Move right", GUI_TEXT_LEFT);
gui_panel_label(&tab, "d", GUI_TEXT_CENTERED);
gui_panel_table_row(&tab);
gui_panel_label(&tab, "Jump", GUI_TEXT_LEFT);
gui_panel_label(&tab, "SPACE", GUI_TEXT_CENTERED);
gui_panel_table_row(&tab);
gui_panel_label(&tab, "Duck", GUI_TEXT_LEFT);
gui_panel_label(&tab, "CTRL", GUI_TEXT_CENTERED);
gui_panel_table_end(&tab);
demo->tbl_off = gui_panel_group_end(panel, &tab);
}
static void
graph_panel(struct gui_panel_layout *panel, struct show_window *demo)
{
enum {HISTO, PLOT};
struct gui_panel_layout tab;
static const char *shelfs[] = {"Histogram", "Lines"};
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, 180, 1);
demo->cur = gui_panel_shelf_begin(panel,&tab,shelfs,LEN(shelfs),demo->cur,demo->shelf_off);
gui_panel_row(&tab, 100, 1);
if (demo->cur == HISTO) {
gui_panel_graph(&tab, GUI_GRAPH_HISTO, values, LEN(values));
} else {
gui_panel_graph(&tab, GUI_GRAPH_LINES, values, LEN(values));
}
demo->shelf_off = gui_panel_shelf_end(panel, &tab);
}
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"};
struct gui_panel_layout tab;
demo->diff_min = gui_panel_tab_begin(panel, &tab, "Comobox", demo->diff_min);
gui_panel_row(&tab, 30, 3);
for (i = 0; i < (gui_int)LEN(options); i++) {
if (gui_panel_option(&tab, options[i], demo->combo_sel == i))
demo->combo_sel = i;
}
gui_panel_tab_end(panel, &tab);
}
static void
widget_panel(struct gui_panel_layout *panel, struct show_window *demo)
{
struct gui_panel_layout tab;
char buffer[MAX_BUFFER];
const char *items[] = {"Fist", "Pistol", "Shotgun", "Railgun", "BFG"};
demo->wid_min = gui_panel_tab_begin(panel, &tab, "Widgets", demo->wid_min);
gui_panel_row(&tab, 30, 1);
gui_panel_label(&tab, "text left", GUI_TEXT_LEFT);
gui_panel_label(&tab, "text center", GUI_TEXT_CENTERED);
gui_panel_label(&tab, "text right", GUI_TEXT_RIGHT);
if (gui_panel_button_text(&tab, "button", GUI_BUTTON_DEFAULT))
fprintf(stdout, "button pressed!\n");
demo->toggle = gui_panel_button_toggle(&tab, "toggle", demo->toggle);
demo->check = gui_panel_check(&tab, "checkbox", demo->check);
gui_panel_row(&tab, 30, 2);
if (gui_panel_option(&tab, "option 0", demo->option == 0)) demo->option = 0;
if (gui_panel_option(&tab, "option 1", demo->option == 1)) demo->option = 1;
demo->slider = gui_panel_slider(&tab, 0, demo->slider, 10, 1.0f);
sprintf(buffer, "%.2f", demo->slider);
gui_panel_label(&tab, buffer, GUI_TEXT_LEFT);
demo->prog = gui_panel_progress(&tab, demo->prog, 100, gui_true);
sprintf(buffer, "%lu", demo->prog);
gui_panel_label(&tab, buffer, GUI_TEXT_LEFT);
gui_panel_row(&tab, 30, 1);
demo->item_cur = gui_panel_selector(&tab, items, LEN(items), demo->item_cur);
demo->spinner = gui_panel_spinner(&tab, 0, demo->spinner, 250, 10, &demo->spin_act);
if (gui_panel_shell(&tab, demo->cmd_buf, &demo->cmd_len, MAX_BUFFER, &demo->cmd_act))
demo->cmd_len = 0;
demo->in_len = gui_panel_edit(&tab, demo->in_buf, demo->in_len,
MAX_BUFFER, &demo->in_act, GUI_INPUT_DEFAULT);
gui_panel_tab_end(panel, &tab);
}
static void
show_panel(struct show_window *show, struct gui_panel_stack *stack,
struct gui_input *in, struct gui_canvas *canvas)
{
struct gui_panel_layout layout;
gui_hook_begin(&layout, &show->hook, stack, "Show", canvas, in);
combobox_panel(&layout, show);
widget_panel(&layout, show);
graph_panel(&layout, show);
table_panel(&layout, show);
gui_hook_end(&layout, &show->hook);
}
static void
flags_tab(struct gui_panel_layout *panel, struct control_window *control)
{
gui_flags i = 0x01;
gui_size n = 0;
gui_flags res = 0;
struct gui_panel_layout tab;
const char *options[] = {"Hidden", "Border", "Minimizable",
"Closeable", "Moveable", "Scaleable"};
control->flag_min = gui_panel_tab_begin(panel, &tab, "Options", control->flag_min);
gui_panel_row(&tab, 30, 2);
do {
if (gui_panel_check(&tab, options[n++], (control->show_flags & i) ? gui_true : gui_false)) res |= i;
i = i << 1;
} while (i <= GUI_PANEL_SCALEABLE);
control->show_flags = res;
gui_panel_tab_end(panel, &tab);
}
static void
style_tab(struct gui_panel_layout *panel, struct control_window *control, struct gui_config *config)
{
gui_int tx, ty;
struct gui_panel_layout tab;
control->style_min = gui_panel_tab_begin(panel, &tab, "Style", control->style_min);
gui_panel_row(&tab, 30, 2);
gui_panel_label(&tab, "scrollbar width:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(&tab, 0, (gui_int)config->scrollbar_width, 20, 1, NULL);
config->scrollbar_width = (float)tx;
gui_panel_row(&tab, 30, 3);
gui_panel_label(&tab, "padding:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(&tab, 0, (gui_int)config->panel_padding.x, 20, 1, NULL);
ty = gui_panel_spinner(&tab, 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(&tab, "item spacing:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(&tab, 0, (gui_int)config->item_spacing.x, 20, 1, NULL);
ty = gui_panel_spinner(&tab, 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(&tab, "item padding:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(&tab, 0, (gui_int)config->item_padding.x, 20, 1, NULL);
ty = gui_panel_spinner(&tab, 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(&tab, "scaler size:", GUI_TEXT_LEFT);
tx = gui_panel_spinner(&tab, 0, (gui_int)config->scaler_size.x, 20, 1, NULL);
ty = gui_panel_spinner(&tab, 0, (gui_int)config->scaler_size.y, 20, 1, NULL);
config->scaler_size.x = (float)tx;
config->scaler_size.y = (float)ty;
gui_panel_tab_end(panel, &tab);
}
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->col_r_act);
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->col_g_act);
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->col_b_act);
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->col_a_act);
return color;
}
static void
color_tab(struct gui_panel_layout *panel, struct control_window *control, struct gui_config *config)
{
gui_size i = 0;
struct gui_panel_layout tab;
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:", "Scroll:", "Scroll Cursor:",
"Slider:", "Slider cursor:", "Progress:", "Progress Cursor:", "Editbox:", "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:", "Scaler:"
};
control->color_min = gui_panel_tab_begin(panel, &tab, "Color", control->color_min);
if (control->picker_act) {
control->color = color_picker(&tab, control, labels[control->current], control->color);
gui_panel_row(&tab, 30, 3);
gui_panel_seperator(&tab, 1);
if (gui_panel_button_text(&tab, "ok", GUI_BUTTON_DEFAULT)) {
config->colors[control->current] = control->color;
control->picker_act = gui_false;
}
if (gui_panel_button_text(&tab, "cancel", GUI_BUTTON_DEFAULT))
control->picker_act = gui_false;
} else {
gui_panel_row(&tab, 30, 2);
for (i = 0; i < GUI_COLOR_COUNT; ++i) {
struct gui_panel_layout layout;
gui_panel_label(&tab, labels[i], GUI_TEXT_LEFT);
if (gui_panel_button_color(&tab, config->colors[i], GUI_BUTTON_DEFAULT)) {
if (!control->picker_act) {
control->picker_act = gui_true;
control->color = config->colors[i];
control->current = i;
} else continue;
}
}
}
gui_panel_tab_end(panel, &tab);
}
static gui_bool
control_panel(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;
running = gui_hook_begin(&layout, &control->hook, stack, "Control", canvas, in);
flags_tab(&layout, control);
style_tab(&layout, control, config);
color_tab(&layout, control, config);
gui_hook_end(&layout, &control->hook);
return running;
}
static void
init_demo(struct show_window *show, struct control_window *control,
struct gui_panel_stack *stack, struct gui_config *config, struct gui_font *font)
{
memset(show, 0, sizeof(*show));
gui_hook_init(&show->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_hook(stack, &show->hook);
/*show->wid_min = gui_true;*/
show->diff_min = gui_true;
show->slider = 5.0f;
show->prog = 50;
show->spinner = 100;
memset(control, 0, sizeof(*control));
gui_hook_init(&control->hook, 380, 50, 400, 350,
GUI_PANEL_BORDER|GUI_PANEL_MOVEABLE|GUI_PANEL_CLOSEABLE|GUI_PANEL_SCALEABLE, config, font);
gui_stack_push_hook(stack, &control->hook);
control->show_flags = gui_hook_panel(&show->hook)->flags;
control->style_min = gui_true;
control->color_min = gui_true;
}
static gui_bool
run_demo(struct show_window *show, struct control_window *control, struct gui_panel_stack *stack,
struct gui_config *config, struct gui_input *in, struct gui_command_buffer *buffer,
gui_size width, gui_size height)
{
gui_bool running;
struct gui_command_buffer sub;
struct gui_canvas canvas;
gui_buffer_begin(NULL, buffer, width, height);
gui_buffer_lock(&canvas, buffer, &sub, 0, width, height);
running = control_panel(control, stack, in, &canvas, config);
gui_buffer_unlock(gui_hook_list(&control->hook), buffer, &sub, &canvas, NULL);
gui_hook_panel(&show->hook)->flags = control->show_flags;
gui_buffer_lock(&canvas, buffer, &sub, 0, width, height);
show_panel(show, stack, in, &canvas);
if (gui_hook_panel(&show->hook)->flags & GUI_PANEL_HIDDEN)
control->show_flags |= GUI_PANEL_HIDDEN;
gui_buffer_unlock(gui_hook_list(&show->hook), buffer, &sub, &canvas, NULL);
gui_buffer_end(NULL, buffer, NULL, NULL);
return running;
}
Reference in New Issue View Git Blame Copy Permalink