351 lines
12 KiB
C
351 lines
12 KiB
C
#include "nuklear.h"
|
|
#include "nuklear_internal.h"
|
|
|
|
/* ===============================================================
|
|
*
|
|
* TREE
|
|
*
|
|
* ===============================================================*/
|
|
NK_INTERN int
|
|
nk_tree_state_base(struct nk_context *ctx, enum nk_tree_type type,
|
|
struct nk_image *img, const char *title, enum nk_collapse_states *state)
|
|
{
|
|
struct nk_window *win;
|
|
struct nk_panel *layout;
|
|
const struct nk_style *style;
|
|
struct nk_command_buffer *out;
|
|
const struct nk_input *in;
|
|
const struct nk_style_button *button;
|
|
enum nk_symbol_type symbol;
|
|
float row_height;
|
|
|
|
struct nk_vec2 item_spacing;
|
|
struct nk_rect header = {0,0,0,0};
|
|
struct nk_rect sym = {0,0,0,0};
|
|
struct nk_text text;
|
|
|
|
nk_flags ws = 0;
|
|
enum nk_widget_layout_states widget_state;
|
|
|
|
NK_ASSERT(ctx);
|
|
NK_ASSERT(ctx->current);
|
|
NK_ASSERT(ctx->current->layout);
|
|
if (!ctx || !ctx->current || !ctx->current->layout)
|
|
return 0;
|
|
|
|
/* cache some data */
|
|
win = ctx->current;
|
|
layout = win->layout;
|
|
out = &win->buffer;
|
|
style = &ctx->style;
|
|
item_spacing = style->window.spacing;
|
|
|
|
/* calculate header bounds and draw background */
|
|
row_height = style->font->height + 2 * style->tab.padding.y;
|
|
nk_layout_set_min_row_height(ctx, row_height);
|
|
nk_layout_row_dynamic(ctx, row_height, 1);
|
|
nk_layout_reset_min_row_height(ctx);
|
|
|
|
widget_state = nk_widget(&header, ctx);
|
|
if (type == NK_TREE_TAB) {
|
|
const struct nk_style_item *background = &style->tab.background;
|
|
|
|
switch(background->type) {
|
|
case NK_STYLE_ITEM_IMAGE:
|
|
nk_draw_image(out, header, &background->data.image, nk_white);
|
|
break;
|
|
case NK_STYLE_ITEM_NINE_SLICE:
|
|
nk_draw_nine_slice(out, header, &background->data.slice, nk_white);
|
|
break;
|
|
case NK_STYLE_ITEM_COLOR:
|
|
nk_fill_rect(out, header, 0, style->tab.border_color);
|
|
nk_fill_rect(out, nk_shrink_rect(header, style->tab.border),
|
|
style->tab.rounding, background->data.color);
|
|
break;
|
|
}
|
|
} else text.background = style->window.background;
|
|
|
|
/* update node state */
|
|
in = (!(layout->flags & NK_WINDOW_ROM)) ? &ctx->input: 0;
|
|
in = (in && widget_state == NK_WIDGET_VALID) ? &ctx->input : 0;
|
|
if (nk_button_behavior(&ws, header, in, NK_BUTTON_DEFAULT))
|
|
*state = (*state == NK_MAXIMIZED) ? NK_MINIMIZED : NK_MAXIMIZED;
|
|
|
|
/* select correct button style */
|
|
if (*state == NK_MAXIMIZED) {
|
|
symbol = style->tab.sym_maximize;
|
|
if (type == NK_TREE_TAB)
|
|
button = &style->tab.tab_maximize_button;
|
|
else button = &style->tab.node_maximize_button;
|
|
} else {
|
|
symbol = style->tab.sym_minimize;
|
|
if (type == NK_TREE_TAB)
|
|
button = &style->tab.tab_minimize_button;
|
|
else button = &style->tab.node_minimize_button;
|
|
}
|
|
|
|
{/* draw triangle button */
|
|
sym.w = sym.h = style->font->height;
|
|
sym.y = header.y + style->tab.padding.y;
|
|
sym.x = header.x + style->tab.padding.x;
|
|
nk_do_button_symbol(&ws, &win->buffer, sym, symbol, NK_BUTTON_DEFAULT,
|
|
button, 0, style->font);
|
|
|
|
if (img) {
|
|
/* draw optional image icon */
|
|
sym.x = sym.x + sym.w + 4 * item_spacing.x;
|
|
nk_draw_image(&win->buffer, sym, img, nk_white);
|
|
sym.w = style->font->height + style->tab.spacing.x;}
|
|
}
|
|
|
|
{/* draw label */
|
|
struct nk_rect label;
|
|
header.w = NK_MAX(header.w, sym.w + item_spacing.x);
|
|
label.x = sym.x + sym.w + item_spacing.x;
|
|
label.y = sym.y;
|
|
label.w = header.w - (sym.w + item_spacing.y + style->tab.indent);
|
|
label.h = style->font->height;
|
|
text.text = style->tab.text;
|
|
text.padding = nk_vec2(0,0);
|
|
nk_widget_text(out, label, title, nk_strlen(title), &text,
|
|
NK_TEXT_LEFT, style->font);}
|
|
|
|
/* increase x-axis cursor widget position pointer */
|
|
if (*state == NK_MAXIMIZED) {
|
|
layout->at_x = header.x + (float)*layout->offset_x + style->tab.indent;
|
|
layout->bounds.w = NK_MAX(layout->bounds.w, style->tab.indent);
|
|
layout->bounds.w -= (style->tab.indent + style->window.padding.x);
|
|
layout->row.tree_depth++;
|
|
return nk_true;
|
|
} else return nk_false;
|
|
}
|
|
NK_INTERN int
|
|
nk_tree_base(struct nk_context *ctx, enum nk_tree_type type,
|
|
struct nk_image *img, const char *title, enum nk_collapse_states initial_state,
|
|
const char *hash, int len, int line)
|
|
{
|
|
struct nk_window *win = ctx->current;
|
|
int title_len = 0;
|
|
nk_hash tree_hash = 0;
|
|
nk_uint *state = 0;
|
|
|
|
/* retrieve tree state from internal widget state tables */
|
|
if (!hash) {
|
|
title_len = (int)nk_strlen(title);
|
|
tree_hash = nk_murmur_hash(title, (int)title_len, (nk_hash)line);
|
|
} else tree_hash = nk_murmur_hash(hash, len, (nk_hash)line);
|
|
state = nk_find_value(win, tree_hash);
|
|
if (!state) {
|
|
state = nk_add_value(ctx, win, tree_hash, 0);
|
|
*state = initial_state;
|
|
}
|
|
return nk_tree_state_base(ctx, type, img, title, (enum nk_collapse_states*)state);
|
|
}
|
|
NK_API nk_bool
|
|
nk_tree_state_push(struct nk_context *ctx, enum nk_tree_type type,
|
|
const char *title, enum nk_collapse_states *state)
|
|
{
|
|
return nk_tree_state_base(ctx, type, 0, title, state);
|
|
}
|
|
NK_API nk_bool
|
|
nk_tree_state_image_push(struct nk_context *ctx, enum nk_tree_type type,
|
|
struct nk_image img, const char *title, enum nk_collapse_states *state)
|
|
{
|
|
return nk_tree_state_base(ctx, type, &img, title, state);
|
|
}
|
|
NK_API void
|
|
nk_tree_state_pop(struct nk_context *ctx)
|
|
{
|
|
struct nk_window *win = 0;
|
|
struct nk_panel *layout = 0;
|
|
|
|
NK_ASSERT(ctx);
|
|
NK_ASSERT(ctx->current);
|
|
NK_ASSERT(ctx->current->layout);
|
|
if (!ctx || !ctx->current || !ctx->current->layout)
|
|
return;
|
|
|
|
win = ctx->current;
|
|
layout = win->layout;
|
|
layout->at_x -= ctx->style.tab.indent + (float)*layout->offset_x;
|
|
layout->bounds.w += ctx->style.tab.indent + ctx->style.window.padding.x;
|
|
NK_ASSERT(layout->row.tree_depth);
|
|
layout->row.tree_depth--;
|
|
}
|
|
NK_API nk_bool
|
|
nk_tree_push_hashed(struct nk_context *ctx, enum nk_tree_type type,
|
|
const char *title, enum nk_collapse_states initial_state,
|
|
const char *hash, int len, int line)
|
|
{
|
|
return nk_tree_base(ctx, type, 0, title, initial_state, hash, len, line);
|
|
}
|
|
NK_API nk_bool
|
|
nk_tree_image_push_hashed(struct nk_context *ctx, enum nk_tree_type type,
|
|
struct nk_image img, const char *title, enum nk_collapse_states initial_state,
|
|
const char *hash, int len,int seed)
|
|
{
|
|
return nk_tree_base(ctx, type, &img, title, initial_state, hash, len, seed);
|
|
}
|
|
NK_API void
|
|
nk_tree_pop(struct nk_context *ctx)
|
|
{
|
|
nk_tree_state_pop(ctx);
|
|
}
|
|
NK_INTERN int
|
|
nk_tree_element_image_push_hashed_base(struct nk_context *ctx, enum nk_tree_type type,
|
|
struct nk_image *img, const char *title, int title_len,
|
|
enum nk_collapse_states *state, nk_bool *selected)
|
|
{
|
|
struct nk_window *win;
|
|
struct nk_panel *layout;
|
|
const struct nk_style *style;
|
|
struct nk_command_buffer *out;
|
|
const struct nk_input *in;
|
|
const struct nk_style_button *button;
|
|
enum nk_symbol_type symbol;
|
|
float row_height;
|
|
struct nk_vec2 padding;
|
|
|
|
int text_len;
|
|
float text_width;
|
|
|
|
struct nk_vec2 item_spacing;
|
|
struct nk_rect header = {0,0,0,0};
|
|
struct nk_rect sym = {0,0,0,0};
|
|
|
|
nk_flags ws = 0;
|
|
enum nk_widget_layout_states widget_state;
|
|
|
|
NK_ASSERT(ctx);
|
|
NK_ASSERT(ctx->current);
|
|
NK_ASSERT(ctx->current->layout);
|
|
if (!ctx || !ctx->current || !ctx->current->layout)
|
|
return 0;
|
|
|
|
/* cache some data */
|
|
win = ctx->current;
|
|
layout = win->layout;
|
|
out = &win->buffer;
|
|
style = &ctx->style;
|
|
item_spacing = style->window.spacing;
|
|
padding = style->selectable.padding;
|
|
|
|
/* calculate header bounds and draw background */
|
|
row_height = style->font->height + 2 * style->tab.padding.y;
|
|
nk_layout_set_min_row_height(ctx, row_height);
|
|
nk_layout_row_dynamic(ctx, row_height, 1);
|
|
nk_layout_reset_min_row_height(ctx);
|
|
|
|
widget_state = nk_widget(&header, ctx);
|
|
if (type == NK_TREE_TAB) {
|
|
const struct nk_style_item *background = &style->tab.background;
|
|
|
|
switch (background->type) {
|
|
case NK_STYLE_ITEM_IMAGE:
|
|
nk_draw_image(out, header, &background->data.image, nk_white);
|
|
break;
|
|
case NK_STYLE_ITEM_NINE_SLICE:
|
|
nk_draw_nine_slice(out, header, &background->data.slice, nk_white);
|
|
break;
|
|
case NK_STYLE_ITEM_COLOR:
|
|
nk_fill_rect(out, header, 0, style->tab.border_color);
|
|
nk_fill_rect(out, nk_shrink_rect(header, style->tab.border),
|
|
style->tab.rounding, background->data.color);
|
|
break;
|
|
}
|
|
}
|
|
|
|
in = (!(layout->flags & NK_WINDOW_ROM)) ? &ctx->input: 0;
|
|
in = (in && widget_state == NK_WIDGET_VALID) ? &ctx->input : 0;
|
|
|
|
/* select correct button style */
|
|
if (*state == NK_MAXIMIZED) {
|
|
symbol = style->tab.sym_maximize;
|
|
if (type == NK_TREE_TAB)
|
|
button = &style->tab.tab_maximize_button;
|
|
else button = &style->tab.node_maximize_button;
|
|
} else {
|
|
symbol = style->tab.sym_minimize;
|
|
if (type == NK_TREE_TAB)
|
|
button = &style->tab.tab_minimize_button;
|
|
else button = &style->tab.node_minimize_button;
|
|
}
|
|
{/* draw triangle button */
|
|
sym.w = sym.h = style->font->height;
|
|
sym.y = header.y + style->tab.padding.y;
|
|
sym.x = header.x + style->tab.padding.x;
|
|
if (nk_do_button_symbol(&ws, &win->buffer, sym, symbol, NK_BUTTON_DEFAULT, button, in, style->font))
|
|
*state = (*state == NK_MAXIMIZED) ? NK_MINIMIZED : NK_MAXIMIZED;}
|
|
|
|
/* draw label */
|
|
{nk_flags dummy = 0;
|
|
struct nk_rect label;
|
|
/* calculate size of the text and tooltip */
|
|
text_len = nk_strlen(title);
|
|
text_width = style->font->width(style->font->userdata, style->font->height, title, text_len);
|
|
text_width += (4 * padding.x);
|
|
|
|
header.w = NK_MAX(header.w, sym.w + item_spacing.x);
|
|
label.x = sym.x + sym.w + item_spacing.x;
|
|
label.y = sym.y;
|
|
label.w = NK_MIN(header.w - (sym.w + item_spacing.y + style->tab.indent), text_width);
|
|
label.h = style->font->height;
|
|
|
|
if (img) {
|
|
nk_do_selectable_image(&dummy, &win->buffer, label, title, title_len, NK_TEXT_LEFT,
|
|
selected, img, &style->selectable, in, style->font);
|
|
} else nk_do_selectable(&dummy, &win->buffer, label, title, title_len, NK_TEXT_LEFT,
|
|
selected, &style->selectable, in, style->font);
|
|
}
|
|
/* increase x-axis cursor widget position pointer */
|
|
if (*state == NK_MAXIMIZED) {
|
|
layout->at_x = header.x + (float)*layout->offset_x + style->tab.indent;
|
|
layout->bounds.w = NK_MAX(layout->bounds.w, style->tab.indent);
|
|
layout->bounds.w -= (style->tab.indent + style->window.padding.x);
|
|
layout->row.tree_depth++;
|
|
return nk_true;
|
|
} else return nk_false;
|
|
}
|
|
NK_INTERN int
|
|
nk_tree_element_base(struct nk_context *ctx, enum nk_tree_type type,
|
|
struct nk_image *img, const char *title, enum nk_collapse_states initial_state,
|
|
nk_bool *selected, const char *hash, int len, int line)
|
|
{
|
|
struct nk_window *win = ctx->current;
|
|
int title_len = 0;
|
|
nk_hash tree_hash = 0;
|
|
nk_uint *state = 0;
|
|
|
|
/* retrieve tree state from internal widget state tables */
|
|
if (!hash) {
|
|
title_len = (int)nk_strlen(title);
|
|
tree_hash = nk_murmur_hash(title, (int)title_len, (nk_hash)line);
|
|
} else tree_hash = nk_murmur_hash(hash, len, (nk_hash)line);
|
|
state = nk_find_value(win, tree_hash);
|
|
if (!state) {
|
|
state = nk_add_value(ctx, win, tree_hash, 0);
|
|
*state = initial_state;
|
|
} return nk_tree_element_image_push_hashed_base(ctx, type, img, title,
|
|
nk_strlen(title), (enum nk_collapse_states*)state, selected);
|
|
}
|
|
NK_API nk_bool
|
|
nk_tree_element_push_hashed(struct nk_context *ctx, enum nk_tree_type type,
|
|
const char *title, enum nk_collapse_states initial_state,
|
|
nk_bool *selected, const char *hash, int len, int seed)
|
|
{
|
|
return nk_tree_element_base(ctx, type, 0, title, initial_state, selected, hash, len, seed);
|
|
}
|
|
NK_API nk_bool
|
|
nk_tree_element_image_push_hashed(struct nk_context *ctx, enum nk_tree_type type,
|
|
struct nk_image img, const char *title, enum nk_collapse_states initial_state,
|
|
nk_bool *selected, const char *hash, int len,int seed)
|
|
{
|
|
return nk_tree_element_base(ctx, type, &img, title, initial_state, selected, hash, len, seed);
|
|
}
|
|
NK_API void
|
|
nk_tree_element_pop(struct nk_context *ctx)
|
|
{
|
|
nk_tree_state_pop(ctx);
|
|
}
|
|
|