Pantyhose-X
/
vengi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TESTNUKLEAR: added style configurator 

see https://github.com/Immediate-Mode-UI/Nuklear/pull/73
Martin Gerhardy 2020-04-08 18:38:32 +02:00
parent f4bce570e5
commit 423be302d7
6 changed files with 821 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/modules/ui/nuklear/NuklearNode.cpp
View File

@ -85,3 +85,10 @@ void nkc_text(struct nkc_context* ctx, const char *string, nk_flags alignment, c
}
}
const struct nk_color* nkc_get_default_color_style(int* n) {
if (n != nullptr) {
*n = NK_COLOR_COUNT;
}
return nk_default_color_style;
}

2
src/modules/ui/nuklear/NuklearNode.h
View File

@ -32,3 +32,5 @@ void nkc_text(struct nkc_context* ctx, const char *string, nk_flags alignment, c
}
}
extern const struct nk_color* nkc_get_default_color_style(int* n);

20
src/tests/testnuklear/TestNuklear.cpp
View File

@ -14,6 +14,9 @@
#include "extended.c"
#include "node_editor.c"
#include "style.c"
#include "style_configurator.c"
static struct nk_color color_table[NK_COLOR_COUNT];
TestNuklear::TestNuklear(const metric::MetricPtr& metric,
const io::FilesystemPtr& filesystem,
@ -37,6 +40,8 @@ void TestNuklear::initUIFonts() {
core::AppState TestNuklear::onInit() {
const core::AppState state = Super::onInit();
SDL_memcpy(color_table, nkc_get_default_color_style(nullptr), sizeof(color_table));
_media.unchecked = loadImageFile("icon/unchecked.png");
_media.checked = loadImageFile("icon/checked.png");
_media.rocket = loadImageFile("icon/rocket.png");
@ -72,10 +77,23 @@ core::AppState TestNuklear::onInit() {
bool TestNuklear::onRenderUI() {
overview(&_ctx);
node_editor(&_ctx);
set_style(&_ctx, THEME_BLUE);
static int mode = 0;
static const char *options[] = {"THEME_BLACK", "THEME_WHITE", "THEME_RED", "THEME_BLUE", "THEME_DARK", "style configurator"};
const struct nk_rect rect = nk_recti(980, 270, 275, 150);
if (nk_begin_titled(&_ctx, "style_options", "Style options", rect, 0)) {
nk_layout_row_dynamic(&_ctx, 25, 1);
mode = nk_combo(&_ctx, options, SDL_arraysize(options), mode, 10, nk_vec2(100, 100));
}
nk_end(&_ctx);
if (mode >= 0 && mode <= THEME_DARK) {
set_style(&_ctx, (theme)mode);
} else {
style_configurator(&_ctx, color_table);
}
basic_demo(&_ctx, &_media);
button_demo(&_ctx, &_media);
grid_demo(&_ctx, &_media);
return true;
}

6
src/tests/testnuklear/extended.c
View File

@ -149,7 +149,7 @@ grid_demo(struct nk_context *ctx, struct media *media)
int i;
nk_style_set_font(ctx, &media->font_20->handle);
if (nk_begin(ctx, "Grid Demo", nk_rect(600, 350, 275, 250),
if (nk_begin(ctx, "Grid Demo", nk_rect(980, 10, 275, 250),
NK_WINDOW_TITLE|NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|
NK_WINDOW_NO_SCROLLBAR))
{
@ -216,7 +216,7 @@ button_demo(struct nk_context *ctx, struct media *media)
static int toggle2 = 1;
nk_style_set_font(ctx, &media->font_20->handle);
nk_begin(ctx, "Button Demo", nk_rect(50,50,255,610),
nk_begin(ctx, "Button Demo", nk_rect(10,10,255,610),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_TITLE);
/*------------------------------------------------
@ -333,7 +333,7 @@ basic_demo(struct nk_context *ctx, struct media *media)
int i = 0;
nk_style_set_font(ctx, &media->font_20->handle);
nk_begin(ctx, "Basic Demo", nk_rect(320, 50, 275, 610),
nk_begin(ctx, "Basic Demo", nk_rect(280, 10, 275, 610),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_TITLE);
/*------------------------------------------------

2
src/tests/testnuklear/overview.c
View File

@ -26,7 +26,7 @@ overview(struct nk_context *ctx)
if (scale_left) window_flags |= NK_WINDOW_SCALE_LEFT;
if (minimizable) window_flags |= NK_WINDOW_MINIMIZABLE;
if (nk_begin(ctx, "Overview", nk_rect(10, 10, 400, 600), window_flags))
if (nk_begin(ctx, "Overview", nk_rect(570, 10, 400, 600), window_flags))
{
if (show_menu)
{

789
src/tests/testnuklear/style_configurator.c Normal file
View File

@ -0,0 +1,789 @@
// TODO design decisions
// plural or not? ie style_button or style_buttons?
// use the duplicate array method, or just let the user
// manually set those after calling the function by accessing ctx->style->*?
static const char* symbols[NK_SYMBOL_MAX] =
{
"NONE",
"X",
"UNDERSCORE",
"CIRCLE_SOLID",
"CIRCLE_OUTLINE",
"RECT_SOLID",
"RECT_OUTLINE",
"TRIANGLE_UP",
"TRIANGLE_DOWN",
"TRIANGLE_LEFT",
"TRIANGLE_RIGHT",
"PLUS",
"MINUS"
};
static int
style_rgb(struct nk_context* ctx, const char* name, struct nk_color* color)
{
nk_label(ctx, name, NK_TEXT_LEFT);
if (nk_combo_begin_color(ctx, *color, nk_vec2(nk_widget_width(ctx), 400))) {
nk_layout_row_dynamic(ctx, 120, 1);
struct nk_colorf colorf = nk_color_picker(ctx, nk_color_cf(*color), NK_RGB);
nk_layout_row_dynamic(ctx, 25, 1);
colorf.r = nk_propertyf(ctx, "#R:", 0, colorf.r, 1.0f, 0.01f,0.005f);
colorf.g = nk_propertyf(ctx, "#G:", 0, colorf.g, 1.0f, 0.01f,0.005f);
colorf.b = nk_propertyf(ctx, "#B:", 0, colorf.b, 1.0f, 0.01f,0.005f);
*color = nk_rgb_cf(colorf);
nk_combo_end(ctx);
return 1;
}
return 0;
}
// TODO style_style_item? how to handle images if at all?
static void
style_item_color(struct nk_context* ctx, const char* name, struct nk_style_item* item)
{
style_rgb(ctx, name, &item->data.color);
}
static void
style_vec2(struct nk_context* ctx, const char* name, struct nk_vec2* vec)
{
char buffer[64];
nk_label(ctx, name, NK_TEXT_LEFT);
sprintf(buffer, "%.2f, %.2f", vec->x, vec->y);
if (nk_combo_begin_label(ctx, buffer, nk_vec2(200,200))) {
nk_layout_row_dynamic(ctx, 25, 1);
nk_property_float(ctx, "#X:", -100.0f, &vec->x, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Y:", -100.0f, &vec->y, 100.0f, 1,0.5f);
nk_combo_end(ctx);
}
}
// style_general? pass array in instead of static?
static void
style_global_colors(struct nk_context* ctx, struct nk_color color_table[NK_COLOR_COUNT])
{
const char* color_labels[NK_COLOR_COUNT] =
{
"COLOR_TEXT:",
"COLOR_WINDOW:",
"COLOR_HEADER:",
"COLOR_BORDER:",
"COLOR_BUTTON:",
"COLOR_BUTTON_HOVER:",
"COLOR_BUTTON_ACTIVE:",
"COLOR_TOGGLE:",
"COLOR_TOGGLE_HOVER:",
"COLOR_TOGGLE_CURSOR:",
"COLOR_SELECT:",
"COLOR_SELECT_ACTIVE:",
"COLOR_SLIDER:",
"COLOR_SLIDER_CURSOR:",
"COLOR_SLIDER_CURSOR_HOVER:",
"COLOR_SLIDER_CURSOR_ACTIVE:",
"COLOR_PROPERTY:",
"COLOR_EDIT:",
"COLOR_EDIT_CURSOR:",
"COLOR_COMBO:",
"COLOR_CHART:",
"COLOR_CHART_COLOR:",
"COLOR_CHART_COLOR_HIGHLIGHT:",
"COLOR_SCROLLBAR:",
"COLOR_SCROLLBAR_CURSOR:",
"COLOR_SCROLLBAR_CURSOR_HOVER:",
"COLOR_SCROLLBAR_CURSOR_ACTIVE:",
"COLOR_TAB_HEADER:"
};
int clicked = 0;
nk_layout_row_dynamic(ctx, 30, 2);
for (int i=0; i<NK_COLOR_COUNT; ++i) {
clicked |= style_rgb(ctx, color_labels[i], &color_table[i]);
}
if (clicked) {
nk_style_from_table(ctx, color_table);
}
}
static void
style_text(struct nk_context* ctx, struct nk_style_text* out_style)
{
struct nk_style_text text = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_rgb(ctx, "Color:", &text.color);
style_vec2(ctx, "Padding:", &text.padding);
*out_style = text;
}
static void
style_button(struct nk_context* ctx, struct nk_style_button* out_style, struct nk_style_button** duplicate_styles, int n_dups)
{
struct nk_style_button button = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &button.normal);
style_item_color(ctx, "Hover:", &button.hover);
style_item_color(ctx, "Active:", &button.active);
style_rgb(ctx, "Border:", &button.border_color);
style_rgb(ctx, "Text Background:", &button.text_background);
style_rgb(ctx, "Text Normal:", &button.text_normal);
style_rgb(ctx, "Text Hover:", &button.text_hover);
style_rgb(ctx, "Text Active:", &button.text_active);
style_vec2(ctx, "Padding:", &button.padding);
style_vec2(ctx, "Image Padding:", &button.image_padding);
style_vec2(ctx, "Touch Padding:", &button.touch_padding);
static const char* alignments[] = {
"LEFT",
"CENTERED",
"RIGHT",
"TOP LEFT",
"TOP CENTERED",
"TOP_RIGHT",
"BOTTOM LEFT",
"BOTTOM CENTERED",
"BOTTOM RIGHT"
};
static nk_flags aligns[] = {
NK_TEXT_LEFT,
NK_TEXT_CENTERED,
NK_TEXT_RIGHT,
NK_TEXT_ALIGN_TOP|NK_TEXT_ALIGN_LEFT,
NK_TEXT_ALIGN_TOP|NK_TEXT_ALIGN_CENTERED,
NK_TEXT_ALIGN_TOP|NK_TEXT_ALIGN_RIGHT,
NK_TEXT_ALIGN_BOTTOM|NK_TEXT_ALIGN_LEFT,
NK_TEXT_ALIGN_BOTTOM|NK_TEXT_ALIGN_CENTERED,
NK_TEXT_ALIGN_BOTTOM|NK_TEXT_ALIGN_RIGHT
};
int cur_align;
for (int i = 0; i < (int)NK_LEN(aligns); ++i) {
if (button.text_alignment == aligns[i]) {
cur_align = i;
break;
}
}
nk_label(ctx, "Text Alignment:", NK_TEXT_LEFT);
cur_align = nk_combo(ctx, alignments, NK_LEN(alignments), cur_align, 25, nk_vec2(200,200));
button.text_alignment = aligns[cur_align];
nk_property_float(ctx, "#Border:", -100.0f, &button.border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Rounding:", -100.0f, &button.rounding, 100.0f, 1,0.5f);
*out_style = button;
if (duplicate_styles) {
for (int i=0; i<n_dups; ++i) {
*duplicate_styles[i] = button;
}
}
}
static void style_toggle(struct nk_context* ctx, struct nk_style_toggle* out_style)
{
struct nk_style_toggle toggle = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &toggle.normal);
style_item_color(ctx, "Hover:", &toggle.hover);
style_item_color(ctx, "Active:", &toggle.active);
style_item_color(ctx, "Cursor Normal:", &toggle.cursor_normal);
style_item_color(ctx, "Cursor Hover:", &toggle.cursor_hover);
style_rgb(ctx, "Border:", &toggle.border_color);
style_rgb(ctx, "Text Background:", &toggle.text_background);
style_rgb(ctx, "Text Normal:", &toggle.text_normal);
style_rgb(ctx, "Text Hover:", &toggle.text_hover);
style_rgb(ctx, "Text Active:", &toggle.text_active);
style_vec2(ctx, "Padding:", &toggle.padding);
style_vec2(ctx, "Touch Padding:", &toggle.touch_padding);
nk_property_float(ctx, "#Border:", -100.0f, &toggle.border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Spacing:", -100.0f, &toggle.spacing, 100.0f, 1,0.5f);
*out_style = toggle;
}
static void
style_selectable(struct nk_context* ctx, struct nk_style_selectable* out_style)
{
struct nk_style_selectable select = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &select.normal);
style_item_color(ctx, "Hover:", &select.hover);
style_item_color(ctx, "Pressed:", &select.pressed);
style_item_color(ctx, "Normal Active:", &select.normal_active);
style_item_color(ctx, "Hover Active:", &select.hover_active);
style_item_color(ctx, "Pressed Active:", &select.pressed_active);
style_rgb(ctx, "Text Normal:", &select.text_normal);
style_rgb(ctx, "Text Hover:", &select.text_hover);
style_rgb(ctx, "Text Pressed:", &select.text_pressed);
style_rgb(ctx, "Text Normal Active:", &select.text_normal_active);
style_rgb(ctx, "Text Hover Active:", &select.text_hover_active);
style_rgb(ctx, "Text Pressed Active:", &select.text_pressed_active);
style_vec2(ctx, "Padding:", &select.padding);
style_vec2(ctx, "Image Padding:", &select.image_padding);
style_vec2(ctx, "Touch Padding:", &select.touch_padding);
nk_property_float(ctx, "#Rounding:", -100.0f, &select.rounding, 100.0f, 1,0.5f);
*out_style = select;
}
static void
style_slider(struct nk_context* ctx, struct nk_style_slider* out_style)
{
struct nk_style_slider slider = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &slider.normal);
style_item_color(ctx, "Hover:", &slider.hover);
style_item_color(ctx, "Active:", &slider.active);
style_rgb(ctx, "Bar Normal:", &slider.bar_normal);
style_rgb(ctx, "Bar Hover:", &slider.bar_hover);
style_rgb(ctx, "Bar Active:", &slider.bar_active);
style_rgb(ctx, "Bar Filled:", &slider.bar_filled);
style_item_color(ctx, "Cursor Normal:", &slider.cursor_normal);
style_item_color(ctx, "Cursor Hover:", &slider.cursor_hover);
style_item_color(ctx, "Cursor Active:", &slider.cursor_active);
style_vec2(ctx, "Cursor Size:", &slider.cursor_size);
style_vec2(ctx, "Padding:", &slider.padding);
style_vec2(ctx, "Spacing:", &slider.spacing);
nk_property_float(ctx, "#Bar Height:", -100.0f, &slider.bar_height, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Rounding:", -100.0f, &slider.rounding, 100.0f, 1,0.5f);
nk_layout_row_dynamic(ctx, 30, 1);
nk_checkbox_label(ctx, "Show Buttons", &slider.show_buttons);
if (slider.show_buttons) {
nk_layout_row_dynamic(ctx, 30, 2);
nk_label(ctx, "Inc Symbol:", NK_TEXT_LEFT);
slider.inc_symbol = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, slider.inc_symbol, 25, nk_vec2(200,200));
nk_label(ctx, "Dec Symbol:", NK_TEXT_LEFT);
slider.dec_symbol = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, slider.dec_symbol, 25, nk_vec2(200,200));
// necessary or do tree's always take the whole width?
//nk_layout_row_dynamic(ctx, 30, 1);
if (nk_tree_push(ctx, NK_TREE_TAB, "Slider Buttons", NK_MINIMIZED)) {
struct nk_style_button* dups[1] = { &ctx->style.slider.dec_button };
style_button(ctx, &ctx->style.slider.inc_button, dups, 1);
nk_tree_pop(ctx);
}
}
*out_style = slider;
}
static void
style_progress(struct nk_context* ctx, struct nk_style_progress* out_style)
{
struct nk_style_progress prog = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &prog.normal);
style_item_color(ctx, "Hover:", &prog.hover);
style_item_color(ctx, "Active:", &prog.active);
style_item_color(ctx, "Cursor Normal:", &prog.cursor_normal);
style_item_color(ctx, "Cursor Hover:", &prog.cursor_hover);
style_item_color(ctx, "Cursor Active:", &prog.cursor_active);
// TODO rgba?
style_rgb(ctx, "Border Color:", &prog.border_color);
style_rgb(ctx, "Cursor Border Color:", &prog.cursor_border_color);
style_vec2(ctx, "Padding:", &prog.padding);
nk_property_float(ctx, "#Rounding:", -100.0f, &prog.rounding, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Border:", -100.0f, &prog.border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Cursor Rounding:", -100.0f, &prog.cursor_rounding, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Cursor Border:", -100.0f, &prog.cursor_border, 100.0f, 1,0.5f);
*out_style = prog;
}
static void
style_scrollbars(struct nk_context* ctx, struct nk_style_scrollbar* out_style, struct nk_style_scrollbar** duplicate_styles, int n_dups)
{
struct nk_style_scrollbar scroll = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &scroll.normal);
style_item_color(ctx, "Hover:", &scroll.hover);
style_item_color(ctx, "Active:", &scroll.active);
style_item_color(ctx, "Cursor Normal:", &scroll.cursor_normal);
style_item_color(ctx, "Cursor Hover:", &scroll.cursor_hover);
style_item_color(ctx, "Cursor Active:", &scroll.cursor_active);
// TODO rgba?
style_rgb(ctx, "Border Color:", &scroll.border_color);
style_rgb(ctx, "Cursor Border Color:", &scroll.cursor_border_color);
style_vec2(ctx, "Padding:", &scroll.padding);
nk_property_float(ctx, "#Border:", -100.0f, &scroll.border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Rounding:", -100.0f, &scroll.rounding, 100.0f, 1,0.5f);
// TODO naming inconsistency with style_scrollress?
nk_property_float(ctx, "#Cursor Border:", -100.0f, &scroll.border_cursor, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Cursor Rounding:", -100.0f, &scroll.rounding_cursor, 100.0f, 1,0.5f);
// TODO what is wrong with scrollbar buttons? Also look into controlling the total width (and height) of scrollbars
nk_layout_row_dynamic(ctx, 30, 1);
nk_checkbox_label(ctx, "Show Buttons", &scroll.show_buttons);
if (scroll.show_buttons) {
nk_layout_row_dynamic(ctx, 30, 2);
nk_label(ctx, "Inc Symbol:", NK_TEXT_LEFT);
scroll.inc_symbol = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, scroll.inc_symbol, 25, nk_vec2(200,200));
nk_label(ctx, "Dec Symbol:", NK_TEXT_LEFT);
scroll.dec_symbol = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, scroll.dec_symbol, 25, nk_vec2(200,200));
//nk_layout_row_dynamic(ctx, 30, 1);
if (nk_tree_push(ctx, NK_TREE_TAB, "Scrollbar Buttons", NK_MINIMIZED)) {
struct nk_style_button* dups[3] = { &ctx->style.scrollh.dec_button,
&ctx->style.scrollv.inc_button,
&ctx->style.scrollv.dec_button };
style_button(ctx, &ctx->style.scrollh.inc_button, dups, 3);
nk_tree_pop(ctx);
}
}
*out_style = scroll;
if (duplicate_styles) {
for (int i=0; i<n_dups; ++i) {
*duplicate_styles[i] = scroll;
}
}
}
static void
style_edit(struct nk_context* ctx, struct nk_style_edit* out_style)
{
struct nk_style_edit edit = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &edit.normal);
style_item_color(ctx, "Hover:", &edit.hover);
style_item_color(ctx, "Active:", &edit.active);
style_rgb(ctx, "Cursor Normal:", &edit.cursor_normal);
style_rgb(ctx, "Cursor Hover:", &edit.cursor_hover);
style_rgb(ctx, "Cursor Text Normal:", &edit.cursor_text_normal);
style_rgb(ctx, "Cursor Text Hover:", &edit.cursor_text_hover);
style_rgb(ctx, "Border:", &edit.border_color);
style_rgb(ctx, "Text Normal:", &edit.text_normal);
style_rgb(ctx, "Text Hover:", &edit.text_hover);
style_rgb(ctx, "Text Active:", &edit.text_active);
style_rgb(ctx, "Selected Normal:", &edit.selected_normal);
style_rgb(ctx, "Selected Hover:", &edit.selected_hover);
style_rgb(ctx, "Selected Text Normal:", &edit.selected_text_normal);
style_rgb(ctx, "Selected Text Hover:", &edit.selected_text_hover);
style_vec2(ctx, "Scrollbar Size:", &edit.scrollbar_size);
style_vec2(ctx, "Padding:", &edit.padding);
nk_property_float(ctx, "#Row Padding:", -100.0f, &edit.row_padding, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Cursor Size:", -100.0f, &edit.cursor_size, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Border:", -100.0f, &edit.border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Rounding:", -100.0f, &edit.rounding, 100.0f, 1,0.5f);
*out_style = edit;
}
static void
style_property(struct nk_context* ctx, struct nk_style_property* out_style)
{
struct nk_style_property property = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &property.normal);
style_item_color(ctx, "Hover:", &property.hover);
style_item_color(ctx, "Active:", &property.active);
style_rgb(ctx, "Border:", &property.border_color);
style_rgb(ctx, "Label Normal:", &property.label_normal);
style_rgb(ctx, "Label Hover:", &property.label_hover);
style_rgb(ctx, "Label Active:", &property.label_active);
style_vec2(ctx, "Padding:", &property.padding);
// TODO check weird hover bug with properties, happens in overview basic section too
nk_property_float(ctx, "#Border:", -100.0f, &property.border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Rounding:", -100.0f, &property.rounding, 100.0f, 1,0.5f);
// there is no property.show_buttons, they're always there
nk_label(ctx, "Left Symbol:", NK_TEXT_LEFT);
property.sym_left = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, property.sym_left, 25, nk_vec2(200,200));
nk_label(ctx, "Right Symbol:", NK_TEXT_LEFT);
property.sym_right = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, property.sym_right, 25, nk_vec2(200,200));
if (nk_tree_push(ctx, NK_TREE_TAB, "Property Buttons", NK_MINIMIZED)) {
struct nk_style_button* dups[1] = { &property.dec_button };
style_button(ctx, &property.inc_button, dups, 1);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Property Edit", NK_MINIMIZED)) {
style_edit(ctx, &ctx->style.property.edit);
nk_tree_pop(ctx);
}
*out_style = property;
}
static void
style_chart(struct nk_context* ctx, struct nk_style_chart* out_style)
{
struct nk_style_chart chart = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Background:", &chart.background);
style_rgb(ctx, "Border:", &chart.border_color);
style_rgb(ctx, "Selected Color:", &chart.selected_color);
style_rgb(ctx, "Color:", &chart.color);
style_vec2(ctx, "Padding:", &chart.padding);
nk_property_float(ctx, "#Border:", -100.0f, &chart.border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Rounding:", -100.0f, &chart.rounding, 100.0f, 1,0.5f);
*out_style = chart;
}
static void
style_combo(struct nk_context* ctx, struct nk_style_combo* out_style)
{
struct nk_style_combo combo = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &combo.normal);
style_item_color(ctx, "Hover:", &combo.hover);
style_item_color(ctx, "Active:", &combo.active);
style_rgb(ctx, "Border:", &combo.border_color);
style_rgb(ctx, "Label Normal:", &combo.label_normal);
style_rgb(ctx, "Label Hover:", &combo.label_hover);
style_rgb(ctx, "Label Active:", &combo.label_active);
nk_label(ctx, "Normal Symbol:", NK_TEXT_LEFT);
combo.sym_normal = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, combo.sym_normal, 25, nk_vec2(200,200));
nk_label(ctx, "Hover Symbol:", NK_TEXT_LEFT);
combo.sym_hover = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, combo.sym_hover, 25, nk_vec2(200,200));
nk_label(ctx, "Active Symbol:", NK_TEXT_LEFT);
combo.sym_active = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, combo.sym_active, 25, nk_vec2(200,200));
style_vec2(ctx, "Content Padding:", &combo.content_padding);
style_vec2(ctx, "Button Padding:", &combo.button_padding);
style_vec2(ctx, "Spacing:", &combo.spacing);
nk_property_float(ctx, "#Border:", -100.0f, &combo.border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Rounding:", -100.0f, &combo.rounding, 100.0f, 1,0.5f);
*out_style = combo;
}
static void
style_tab(struct nk_context* ctx, struct nk_style_tab* out_style)
{
struct nk_style_tab tab = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Background:", &tab.background);
style_rgb(ctx, "Border:", &tab.border_color);
style_rgb(ctx, "Text:", &tab.text);
// FTR, I feel these fields are misnamed and should be sym_minimized and sym_maximized since they are
// what show in that state, not the button to push to get to that state
nk_label(ctx, "Minimize Symbol:", NK_TEXT_LEFT);
tab.sym_minimize = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, tab.sym_minimize, 25, nk_vec2(200,200));
nk_label(ctx, "Maxmize Symbol:", NK_TEXT_LEFT);
tab.sym_maximize = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, tab.sym_maximize, 25, nk_vec2(200,200));
style_vec2(ctx, "Padding:", &tab.padding);
style_vec2(ctx, "Spacing:", &tab.spacing);
nk_property_float(ctx, "#Indent:", -100.0f, &tab.indent, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Border:", -100.0f, &tab.border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Rounding:", -100.0f, &tab.rounding, 100.0f, 1,0.5f);
*out_style = tab;
}
static void
style_window_header(struct nk_context* ctx, struct nk_style_window_header* out_style)
{
struct nk_style_window_header header = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_item_color(ctx, "Normal:", &header.normal);
style_item_color(ctx, "Hover:", &header.hover);
style_item_color(ctx, "Active:", &header.active);
style_rgb(ctx, "Label Normal:", &header.label_normal);
style_rgb(ctx, "Label Hover:", &header.label_hover);
style_rgb(ctx, "Label Active:", &header.label_active);
style_vec2(ctx, "Label Padding:", &header.label_padding);
style_vec2(ctx, "Padding:", &header.padding);
style_vec2(ctx, "Spacing:", &header.spacing);
#define NUM_ALIGNS 2
const char* alignments[NUM_ALIGNS] = { "LEFT", "RIGHT" };
nk_layout_row_dynamic(ctx, 30, 2);
nk_label(ctx, "Button Alignment:", NK_TEXT_LEFT);
header.align = (nk_style_header_align)nk_combo(ctx, alignments, NUM_ALIGNS, header.align, 25, nk_vec2(200,200));
#undef NUM_ALIGNS
nk_label(ctx, "Close Symbol:", NK_TEXT_LEFT);
header.close_symbol = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, header.close_symbol, 25, nk_vec2(200,200));
nk_label(ctx, "Minimize Symbol:", NK_TEXT_LEFT);
header.minimize_symbol = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, header.minimize_symbol, 25, nk_vec2(200,200));
nk_label(ctx, "Maximize Symbol:", NK_TEXT_LEFT);
header.maximize_symbol = (nk_symbol_type)nk_combo(ctx, symbols, NK_SYMBOL_MAX, header.maximize_symbol, 25, nk_vec2(200,200));
// necessary or do tree's always take the whole width?
//nk_layout_row_dynamic(ctx, 30, 1);
if (nk_tree_push(ctx, NK_TREE_TAB, "Close and Minimize Button", NK_MINIMIZED)) {
struct nk_style_button* dups[1] = { &header.minimize_button };
style_button(ctx, &header.close_button, dups, 1);
nk_tree_pop(ctx);
}
*out_style = header;
}
static void
style_window(struct nk_context* ctx, struct nk_style_window* out_style)
{
struct nk_style_window win = *out_style;
nk_layout_row_dynamic(ctx, 30, 2);
style_rgb(ctx, "Background:", &win.background);
style_item_color(ctx, "Fixed Background:", &win.fixed_background);
style_rgb(ctx, "Border:", &win.border_color);
style_rgb(ctx, "Popup Border:", &win.popup_border_color);
style_rgb(ctx, "Combo Border:", &win.combo_border_color);
style_rgb(ctx, "Contextual Border:", &win.contextual_border_color);
style_rgb(ctx, "Menu Border:", &win.menu_border_color);
style_rgb(ctx, "Group Border:", &win.group_border_color);
style_rgb(ctx, "Tooltip Border:", &win.tooltip_border_color);
style_item_color(ctx, "Scaler:", &win.scaler);
style_vec2(ctx, "Spacing:", &win.spacing);
style_vec2(ctx, "Scrollbar Size:", &win.scrollbar_size);
style_vec2(ctx, "Min Size:", &win.min_size);
style_vec2(ctx, "Padding:", &win.padding);
style_vec2(ctx, "Group Padding:", &win.group_padding);
style_vec2(ctx, "Popup Padding:", &win.popup_padding);
style_vec2(ctx, "Combo Padding:", &win.combo_padding);
style_vec2(ctx, "Contextual Padding:", &win.contextual_padding);
style_vec2(ctx, "Menu Padding:", &win.menu_padding);
style_vec2(ctx, "Tooltip Padding:", &win.tooltip_padding);
nk_property_float(ctx, "#Rounding:", -100.0f, &win.rounding, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Combo Border:", -100.0f, &win.combo_border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Contextual Border:", -100.0f, &win.contextual_border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Menu Border:", -100.0f, &win.menu_border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Group Border:", -100.0f, &win.group_border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Tooltip Border:", -100.0f, &win.tooltip_border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Popup Border:", -100.0f, &win.popup_border, 100.0f, 1,0.5f);
nk_property_float(ctx, "#Border:", -100.0f, &win.border, 100.0f, 1,0.5f);
nk_layout_row_dynamic(ctx, 30, 1);
nk_property_float(ctx, "#Min Row Height Padding:", -100.0f, &win.min_row_height_padding, 100.0f, 1,0.5f);
if (nk_tree_push(ctx, NK_TREE_TAB, "Window Header", NK_MINIMIZED)) {
style_window_header(ctx, &win.header);
nk_tree_pop(ctx);
}
*out_style = win;
}
static int
style_configurator(struct nk_context *ctx, struct nk_color color_table[NK_COLOR_COUNT])
{
/* window flags */
int border = nk_true;
int resize = nk_true;
int movable = nk_true;
int no_scrollbar = nk_false;
int scale_left = nk_false;
nk_flags window_flags = 0;
int minimizable = nk_true;
/* window flags */
window_flags = 0;
if (border) window_flags |= NK_WINDOW_BORDER;
if (resize) window_flags |= NK_WINDOW_SCALABLE;
if (movable) window_flags |= NK_WINDOW_MOVABLE;
if (no_scrollbar) window_flags |= NK_WINDOW_NO_SCROLLBAR;
if (scale_left) window_flags |= NK_WINDOW_SCALE_LEFT;
if (minimizable) window_flags |= NK_WINDOW_MINIMIZABLE;
struct nk_style *style = &ctx->style;
if (nk_begin(ctx, "Configurator", nk_rect(980, 440, 400, 600), window_flags))
{
if (nk_tree_push(ctx, NK_TREE_TAB, "Global Colors", NK_MINIMIZED)) {
style_global_colors(ctx, color_table);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Text", NK_MINIMIZED)) {
style_text(ctx, &style->text);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Button", NK_MINIMIZED)) {
style_button(ctx, &style->button, NULL, 0);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Contextual Button", NK_MINIMIZED)) {
style_button(ctx, &style->contextual_button, NULL, 0);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Menu Button", NK_MINIMIZED)) {
style_button(ctx, &style->menu_button, NULL, 0);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Combo Buttons", NK_MINIMIZED)) {
style_button(ctx, &style->combo.button, NULL, 0);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Tab Min/Max Buttons", NK_MINIMIZED)) {
struct nk_style_button* dups[1] = { &style->tab.tab_maximize_button };
style_button(ctx, &style->tab.tab_minimize_button, dups, 1);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Node Min/Max Buttons", NK_MINIMIZED)) {
struct nk_style_button* dups[1] = { &style->tab.node_maximize_button };
style_button(ctx, &style->tab.node_minimize_button, dups, 1);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Window Header Close Buttons", NK_MINIMIZED)) {
style_button(ctx, &style->window.header.close_button, NULL, 0);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Window Header Minimize Buttons", NK_MINIMIZED)) {
style_button(ctx, &style->window.header.minimize_button, NULL, 0);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Checkbox", NK_MINIMIZED)) {
style_toggle(ctx, &style->checkbox);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Option", NK_MINIMIZED)) {
style_toggle(ctx, &style->option);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Selectable", NK_MINIMIZED)) {
style_selectable(ctx, &style->selectable);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Slider", NK_MINIMIZED)) {
style_slider(ctx, &style->slider);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Progress", NK_MINIMIZED)) {
style_progress(ctx, &style->progress);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Scrollbars", NK_MINIMIZED)) {
struct nk_style_scrollbar* dups[1] = { &style->scrollv };
style_scrollbars(ctx, &style->scrollh, dups, 1);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Edit", NK_MINIMIZED)) {
style_edit(ctx, &style->edit);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Property", NK_MINIMIZED)) {
style_property(ctx, &style->property);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Chart", NK_MINIMIZED)) {
style_chart(ctx, &style->chart);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Combo", NK_MINIMIZED)) {
style_combo(ctx, &style->combo);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Tab", NK_MINIMIZED)) {
style_tab(ctx, &style->tab);
nk_tree_pop(ctx);
}
if (nk_tree_push(ctx, NK_TREE_TAB, "Window", NK_MINIMIZED)) {
style_window(ctx, &style->window);
nk_tree_pop(ctx);
}
nk_layout_row_dynamic(ctx, 30, 1);
if (nk_button_label(ctx, "Reset all styles to defaults")) {
memcpy(color_table, nkc_get_default_color_style(nullptr), NK_COLOR_COUNT * sizeof(struct nk_color));
nk_style_default(ctx);
}
}
nk_end(ctx);
return !nk_window_is_closed(ctx, "Configurator");
}