anulax
/
glfw
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Update Nuklear to 1.156

Browse Source
master
Camilla Berglund ago%!(EXTRA string=9 years)
parent ea1958a948
commit 2af40c3fe6
2 changed files with 175 additions and 136 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 310
      deps/nuklear.h
  2. 1
      tests/joysticks.c

310
deps/nuklear.h vendored
Unescape View File

@ -1,5 +1,5 @@
/*
Nuklear - v1.15 - public domain
Nuklear - v1.156 - public domain
no warrenty implied; use at your own risk.
authored from 2015-2016 by Micha Mettke
@ -94,10 +94,10 @@ OPTIONAL DEFINES:
<!> If used needs to be defined for implementation and header <!>
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
<!> Adds the standard library with va_list and vsprintf/vsnprintf
so don't define this if you don't want to link to the standard library<!>
<!> Adds the standard library with va_list and so don't define this if
you don't want to link to the standard library<!>
<!> If used needs to be defined for implementation and header <!>
NK_INCLUDE_VERTEX_BUFFER_OUTPUT
@ -214,6 +214,13 @@ OPTIONAL DEFINES:
will be selected and compile time validated. If they are incorrect you can
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:
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_POINTER_TYPE uintptr_t
#else
#ifndef NK_INT8
#define NK_INT8 char
#endif
#ifndef NK_UINT8
#define NK_BYTE unsigned char
#endif
#ifndef NK_INT16
#define NK_INT16 signed char
#endif
#ifndef NK_UINT16
#define NK_UINT16 unsigned short
#endif
#ifndef NK_INT32
#define NK_INT32 signed int
#endif
#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
#ifndef NK_INT8
#define NK_INT8 char
#endif
#ifndef NK_UINT8
#define NK_UINT8 unsigned char
#endif
#ifndef NK_INT16
#define NK_INT16 signed short
#endif
#ifndef NK_UINT16
#define NK_UINT16 unsigned short
#endif
#ifndef NK_INT32
#if defined(_MSC_VER)
#define NK_INT32 __int32
#else
#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
#define NK_POINTER_TYPE unsigned long
#endif
#endif
#endif
@ -2833,7 +2848,6 @@ template<typename T> struct nk_alignof{struct Big {T x; char c;}; enum {
#endif
#ifdef NK_INCLUDE_STANDARD_VARARGS
#include <stdarg.h> /* valist, va_start, va_end, ... */
#include <stdio.h> /* vsnprintf */
#endif
#ifndef NK_ASSERT
#include <assert.h>
@ -3509,8 +3523,7 @@ nk_strmatch_fuzzy_text(const char *str, int str_len,
{
int new_score = 0;
/* 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 penalty = NK_LEADING_LETTER_PENALTY * count;
if (penalty < NK_MAX_LEADING_LETTER_PENALTY)
@ -3536,8 +3549,7 @@ nk_strmatch_fuzzy_text(const char *str, int str_len,
++pattern_iter;
/* 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 */
if (best_letter != 0)
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_score = new_score;
}
prev_matched = nk_true;
}
else
{
} else {
score += NK_UNMATCHED_LETTER_PENALTY;
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 {
NK_ARG_TYPE_CHAR,
NK_ARG_TYPE_SHORT,
NK_ARG_TYPE_INT,
NK_ARG_TYPE_DEFAULT,
NK_ARG_TYPE_LONG
};
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
};
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 width = NK_DEFAULT;
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_size);
if (!buf || !buf_size || !fmt) return 0;
for (iter = fmt; *iter && len < buf_size; iter++) {
/* copy all non-format characters */
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') {
arg_type = NK_ARG_TYPE_LONG;
iter++;
} else arg_type = NK_ARG_TYPE_INT;
} else arg_type = NK_ARG_TYPE_DEFAULT;
/* specifier */
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(width == NK_DEFAULT);
if (len < buf_size)
@ -3878,7 +3886,7 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
/* string */
const char *str = va_arg(args, const char*);
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(width == NK_DEFAULT);
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') {
/* current length callback */
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(width == NK_DEFAULT);
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);
num_len = nk_strlen(number_buffer);
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 */
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' */
num_print = NK_MAX(cur_precision, num_len);
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 */
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)
buf[len++] = *num_iter++;
@ -3975,33 +3987,33 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
number_buffer[num_len++] = (char)digit;
value /= base;
} while (value > 0);
num_print = NK_MAX(cur_precision, num_len);
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 */
if (!(flag & NK_ARG_FLAG_LEFT)) {
while ((padding-- > 0) && (len < buf_size)) {
if ((flag & NK_ARG_FLAG_ZERO) && (precision == NK_DEFAULT))
buf[len++] = '0';
else buf[len++] = ' ';
}
}
/* fill up to precision number of digits */
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)) {
while ((padding-- > 0) && (len < buf_size)) {
if ((flag & NK_ARG_FLAG_ZERO) && (precision == NK_DEFAULT))
buf[len++] = '0';
else buf[len++] = ' ';
}
}
/* fill up to precision number of digits */
while (precision && (num_print > num_len) && (len < buf_size)) {
buf[len++] = '0';
num_print--;
@ -4021,17 +4033,26 @@ nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
}
} else if (*iter == 'f') {
/* floating point */
const char *num_iter;
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);
int num_len = 0, frac_len = 0, dot = 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);
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 */
if (!(flag & NK_ARG_FLAG_LEFT)) {
@ -4854,8 +4875,8 @@ nk_text_calculate_text_bounds(const struct nk_user_font *font,
*glyphs = *glyphs + 1;
text_len += glyph_len;
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_width = font->width(font->userdata, font->height, begin+text_len, glyph_len);
continue;
}
@ -5464,16 +5485,24 @@ nk_str_insert_at_rune(struct nk_str *str, int pos, const char *cstr, int len)
NK_ASSERT(len);
if (!str || !cstr || !len) return 0;
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);
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)
{return nk_str_insert_at_char(str, pos, text, len);}
NK_API int
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)
{return nk_str_insert_at_char(str, pos, text, nk_strlen(text));}
NK_API int
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_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;
}
i+= glyph_len;
i++;
src_len = src_len + glyph_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);
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->next = b->base->allocated + alignment;
#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->clip_rect = clip;
cmd->texture = texture;
#ifdef NK_INCLUDE_COMMAND_USERDATA
cmd->userdata = list->userdata;
#endif
list->cmd_count++;
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);
} else {
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;
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_draw_list_push_userdata(struct nk_draw_list *list, nk_handle userdata)
{
NK_ASSERT(list);
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;
}
}
list->userdata = userdata;
}
#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);
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;
/* draw every glyph image */
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 char_width = 0;
if (unicode == NK_UTF_INVALID) break;
/* 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,
(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"
"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("
"$/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'?"
"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"
@ -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_H 27
NK_GLOBAL const char
nk_custom_cursor_data[NK_CURSOR_DATA_W * NK_CURSOR_DATA_H + 1] =
NK_GLOBAL const char nk_custom_cursor_data[NK_CURSOR_DATA_W * NK_CURSOR_DATA_H + 1] =
{
"..- -XXXXXXX- X - X -XXXXXXX - XXXXXXX"
"..- -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_str_delete_runes(&state->string, state->cursor, 1);
}
if (nk_str_insert_text_char(&state->string, state->cursor,
text+text_len, glyph_len))
if (nk_str_insert_text_utf8(&state->string, state->cursor,
text+text_len, 1))
{
++state->cursor;
state->has_preferred_x = 0;
}
} else {
nk_textedit_delete_selection(state); /* implicitly clamps */
if (nk_str_insert_text_char(&state->string, state->cursor,
text+text_len, glyph_len))
if (nk_str_insert_text_utf8(&state->string, state->cursor,
text+text_len, 1))
{
nk_textedit_makeundo_insert(state, state->cursor, 1);
++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->mode = NK_TEXT_EDIT_MODE_VIEW;
state->filter = filter;
state->scrollbar = nk_vec2(0,0);
}
NK_API void
@ -13279,7 +13299,7 @@ nk_do_slider(nk_flags *state,
bounds.w -= style->cursor_size.x;
/* 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. */
logical_cursor.h = bounds.h;
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;
const float mouse_x = (in->mouse.pos.x - area.x) + edit->scrollbar.x;
const float mouse_y = (!(flags & NK_EDIT_MULTILINE)) ?
(in->mouse.pos.y - (area.y + area.h * 0.5f)) + edit->scrollbar.y:
(in->mouse.pos.y - area.y) + edit->scrollbar.y;
const float mouse_y = (in->mouse.pos.y - area.y) + edit->scrollbar.y;
/* mouse click handler */
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;
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,
text+text_len, glyph_len);
glyph_len = nk_utf_decode(text + text_len, &unicode, len-text_len);
continue;
}
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) {
cursor_pos.x = line_width;
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;
txt.padding = nk_vec2(0,0);
txt.background = cursor_color;
txt.background = cursor_color;;
txt.text = cursor_text_color;
nk_fill_rect(out, label, 0, cursor_color);
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 {
/* 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 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));
pool->alloc = *alloc;
pool->capacity = capacity;
pool->pages = 0;
pool->type = NK_BUFFER_DYNAMIC;
pool->pages = 0;
}
NK_INTERN void
@ -15658,7 +15676,6 @@ nk_setup(struct nk_context *ctx, const struct nk_user_font *font)
nk_style_default(ctx);
ctx->seq = 1;
if (font) ctx->style.font = font;
#ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
nk_draw_list_init(&ctx->draw_list);
#endif
@ -15910,6 +15927,7 @@ nk_finish(struct nk_context *ctx, struct nk_window *win)
if (!win->layout->popup_buffer.active) return;
/* from here on is for popup window buffer handling */
/*--------------------------------------------------*/
buf = &win->layout->popup_buffer;
memory = ctx->memory.memory.ptr;
@ -16504,8 +16522,8 @@ nk_panel_end(struct nk_context *ctx)
padding_y, layout->border, border_color);
/* draw right border */
nk_stroke_line(out, window->bounds.x + window->bounds.w,
window->bounds.y, 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 - layout->border*0.5f,
padding_y, layout->border, border_color);
}
@ -16892,9 +16910,11 @@ nk_begin_titled(struct nk_context *ctx, struct nk_panel *layout,
int ret = 0;
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->current && "if this triggers you missed a `nk_end` call");
if (!ctx || ctx->current || !title)
if (!ctx || ctx->current || !title || !name)
return 0;
/* find or create window */
@ -18679,6 +18699,7 @@ nk_button_color(struct nk_context *ctx, struct nk_color color)
int ret = 0;
struct nk_rect bounds;
struct nk_rect content;
enum nk_widget_layout_states state;
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.hover = 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,
&button, in, ctx->button_behavior, &bounds);
&button, in, ctx->button_behavior, &content);
nk_draw_button(&win->buffer, &bounds, ctx->last_widget_state, &button);
return ret;
}
@ -18856,6 +18876,7 @@ nk_selectable_text(struct nk_context *ctx, const char *str, int len,
win = ctx->current;
layout = win->layout;
style = &ctx->style;
state = nk_widget(&bounds, ctx);
if (!state) return 0;
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;
layout = win->layout;
style = &ctx->style;
state = nk_widget(&bounds, ctx);
if (!state) return 0;
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;
style = &ctx->style;
layout = win->layout;
state = nk_widget(&bounds, ctx);
if (!state) return active;
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;
style = &ctx->style;
layout = win->layout;
state = nk_widget(&bounds, ctx);
if (!state) return state;
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;
style = &ctx->style;
layout = win->layout;
state = nk_widget(&bounds, ctx);
if (!state) return ret;
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;
nk_panel_alloc_space(&bounds, ctx);
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 */
title_len = (int)nk_strlen(title);

1
tests/joysticks.c
Unescape View File

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

Write Preview
Loading…
Cancel
Save