Zengtudor/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-22 10:05:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update Nuklear to 1.33.0

Browse Source
This commit is contained in:
Camilla Löwy 2017-02-23 17:49:39 +01:00
parent 3817b4e1c5
commit 106a617fa8
4 changed files with 311 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

372
deps/nuklear.h vendored
View File

@ -1,5 +1,5 @@
/*
Nuklear - v1.20 - public domain
Nuklear - 1.33.0 - public domain
no warrenty implied; use at your own risk.
authored from 2015-2016 by Micha Mettke
@ -272,7 +272,13 @@ extern "C" {
*/
#ifndef NK_API
#ifdef NK_PRIVATE
#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199409L))
#define NK_API static inline
#elif defined(__cplusplus)
#define NK_API static inline
#else
#define NK_API static
#endif
#else
#define NK_API extern
#endif
@ -356,10 +362,10 @@ extern "C" {
#endif
#endif
#ifndef NK_SIZE_TYPE
#if (defined(__WIN32) || defined(WIN32)) && defined(_MSC_VER)
#define NK_SIZE_TYPE __int32
#elif defined(__WIN64) && defined(_MSC_VER)
#define NK_SIZE_TYPE __int64
#if defined(_WIN64) && defined(_MSC_VER)
#define NK_SIZE_TYPE unsigned __int64
#elif (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
#define NK_SIZE_TYPE unsigned __int32
#elif defined(__GNUC__) || defined(__clang__)
#if defined(__x86_64__) || defined(__ppc64__)
#define NK_SIZE_TYPE unsigned long
@ -371,10 +377,10 @@ extern "C" {
#endif
#endif
#ifndef NK_POINTER_TYPE
#if (defined(__WIN32) || defined(WIN32)) && defined(_MSC_VER)
#define NK_POINTER_TYPE unsigned __int32
#elif defined(__WIN64) && defined(_MSC_VER)
#if defined(_WIN64) && defined(_MSC_VER)
#define NK_POINTER_TYPE unsigned __int64
#elif (defined(_WIN32) || defined(WIN32)) && defined(_MSC_VER)
#define NK_POINTER_TYPE unsigned __int32
#elif defined(__GNUC__) || defined(__clang__)
#if defined(__x86_64__) || defined(__ppc64__)
#define NK_POINTER_TYPE unsigned long
@ -688,7 +694,8 @@ enum nk_panel_flags {
NK_WINDOW_NO_SCROLLBAR = NK_FLAG(5), /* Removes the scrollbar from the window */
NK_WINDOW_TITLE = NK_FLAG(6), /* Forces a header at the top at the window showing the title */
NK_WINDOW_SCROLL_AUTO_HIDE = NK_FLAG(7), /* Automatically hides the window scrollbar if no user interaction: also requires delta time in `nk_context` to be set each frame */
NK_WINDOW_BACKGROUND = NK_FLAG(8) /* Always keep window in the background */
NK_WINDOW_BACKGROUND = NK_FLAG(8), /* Always keep window in the background */
NK_WINDOW_SCALE_LEFT = NK_FLAG(9) /* Puts window scaler in the left-ottom corner instead right-bottom*/
};
/* context */
@ -751,10 +758,17 @@ NK_API void nk_layout_row_push(struct nk_context*, float val
NK_API void nk_layout_row_end(struct nk_context*);
NK_API void nk_layout_row(struct nk_context*, enum nk_layout_format, float height, int cols, const float *ratio);
NK_API void nk_layout_row_template_begin(struct nk_context*, float height);
NK_API void nk_layout_row_template_push_dynamic(struct nk_context*);
NK_API void nk_layout_row_template_push_variable(struct nk_context*, float min_width);
NK_API void nk_layout_row_template_push_static(struct nk_context*, float width);
NK_API void nk_layout_row_template_end(struct nk_context*);
NK_API void nk_layout_space_begin(struct nk_context*, enum nk_layout_format, float height, int widget_count);
NK_API void nk_layout_space_push(struct nk_context*, struct nk_rect);
NK_API void nk_layout_space_end(struct nk_context*);
/* Layout: Utility */
NK_API struct nk_rect nk_layout_space_bounds(struct nk_context*);
NK_API struct nk_vec2 nk_layout_space_to_screen(struct nk_context*, struct nk_vec2);
NK_API struct nk_vec2 nk_layout_space_to_local(struct nk_context*, struct nk_vec2);
@ -885,7 +899,8 @@ NK_API float nk_propertyf(struct nk_context*, const char *nam
NK_API double nk_propertyd(struct nk_context*, const char *name, double min, double val, double max, double step, float inc_per_pixel);
/* Widgets: TextEdit */
NK_API void nk_edit_focus(struct nk_context *ctx, nk_flags flags);
NK_API void nk_edit_focus(struct nk_context*, nk_flags flags);
NK_API void nk_edit_unfocus(struct nk_context*);
NK_API nk_flags nk_edit_string(struct nk_context*, nk_flags, char *buffer, int *len, int max, nk_plugin_filter);
NK_API nk_flags nk_edit_buffer(struct nk_context*, nk_flags, struct nk_text_edit*, nk_plugin_filter);
NK_API nk_flags nk_edit_string_zero_terminated(struct nk_context*, nk_flags, char *buffer, int max, nk_plugin_filter);
@ -2612,6 +2627,9 @@ NK_API struct nk_style_item nk_style_item_hide(void);
/*==============================================================
* PANEL
* =============================================================*/
#ifndef NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS
#define NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS 16
#endif
#ifndef NK_CHART_MAX_SLOT
#define NK_CHART_MAX_SLOT 4
#endif
@ -2647,8 +2665,20 @@ struct nk_chart {
struct nk_chart_slot slots[NK_CHART_MAX_SLOT];
};
enum nk_panel_row_layout_type {
NK_LAYOUT_DYNAMIC_FIXED = 0,
NK_LAYOUT_DYNAMIC_ROW,
NK_LAYOUT_DYNAMIC_FREE,
NK_LAYOUT_DYNAMIC,
NK_LAYOUT_STATIC_FIXED,
NK_LAYOUT_STATIC_ROW,
NK_LAYOUT_STATIC_FREE,
NK_LAYOUT_STATIC,
NK_LAYOUT_TEMPLATE,
NK_LAYOUT_COUNT
};
struct nk_row_layout {
int type;
enum nk_panel_row_layout_type type;
int index;
float height;
int columns;
@ -2659,6 +2689,7 @@ struct nk_row_layout {
float filled;
struct nk_rect item;
int tree_depth;
float templates[NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS];
};
struct nk_popup_buffer {
@ -3115,7 +3146,7 @@ template<typename T> struct nk_alignof{struct Big {T x; char c;}; enum {
#define NK_SINT_MIN (-2147483647)
#define NK_SINT_MAX 2147483647
#define NK_UINT_MIN 0
#define NK_UINT_MAX 4294967295
#define NK_UINT_MAX 4294967295u
/* Make sure correct type size:
* This will fire with a negative subscript error if the type sizes
@ -3716,7 +3747,7 @@ nk_strmatch_fuzzy_text(const char *str, int str_len,
int next_match = *pattern_iter != '\0' &&
nk_to_lower(pattern_letter) == nk_to_lower(str_letter);
int rematch = best_letter && nk_to_lower(*best_letter) == nk_to_lower(str_letter);
int rematch = best_letter && nk_to_upper(*best_letter) == nk_to_upper(str_letter);
int advanced = next_match && best_letter;
int pattern_repeat = best_letter && *pattern_iter != '\0';
@ -13407,8 +13438,8 @@ nk_slider_behavior(nk_flags *state, struct nk_rect *logical_cursor,
if (left_mouse_down && left_mouse_click_in_cursor)
{
float ratio = 0;
const float d = in->mouse.pos.x - (visual_cursor->x + visual_cursor->w / 2.0f);
const float pxstep = (bounds.w - (2 * style->padding.x)) / slider_steps;
const float d = in->mouse.pos.x - (visual_cursor->x+visual_cursor->w*0.5f);
const float pxstep = bounds.w / slider_steps;
/* only update value if the next slider step is reached */
*state = NK_WIDGET_STATE_ACTIVE;
@ -13418,7 +13449,7 @@ nk_slider_behavior(nk_flags *state, struct nk_rect *logical_cursor,
slider_value = NK_CLAMP(slider_min, slider_value, slider_max);
ratio = (slider_value - slider_min)/slider_step;
logical_cursor->x = bounds.x + (logical_cursor->w * ratio);
in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = logical_cursor->x + logical_cursor->w/2.0f;
in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = logical_cursor->x;
}
}
@ -13548,6 +13579,10 @@ nk_do_slider(nk_flags *state,
bounds.w = bounds.w - (2*button.w + 2*style->spacing.x);
}
/* remove one cursor size to support visual cursor */
bounds.x += style->cursor_size.x*0.5f;
bounds.w -= style->cursor_size.x;
/* make sure the provided values are correct */
slider_max = NK_MAX(min, max);
slider_min = NK_MIN(min, max);
@ -13556,10 +13591,6 @@ nk_do_slider(nk_flags *state,
slider_steps = slider_range / step;
cursor_offset = (slider_value - slider_min) / step;
/* remove one cursor size to support visual cursor */
bounds.x += style->cursor_size.x*0.5f;
bounds.w -= style->cursor_size.x;
/* calculate cursor
Basically you have two cursors. One for visual representation and interaction
and one for updating the actual cursor value. */
@ -13571,7 +13602,7 @@ nk_do_slider(nk_flags *state,
visual_cursor.h = style->cursor_size.y;
visual_cursor.w = style->cursor_size.x;
visual_cursor.y = (bounds.y + bounds.h*0.5f) - visual_cursor.h*0.5f;
visual_cursor.x = (logical_cursor.x + logical_cursor.w*0.5f) - visual_cursor.w*0.5f;
visual_cursor.x = logical_cursor.x - visual_cursor.w*0.5f;
slider_value = nk_slider_behavior(state, &logical_cursor, &visual_cursor,
in, style, bounds, slider_min, slider_max, slider_value, step, slider_steps);
@ -16069,6 +16100,12 @@ nk_clear(struct nk_context *ctx)
continue;
}
/* remove hotness from hidden or closed windows*/
if (((iter->flags & NK_WINDOW_HIDDEN) ||
(iter->flags & NK_WINDOW_CLOSED)) &&
iter == ctx->active)
ctx->active = iter->next;
/* free unused popup windows */
if (iter->popup.win && iter->popup.win->seq != ctx->seq) {
nk_free_window(ctx, iter->popup.win);
@ -16683,7 +16720,7 @@ nk_panel_end(struct nk_context *ctx)
scroll.w = scrollbar_size.x;
scroll.h = layout->bounds.h;
scroll_offset = *layout->offset_y;
scroll_offset = (float)*layout->offset_y;
scroll_step = scroll.h * 0.10f;
scroll_inc = scroll.h * 0.01f;
scroll_target = (float)(int)(layout->at_y - scroll.y);
@ -16741,7 +16778,7 @@ nk_panel_end(struct nk_context *ctx)
scroll.w = layout->bounds.w;
scroll.h = scrollbar_size.y;
scroll_offset = *layout->offset_x;
scroll_offset = (float)*layout->offset_x;
scroll_target = (float)(int)(layout->max_x - scroll.x);
scroll_step = layout->max_x * 0.05f;
scroll_inc = layout->max_x * 0.005f;
@ -16801,7 +16838,9 @@ nk_panel_end(struct nk_context *ctx)
scaler.w = scrollbar_size.x;
scaler.h = scrollbar_size.y;
scaler.y = layout->bounds.y + layout->bounds.h;
scaler.x = layout->bounds.x + layout->bounds.w + panel_padding.x;
if (layout->flags & NK_WINDOW_SCALE_LEFT)
scaler.x = layout->bounds.x - panel_padding.x * 0.5f;
else scaler.x = layout->bounds.x + layout->bounds.w + panel_padding.x;
if (layout->flags & NK_WINDOW_NO_SCROLLBAR)
scaler.x -= scaler.w;
@ -16809,9 +16848,16 @@ nk_panel_end(struct nk_context *ctx)
{const struct nk_style_item *item = &style->window.scaler;
if (item->type == NK_STYLE_ITEM_IMAGE)
nk_draw_image(out, scaler, &item->data.image, nk_white);
else nk_fill_triangle(out, scaler.x + scaler.w, scaler.y, scaler.x + scaler.w,
else {
if (layout->flags & NK_WINDOW_SCALE_LEFT) {
nk_fill_triangle(out, scaler.x, scaler.y, scaler.x,
scaler.y + scaler.h, scaler.x + scaler.w,
scaler.y + scaler.h, item->data.color);
} else {
nk_fill_triangle(out, scaler.x + scaler.w, scaler.y, scaler.x + scaler.w,
scaler.y + scaler.h, scaler.x, scaler.y + scaler.h, item->data.color);
}
}}
/* do window scaling */
if (!(window->flags & NK_WINDOW_ROM)) {
@ -16821,7 +16867,13 @@ nk_panel_end(struct nk_context *ctx)
NK_BUTTON_LEFT, scaler, nk_true);
if (nk_input_is_mouse_down(in, NK_BUTTON_LEFT) && left_mouse_down && left_mouse_click_in_scaler) {
window->bounds.w = NK_MAX(window_size.x, window->bounds.w + in->mouse.delta.x);
float delta_x = in->mouse.delta.x;
if (layout->flags & NK_WINDOW_SCALE_LEFT) {
delta_x =- delta_x;
window->bounds.x += in->mouse.delta.x;
}
window->bounds.w = NK_MAX(window_size.x, window->bounds.w + delta_x);
/* dragging in y-direction is only possible if static window */
if (!(layout->flags & NK_WINDOW_DYNAMIC))
window->bounds.h = NK_MAX(window_size.y, window->bounds.h + in->mouse.delta.y);
@ -17266,7 +17318,7 @@ nk_begin_titled(struct nk_context *ctx, const char *name, const char *title,
* provided demo backends). */
NK_ASSERT(win->seq != ctx->seq);
win->seq = ctx->seq;
if (!ctx->active)
if (!ctx->active && !(win->flags & NK_WINDOW_HIDDEN))
ctx->active = win;
}
if (win->flags & NK_WINDOW_HIDDEN) {
@ -17680,9 +17732,9 @@ nk_window_show(struct nk_context *ctx, const char *name, enum nk_show_states s)
title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
win = nk_find_window(ctx, title_hash, name);
if (!win) return;
if (s == NK_HIDDEN)
if (s == NK_HIDDEN) {
win->flags |= NK_WINDOW_HIDDEN;
else win->flags &= ~(nk_flags)NK_WINDOW_HIDDEN;
} else win->flags &= ~(nk_flags)NK_WINDOW_HIDDEN;
}
NK_API void
@ -17792,14 +17844,26 @@ nk_menubar_end(struct nk_context *ctx)
* LAYOUT
*
* --------------------------------------------------------------*/
#define NK_LAYOUT_DYNAMIC_FIXED 0
#define NK_LAYOUT_DYNAMIC_ROW 1
#define NK_LAYOUT_DYNAMIC_FREE 2
#define NK_LAYOUT_DYNAMIC 3
#define NK_LAYOUT_STATIC_FIXED 4
#define NK_LAYOUT_STATIC_ROW 5
#define NK_LAYOUT_STATIC_FREE 6
#define NK_LAYOUT_STATIC 7
NK_INTERN float
nk_layout_row_calculate_usable_space(const struct nk_style *style, enum nk_panel_type type,
float total_space, int columns)
{
float panel_padding;
float panel_spacing;
float panel_space;
struct nk_vec2 spacing;
struct nk_vec2 padding;
spacing = style->window.spacing;
padding = nk_panel_get_padding(style, type);
/* calculate the usable panel space */
panel_padding = 2 * padding.x;
panel_spacing = (float)NK_MAX(columns - 1, 0) * spacing.x;
panel_space = total_space - panel_padding - panel_spacing;
return panel_space;
}
NK_INTERN void
nk_panel_layout(const struct nk_context *ctx, struct nk_window *win,
@ -17939,6 +18003,10 @@ nk_layout_row_push(struct nk_context *ctx, float ratio_or_width)
win = ctx->current;
layout = win->layout;
NK_ASSERT(layout->row.type == NK_LAYOUT_STATIC_ROW || layout->row.type == NK_LAYOUT_DYNAMIC_ROW);
if (layout->row.type != NK_LAYOUT_STATIC_ROW && layout->row.type != NK_LAYOUT_DYNAMIC_ROW)
return;
if (layout->row.type == NK_LAYOUT_DYNAMIC_ROW) {
float ratio = ratio_or_width;
if ((ratio + layout->row.filled) > 1.0f) return;
@ -17962,6 +18030,9 @@ nk_layout_row_end(struct nk_context *ctx)
win = ctx->current;
layout = win->layout;
NK_ASSERT(layout->row.type == NK_LAYOUT_STATIC_ROW || layout->row.type == NK_LAYOUT_DYNAMIC_ROW);
if (layout->row.type != NK_LAYOUT_STATIC_ROW && layout->row.type != NK_LAYOUT_DYNAMIC_ROW)
return;
layout->row.item_width = 0;
layout->row.item_offset = 0;
}
@ -18006,6 +18077,149 @@ nk_layout_row(struct nk_context *ctx, enum nk_layout_format fmt,
layout->row.filled = 0;
}
NK_API void
nk_layout_row_template_begin(struct nk_context *ctx, float height)
{
struct nk_window *win;
struct nk_panel *layout;
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;
nk_panel_layout(ctx, win, height, 1);
layout->row.type = NK_LAYOUT_TEMPLATE;
layout->row.columns = 0;
layout->row.ratio = 0;
layout->row.item_width = 0;
layout->row.item_height = 0;
layout->row.item_offset = 0;
layout->row.filled = 0;
layout->row.item.x = 0;
layout->row.item.y = 0;
layout->row.item.w = 0;
layout->row.item.h = 0;
}
NK_API void
nk_layout_row_template_push_dynamic(struct nk_context *ctx)
{
struct nk_window *win;
struct nk_panel *layout;
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;
NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE);
NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return;
layout->row.templates[layout->row.columns++] = -1.0f;
}
NK_API void
nk_layout_row_template_push_variable(struct nk_context *ctx, float min_width)
{
struct nk_window *win;
struct nk_panel *layout;
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;
NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE);
NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return;
layout->row.templates[layout->row.columns++] = -min_width;
}
NK_API void
nk_layout_row_template_push_static(struct nk_context *ctx, float width)
{
struct nk_window *win;
struct nk_panel *layout;
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;
NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE);
NK_ASSERT(layout->row.columns < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
if (layout->row.columns >= NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS) return;
layout->row.templates[layout->row.columns++] = width;
}
NK_API void
nk_layout_row_template_end(struct nk_context *ctx)
{
struct nk_window *win;
struct nk_panel *layout;
int i = 0;
int variable_count = 0;
int min_variable_count = 0;
float min_fixed_width = 0.0f;
float total_fixed_width = 0.0f;
float max_variable_width = 0.0f;
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;
NK_ASSERT(layout->row.type == NK_LAYOUT_TEMPLATE);
if (layout->row.type != NK_LAYOUT_TEMPLATE) return;
for (i = 0; i < layout->row.columns; ++i) {
float width = layout->row.templates[i];
if (width >= 0.0f) {
total_fixed_width += width;
min_fixed_width += width;
} else if (width < -1.0f) {
width = -width;
total_fixed_width += width;
max_variable_width = NK_MAX(max_variable_width, width);
variable_count++;
} else {
min_variable_count++;
variable_count++;
}
}
if (variable_count) {
float space = nk_layout_row_calculate_usable_space(&ctx->style, layout->type,
layout->bounds.w, layout->row.columns);
float var_width = (NK_MAX(space-min_fixed_width,0.0f)) / (float)variable_count;
int enough_space = var_width >= max_variable_width;
if (!enough_space)
var_width = (NK_MAX(space-total_fixed_width,0)) / (float)min_variable_count;
for (i = 0; i < layout->row.columns; ++i) {
float *width = &layout->row.templates[i];
*width = (*width >= 0.0f)? *width: (*width < -1.0f && !enough_space)? -(*width): var_width;
}
}
}
NK_API void
nk_layout_space_begin(struct nk_context *ctx, enum nk_layout_format fmt,
float height, int widget_count)
@ -18101,8 +18315,8 @@ nk_layout_space_to_screen(struct nk_context *ctx, struct nk_vec2 ret)
win = ctx->current;
layout = win->layout;
ret.x += layout->at_x - *layout->offset_x;
ret.y += layout->at_y - *layout->offset_y;
ret.x += layout->at_x - (float)*layout->offset_x;
ret.y += layout->at_y - (float)*layout->offset_y;
return ret;
}
@ -18118,8 +18332,8 @@ nk_layout_space_to_local(struct nk_context *ctx, struct nk_vec2 ret)
win = ctx->current;
layout = win->layout;
ret.x += -layout->at_x + *layout->offset_x;
ret.y += -layout->at_y + *layout->offset_y;
ret.x += -layout->at_x + (float)*layout->offset_x;
ret.y += -layout->at_y + (float)*layout->offset_y;
return ret;
}
@ -18135,8 +18349,8 @@ nk_layout_space_rect_to_screen(struct nk_context *ctx, struct nk_rect ret)
win = ctx->current;
layout = win->layout;
ret.x += layout->at_x - *layout->offset_x;
ret.y += layout->at_y - *layout->offset_y;
ret.x += layout->at_x - (float)*layout->offset_x;
ret.y += layout->at_y - (float)*layout->offset_y;
return ret;
}
@ -18152,8 +18366,8 @@ nk_layout_space_rect_to_local(struct nk_context *ctx, struct nk_rect ret)
win = ctx->current;
layout = win->layout;
ret.x += -layout->at_x + *layout->offset_x;
ret.y += -layout->at_y + *layout->offset_y;
ret.x += -layout->at_x + (float)*layout->offset_x;
ret.y += -layout->at_y + (float)*layout->offset_y;
return ret;
}
@ -18173,16 +18387,13 @@ nk_layout_widget_space(struct nk_rect *bounds, const struct nk_context *ctx,
struct nk_panel *layout;
const struct nk_style *style;
struct nk_vec2 spacing;
struct nk_vec2 padding;
float item_offset = 0;
float item_width = 0;
float item_spacing = 0;
float panel_padding;
float panel_spacing;
float panel_space;
struct nk_vec2 spacing;
struct nk_vec2 padding;
float panel_space = 0;
NK_ASSERT(ctx);
NK_ASSERT(ctx->current);
@ -18191,18 +18402,14 @@ nk_layout_widget_space(struct nk_rect *bounds, const struct nk_context *ctx,
return;
win = ctx->current;
style = &ctx->style;
layout = win->layout;
style = &ctx->style;
NK_ASSERT(bounds);
/* cache some configuration data */
spacing = ctx->style.window.spacing;
spacing = style->window.spacing;
padding = nk_panel_get_padding(style, layout->type);
/* calculate the usable panel space */
panel_padding = 2 * padding.x;
panel_spacing = (float)(layout->row.columns - 1) * spacing.x;
panel_space = layout->bounds.w - panel_padding - panel_spacing;
panel_space = nk_layout_row_calculate_usable_space(&ctx->style, layout->type,
layout->bounds.w, layout->row.columns);
/* calculate the width of one item inside the current layout space */
switch (layout->row.type) {
@ -18227,13 +18434,13 @@ nk_layout_widget_space(struct nk_rect *bounds, const struct nk_context *ctx,
case NK_LAYOUT_DYNAMIC_FREE: {
/* panel width depended free widget placing */
bounds->x = layout->at_x + (layout->bounds.w * layout->row.item.x);
bounds->x -= *layout->offset_x;
bounds->x -= (float)*layout->offset_x;
bounds->y = layout->at_y + (layout->row.height * layout->row.item.y);
bounds->y -= *layout->offset_y;
bounds->y -= (float)*layout->offset_y;
bounds->w = layout->bounds.w * layout->row.item.w;
bounds->h = layout->row.height * layout->row.item.h;
return;
};
} break;
case NK_LAYOUT_DYNAMIC: {
/* scaling arrays of panel width ratios for every widget */
float ratio;
@ -18269,12 +18476,12 @@ nk_layout_widget_space(struct nk_rect *bounds, const struct nk_context *ctx,
bounds->w = layout->row.item.w;
if (((bounds->x + bounds->w) > layout->max_x) && modify)
layout->max_x = (bounds->x + bounds->w);
bounds->x -= *layout->offset_x;
bounds->x -= (float)*layout->offset_x;
bounds->y = layout->at_y + layout->row.item.y;
bounds->y -= *layout->offset_y;
bounds->y -= (float)*layout->offset_y;
bounds->h = layout->row.item.h;
return;
};
} break;
case NK_LAYOUT_STATIC: {
/* non-scaling array of panel pixel width for every widget */
item_spacing = (float)layout->row.index * spacing.x;
@ -18282,17 +18489,26 @@ nk_layout_widget_space(struct nk_rect *bounds, const struct nk_context *ctx,
item_offset = layout->row.item_offset;
if (modify) layout->row.item_offset += item_width;
} break;
case NK_LAYOUT_TEMPLATE: {
/* stretchy row layout with combined dynamic/static widget width*/
NK_ASSERT(layout->row.index < layout->row.columns);
NK_ASSERT(layout->row.index < NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS);
item_width = layout->row.templates[layout->row.index];
item_offset = layout->row.item_offset;
item_spacing = (float)layout->row.index * spacing.x;
if (modify) layout->row.item_offset += item_width;
} break;
default: NK_ASSERT(0); break;
};
/* set the bounds of the newly allocated widget */
bounds->w = item_width;
bounds->h = layout->row.height - spacing.y;
bounds->y = layout->at_y - *layout->offset_y;
bounds->y = layout->at_y - (float)*layout->offset_y;
bounds->x = layout->at_x + item_offset + item_spacing + padding.x;
if (((bounds->x + bounds->w) > layout->max_x) && modify)
layout->max_x = bounds->x + bounds->w;
bounds->x -= *layout->offset_x;
bounds->x -= (float)*layout->offset_x;
}
NK_INTERN void
@ -18441,7 +18657,7 @@ nk_tree_state_base(struct nk_context *ctx, enum nk_tree_type type,
/* increase x-axis cursor widget position pointer */
if (*state == NK_MAXIMIZED) {
layout->at_x = header.x + *layout->offset_x + style->tab.indent;
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++;
@ -19602,6 +19818,19 @@ nk_edit_focus(struct nk_context *ctx, nk_flags flags)
win->edit.mode = NK_TEXT_EDIT_MODE_INSERT;
}
NK_API void
nk_edit_unfocus(struct nk_context *ctx)
{
struct nk_window *win;
NK_ASSERT(ctx);
NK_ASSERT(ctx->current);
if (!ctx || !ctx->current) return;
win = ctx->current;
win->edit.active = nk_false;
win->edit.name = 0;
}
NK_API nk_flags
nk_edit_string(struct nk_context *ctx, nk_flags flags,
char *memory, int *len, int max, nk_plugin_filter filter)
@ -20349,7 +20578,6 @@ nk_group_scrolled_offset_begin(struct nk_context *ctx,
win->layout = panel.layout;
ctx->current = win;
return 1;
}
NK_API void
@ -20504,7 +20732,7 @@ nk_list_view_begin(struct nk_context *ctx, struct nk_list_view *view,
layout = win->layout;
view->total_height = row_height * NK_MAX(row_count,1);
view->begin = (int)NK_MAX((view->scroll_value / (float)row_height), 0.0f);
view->begin = (int)NK_MAX(((float)view->scroll_value / (float)row_height), 0.0f);
view->count = (int)NK_MAX(nk_iceilf((layout->clip.h)/(float)row_height), 0);
view->end = view->begin + view->count;
view->ctx = ctx;
@ -20558,6 +20786,7 @@ nk_popup_begin(struct nk_context *ctx, enum nk_popup_type type,
win = ctx->current;
panel = win->layout;
NK_ASSERT(!(panel->type & NK_PANEL_SET_POPUP) && "popups are not allowed to have popups");
(void)panel;
title_len = (int)nk_strlen(title);
title_hash = nk_murmur_hash(title, (int)title_len, NK_PANEL_POPUP);
@ -20652,6 +20881,7 @@ nk_nonblock_begin(struct nk_context *ctx,
win = ctx->current;
panel = win->layout;
NK_ASSERT(!(panel->type & NK_PANEL_SET_POPUP));
(void)panel;
popup = win->popup.win;
if (!popup) {
/* create window for nonblocking popup */

8
deps/nuklear_glfw_gl2.h vendored
View File

@ -1,5 +1,5 @@
/*
* Nuklear - v1.17 - public domain
* Nuklear - v1.32.0 - public domain
* no warrenty implied; use at your own risk.
* authored from 2015-2016 by Micha Mettke
*/
@ -15,8 +15,6 @@
#include <GLFW/glfw3.h>
#include <string.h>
enum nk_glfw_init_state{
NK_GLFW3_DEFAULT = 0,
NK_GLFW3_INSTALL_CALLBACKS
@ -221,7 +219,7 @@ nk_glfw3_clipbard_copy(nk_handle usr, const char *text, int len)
if (!len) return;
str = (char*)malloc((size_t)len+1);
if (!str) return;
memcpy(str, text, (size_t)len);
NK_MEMCPY(str, text, (size_t)len);
str[len] = '\0';
glfwSetClipboardString(glfw.win, str);
free(str);
@ -346,7 +344,7 @@ void nk_glfw3_shutdown(void)
nk_free(&glfw.ctx);
glDeleteTextures(1, &dev->font_tex);
nk_buffer_free(&dev->cmds);
memset(&glfw, 0, sizeof(glfw));
NK_MEMSET(&glfw, 0, sizeof(glfw));
}
#endif

2
tests/gamma.c
View File

@ -132,13 +132,11 @@ int main(int argc, char** argv)
if (nk_slider_float(nk, 0.1f, &gamma_value, 5.f, 0.1f))
glfwSetGamma(monitor, gamma_value);
nk_labelf(nk, NK_TEXT_LEFT, "%0.1f", gamma_value);
nk_layout_row_end(nk);
nk_layout_row_dynamic(nk, height - 60.f, 3);
chart_ramp_array(nk, nk_rgb(255, 0, 0), ramp->size, ramp->red);
chart_ramp_array(nk, nk_rgb(0, 255, 0), ramp->size, ramp->green);
chart_ramp_array(nk, nk_rgb(0,0, 255), ramp->size, ramp->blue);
nk_layout_row_end(nk);
}
nk_end(nk);

2
tests/joysticks.c
View File

@ -192,8 +192,6 @@ int main(void)
nk_select_label(nk, name, NK_TEXT_CENTERED, buttons[j]);
}
}
nk_layout_row_end(nk);
}
nk_end(nk);