gwm17/glfw
1
0
Fork 0
mirror of https://github.com/gwm17/glfw.git synced 2024-11-26 20:28:49 -05:00
Code Issues Projects Releases Wiki Activity

Update Nuklear to 1.156

Browse Source
This commit is contained in:
Camilla Berglund 2016-10-06 19:07:28 +02:00
parent ea1958a948
commit 2af40c3fe6
2 changed files with 177 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

314
deps/nuklear.h vendored
View File

@ -1,5 +1,5 @@
/* /*
Nuklear - v1.15 - public domain Nuklear - v1.156 - public domain
no warrenty implied; use at your own risk. no warrenty implied; use at your own risk.
authored from 2015-2016 by Micha Mettke authored from 2015-2016 by Micha Mettke
@ -94,10 +94,10 @@ OPTIONAL DEFINES:
<!> If used needs to be defined for implementation and header <!> <!> If used needs to be defined for implementation and header <!>
NK_INCLUDE_STANDARD_VARARGS NK_INCLUDE_STANDARD_VARARGS
if defined it will include header <stdarg.h> as well as <stdio.h> and provide if defined it will include header <stdarg.h> and provide
additional functions depending on variable arguments additional functions depending on variable arguments
<!> Adds the standard library with va_list and vsprintf/vsnprintf <!> Adds the standard library with va_list and so don't define this if
so don't define this if you don't want to link to the standard library<!> you don't want to link to the standard library<!>
<!> If used needs to be defined for implementation and header <!> <!> If used needs to be defined for implementation and header <!>
NK_INCLUDE_VERTEX_BUFFER_OUTPUT NK_INCLUDE_VERTEX_BUFFER_OUTPUT
@ -214,6 +214,13 @@ OPTIONAL DEFINES:
will be selected and compile time validated. If they are incorrect you can will be selected and compile time validated. If they are incorrect you can
define the correct types by overloading these type defines. define the correct types by overloading these type defines.
NK_ZERO_COMMAND_MEMORY
Defining this will zero out memory for each drawing command added to a
drawing queue (inside nk_command_buffer_push). This can be used to
implement fast check (using memcmp) that command buffers are equal and
avoid drawing frames when nothing on screen has changed since previous
frame.
CREDITS: CREDITS:
Developed by Micha Mettke and every direct or indirect contributor to the GitHub. Developed by Micha Mettke and every direct or indirect contributor to the GitHub.
@ -317,52 +324,60 @@ extern "C" {
#define NK_SIZE_TYPE uintptr_t #define NK_SIZE_TYPE uintptr_t
#define NK_POINTER_TYPE uintptr_t #define NK_POINTER_TYPE uintptr_t
#else #else
#ifndef NK_INT8 #ifndef NK_INT8
#define NK_INT8 char #define NK_INT8 char
#endif #endif
#ifndef NK_UINT8 #ifndef NK_UINT8
#define NK_BYTE unsigned char #define NK_UINT8 unsigned char
#endif #endif
#ifndef NK_INT16 #ifndef NK_INT16
#define NK_INT16 signed char #define NK_INT16 signed short
#endif #endif
#ifndef NK_UINT16 #ifndef NK_UINT16
#define NK_UINT16 unsigned short #define NK_UINT16 unsigned short
#endif #endif
#ifndef NK_INT32 #ifndef NK_INT32
#define NK_INT32 signed int #if defined(_MSC_VER)
#endif #define NK_INT32 __int32
#ifndef NK_UINT32
#define NK_UINT32 unsigned int
#endif
#ifndef NK_SIZE_TYPE
#if __WIN32
#define NK_SIZE_TYPE __int32
#elif __WIN64
#define NK_SIZE_TYPE __int64
#elif __GNUC__ || __clang__
#if __x86_64__ || __ppc64__
#define NK_SIZE_TYPE unsigned long
#else
#define NK_SIZE_TYPE unsigned int
#endif
#else
#define NK_SIZE_TYPE unsigned long
#endif
#endif
#ifndef NK_POINTER_TYPE
#if __WIN32
#define NK_POINTER_TYPE unsigned __int32
#elif __WIN64
#define NK_POINTER_TYPE unsigned __int64
#elif __GNUC__ || __clang__
#if __x86_64__ || __ppc64__
#define NK_POINTER_TYPE unsigned long
#else
#define NK_POINTER_TYPE unsigned int
#endif
#else #else
#define NK_POINTER_TYPE unsigned long #define NK_INT32 signed int
#endif
#endif
#ifndef NK_UINT32
#if defined(_MSC_VER)
#define NK_UINT32 unsigned __int32
#else
#define NK_UINT32 unsigned int
#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
#elif defined(__GNUC__) || defined(__clang__)
#if defined(__x86_64__) || defined(__ppc64__)
#define NK_SIZE_TYPE unsigned long
#else
#define NK_SIZE_TYPE unsigned int
#endif
#else
#define NK_SIZE_TYPE unsigned long
#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)
#define NK_POINTER_TYPE unsigned __int64
#elif defined(__GNUC__) || defined(__clang__)
#if defined(__x86_64__) || defined(__ppc64__)
#define NK_POINTER_TYPE unsigned long
#else
#define NK_POINTER_TYPE unsigned int
#endif
#else
#define NK_POINTER_TYPE unsigned long
#endif #endif
#endif #endif
#endif #endif
@ -2833,7 +2848,6 @@ template<typename T> struct nk_alignof{struct Big {T x; char c;}; enum {
#endif #endif
#ifdef NK_INCLUDE_STANDARD_VARARGS #ifdef NK_INCLUDE_STANDARD_VARARGS
#include <stdarg.h> /* valist, va_start, va_end, ... */ #include <stdarg.h> /* valist, va_start, va_end, ... */
#include <stdio.h> /* vsnprintf */
#endif #endif
#ifndef NK_ASSERT #ifndef NK_ASSERT
#include <assert.h> #include <assert.h>
@ -3509,8 +3523,7 @@ nk_strmatch_fuzzy_text(const char *str, int str_len,
{ {
int new_score = 0; int new_score = 0;
/* Apply penalty for each letter before the first pattern match */ /* Apply penalty for each letter before the first pattern match */
if (pattern_iter == pattern) if (pattern_iter == pattern) {
{
int count = (int)(&str[str_iter] - str); int count = (int)(&str[str_iter] - str);
int penalty = NK_LEADING_LETTER_PENALTY * count; int penalty = NK_LEADING_LETTER_PENALTY * count;
if (penalty < NK_MAX_LEADING_LETTER_PENALTY) if (penalty < NK_MAX_LEADING_LETTER_PENALTY)
@ -3536,8 +3549,7 @@ nk_strmatch_fuzzy_text(const char *str, int str_len,
++pattern_iter; ++pattern_iter;
/* update best letter in str which may be for a "next" letter or a rematch */ /* update best letter in str which may be for a "next" letter or a rematch */
if (new_score >= best_letter_score) if (new_score >= best_letter_score) {
{
/* apply penalty for now skipped letter */ /* apply penalty for now skipped letter */
if (best_letter != 0) if (best_letter != 0)
score += NK_UNMATCHED_LETTER_PENALTY; score += NK_UNMATCHED_LETTER_PENALTY;
@ -3545,11 +3557,8 @@ nk_strmatch_fuzzy_text(const char *str, int str_len,
best_letter = &str[str_iter]; best_letter = &str[str_iter];
best_letter_score = new_score; best_letter_score = new_score;
} }
prev_matched = nk_true; prev_matched = nk_true;
} } else {
else
{
score += NK_UNMATCHED_LETTER_PENALTY; score += NK_UNMATCHED_LETTER_PENALTY;
prev_matched = nk_false; prev_matched = nk_false;
} }
@ -3784,7 +3793,7 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
enum nk_arg_type { enum nk_arg_type {
NK_ARG_TYPE_CHAR, NK_ARG_TYPE_CHAR,
NK_ARG_TYPE_SHORT, NK_ARG_TYPE_SHORT,
NK_ARG_TYPE_INT, NK_ARG_TYPE_DEFAULT,
NK_ARG_TYPE_LONG NK_ARG_TYPE_LONG
}; };
enum nk_arg_flags { enum nk_arg_flags {
@ -3795,7 +3804,7 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
NK_ARG_FLAG_ZERO = 0x20 NK_ARG_FLAG_ZERO = 0x20
}; };
char number_buffer[NK_MAX_NUMBER_BUFFER]; char number_buffer[NK_MAX_NUMBER_BUFFER];
enum nk_arg_type arg_type = NK_ARG_TYPE_INT; enum nk_arg_type arg_type = NK_ARG_TYPE_DEFAULT;
int precision = NK_DEFAULT; int precision = NK_DEFAULT;
int width = NK_DEFAULT; int width = NK_DEFAULT;
nk_flags flag = 0; nk_flags flag = 0;
@ -3807,7 +3816,6 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
NK_ASSERT(buf); NK_ASSERT(buf);
NK_ASSERT(buf_size); NK_ASSERT(buf_size);
if (!buf || !buf_size || !fmt) return 0; if (!buf || !buf_size || !fmt) return 0;
for (iter = fmt; *iter && len < buf_size; iter++) { for (iter = fmt; *iter && len < buf_size; iter++) {
/* copy all non-format characters */ /* copy all non-format characters */
while (*iter && (*iter != '%') && (len < buf_size)) while (*iter && (*iter != '%') && (len < buf_size))
@ -3865,11 +3873,11 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
} else if (*iter == 'l') { } else if (*iter == 'l') {
arg_type = NK_ARG_TYPE_LONG; arg_type = NK_ARG_TYPE_LONG;
iter++; iter++;
} else arg_type = NK_ARG_TYPE_INT; } else arg_type = NK_ARG_TYPE_DEFAULT;
/* specifier */ /* specifier */
if (*iter == '%') { if (*iter == '%') {
NK_ASSERT(arg_type == NK_ARG_TYPE_INT); NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT);
NK_ASSERT(precision == NK_DEFAULT); NK_ASSERT(precision == NK_DEFAULT);
NK_ASSERT(width == NK_DEFAULT); NK_ASSERT(width == NK_DEFAULT);
if (len < buf_size) if (len < buf_size)
@ -3878,7 +3886,7 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
/* string */ /* string */
const char *str = va_arg(args, const char*); const char *str = va_arg(args, const char*);
NK_ASSERT(str != buf && "buffer and argument are not allowed to overlap!"); NK_ASSERT(str != buf && "buffer and argument are not allowed to overlap!");
NK_ASSERT(arg_type == NK_ARG_TYPE_INT); NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT);
NK_ASSERT(precision == NK_DEFAULT); NK_ASSERT(precision == NK_DEFAULT);
NK_ASSERT(width == NK_DEFAULT); NK_ASSERT(width == NK_DEFAULT);
if (str == buf) return -1; if (str == buf) return -1;
@ -3887,7 +3895,7 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
} else if (*iter == 'n') { } else if (*iter == 'n') {
/* current length callback */ /* current length callback */
signed int *n = va_arg(args, int*); signed int *n = va_arg(args, int*);
NK_ASSERT(arg_type == NK_ARG_TYPE_INT); NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT);
NK_ASSERT(precision == NK_DEFAULT); NK_ASSERT(precision == NK_DEFAULT);
NK_ASSERT(width == NK_DEFAULT); NK_ASSERT(width == NK_DEFAULT);
if (n) *n = len; if (n) *n = len;
@ -3914,6 +3922,8 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
nk_itoa(number_buffer, value); nk_itoa(number_buffer, value);
num_len = nk_strlen(number_buffer); num_len = nk_strlen(number_buffer);
padding = NK_MAX(cur_width - NK_MAX(cur_precision, num_len), 0); padding = NK_MAX(cur_width - NK_MAX(cur_precision, num_len), 0);
if ((flag & NK_ARG_FLAG_PLUS) || (flag & NK_ARG_FLAG_SPACE))
padding = NK_MAX(padding-1, 0);
/* fill left padding up to a total of `width` characters */ /* fill left padding up to a total of `width` characters */
if (!(flag & NK_ARG_FLAG_LEFT)) { if (!(flag & NK_ARG_FLAG_LEFT)) {
@ -3924,6 +3934,12 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
} }
} }
/* copy string value representation into buffer */
if ((flag & NK_ARG_FLAG_PLUS) && value >= 0 && len < buf_size)
buf[len++] = '+';
else if ((flag & NK_ARG_FLAG_SPACE) && value >= 0 && len < buf_size)
buf[len++] = ' ';
/* fill up to precision number of digits with '0' */ /* fill up to precision number of digits with '0' */
num_print = NK_MAX(cur_precision, num_len); num_print = NK_MAX(cur_precision, num_len);
while (precision && (num_print > num_len) && (len < buf_size)) { while (precision && (num_print > num_len) && (len < buf_size)) {
@ -3933,10 +3949,6 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
/* copy string value representation into buffer */ /* copy string value representation into buffer */
num_iter = number_buffer; num_iter = number_buffer;
if ((flag & NK_ARG_FLAG_PLUS) && value >= 0 && len < buf_size)
buf[len++] = '+';
else if ((flag & NK_ARG_FLAG_SPACE) && value >= 0 && len < buf_size)
buf[len++] = ' ';
while (precision && *num_iter && len < buf_size) while (precision && *num_iter && len < buf_size)
buf[len++] = *num_iter++; buf[len++] = *num_iter++;
@ -3975,24 +3987,13 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
number_buffer[num_len++] = (char)digit; number_buffer[num_len++] = (char)digit;
value /= base; value /= base;
} while (value > 0); } while (value > 0);
num_print = NK_MAX(cur_precision, num_len); num_print = NK_MAX(cur_precision, num_len);
padding = NK_MAX(cur_width - NK_MAX(cur_precision, num_len), 0); padding = NK_MAX(cur_width - NK_MAX(cur_precision, num_len), 0);
if (flag & NK_ARG_FLAG_NUM)
padding = NK_MAX(padding-1, 0);
/* fill left padding up to a total of `width` characters */ /* fill left padding up to a total of `width` characters */
if (num_print && (flag & NK_ARG_FLAG_NUM)) {
if ((*iter == 'o') && (len < buf_size)) {
buf[len++] = '0';
padding--;
} else if ((*iter == 'x') && ((len+1) < buf_size)) {
buf[len++] = '0';
buf[len++] = 'x';
padding -= 2;
} else if ((*iter == 'X') && ((len+1) < buf_size)) {
buf[len++] = '0';
buf[len++] = 'X';
padding -= 2;
}
}
if (!(flag & NK_ARG_FLAG_LEFT)) { if (!(flag & NK_ARG_FLAG_LEFT)) {
while ((padding-- > 0) && (len < buf_size)) { while ((padding-- > 0) && (len < buf_size)) {
if ((flag & NK_ARG_FLAG_ZERO) && (precision == NK_DEFAULT)) if ((flag & NK_ARG_FLAG_ZERO) && (precision == NK_DEFAULT))
@ -4002,6 +4003,17 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
} }
/* fill up to precision number of digits */ /* fill up to precision number of digits */
if (num_print && (flag & NK_ARG_FLAG_NUM)) {
if ((*iter == 'o') && (len < buf_size)) {
buf[len++] = '0';
} else if ((*iter == 'x') && ((len+1) < buf_size)) {
buf[len++] = '0';
buf[len++] = 'x';
} else if ((*iter == 'X') && ((len+1) < buf_size)) {
buf[len++] = '0';
buf[len++] = 'X';
}
}
while (precision && (num_print > num_len) && (len < buf_size)) { while (precision && (num_print > num_len) && (len < buf_size)) {
buf[len++] = '0'; buf[len++] = '0';
num_print--; num_print--;
@ -4021,17 +4033,26 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
} }
} else if (*iter == 'f') { } else if (*iter == 'f') {
/* floating point */ /* floating point */
const char *num_iter;
int cur_precision = (precision < 0) ? 6: precision; int cur_precision = (precision < 0) ? 6: precision;
int cur_width = NK_MAX(width, 0); int prefix, cur_width = NK_MAX(width, 0);
double value = va_arg(args, double); double value = va_arg(args, double);
int num_len = 0, frac_len = 0, dot = 0; int num_len = 0, frac_len = 0, dot = 0;
int padding = 0; int padding = 0;
const char *num_iter;
NK_ASSERT(arg_type == NK_ARG_TYPE_INT);
NK_ASSERT(arg_type == NK_ARG_TYPE_DEFAULT);
NK_DTOA(number_buffer, value); NK_DTOA(number_buffer, value);
num_len = nk_strlen(number_buffer); num_len = nk_strlen(number_buffer);
padding = NK_MAX(cur_width - NK_MAX(cur_precision, num_len), 0);
/* calculate padding */
num_iter = number_buffer;
while (*num_iter && *num_iter != '.')
num_iter++;
prefix = (*num_iter == '.')?(int)(num_iter - number_buffer)+1:0;
padding = NK_MAX(cur_width - (prefix + NK_MIN(cur_precision, num_len - prefix)) , 0);
if ((flag & NK_ARG_FLAG_PLUS) || (flag & NK_ARG_FLAG_SPACE))
padding = NK_MAX(padding-1, 0);
/* fill left padding up to a total of `width` characters */ /* fill left padding up to a total of `width` characters */
if (!(flag & NK_ARG_FLAG_LEFT)) { if (!(flag & NK_ARG_FLAG_LEFT)) {
@ -4854,8 +4875,8 @@ nk_text_calculate_text_bounds(const struct nk_user_font *font,
*glyphs = *glyphs + 1; *glyphs = *glyphs + 1;
text_len += glyph_len; text_len += glyph_len;
line_width += (float)glyph_width; line_width += (float)glyph_width;
glyph_width = font->width(font->userdata, font->height, begin+text_len, glyph_len);
glyph_len = nk_utf_decode(begin + text_len, &unicode, byte_len-text_len); glyph_len = nk_utf_decode(begin + text_len, &unicode, byte_len-text_len);
glyph_width = font->width(font->userdata, font->height, begin+text_len, glyph_len);
continue; continue;
} }
@ -5464,16 +5485,24 @@ nk_str_insert_at_rune(struct nk_str *str, int pos, const char *cstr, int len)
NK_ASSERT(len); NK_ASSERT(len);
if (!str || !cstr || !len) return 0; if (!str || !cstr || !len) return 0;
begin = nk_str_at_rune(str, pos, &unicode, &glyph_len); begin = nk_str_at_rune(str, pos, &unicode, &glyph_len);
if (!str->len)
return nk_str_append_text_char(str, cstr, len);
buffer = nk_str_get_const(str); buffer = nk_str_get_const(str);
if (!begin) return 0; if (!begin) return 0;
return nk_str_insert_text_char(str, (int)(begin - buffer), cstr, len); return nk_str_insert_at_char(str, (int)(begin - buffer), cstr, len);
} }
NK_API int nk_str_insert_text_char(struct nk_str *str, int pos, const char *text, int len) NK_API int
{return nk_str_insert_at_char(str, pos, text, len);} nk_str_insert_text_char(struct nk_str *str, int pos, const char *text, int len)
{
return nk_str_insert_text_utf8(str, pos, text, len);
}
NK_API int nk_str_insert_str_char(struct nk_str *str, int pos, const char *text) NK_API int
{return nk_str_insert_at_char(str, pos, text, nk_strlen(text));} nk_str_insert_str_char(struct nk_str *str, int pos, const char *text)
{
return nk_str_insert_text_utf8(str, pos, text, nk_strlen(text));
}
NK_API int NK_API int
nk_str_insert_text_utf8(struct nk_str *str, int pos, const char *text, int len) nk_str_insert_text_utf8(struct nk_str *str, int pos, const char *text, int len)
@ -5657,7 +5686,7 @@ nk_str_at_rune(struct nk_str *str, int pos, nk_rune *unicode, int *len)
break; break;
} }
i+= glyph_len; i++;
src_len = src_len + glyph_len; src_len = src_len + glyph_len;
glyph_len = nk_utf_decode(text + src_len, unicode, text_len - src_len); glyph_len = nk_utf_decode(text + src_len, unicode, text_len - src_len);
} }
@ -5825,6 +5854,10 @@ nk_command_buffer_push(struct nk_command_buffer* b,
memory = NK_ALIGN_PTR(unaligned, align); memory = NK_ALIGN_PTR(unaligned, align);
alignment = (nk_size)((nk_byte*)memory - (nk_byte*)unaligned); alignment = (nk_size)((nk_byte*)memory - (nk_byte*)unaligned);
#ifdef NK_ZERO_COMMAND_MEMORY
NK_MEMSET(cmd, 0, size + alignment);
#endif
cmd->type = t; cmd->type = t;
cmd->next = b->base->allocated + alignment; cmd->next = b->base->allocated + alignment;
#ifdef NK_INCLUDE_COMMAND_USERDATA #ifdef NK_INCLUDE_COMMAND_USERDATA
@ -6400,6 +6433,9 @@ nk_draw_list_push_command(struct nk_draw_list *list, struct nk_rect clip,
cmd->elem_count = 0; cmd->elem_count = 0;
cmd->clip_rect = clip; cmd->clip_rect = clip;
cmd->texture = texture; cmd->texture = texture;
#ifdef NK_INCLUDE_COMMAND_USERDATA
cmd->userdata = list->userdata;
#endif
list->cmd_count++; list->cmd_count++;
list->clip_rect = clip; list->clip_rect = clip;
@ -6429,9 +6465,9 @@ nk_draw_list_add_clip(struct nk_draw_list *list, struct nk_rect rect)
nk_draw_list_push_command(list, rect, list->config.null.texture); nk_draw_list_push_command(list, rect, list->config.null.texture);
} else { } else {
struct nk_draw_command *prev = nk_draw_list_command_last(list); struct nk_draw_command *prev = nk_draw_list_command_last(list);
if (prev->elem_count == 0) if (prev->elem_count == 0) {
prev->clip_rect = rect; prev->clip_rect = rect;
nk_draw_list_push_command(list, rect, prev->texture); } else nk_draw_list_push_command(list, rect, prev->texture);
} }
} }
@ -6455,23 +6491,7 @@ nk_draw_list_push_image(struct nk_draw_list *list, nk_handle texture)
NK_API void NK_API void
nk_draw_list_push_userdata(struct nk_draw_list *list, nk_handle userdata) nk_draw_list_push_userdata(struct nk_draw_list *list, nk_handle userdata)
{ {
NK_ASSERT(list); list->userdata = userdata;
if (!list) return;
if (!list->cmd_count) {
struct nk_draw_command *prev;
nk_draw_list_push_command(list, nk_null_rect, list->config.null.texture);
prev = nk_draw_list_command_last(list);
prev->userdata = userdata;
} else {
struct nk_draw_command *prev = nk_draw_list_command_last(list);
if (prev->elem_count == 0) {
prev->userdata = userdata;
} else if (prev->userdata.ptr != userdata.ptr) {
nk_draw_list_push_command(list, prev->clip_rect, prev->texture);
prev = nk_draw_list_command_last(list);
prev->userdata = userdata;
}
}
} }
#endif #endif
@ -7371,18 +7391,18 @@ nk_draw_list_add_text(struct nk_draw_list *list, const struct nk_user_font *font
nk_draw_list_push_image(list, font->texture); nk_draw_list_push_image(list, font->texture);
x = rect.x; x = rect.x;
glyph_len = text_len = nk_utf_decode(text, &unicode, len); glyph_len = nk_utf_decode(text, &unicode, len);
if (!glyph_len) return; if (!glyph_len) return;
/* draw every glyph image */ /* draw every glyph image */
fg.a = (nk_byte)((float)fg.a * list->config.global_alpha); fg.a = (nk_byte)((float)fg.a * list->config.global_alpha);
while (text_len <= len && glyph_len) { while (text_len < len && glyph_len) {
float gx, gy, gh, gw; float gx, gy, gh, gw;
float char_width = 0; float char_width = 0;
if (unicode == NK_UTF_INVALID) break; if (unicode == NK_UTF_INVALID) break;
/* query currently drawn glyph information */ /* query currently drawn glyph information */
next_glyph_len = nk_utf_decode(text + text_len, &next, (int)len - text_len); next_glyph_len = nk_utf_decode(text + text_len + glyph_len, &next, (int)len - text_len);
font->query(font->userdata, font_height, &g, unicode, font->query(font->userdata, font_height, &g, unicode,
(next == NK_UTF_INVALID) ? '\0' : next); (next == NK_UTF_INVALID) ? '\0' : next);
@ -10222,7 +10242,7 @@ NK_GLOBAL const char nk_proggy_clean_ttf_compressed_data_base85[11980+1] =
"%(?A%R$f<->Zts'^kn=-^@c4%-pY6qI%J%1IGxfLU9CP8cbPlXv);C=b),<2mOvP8up,UVf3839acAWAW-W?#ao/^#%KYo8fRULNd2.>%m]UK:n%r$'sw]J;5pAoO_#2mO3n,'=H5(et" "%(?A%R$f<->Zts'^kn=-^@c4%-pY6qI%J%1IGxfLU9CP8cbPlXv);C=b),<2mOvP8up,UVf3839acAWAW-W?#ao/^#%KYo8fRULNd2.>%m]UK:n%r$'sw]J;5pAoO_#2mO3n,'=H5(et"
"Hg*`+RLgv>=4U8guD$I%D:W>-r5V*%j*W:Kvej.Lp$<M-SGZ':+Q_k+uvOSLiEo(<aD/K<CCc`'Lx>'?;++O'>()jLR-^u68PHm8ZFWe+ej8h:9r6L*0//c&iH&R8pRbA#Kjm%upV1g:" "Hg*`+RLgv>=4U8guD$I%D:W>-r5V*%j*W:Kvej.Lp$<M-SGZ':+Q_k+uvOSLiEo(<aD/K<CCc`'Lx>'?;++O'>()jLR-^u68PHm8ZFWe+ej8h:9r6L*0//c&iH&R8pRbA#Kjm%upV1g:"
"a_#Ur7FuA#(tRh#.Y5K+@?3<-8m0$PEn;J:rh6?I6uG<-`wMU'ircp0LaE_OtlMb&1#6T.#FDKu#1Lw%u%+GM+X'e?YLfjM[VO0MbuFp7;>Q&#WIo)0@F%q7c#4XAXN-U&VB<HFF*qL(" "a_#Ur7FuA#(tRh#.Y5K+@?3<-8m0$PEn;J:rh6?I6uG<-`wMU'ircp0LaE_OtlMb&1#6T.#FDKu#1Lw%u%+GM+X'e?YLfjM[VO0MbuFp7;>Q&#WIo)0@F%q7c#4XAXN-U&VB<HFF*qL("
"$/V,;(kXZejWO`<[5??ewY(*9=%wDc;,u<'9t3W-(H1th3+G]ucQ]kLs7df($/*JL]@*t7Bu_G3_7mp7<iaQjO@.kLg;x3B0lqp7Hf,^Ze7-##@/c58Mo(3;knp0%)A7?-W+eI'o8)b<" "$/V,;(kXZejWO`<[5?\?ewY(*9=%wDc;,u<'9t3W-(H1th3+G]ucQ]kLs7df($/*JL]@*t7Bu_G3_7mp7<iaQjO@.kLg;x3B0lqp7Hf,^Ze7-##@/c58Mo(3;knp0%)A7?-W+eI'o8)b<"
"nKnw'Ho8C=Y>pqB>0ie&jhZ[?iLR@@_AvA-iQC(=ksRZRVp7`.=+NpBC%rh&3]R:8XDmE5^V8O(x<<aG/1N$#FX$0V5Y6x'aErI3I$7x%E`v<-BY,)%-?Psf*l?%C3.mM(=/M0:JxG'?" "nKnw'Ho8C=Y>pqB>0ie&jhZ[?iLR@@_AvA-iQC(=ksRZRVp7`.=+NpBC%rh&3]R:8XDmE5^V8O(x<<aG/1N$#FX$0V5Y6x'aErI3I$7x%E`v<-BY,)%-?Psf*l?%C3.mM(=/M0:JxG'?"
"7WhH%o'a<-80g0NBxoO(GH<dM]n.+%q@jH?f.UsJ2Ggs&4<-e47&Kl+f//9@`b+?.TeN_&B8Ss?v;^Trk;f#YvJkl&w$]>-+k?'(<S:68tq*WoDfZu';mM?8X[ma8W%*`-=;D.(nc7/;" "7WhH%o'a<-80g0NBxoO(GH<dM]n.+%q@jH?f.UsJ2Ggs&4<-e47&Kl+f//9@`b+?.TeN_&B8Ss?v;^Trk;f#YvJkl&w$]>-+k?'(<S:68tq*WoDfZu';mM?8X[ma8W%*`-=;D.(nc7/;"
")g:T1=^J$&BRV(-lTmNB6xqB[@0*o.erM*<SWF]u2=st-*(6v>^](H.aREZSi,#1:[IXaZFOm<-ui#qUq2$##Ri;u75OK#(RtaW-K-F`S+cF]uN`-KMQ%rP/Xri.LRcB##=YL3BgM/3M" ")g:T1=^J$&BRV(-lTmNB6xqB[@0*o.erM*<SWF]u2=st-*(6v>^](H.aREZSi,#1:[IXaZFOm<-ui#qUq2$##Ri;u75OK#(RtaW-K-F`S+cF]uN`-KMQ%rP/Xri.LRcB##=YL3BgM/3M"
@ -10285,8 +10305,7 @@ NK_GLOBAL const char nk_proggy_clean_ttf_compressed_data_base85[11980+1] =
#define NK_CURSOR_DATA_W 90 #define NK_CURSOR_DATA_W 90
#define NK_CURSOR_DATA_H 27 #define NK_CURSOR_DATA_H 27
NK_GLOBAL const char NK_GLOBAL const char nk_custom_cursor_data[NK_CURSOR_DATA_W * NK_CURSOR_DATA_H + 1] =
nk_custom_cursor_data[NK_CURSOR_DATA_W * NK_CURSOR_DATA_H + 1] =
{ {
"..- -XXXXXXX- X - X -XXXXXXX - XXXXXXX" "..- -XXXXXXX- X - X -XXXXXXX - XXXXXXX"
"..- -X.....X- X.X - X.X -X.....X - X.....X" "..- -X.....X- X.X - X.X -X.....X - X.....X"
@ -11634,16 +11653,16 @@ nk_textedit_text(struct nk_text_edit *state, const char *text, int total_len)
nk_textedit_makeundo_replace(state, state->cursor, 1, 1); nk_textedit_makeundo_replace(state, state->cursor, 1, 1);
nk_str_delete_runes(&state->string, state->cursor, 1); nk_str_delete_runes(&state->string, state->cursor, 1);
} }
if (nk_str_insert_text_char(&state->string, state->cursor, if (nk_str_insert_text_utf8(&state->string, state->cursor,
text+text_len, glyph_len)) text+text_len, 1))
{ {
++state->cursor; ++state->cursor;
state->has_preferred_x = 0; state->has_preferred_x = 0;
} }
} else { } else {
nk_textedit_delete_selection(state); /* implicitly clamps */ nk_textedit_delete_selection(state); /* implicitly clamps */
if (nk_str_insert_text_char(&state->string, state->cursor, if (nk_str_insert_text_utf8(&state->string, state->cursor,
text+text_len, glyph_len)) text+text_len, 1))
{ {
nk_textedit_makeundo_insert(state, state->cursor, 1); nk_textedit_makeundo_insert(state, state->cursor, 1);
++state->cursor; ++state->cursor;
@ -12237,6 +12256,7 @@ nk_textedit_clear_state(struct nk_text_edit *state, enum nk_text_edit_type type,
state->single_line = (unsigned char)(type == NK_TEXT_EDIT_SINGLE_LINE); state->single_line = (unsigned char)(type == NK_TEXT_EDIT_SINGLE_LINE);
state->mode = NK_TEXT_EDIT_MODE_VIEW; state->mode = NK_TEXT_EDIT_MODE_VIEW;
state->filter = filter; state->filter = filter;
state->scrollbar = nk_vec2(0,0);
} }
NK_API void NK_API void
@ -13279,7 +13299,7 @@ nk_do_slider(nk_flags *state,
bounds.w -= style->cursor_size.x; bounds.w -= style->cursor_size.x;
/* calculate cursor /* calculate cursor
Basically you have to cursors. One for visual representation and interaction Basically you have two cursors. One for visual representation and interaction
and one for updating the actual cursor value. */ and one for updating the actual cursor value. */
logical_cursor.h = bounds.h; logical_cursor.h = bounds.h;
logical_cursor.w = bounds.w / slider_steps; logical_cursor.w = bounds.w / slider_steps;
@ -13915,9 +13935,7 @@ nk_do_edit(nk_flags *state, struct nk_command_buffer *out,
{ {
int shift_mod = in->keyboard.keys[NK_KEY_SHIFT].down; int shift_mod = in->keyboard.keys[NK_KEY_SHIFT].down;
const float mouse_x = (in->mouse.pos.x - area.x) + edit->scrollbar.x; const float mouse_x = (in->mouse.pos.x - area.x) + edit->scrollbar.x;
const float mouse_y = (!(flags & NK_EDIT_MULTILINE)) ? const float mouse_y = (in->mouse.pos.y - area.y) + edit->scrollbar.y;
(in->mouse.pos.y - (area.y + area.h * 0.5f)) + edit->scrollbar.y:
(in->mouse.pos.y - area.y) + edit->scrollbar.y;
/* mouse click handler */ /* mouse click handler */
is_hovered = (char)nk_input_is_mouse_hovering_rect(in, area); is_hovered = (char)nk_input_is_mouse_hovering_rect(in, area);
@ -14137,14 +14155,14 @@ nk_do_edit(nk_flags *state, struct nk_command_buffer *out,
text_len += glyph_len; text_len += glyph_len;
line_width += (float)glyph_width; line_width += (float)glyph_width;
glyph_len = nk_utf_decode(text + text_len, &unicode, len-text_len);
glyph_width = font->width(font->userdata, font->height, glyph_width = font->width(font->userdata, font->height,
text+text_len, glyph_len); text+text_len, glyph_len);
glyph_len = nk_utf_decode(text + text_len, &unicode, len-text_len);
continue; continue;
} }
text_size.y = (float)total_lines * row_height; text_size.y = (float)total_lines * row_height;
/* handle case if cursor is at end of text buffer */ /* handle case when cursor is at end of text buffer */
if (!cursor_ptr && edit->cursor == edit->string.len) { if (!cursor_ptr && edit->cursor == edit->string.len) {
cursor_pos.x = line_width; cursor_pos.x = line_width;
cursor_pos.y = text_size.y - row_height; cursor_pos.y = text_size.y - row_height;
@ -14312,7 +14330,7 @@ nk_do_edit(nk_flags *state, struct nk_command_buffer *out,
label.h = row_height; label.h = row_height;
txt.padding = nk_vec2(0,0); txt.padding = nk_vec2(0,0);
txt.background = cursor_color; txt.background = cursor_color;;
txt.text = cursor_text_color; txt.text = cursor_text_color;
nk_fill_rect(out, label, 0, cursor_color); nk_fill_rect(out, label, 0, cursor_color);
nk_widget_text(out, label, cursor_ptr, glyph_len, &txt, NK_TEXT_LEFT, font); nk_widget_text(out, label, cursor_ptr, glyph_len, &txt, NK_TEXT_LEFT, font);
@ -14320,7 +14338,7 @@ nk_do_edit(nk_flags *state, struct nk_command_buffer *out,
}} }}
} else { } else {
/* not active so just draw text */ /* not active so just draw text */
int l = nk_str_len(&edit->string); int l = nk_str_len_char(&edit->string);
const char *begin = nk_str_get_const(&edit->string); const char *begin = nk_str_get_const(&edit->string);
const struct nk_style_item *background; const struct nk_style_item *background;
@ -15583,8 +15601,8 @@ nk_pool_init(struct nk_pool *pool, struct nk_allocator *alloc,
nk_zero(pool, sizeof(*pool)); nk_zero(pool, sizeof(*pool));
pool->alloc = *alloc; pool->alloc = *alloc;
pool->capacity = capacity; pool->capacity = capacity;
pool->pages = 0;
pool->type = NK_BUFFER_DYNAMIC; pool->type = NK_BUFFER_DYNAMIC;
pool->pages = 0;
} }
NK_INTERN void NK_INTERN void
@ -15658,7 +15676,6 @@ nk_setup(struct nk_context *ctx, const struct nk_user_font *font)
nk_style_default(ctx); nk_style_default(ctx);
ctx->seq = 1; ctx->seq = 1;
if (font) ctx->style.font = font; if (font) ctx->style.font = font;
#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT #ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
nk_draw_list_init(&ctx->draw_list); nk_draw_list_init(&ctx->draw_list);
#endif #endif
@ -15910,6 +15927,7 @@ nk_finish(struct nk_context *ctx, struct nk_window *win)
if (!win->layout->popup_buffer.active) return; if (!win->layout->popup_buffer.active) return;
/* from here on is for popup window buffer handling */ /* from here on is for popup window buffer handling */
/*--------------------------------------------------*/
buf = &win->layout->popup_buffer; buf = &win->layout->popup_buffer;
memory = ctx->memory.memory.ptr; memory = ctx->memory.memory.ptr;
@ -16504,8 +16522,8 @@ nk_panel_end(struct nk_context *ctx)
padding_y, layout->border, border_color); padding_y, layout->border, border_color);
/* draw right border */ /* draw right border */
nk_stroke_line(out, window->bounds.x + window->bounds.w, nk_stroke_line(out, window->bounds.x + window->bounds.w - layout->border*0.5f,
window->bounds.y, window->bounds.x + window->bounds.w, window->bounds.y, window->bounds.x + window->bounds.w - layout->border*0.5f,
padding_y, layout->border, border_color); padding_y, layout->border, border_color);
} }
@ -16892,9 +16910,11 @@ nk_begin_titled(struct nk_context *ctx, struct nk_panel *layout,
int ret = 0; int ret = 0;
NK_ASSERT(ctx); NK_ASSERT(ctx);
NK_ASSERT(name);
NK_ASSERT(title);
NK_ASSERT(ctx->style.font && ctx->style.font->width && "if this triggers you forgot to add a font"); NK_ASSERT(ctx->style.font && ctx->style.font->width && "if this triggers you forgot to add a font");
NK_ASSERT(!ctx->current && "if this triggers you missed a `nk_end` call"); NK_ASSERT(!ctx->current && "if this triggers you missed a `nk_end` call");
if (!ctx || ctx->current || !title) if (!ctx || ctx->current || !title || !name)
return 0; return 0;
/* find or create window */ /* find or create window */
@ -18679,6 +18699,7 @@ nk_button_color(struct nk_context *ctx, struct nk_color color)
int ret = 0; int ret = 0;
struct nk_rect bounds; struct nk_rect bounds;
struct nk_rect content;
enum nk_widget_layout_states state; enum nk_widget_layout_states state;
NK_ASSERT(ctx); NK_ASSERT(ctx);
@ -18698,9 +18719,8 @@ nk_button_color(struct nk_context *ctx, struct nk_color color)
button.normal = nk_style_item_color(color); button.normal = nk_style_item_color(color);
button.hover = nk_style_item_color(color); button.hover = nk_style_item_color(color);
button.active = nk_style_item_color(color); button.active = nk_style_item_color(color);
button.padding = nk_vec2(0,0);
ret = nk_do_button(&ctx->last_widget_state, &win->buffer, bounds, ret = nk_do_button(&ctx->last_widget_state, &win->buffer, bounds,
&button, in, ctx->button_behavior, &bounds); &button, in, ctx->button_behavior, &content);
nk_draw_button(&win->buffer, &bounds, ctx->last_widget_state, &button); nk_draw_button(&win->buffer, &bounds, ctx->last_widget_state, &button);
return ret; return ret;
} }
@ -18856,6 +18876,7 @@ nk_selectable_text(struct nk_context *ctx, const char *str, int len,
win = ctx->current; win = ctx->current;
layout = win->layout; layout = win->layout;
style = &ctx->style; style = &ctx->style;
state = nk_widget(&bounds, ctx); state = nk_widget(&bounds, ctx);
if (!state) return 0; if (!state) return 0;
in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
@ -18885,6 +18906,7 @@ nk_selectable_image_text(struct nk_context *ctx, struct nk_image img,
win = ctx->current; win = ctx->current;
layout = win->layout; layout = win->layout;
style = &ctx->style; style = &ctx->style;
state = nk_widget(&bounds, ctx); state = nk_widget(&bounds, ctx);
if (!state) return 0; if (!state) return 0;
in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
@ -18939,6 +18961,7 @@ nk_check_text(struct nk_context *ctx, const char *text, int len, int active)
win = ctx->current; win = ctx->current;
style = &ctx->style; style = &ctx->style;
layout = win->layout; layout = win->layout;
state = nk_widget(&bounds, ctx); state = nk_widget(&bounds, ctx);
if (!state) return active; if (!state) return active;
in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
@ -19032,6 +19055,7 @@ nk_option_text(struct nk_context *ctx, const char *text, int len, int is_active)
win = ctx->current; win = ctx->current;
style = &ctx->style; style = &ctx->style;
layout = win->layout; layout = win->layout;
state = nk_widget(&bounds, ctx); state = nk_widget(&bounds, ctx);
if (!state) return state; if (!state) return state;
in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
@ -19090,6 +19114,7 @@ nk_slider_float(struct nk_context *ctx, float min_value, float *value, float max
win = ctx->current; win = ctx->current;
style = &ctx->style; style = &ctx->style;
layout = win->layout; layout = win->layout;
state = nk_widget(&bounds, ctx); state = nk_widget(&bounds, ctx);
if (!state) return ret; if (!state) return ret;
in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input; in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
@ -19897,6 +19922,19 @@ nk_group_begin(struct nk_context *ctx, struct nk_panel *layout, const char *titl
c = &win->layout->clip; c = &win->layout->clip;
nk_panel_alloc_space(&bounds, ctx); nk_panel_alloc_space(&bounds, ctx);
nk_zero(layout, sizeof(*layout)); nk_zero(layout, sizeof(*layout));
NK_ASSERT(win->layout != layout && "Parent and group are not allowed to use the same panel");
/* This assert triggers either if you pass the same panel to a parent parent and child group
* or forgot to add a `nk_group_end` to a `nk_group_begin`.
* Correct example:
* struct nk_panel panel;
* if (nk_begin(...,&panel,...)) {
* struct nk_panel tab;
* if (nk_group_begin(...,&tab,...)) {
* ....
* nk_group_end(...);
* }
* }
*/
/* find persistent group scrollbar value */ /* find persistent group scrollbar value */
title_len = (int)nk_strlen(title); title_len = (int)nk_strlen(title);

1
tests/joysticks.c
View File

@ -43,6 +43,7 @@
#define NK_GLFW_GL2_IMPLEMENTATION #define NK_GLFW_GL2_IMPLEMENTATION
#include <nuklear_glfw_gl2.h> #include <nuklear_glfw_gl2.h>
#include <stdio.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>