diff --git a/Readme.md b/Readme.md index 2abbd9cfd..a65d2bc5c 100644 --- a/Readme.md +++ b/Readme.md @@ -59,37 +59,55 @@ This is very important; not doing it either leads to compiler errors, or even wo struct nk_context ctx; nk_init_fixed(&ctx, calloc(1, MAX_MEMORY), MAX_MEMORY, &font); -enum {EASY, HARD}; -static int op = EASY; +enum { EASY, NORMAL, HARD }; +static int op = EASY, active[3]{ 1, 0, 1 }, selected{}; static float value = 0.6f; static int i = 20; - -if (nk_begin(&ctx, "Show", nk_rect(50, 50, 220, 220), - NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_CLOSABLE)) { - /* fixed widget pixel width */ - nk_layout_row_static(&ctx, 30, 80, 1); - if (nk_button_label(&ctx, "button")) { - /* event handling */ - } - - /* fixed widget window ratio width */ - nk_layout_row_dynamic(&ctx, 30, 2); - if (nk_option_label(&ctx, "easy", op == EASY)) op = EASY; - if (nk_option_label(&ctx, "hard", op == HARD)) op = HARD; - - /* custom widget pixel width */ - nk_layout_row_begin(&ctx, NK_STATIC, 30, 2); - { - nk_layout_row_push(&ctx, 50); - nk_label(&ctx, "Volume:", NK_TEXT_LEFT); - nk_layout_row_push(&ctx, 110); - nk_slider_float(&ctx, 0, &value, 1.0f, 0.1f); - } - nk_layout_row_end(&ctx); +static size_t test{}; + +static char const * biomes[] = { + "Large biome", + "Small biome" +}; + +static int biomeCount = int(sizeof(biomes) / sizeof(biomes[0])); + +if (nk_begin(&ctx, "Show", nk_rect(50, 50, 300, 350), + NK_WINDOW_BORDER|NK_WINDOW_SCALABLE|NK_WINDOW_MOVABLE|NK_WINDOW_TITLE)) { + + // fixed widget pixel width + nk_layout_row_static(&ctx, 30, 150, 1); + if (nk_button_label(&ctx, "Play")) + myPlayFunction(); + + // fixed widget window ratio width + nk_layout_row_dynamic(&ctx, 30, 2); + if (nk_option_label(&ctx, "Easy", op == EASY)) op = EASY; + if (nk_option_label(&ctx, "Normal", op == NORMAL)) op = NORMAL; + if (nk_option_label(&ctx, "Hard", op == HARD)) op = HARD; + + nk_layout_row_dynamic(ctx, 30, 2); + nk_checkbox_label(&ctx, "Silver", active); + nk_checkbox_label(&ctx, "Bronze", active + 1); + nk_checkbox_label(&ctx, "Gold", active + 2); + + nk_layout_row_dynamic(&ctx, 30, 2); + nk_combobox(&ctx, names, biome_count, &selected, 30, nk_vec2(150, 200)); + + // custom widget pixel width + nk_layout_row_begin(&ctx, NK_STATIC, 30, 2); + { + nk_layout_row_push(&ctx, 50); + nk_label(&ctx, "Volume:", NK_TEXT_LEFT); + nk_layout_row_push(&ctx, 110); + nk_slider_float(&ctx, 0, &value, 1.0f, 0.1f); + nk_progress(&ctx, &test, 100, 1); + } + nk_layout_row_end(&ctx); } nk_end(&ctx); ``` -![example](https://cloud.githubusercontent.com/assets/8057201/10187981/584ecd68-675c-11e5-897c-822ef534a876.png) +![example](img/test%20window.png) ## Bindings There are a number of nuklear bindings for different languges created by other authors. diff --git a/img/test window.png b/img/test window.png new file mode 100644 index 000000000..d6b6b2062 Binary files /dev/null and b/img/test window.png differ diff --git a/nuklear.h b/nuklear.h index 94939bdbe..d6a8576ea 100644 --- a/nuklear.h +++ b/nuklear.h @@ -422,6 +422,11 @@ NK_STATIC_ASSERT(sizeof(nk_rune) >= 4); NK_STATIC_ASSERT(sizeof(nk_size) >= sizeof(void*)); NK_STATIC_ASSERT(sizeof(nk_ptr) >= sizeof(void*)); +/* Sub-pixel API can be enabled by defining following macro. + * This will allow drawing in subpixel precision, + * but will increase memory footprint. */ +/* #define NK_ENABLE_SUBPIXEL_API */ + /* ============================================================================ * * API @@ -466,6 +471,16 @@ struct nk_image {nk_handle handle;unsigned short w,h;unsigned short region[4];}; struct nk_cursor {struct nk_image img; struct nk_vec2 size, offset;}; struct nk_scroll {nk_uint x, y;}; +#ifdef NK_ENABLE_SUBPIXEL_API +typedef float nk_scalar_cmd; +typedef float nk_unsigned_scalar_cmd; +typedef struct nk_vec2 nk_vec2_cmd; +#else +typedef short nk_scalar_cmd; +typedef unsigned short nk_unsigned_scalar_cmd; +typedef struct nk_vec2i nk_vec2_cmd; +#endif + enum nk_heading {NK_UP, NK_RIGHT, NK_DOWN, NK_LEFT}; enum nk_button_behavior {NK_BUTTON_DEFAULT, NK_BUTTON_REPEATER}; enum nk_modify {NK_FIXED = nk_false, NK_MODIFIABLE = nk_true}; @@ -1475,10 +1490,10 @@ enum nk_panel_flags { /// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame /// __flags__ | Window flags defined in the nk_panel_flags section with a number of different window behaviors /// -/// Returns `true(1)` if the window can be filled up with widgets from this point -/// until `nk_end` or `false(0)` otherwise for example if minimized +/// Returns a non-zero window pointer if the window can be filled up with widgets from this point +/// until `nk_end` or `nullptr(0)` otherwise for example if minimized */ -NK_API int nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bounds, nk_flags flags); +NK_API struct nk_window* nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bounds, nk_flags flags); /*/// #### nk_begin_titled /// Extended window start with separated title and identifier to allow multiple /// windows with same title but not name @@ -1495,10 +1510,53 @@ NK_API int nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bo /// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame /// __flags__ | Window flags defined in the nk_panel_flags section with a number of different window behaviors /// -/// Returns `true(1)` if the window can be filled up with widgets from this point -/// until `nk_end` or `false(0)` otherwise for example if minimized +/// Returns a non-zero window pointer if the window can be filled up with widgets from this point +/// until `nk_end` or `nullptr(0)` otherwise for example if minimized +*/ +NK_API struct nk_window* nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_rect bounds, nk_flags flags); +/*/// #### nk_add_window +/// Adds a new window; needs to be called every frame for every +/// window (unless hidden) or otherwise the window gets removed +/// it always returns a window pointer, even if the window is hidden or removed +/// this function allows the application to query state and perform the necessary updates +/// to get the same functionality as nk_begin, you should query the following states: +/// - NK_WINDOW_CLOSED +/// - NK_WINDOW_HIDDEN +/// - NK_WINDOW_MINIMIZED +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_add_window(struct nk_context *ctx, nk_hash id, const char *title, struct nk_rect bounds, nk_flags flags); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __id__ | The id of the window; unique and needs to be persistent over frames to identify the window +/// __title__ | Window title. +/// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame +/// __flags__ | Window flags defined in the nk_panel_flags section with a number of different window behaviors +/// +/// Returns a non-zero window pointer if the window can be created +/// call nk_window_has_contents(ctx, window) to see if window can be filled up with widgets from this point +*/ +NK_API struct nk_window* nk_add_window(struct nk_context *ctx, nk_hash id, const char *title, struct nk_rect bounds, nk_flags flags); +/*/// #### nk_window_has_contents +/// Checks if the window is ready to be filled up +/// generally used after nk_add_window(_titled) +/// to check if window can be filled up with widgets from this point +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_window_has_contents(struct nk_window *window); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ---------------|----------------------------------------------------------- +/// __nk_window__ | The window to check +/// +/// Returns true(1) if the window's contents are visible +/// false(0) otherwise */ -NK_API int nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_rect bounds, nk_flags flags); +NK_API int nk_window_has_contents(struct nk_window *window); /*/// #### nk_end /// Needs to be called at the end of the window building process to process scaling, scrollbars and general cleanup. /// All widget calls after this functions will result in asserts or no state changes @@ -4404,48 +4462,48 @@ struct nk_command { struct nk_command_scissor { struct nk_command header; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; }; struct nk_command_line { struct nk_command header; - unsigned short line_thickness; - struct nk_vec2i begin; - struct nk_vec2i end; + nk_unsigned_scalar_cmd line_thickness; + nk_vec2_cmd begin; + nk_vec2_cmd end; struct nk_color color; }; struct nk_command_curve { struct nk_command header; - unsigned short line_thickness; - struct nk_vec2i begin; - struct nk_vec2i end; - struct nk_vec2i ctrl[2]; + nk_unsigned_scalar_cmd line_thickness; + nk_vec2_cmd begin; + nk_vec2_cmd end; + nk_vec2_cmd ctrl[2]; struct nk_color color; }; struct nk_command_rect { struct nk_command header; - unsigned short rounding; - unsigned short line_thickness; - short x, y; - unsigned short w, h; + nk_unsigned_scalar_cmd rounding; + nk_unsigned_scalar_cmd line_thickness; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_color color; }; struct nk_command_rect_filled { struct nk_command header; - unsigned short rounding; - short x, y; - unsigned short w, h; + nk_unsigned_scalar_cmd rounding; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_color color; }; struct nk_command_rect_multi_color { struct nk_command header; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_color left; struct nk_color top; struct nk_color bottom; @@ -4454,49 +4512,49 @@ struct nk_command_rect_multi_color { struct nk_command_triangle { struct nk_command header; - unsigned short line_thickness; - struct nk_vec2i a; - struct nk_vec2i b; - struct nk_vec2i c; + nk_unsigned_scalar_cmd line_thickness; + nk_vec2_cmd a; + nk_vec2_cmd b; + nk_vec2_cmd c; struct nk_color color; }; struct nk_command_triangle_filled { struct nk_command header; - struct nk_vec2i a; - struct nk_vec2i b; - struct nk_vec2i c; + nk_vec2_cmd a; + nk_vec2_cmd b; + nk_vec2_cmd c; struct nk_color color; }; struct nk_command_circle { struct nk_command header; - short x, y; - unsigned short line_thickness; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd line_thickness; + nk_unsigned_scalar_cmd w, h; struct nk_color color; }; struct nk_command_circle_filled { struct nk_command header; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_color color; }; struct nk_command_arc { struct nk_command header; - short cx, cy; - unsigned short r; - unsigned short line_thickness; + nk_scalar_cmd cx, cy; + nk_unsigned_scalar_cmd r; + nk_unsigned_scalar_cmd line_thickness; float a[2]; struct nk_color color; }; struct nk_command_arc_filled { struct nk_command header; - short cx, cy; - unsigned short r; + nk_scalar_cmd cx, cy; + nk_unsigned_scalar_cmd r; float a[2]; struct nk_color color; }; @@ -4504,30 +4562,30 @@ struct nk_command_arc_filled { struct nk_command_polygon { struct nk_command header; struct nk_color color; - unsigned short line_thickness; + nk_unsigned_scalar_cmd line_thickness; unsigned short point_count; - struct nk_vec2i points[1]; + nk_vec2_cmd points[1]; }; struct nk_command_polygon_filled { struct nk_command header; struct nk_color color; unsigned short point_count; - struct nk_vec2i points[1]; + nk_vec2_cmd points[1]; }; struct nk_command_polyline { struct nk_command header; struct nk_color color; - unsigned short line_thickness; + nk_unsigned_scalar_cmd line_thickness; unsigned short point_count; - struct nk_vec2i points[1]; + nk_vec2_cmd points[1]; }; struct nk_command_image { struct nk_command header; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_image img; struct nk_color col; }; @@ -4547,8 +4605,8 @@ struct nk_command_text { const struct nk_user_font *font; struct nk_color background; struct nk_color foreground; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; float height; int length; char string[1]; @@ -4591,6 +4649,29 @@ NK_API void nk_draw_text(struct nk_command_buffer*, struct nk_rect, const char * NK_API void nk_push_scissor(struct nk_command_buffer*, struct nk_rect); NK_API void nk_push_custom(struct nk_command_buffer*, struct nk_rect, nk_command_custom_callback, nk_handle usr); +/* subpixel APIs */ +#ifdef NK_ENABLE_SUBPIXEL_API +NK_API void nk_stroke_line_subpixel(struct nk_command_buffer *b, float x0, float y0, float x1, float y1, float line_thickness, struct nk_color); +NK_API void nk_stroke_curve_subpixel(struct nk_command_buffer*, float, float, float, float, float, float, float, float, float line_thickness, struct nk_color); +NK_API void nk_stroke_rect_subpixel(struct nk_command_buffer*, struct nk_rect, float rounding, float line_thickness, struct nk_color); +NK_API void nk_stroke_circle_subpixel(struct nk_command_buffer*, struct nk_rect, float line_thickness, struct nk_color); +NK_API void nk_stroke_arc_subpixel(struct nk_command_buffer*, float cx, float cy, float radius, float a_min, float a_max, float line_thickness, struct nk_color); +NK_API void nk_stroke_triangle_subpixel(struct nk_command_buffer*, float, float, float, float, float, float, float line_thichness, struct nk_color); +NK_API void nk_stroke_polyline_subpixel(struct nk_command_buffer*, float *points, int point_count, float line_thickness, struct nk_color col); +NK_API void nk_stroke_polygon_subpixel(struct nk_command_buffer*, float*, int point_count, float line_thickness, struct nk_color); + +NK_API void nk_fill_rect_subpixel(struct nk_command_buffer*, struct nk_rect, float rounding, struct nk_color); +NK_API void nk_fill_rect_multi_color_subpixel(struct nk_command_buffer*, struct nk_rect, struct nk_color left, struct nk_color top, struct nk_color right, struct nk_color bottom); +NK_API void nk_fill_circle_subpixel(struct nk_command_buffer*, struct nk_rect, struct nk_color); +NK_API void nk_fill_arc_subpixel(struct nk_command_buffer*, float cx, float cy, float radius, float a_min, float a_max, struct nk_color); +NK_API void nk_fill_triangle_subpixel(struct nk_command_buffer*, float x0, float y0, float x1, float y1, float x2, float y2, struct nk_color); +NK_API void nk_fill_polygon_subpixel(struct nk_command_buffer*, float*, int point_count, struct nk_color); + +NK_API void nk_draw_image_subpixel(struct nk_command_buffer*, struct nk_rect, const struct nk_image*, struct nk_color); +NK_API void nk_draw_text_subpixel(struct nk_command_buffer*, struct nk_rect, const char *text, int len, const struct nk_user_font*, struct nk_color, struct nk_color); +NK_API void nk_push_scissor_subpixel(struct nk_command_buffer*, struct nk_rect); +#endif + /* =============================================================== * * INPUT @@ -4610,6 +4691,7 @@ struct nk_mouse { unsigned char grab; unsigned char grabbed; unsigned char ungrab; + unsigned char clicked; }; struct nk_key { @@ -5716,9 +5798,11 @@ template struct nk_alignof{struct Big {T x; char c;}; enum { #ifndef NK_MEMSET #define NK_MEMSET nk_memset +#define NK_MEMSET_BUILTIN #endif #ifndef NK_MEMCPY #define NK_MEMCPY nk_memcopy +#define NK_MEMCPY_BUILTIN #endif #ifndef NK_SQRT #define NK_SQRT nk_sqrt @@ -5817,8 +5901,15 @@ NK_LIB int nk_is_lower(int c); NK_LIB int nk_is_upper(int c); NK_LIB int nk_to_upper(int c); NK_LIB int nk_to_lower(int c); + +#ifdef NK_MEMCPY_BUILTIN NK_LIB void* nk_memcopy(void *dst, const void *src, nk_size n); +#endif + +#ifdef NK_MEMSET_BUILTIN NK_LIB void nk_memset(void *ptr, int c0, nk_size size); +#endif + NK_LIB void nk_zero(void *ptr, nk_size size); NK_LIB char *nk_itoa(char *s, long n); NK_LIB int nk_string_float_limit(char *string, int prec); @@ -5926,29 +6017,29 @@ NK_LIB void nk_widget_text(struct nk_command_buffer *o, struct nk_rect b, const NK_LIB void nk_widget_text_wrap(struct nk_command_buffer *o, struct nk_rect b, const char *string, int len, const struct nk_text *t, const struct nk_user_font *f); /* button */ -NK_LIB int nk_button_behavior(nk_flags *state, struct nk_rect r, const struct nk_input *i, enum nk_button_behavior behavior); +NK_LIB int nk_button_behavior(nk_flags *state, struct nk_rect r, struct nk_input *i, enum nk_button_behavior behavior); NK_LIB const struct nk_style_item* nk_draw_button(struct nk_command_buffer *out, const struct nk_rect *bounds, nk_flags state, const struct nk_style_button *style); -NK_LIB int nk_do_button(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, const struct nk_style_button *style, const struct nk_input *in, enum nk_button_behavior behavior, struct nk_rect *content); +NK_LIB int nk_do_button(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, const struct nk_style_button *style, struct nk_input *in, enum nk_button_behavior behavior, struct nk_rect *content); NK_LIB void nk_draw_button_text(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, const struct nk_style_button *style, const char *txt, int len, nk_flags text_alignment, const struct nk_user_font *font); -NK_LIB int nk_do_button_text(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *string, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_button_text(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *string, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, struct nk_input *in, const struct nk_user_font *font); NK_LIB void nk_draw_button_symbol(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, const struct nk_style_button *style, enum nk_symbol_type type, const struct nk_user_font *font); -NK_LIB int nk_do_button_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_button_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, enum nk_button_behavior behavior, const struct nk_style_button *style, struct nk_input *in, const struct nk_user_font *font); NK_LIB void nk_draw_button_image(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, const struct nk_style_button *style, const struct nk_image *img); -NK_LIB int nk_do_button_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, enum nk_button_behavior b, const struct nk_style_button *style, const struct nk_input *in); +NK_LIB int nk_do_button_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, enum nk_button_behavior b, const struct nk_style_button *style, struct nk_input *in); NK_LIB void nk_draw_button_text_symbol(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *label, const struct nk_rect *symbol, nk_flags state, const struct nk_style_button *style, const char *str, int len, enum nk_symbol_type type, const struct nk_user_font *font); -NK_LIB int nk_do_button_text_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, const char *str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, const struct nk_input *in); +NK_LIB int nk_do_button_text_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, const char *str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, struct nk_input *in); NK_LIB void nk_draw_button_text_image(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *label, const struct nk_rect *image, nk_flags state, const struct nk_style_button *style, const char *str, int len, const struct nk_user_font *font, const struct nk_image *img); -NK_LIB int nk_do_button_text_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, const char* str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, const struct nk_input *in); +NK_LIB int nk_do_button_text_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, const char* str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, struct nk_input *in); /* toggle */ enum nk_toggle_type { NK_TOGGLE_CHECK, NK_TOGGLE_OPTION }; -NK_LIB int nk_toggle_behavior(const struct nk_input *in, struct nk_rect select, nk_flags *state, int active); +NK_LIB int nk_toggle_behavior(struct nk_input *in, struct nk_rect select, nk_flags *state, int active); NK_LIB void nk_draw_checkbox(struct nk_command_buffer *out, nk_flags state, const struct nk_style_toggle *style, int active, const struct nk_rect *label, const struct nk_rect *selector, const struct nk_rect *cursors, const char *string, int len, const struct nk_user_font *font); NK_LIB void nk_draw_option(struct nk_command_buffer *out, nk_flags state, const struct nk_style_toggle *style, int active, const struct nk_rect *label, const struct nk_rect *selector, const struct nk_rect *cursors, const char *string, int len, const struct nk_user_font *font); -NK_LIB int nk_do_toggle(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, int *active, const char *str, int len, enum nk_toggle_type type, const struct nk_style_toggle *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_toggle(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, int *active, const char *str, int len, enum nk_toggle_type type, const struct nk_style_toggle *style, struct nk_input *in, const struct nk_user_font *font); /* progress */ NK_LIB nk_size nk_progress_behavior(nk_flags *state, struct nk_input *in, struct nk_rect r, struct nk_rect cursor, nk_size max, nk_size value, int modifiable); @@ -5968,17 +6059,17 @@ NK_LIB float nk_do_scrollbarh(nk_flags *state, struct nk_command_buffer *out, st /* selectable */ NK_LIB void nk_draw_selectable(struct nk_command_buffer *out, nk_flags state, const struct nk_style_selectable *style, int active, const struct nk_rect *bounds, const struct nk_rect *icon, const struct nk_image *img, enum nk_symbol_type sym, const char *string, int len, nk_flags align, const struct nk_user_font *font); -NK_LIB int nk_do_selectable(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_style_selectable *style, const struct nk_input *in, const struct nk_user_font *font); -NK_LIB int nk_do_selectable_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_image *img, const struct nk_style_selectable *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_selectable(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_style_selectable *style, struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_selectable_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_image *img, const struct nk_style_selectable *style, struct nk_input *in, const struct nk_user_font *font); /* edit */ NK_LIB void nk_edit_draw_text(struct nk_command_buffer *out, const struct nk_style_edit *style, float pos_x, float pos_y, float x_offset, const char *text, int byte_len, float row_height, const struct nk_user_font *font, struct nk_color background, struct nk_color foreground, int is_selected); NK_LIB nk_flags nk_do_edit(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, nk_flags flags, nk_plugin_filter filter, struct nk_text_edit *edit, const struct nk_style_edit *style, struct nk_input *in, const struct nk_user_font *font); /* color-picker */ -NK_LIB int nk_color_picker_behavior(nk_flags *state, const struct nk_rect *bounds, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, struct nk_colorf *color, const struct nk_input *in); +NK_LIB int nk_color_picker_behavior(nk_flags *state, const struct nk_rect *bounds, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, struct nk_colorf *color, struct nk_input *in); NK_LIB void nk_draw_color_picker(struct nk_command_buffer *o, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, struct nk_colorf col); -NK_LIB int nk_do_color_picker(nk_flags *state, struct nk_command_buffer *out, struct nk_colorf *col, enum nk_color_format fmt, struct nk_rect bounds, struct nk_vec2 padding, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_color_picker(nk_flags *state, struct nk_command_buffer *out, struct nk_colorf *col, enum nk_color_format fmt, struct nk_rect bounds, struct nk_vec2 padding, struct nk_input *in, const struct nk_user_font *font); /* property */ enum nk_property_status { @@ -6011,8 +6102,8 @@ NK_LIB struct nk_property_variant nk_property_variant_int(int value, int min_val NK_LIB struct nk_property_variant nk_property_variant_float(float value, float min_value, float max_value, float step); NK_LIB struct nk_property_variant nk_property_variant_double(double value, double min_value, double max_value, double step); -NK_LIB void nk_drag_behavior(nk_flags *state, const struct nk_input *in, struct nk_rect drag, struct nk_property_variant *variant, float inc_per_pixel); -NK_LIB void nk_property_behavior(nk_flags *ws, const struct nk_input *in, struct nk_rect property, struct nk_rect label, struct nk_rect edit, struct nk_rect empty, int *state, struct nk_property_variant *variant, float inc_per_pixel); +NK_LIB void nk_drag_behavior(nk_flags *state, struct nk_input *in, struct nk_rect drag, struct nk_property_variant *variant, float inc_per_pixel); +NK_LIB void nk_property_behavior(nk_flags *ws, struct nk_input *in, struct nk_rect property, struct nk_rect label, struct nk_rect edit, struct nk_rect empty, int *state, struct nk_property_variant *variant, float inc_per_pixel); NK_LIB void nk_draw_property(struct nk_command_buffer *out, const struct nk_style_property *style, const struct nk_rect *bounds, const struct nk_rect *label, nk_flags state, const char *name, int len, const struct nk_user_font *font); NK_LIB void nk_do_property(nk_flags *ws, struct nk_command_buffer *out, struct nk_rect property, const char *name, struct nk_property_variant *variant, float inc_per_pixel, char *buffer, int *len, int *state, int *cursor, int *select_begin, int *select_end, const struct nk_style_property *style, enum nk_property_filter filter, struct nk_input *in, const struct nk_user_font *font, struct nk_text_edit *text_edit, enum nk_button_behavior behavior); NK_LIB void nk_property(struct nk_context *ctx, const char *name, struct nk_property_variant *variant, float inc_per_pixel, const enum nk_property_filter filter); @@ -6334,6 +6425,8 @@ NK_LIB int nk_is_upper(int c){return (c >= 'A' && c <= 'Z') || (c >= 0xC0 && c < NK_LIB int nk_to_upper(int c) {return (c >= 'a' && c <= 'z') ? (c - ('a' - 'A')) : c;} NK_LIB int nk_to_lower(int c) {return (c >= 'A' && c <= 'Z') ? (c - ('a' + 'A')) : c;} +#ifdef NK_MEMCPY_BUILTIN + NK_LIB void* nk_memcopy(void *dst0, const void *src0, nk_size length) { @@ -6390,6 +6483,11 @@ nk_memcopy(void *dst0, const void *src0, nk_size length) done: return (dst0); } + +#endif + +#ifdef NK_MEMSET_BUILTIN + NK_LIB void nk_memset(void *ptr, int c0, nk_size size) { @@ -6441,6 +6539,9 @@ nk_memset(void *ptr, int c0, nk_size size) #undef nk_wsize #undef nk_wmask } + +#endif + NK_LIB void nk_zero(void *ptr, nk_size size) { @@ -9069,7 +9170,7 @@ nk_stroke_polygon(struct nk_command_buffer *b, float *points, int point_count, NK_ASSERT(b); if (!b || col.a == 0 || line_thickness <= 0) return; - size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; cmd = (struct nk_command_polygon*) nk_command_buffer_push(b, NK_COMMAND_POLYGON, size); if (!cmd) return; cmd->color = col; @@ -9090,7 +9191,7 @@ nk_fill_polygon(struct nk_command_buffer *b, float *points, int point_count, NK_ASSERT(b); if (!b || col.a == 0) return; - size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; cmd = (struct nk_command_polygon_filled*) nk_command_buffer_push(b, NK_COMMAND_POLYGON_FILLED, size); if (!cmd) return; @@ -9111,7 +9212,7 @@ nk_stroke_polyline(struct nk_command_buffer *b, float *points, int point_count, NK_ASSERT(b); if (!b || col.a == 0 || line_thickness <= 0) return; - size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; cmd = (struct nk_command_polyline*) nk_command_buffer_push(b, NK_COMMAND_POLYLINE, size); if (!cmd) return; cmd->color = col; @@ -9146,10 +9247,403 @@ nk_draw_image(struct nk_command_buffer *b, struct nk_rect r, cmd->col = col; } NK_API void -nk_push_custom(struct nk_command_buffer *b, struct nk_rect r, - nk_command_custom_callback cb, nk_handle usr) +nk_push_custom(struct nk_command_buffer *b, struct nk_rect r, + nk_command_custom_callback cb, nk_handle usr) +{ + struct nk_command_custom *cmd; + NK_ASSERT(b); + if (!b) return; + if (b->use_clipping) { + const struct nk_rect *c = &b->clip; + if (c->w == 0 || c->h == 0 || !NK_INTERSECT(r.x, r.y, r.w, r.h, c->x, c->y, c->w, c->h)) + return; + } + + cmd = (struct nk_command_custom*) + nk_command_buffer_push(b, NK_COMMAND_CUSTOM, sizeof(*cmd)); + if (!cmd) return; + cmd->x = (short)r.x; + cmd->y = (short)r.y; + cmd->w = (unsigned short)NK_MAX(0, r.w); + cmd->h = (unsigned short)NK_MAX(0, r.h); + cmd->callback_data = usr; + cmd->callback = cb; +} +NK_API void +nk_draw_text(struct nk_command_buffer *b, struct nk_rect r, + const char *string, int length, const struct nk_user_font *font, + struct nk_color bg, struct nk_color fg) +{ + float text_width = 0; + struct nk_command_text *cmd; + + NK_ASSERT(b); + NK_ASSERT(font); + if (!b || !string || !length || (bg.a == 0 && fg.a == 0)) return; + if (b->use_clipping) { + const struct nk_rect *c = &b->clip; + if (c->w == 0 || c->h == 0 || !NK_INTERSECT(r.x, r.y, r.w, r.h, c->x, c->y, c->w, c->h)) + return; + } + + /* make sure text fits inside bounds */ + text_width = font->width(font->userdata, font->height, string, length); + if (text_width > r.w){ + int glyphs = 0; + float txt_width = (float)text_width; + length = nk_text_clamp(font, string, length, r.w, &glyphs, &txt_width, 0,0); + } + + if (!length) return; + cmd = (struct nk_command_text*) + nk_command_buffer_push(b, NK_COMMAND_TEXT, sizeof(*cmd) + (nk_size)(length + 1)); + if (!cmd) return; + cmd->x = (short)r.x; + cmd->y = (short)r.y; + cmd->w = (unsigned short)r.w; + cmd->h = (unsigned short)r.h; + cmd->background = bg; + cmd->foreground = fg; + cmd->font = font; + cmd->length = length; + cmd->height = font->height; + NK_MEMCPY(cmd->string, string, (nk_size)length); + cmd->string[length] = '\0'; +} + +#ifdef NK_ENABLE_SUBPIXEL_API + +NK_API void +nk_push_scissor_subpixel(struct nk_command_buffer *b, struct nk_rect r) +{ + struct nk_command_scissor *cmd; + NK_ASSERT(b); + if (!b) return; + + b->clip.x = r.x; + b->clip.y = r.y; + b->clip.w = r.w; + b->clip.h = r.h; + cmd = (struct nk_command_scissor*) + nk_command_buffer_push(b, NK_COMMAND_SCISSOR, sizeof(*cmd)); + + if (!cmd) return; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = NK_MAX(0, r.w); + cmd->h = NK_MAX(0, r.h); +} +NK_API void +nk_stroke_line_subpixel(struct nk_command_buffer *b, float x0, float y0, + float x1, float y1, float line_thickness, struct nk_color c) +{ + struct nk_command_line *cmd; + NK_ASSERT(b); + if (!b || line_thickness <= 0) return; + cmd = (struct nk_command_line*) + nk_command_buffer_push(b, NK_COMMAND_LINE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->begin.x = x0; + cmd->begin.y = y0; + cmd->end.x = x1; + cmd->end.y = y1; + cmd->color = c; +} +NK_API void +nk_stroke_curve_subpixel(struct nk_command_buffer *b, float ax, float ay, + float ctrl0x, float ctrl0y, float ctrl1x, float ctrl1y, + float bx, float by, float line_thickness, struct nk_color col) +{ + struct nk_command_curve *cmd; + NK_ASSERT(b); + if (!b || col.a == 0 || line_thickness <= 0) return; + + cmd = (struct nk_command_curve*) + nk_command_buffer_push(b, NK_COMMAND_CURVE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->begin.x = ax; + cmd->begin.y = ay; + cmd->ctrl[0].x = ctrl0x; + cmd->ctrl[0].y = ctrl0y; + cmd->ctrl[1].x = ctrl1x; + cmd->ctrl[1].y = ctrl1y; + cmd->end.x = bx; + cmd->end.y = by; + cmd->color = col; +} +NK_API void +nk_stroke_rect_subpixel(struct nk_command_buffer *b, struct nk_rect rect, + float rounding, float line_thickness, struct nk_color c) +{ + struct nk_command_rect *cmd; + NK_ASSERT(b); + if (!b || c.a == 0 || rect.w == 0 || rect.h == 0 || line_thickness <= 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + clip->x, clip->y, clip->w, clip->h)) return; + } + cmd = (struct nk_command_rect*) + nk_command_buffer_push(b, NK_COMMAND_RECT, sizeof(*cmd)); + if (!cmd) return; + cmd->rounding = rounding; + cmd->line_thickness = line_thickness; + cmd->x = rect.x; + cmd->y = rect.y; + cmd->w = NK_MAX(0, rect.w); + cmd->h = NK_MAX(0, rect.h); + cmd->color = c; +} +NK_API void +nk_fill_rect_subpixel(struct nk_command_buffer *b, struct nk_rect rect, + float rounding, struct nk_color c) +{ + struct nk_command_rect_filled *cmd; + NK_ASSERT(b); + if (!b || c.a == 0 || rect.w == 0 || rect.h == 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + clip->x, clip->y, clip->w, clip->h)) return; + } + + cmd = (struct nk_command_rect_filled*) + nk_command_buffer_push(b, NK_COMMAND_RECT_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->rounding = rounding; + cmd->x = rect.x; + cmd->y = rect.y; + cmd->w = NK_MAX(0, rect.w); + cmd->h = NK_MAX(0, rect.h); + cmd->color = c; +} +NK_API void +nk_fill_rect_multi_color_subpixel(struct nk_command_buffer *b, struct nk_rect rect, + struct nk_color left, struct nk_color top, struct nk_color right, + struct nk_color bottom) +{ + struct nk_command_rect_multi_color *cmd; + NK_ASSERT(b); + if (!b || rect.w == 0 || rect.h == 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + clip->x, clip->y, clip->w, clip->h)) return; + } + + cmd = (struct nk_command_rect_multi_color*) + nk_command_buffer_push(b, NK_COMMAND_RECT_MULTI_COLOR, sizeof(*cmd)); + if (!cmd) return; + cmd->x = rect.x; + cmd->y = rect.y; + cmd->w = NK_MAX(0, rect.w); + cmd->h = NK_MAX(0, rect.h); + cmd->left = left; + cmd->top = top; + cmd->right = right; + cmd->bottom = bottom; +} +NK_API void +nk_stroke_circle_subpixel(struct nk_command_buffer *b, struct nk_rect r, + float line_thickness, struct nk_color c) +{ + struct nk_command_circle *cmd; + if (!b || r.w == 0 || r.h == 0 || line_thickness <= 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(r.x, r.y, r.w, r.h, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_circle*) + nk_command_buffer_push(b, NK_COMMAND_CIRCLE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = NK_MAX(r.w, 0); + cmd->h = NK_MAX(r.h, 0); + cmd->color = c; +} +NK_API void +nk_fill_circle_subpixel(struct nk_command_buffer *b, struct nk_rect r, struct nk_color c) +{ + struct nk_command_circle_filled *cmd; + NK_ASSERT(b); + if (!b || c.a == 0 || r.w == 0 || r.h == 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(r.x, r.y, r.w, r.h, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_circle_filled*) + nk_command_buffer_push(b, NK_COMMAND_CIRCLE_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = NK_MAX(r.w, 0); + cmd->h = NK_MAX(r.h, 0); + cmd->color = c; +} +NK_API void +nk_stroke_arc_subpixel(struct nk_command_buffer *b, float cx, float cy, float radius, + float a_min, float a_max, float line_thickness, struct nk_color c) +{ + struct nk_command_arc *cmd; + if (!b || c.a == 0 || line_thickness <= 0) return; + cmd = (struct nk_command_arc*) + nk_command_buffer_push(b, NK_COMMAND_ARC, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->cx = cx; + cmd->cy = cy; + cmd->r = radius; + cmd->a[0] = a_min; + cmd->a[1] = a_max; + cmd->color = c; +} +NK_API void +nk_fill_arc_subpixel(struct nk_command_buffer *b, float cx, float cy, float radius, + float a_min, float a_max, struct nk_color c) +{ + struct nk_command_arc_filled *cmd; + NK_ASSERT(b); + if (!b || c.a == 0) return; + cmd = (struct nk_command_arc_filled*) + nk_command_buffer_push(b, NK_COMMAND_ARC_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->cx = cx; + cmd->cy = cy; + cmd->r = radius; + cmd->a[0] = a_min; + cmd->a[1] = a_max; + cmd->color = c; +} +NK_API void +nk_stroke_triangle_subpixel(struct nk_command_buffer *b, float x0, float y0, float x1, + float y1, float x2, float y2, float line_thickness, struct nk_color c) +{ + struct nk_command_triangle *cmd; + NK_ASSERT(b); + if (!b || c.a == 0 || line_thickness <= 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INBOX(x0, y0, clip->x, clip->y, clip->w, clip->h) && + !NK_INBOX(x1, y1, clip->x, clip->y, clip->w, clip->h) && + !NK_INBOX(x2, y2, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_triangle*) + nk_command_buffer_push(b, NK_COMMAND_TRIANGLE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->a.x = x0; + cmd->a.y = y0; + cmd->b.x = x1; + cmd->b.y = y1; + cmd->c.x = x2; + cmd->c.y = y2; + cmd->color = c; +} +NK_API void +nk_fill_triangle_subpixel(struct nk_command_buffer *b, float x0, float y0, float x1, + float y1, float x2, float y2, struct nk_color c) +{ + struct nk_command_triangle_filled *cmd; + NK_ASSERT(b); + if (!b || c.a == 0) return; + if (!b) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INBOX(x0, y0, clip->x, clip->y, clip->w, clip->h) && + !NK_INBOX(x1, y1, clip->x, clip->y, clip->w, clip->h) && + !NK_INBOX(x2, y2, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_triangle_filled*) + nk_command_buffer_push(b, NK_COMMAND_TRIANGLE_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->a.x = x0; + cmd->a.y = y0; + cmd->b.x = x1; + cmd->b.y = y1; + cmd->c.x = x2; + cmd->c.y = y2; + cmd->color = c; +} +NK_API void +nk_stroke_polygon_subpixel(struct nk_command_buffer *b, float *points, int point_count, + float line_thickness, struct nk_color col) +{ + int i; + nk_size size = 0; + struct nk_command_polygon *cmd; + + NK_ASSERT(b); + if (!b || col.a == 0 || line_thickness <= 0) return; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; + cmd = (struct nk_command_polygon*) nk_command_buffer_push(b, NK_COMMAND_POLYGON, size); + if (!cmd) return; + cmd->color = col; + cmd->line_thickness = line_thickness; + cmd->point_count = (unsigned short)point_count; + for (i = 0; i < point_count; ++i) { + cmd->points[i].x = points[i*2]; + cmd->points[i].y = points[i*2+1]; + } +} +NK_API void +nk_fill_polygon_subpixel(struct nk_command_buffer *b, float *points, int point_count, + struct nk_color col) +{ + int i; + nk_size size = 0; + struct nk_command_polygon_filled *cmd; + + NK_ASSERT(b); + if (!b || col.a == 0) return; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; + cmd = (struct nk_command_polygon_filled*) + nk_command_buffer_push(b, NK_COMMAND_POLYGON_FILLED, size); + if (!cmd) return; + cmd->color = col; + cmd->point_count = (unsigned short)point_count; + for (i = 0; i < point_count; ++i) { + cmd->points[i].x = points[i*2+0]; + cmd->points[i].y = points[i*2+1]; + } +} +NK_API void +nk_stroke_polyline_subpixel(struct nk_command_buffer *b, float *points, int point_count, + float line_thickness, struct nk_color col) +{ + int i; + nk_size size = 0; + struct nk_command_polyline *cmd; + + NK_ASSERT(b); + if (!b || col.a == 0 || line_thickness <= 0) return; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; + cmd = (struct nk_command_polyline*) nk_command_buffer_push(b, NK_COMMAND_POLYLINE, size); + if (!cmd) return; + cmd->color = col; + cmd->point_count = (unsigned short)point_count; + cmd->line_thickness = line_thickness; + for (i = 0; i < point_count; ++i) { + cmd->points[i].x = points[i*2]; + cmd->points[i].y = points[i*2+1]; + } +} +NK_API void +nk_draw_image_subpixel(struct nk_command_buffer *b, struct nk_rect r, + const struct nk_image *img, struct nk_color col) { - struct nk_command_custom *cmd; + struct nk_command_image *cmd; NK_ASSERT(b); if (!b) return; if (b->use_clipping) { @@ -9158,18 +9652,18 @@ nk_push_custom(struct nk_command_buffer *b, struct nk_rect r, return; } - cmd = (struct nk_command_custom*) - nk_command_buffer_push(b, NK_COMMAND_CUSTOM, sizeof(*cmd)); + cmd = (struct nk_command_image*) + nk_command_buffer_push(b, NK_COMMAND_IMAGE, sizeof(*cmd)); if (!cmd) return; - cmd->x = (short)r.x; - cmd->y = (short)r.y; - cmd->w = (unsigned short)NK_MAX(0, r.w); - cmd->h = (unsigned short)NK_MAX(0, r.h); - cmd->callback_data = usr; - cmd->callback = cb; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = NK_MAX(0, r.w); + cmd->h = NK_MAX(0, r.h); + cmd->img = *img; + cmd->col = col; } NK_API void -nk_draw_text(struct nk_command_buffer *b, struct nk_rect r, +nk_draw_text_subpixel(struct nk_command_buffer *b, struct nk_rect r, const char *string, int length, const struct nk_user_font *font, struct nk_color bg, struct nk_color fg) { @@ -9197,10 +9691,10 @@ nk_draw_text(struct nk_command_buffer *b, struct nk_rect r, cmd = (struct nk_command_text*) nk_command_buffer_push(b, NK_COMMAND_TEXT, sizeof(*cmd) + (nk_size)(length + 1)); if (!cmd) return; - cmd->x = (short)r.x; - cmd->y = (short)r.y; - cmd->w = (unsigned short)r.w; - cmd->h = (unsigned short)r.h; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = r.w; + cmd->h = r.h; cmd->background = bg; cmd->foreground = fg; cmd->font = font; @@ -9210,7 +9704,7 @@ nk_draw_text(struct nk_command_buffer *b, struct nk_rect r, cmd->string[length] = '\0'; } - +#endif @@ -9437,6 +9931,8 @@ nk_draw_list_alloc_vertices(struct nk_draw_list *list, nk_size count) if (!vtx) return 0; list->vertex_count += (unsigned int)count; + #ifndef NK_UINT_DRAW_INDEX + /* This assert triggers because your are drawing a lot of stuff and nuklear * defined `nk_draw_index` as `nk_ushort` to safe space be default. * @@ -9446,8 +9942,11 @@ nk_draw_list_alloc_vertices(struct nk_draw_list *list, nk_size count) * backend (OpenGL, DirectX, ...). For example in OpenGL for `glDrawElements` * instead of specifing `GL_UNSIGNED_SHORT` you have to define `GL_UNSIGNED_INT`. * Sorry for the inconvenience. */ - if(sizeof(nk_draw_index)==2) NK_ASSERT((list->vertex_count < NK_USHORT_MAX && + NK_ASSERT((list->vertex_count < NK_USHORT_MAX && "To many verticies for 16-bit vertex indicies. Please read comment above on how to solve this problem")); + + #endif + return vtx; } NK_INTERN nk_draw_index* @@ -13959,6 +14458,11 @@ nk_input_begin(struct nk_context *ctx) in->mouse.prev.y = in->mouse.pos.y; in->mouse.delta.x = 0; in->mouse.delta.y = 0; + + #if defined(NK_KEYSTATE_BASED_INPUT) || defined(NK_BUTTON_TRIGGER_ON_RELEASE) + in->mouse.clicked = 0; + #endif + for (i = 0; i < NK_KEY_MAX; i++) in->keyboard.keys[i].clicked = 0; } @@ -14015,6 +14519,14 @@ nk_input_button(struct nk_context *ctx, enum nk_buttons id, int x, int y, int do if (in->mouse.buttons[id].down == down) return; btn = &in->mouse.buttons[id]; + + #ifndef NK_BUTTON_TRIGGER_ON_RELEASE + + if(id == NK_BUTTON_LEFT && !down) + in->mouse.clicked = 0; + + #endif + btn->clicked_pos.x = (float)x; btn->clicked_pos.y = (float)y; btn->down = down; @@ -14077,7 +14589,7 @@ nk_input_has_mouse_click_in_rect(const struct nk_input *i, enum nk_buttons id, struct nk_rect b) { const struct nk_mouse_button *btn; - if (!i) return nk_false; + if (!i || i->mouse.clicked) return nk_false; btn = &i->mouse.buttons[id]; if (!NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h)) return nk_false; @@ -14151,7 +14663,7 @@ nk_input_is_mouse_pressed(const struct nk_input *i, enum nk_buttons id) const struct nk_mouse_button *b; if (!i) return nk_false; b = &i->mouse.buttons[id]; - if (b->down && b->clicked) + if (b->down && b->clicked && !i->mouse.clicked) return nk_true; return nk_false; } @@ -14159,7 +14671,7 @@ NK_API int nk_input_is_mouse_released(const struct nk_input *i, enum nk_buttons id) { if (!i) return nk_false; - return (!i->mouse.buttons[id].down && i->mouse.buttons[id].clicked); + return (!i->mouse.buttons[id].down && !(i->mouse.buttons[id].clicked && !i->mouse.clicked)); } NK_API int nk_input_is_key_pressed(const struct nk_input *i, enum nk_keys key) @@ -16178,6 +16690,7 @@ nk_find_window(struct nk_context *ctx, nk_hash hash, const char *name) while (iter) { NK_ASSERT(iter != iter->next); if (iter->name == hash) { + if (!name) return iter; int max_len = nk_strlen(iter->name_string); if (!nk_stricmpn(iter->name_string, name, max_len)) return iter; @@ -16260,13 +16773,13 @@ nk_remove_window(struct nk_context *ctx, struct nk_window *win) win->prev = 0; ctx->count--; } -NK_API int +NK_API struct nk_window* nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bounds, nk_flags flags) { return nk_begin_titled(ctx, title, title, bounds, flags); } -NK_API int +NK_API struct nk_window* nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_rect bounds, nk_flags flags) { @@ -16274,7 +16787,6 @@ nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_style *style; nk_hash name_hash; int name_len; - int ret = 0; NK_ASSERT(ctx); NK_ASSERT(name); @@ -16415,10 +16927,178 @@ nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, } win->layout = (struct nk_panel*)nk_create_panel(ctx); ctx->current = win; - ret = nk_panel_begin(ctx, title, NK_PANEL_WINDOW); + + if (!nk_panel_begin(ctx, title, NK_PANEL_WINDOW)) + return 0; + win->layout->offset_x = &win->scrollbar.x; win->layout->offset_y = &win->scrollbar.y; - return ret; + return win; +} +NK_API int +nk_window_has_contents(struct nk_window *window) +{ + NK_ASSERT(window); + if (!window) + return 0; + + return !((window->flags & NK_WINDOW_MINIMIZED) || (window->flags & NK_WINDOW_CLOSED) || (window->flags & NK_WINDOW_HIDDEN)); +} +NK_API struct nk_window* +nk_add_window(struct nk_context *ctx, nk_hash id, const char *title, + struct nk_rect bounds, nk_flags flags) +{ + struct nk_window *win; + struct nk_style *style; + + NK_ASSERT(ctx); + 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) + return 0; + + /* find or create window */ + style = &ctx->style; + win = nk_find_window(ctx, id, 0); + if (!win) { + /* create new window */ + win = (struct nk_window*)nk_create_window(ctx); + NK_ASSERT(win); + if (!win) return 0; + + if (flags & NK_WINDOW_BACKGROUND) + nk_insert_window(ctx, win, NK_INSERT_FRONT); + else nk_insert_window(ctx, win, NK_INSERT_BACK); + nk_command_buffer_init(&win->buffer, &ctx->memory, NK_CLIPPING_ON); + + win->flags = flags; + win->bounds = bounds; + win->name = id; //0 means use "hash" only + win->name_string[0] = 0; + win->popup.win = 0; + if (!ctx->active) + ctx->active = win; + } else { + /* update window */ + win->flags &= ~(nk_flags)(NK_WINDOW_PRIVATE-1); + win->flags |= flags; + if (!(win->flags & (NK_WINDOW_MOVABLE | NK_WINDOW_SCALABLE))) + win->bounds = bounds; + /* If this assert triggers you either: + * + * I.) Have more than one window with the same name or + * II.) You forgot to actually draw the window. + * More specific you did not call `nk_clear` (nk_clear will be + * automatically called for you if you are using one of the + * provided demo backends). */ + NK_ASSERT(win->seq != ctx->seq); + win->seq = ctx->seq; + if (!ctx->active && !(win->flags & NK_WINDOW_HIDDEN)) { + ctx->active = win; + ctx->end = win; + } + } + if (win->flags & NK_WINDOW_HIDDEN) { + ctx->current = win; + win->layout = 0; + return win; + } else nk_start(ctx, win); + + /* window overlapping */ + if (!(win->flags & NK_WINDOW_HIDDEN) && !(win->flags & NK_WINDOW_NO_INPUT)) + { + int inpanel, ishovered; + struct nk_window *iter = win; + float h = ctx->style.font->height + 2.0f * style->window.header.padding.y + + (2.0f * style->window.header.label_padding.y); + struct nk_rect win_bounds = (!(win->flags & NK_WINDOW_MINIMIZED))? + win->bounds: nk_rect(win->bounds.x, win->bounds.y, win->bounds.w, h); + + /* activate window if hovered and no other window is overlapping this window */ + inpanel = nk_input_has_mouse_click_down_in_rect(&ctx->input, NK_BUTTON_LEFT, win_bounds, nk_true); + inpanel = inpanel && ctx->input.mouse.buttons[NK_BUTTON_LEFT].clicked; + ishovered = nk_input_is_mouse_hovering_rect(&ctx->input, win_bounds); + if ((win != ctx->active) && ishovered && !ctx->input.mouse.buttons[NK_BUTTON_LEFT].down) { + iter = win->next; + while (iter) { + struct nk_rect iter_bounds = (!(iter->flags & NK_WINDOW_MINIMIZED))? + iter->bounds: nk_rect(iter->bounds.x, iter->bounds.y, iter->bounds.w, h); + if (NK_INTERSECT(win_bounds.x, win_bounds.y, win_bounds.w, win_bounds.h, + iter_bounds.x, iter_bounds.y, iter_bounds.w, iter_bounds.h) && + (!(iter->flags & NK_WINDOW_HIDDEN))) + break; + + if (iter->popup.win && iter->popup.active && !(iter->flags & NK_WINDOW_HIDDEN) && + NK_INTERSECT(win->bounds.x, win_bounds.y, win_bounds.w, win_bounds.h, + iter->popup.win->bounds.x, iter->popup.win->bounds.y, + iter->popup.win->bounds.w, iter->popup.win->bounds.h)) + break; + iter = iter->next; + } + } + + /* activate window if clicked */ + if (iter && inpanel && (win != ctx->end)) { + iter = win->next; + while (iter) { + /* try to find a panel with higher priority in the same position */ + struct nk_rect iter_bounds = (!(iter->flags & NK_WINDOW_MINIMIZED))? + iter->bounds: nk_rect(iter->bounds.x, iter->bounds.y, iter->bounds.w, h); + if (NK_INBOX(ctx->input.mouse.pos.x, ctx->input.mouse.pos.y, + iter_bounds.x, iter_bounds.y, iter_bounds.w, iter_bounds.h) && + !(iter->flags & NK_WINDOW_HIDDEN)) + break; + if (iter->popup.win && iter->popup.active && !(iter->flags & NK_WINDOW_HIDDEN) && + NK_INTERSECT(win_bounds.x, win_bounds.y, win_bounds.w, win_bounds.h, + iter->popup.win->bounds.x, iter->popup.win->bounds.y, + iter->popup.win->bounds.w, iter->popup.win->bounds.h)) + break; + iter = iter->next; + } + } + if (iter && !(win->flags & NK_WINDOW_ROM) && (win->flags & NK_WINDOW_BACKGROUND)) { + win->flags |= (nk_flags)NK_WINDOW_ROM; + iter->flags &= ~(nk_flags)NK_WINDOW_ROM; + ctx->active = iter; + if (!(iter->flags & NK_WINDOW_BACKGROUND)) { + /* current window is active in that position so transfer to top + * at the highest priority in stack */ + nk_remove_window(ctx, iter); + nk_insert_window(ctx, iter, NK_INSERT_BACK); + } + } else { + if (!iter && ctx->end != win) { + if (!(win->flags & NK_WINDOW_BACKGROUND)) { + /* current window is active in that position so transfer to top + * at the highest priority in stack */ + nk_remove_window(ctx, win); + nk_insert_window(ctx, win, NK_INSERT_BACK); + } + win->flags &= ~(nk_flags)NK_WINDOW_ROM; + ctx->active = win; + } + if (ctx->end != win && !(win->flags & NK_WINDOW_BACKGROUND)) + win->flags |= NK_WINDOW_ROM; + } + } + win->layout = (struct nk_panel*)nk_create_panel(ctx); + ctx->current = win; + + if (!nk_panel_begin(ctx, title, NK_PANEL_WINDOW)) { + + if(win->layout->flags & NK_WINDOW_HIDDEN) + win->flags |= NK_WINDOW_CLOSED; + + if(win->layout->flags & NK_WINDOW_MINIMIZED) + win->flags |= NK_WINDOW_MINIMIZED; + + return win; + } + + win->layout->offset_x = &win->scrollbar.x; + win->layout->offset_y = &win->scrollbar.y; + return win; } NK_API void nk_end(struct nk_context *ctx) @@ -17129,7 +17809,7 @@ nk_contextual_item_text(struct nk_context *ctx, const char *text, int len, nk_flags alignment) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; @@ -17164,7 +17844,7 @@ nk_contextual_item_image_text(struct nk_context *ctx, struct nk_image img, const char *text, int len, nk_flags align) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; @@ -17200,7 +17880,7 @@ nk_contextual_item_symbol_text(struct nk_context *ctx, enum nk_symbol_type symbo const char *text, int len, nk_flags align) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; @@ -17393,7 +18073,7 @@ nk_menu_begin_text(struct nk_context *ctx, const char *title, int len, nk_flags align, struct nk_vec2 size) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; nk_flags state; @@ -17424,7 +18104,7 @@ nk_menu_begin_image(struct nk_context *ctx, const char *id, struct nk_image img, { struct nk_window *win; struct nk_rect header; - const struct nk_input *in; + struct nk_input *in; int is_clicked = nk_false; nk_flags state; @@ -17448,7 +18128,7 @@ nk_menu_begin_symbol(struct nk_context *ctx, const char *id, enum nk_symbol_type sym, struct nk_vec2 size) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; nk_flags state; @@ -17474,7 +18154,7 @@ nk_menu_begin_image_text(struct nk_context *ctx, const char *title, int len, { struct nk_window *win; struct nk_rect header; - const struct nk_input *in; + struct nk_input *in; int is_clicked = nk_false; nk_flags state; @@ -17506,7 +18186,7 @@ nk_menu_begin_symbol_text(struct nk_context *ctx, const char *title, int len, { struct nk_window *win; struct nk_rect header; - const struct nk_input *in; + struct nk_input *in; int is_clicked = nk_false; nk_flags state; @@ -18357,7 +19037,7 @@ nk_tree_state_base(struct nk_context *ctx, enum nk_tree_type type, struct nk_panel *layout; const struct nk_style *style; struct nk_command_buffer *out; - const struct nk_input *in; + struct nk_input *in; const struct nk_style_button *button; enum nk_symbol_type symbol; float row_height; @@ -18538,7 +19218,7 @@ nk_tree_element_image_push_hashed_base(struct nk_context *ctx, enum nk_tree_type struct nk_panel *layout; const struct nk_style *style; struct nk_command_buffer *out; - const struct nk_input *in; + struct nk_input *in; const struct nk_style_button *button; enum nk_symbol_type symbol; float row_height; @@ -18685,7 +19365,6 @@ nk_tree_element_pop(struct nk_context *ctx) - /* =============================================================== * * GROUP @@ -19747,7 +20426,7 @@ nk_draw_symbol(struct nk_command_buffer *out, enum nk_symbol_type type, } NK_LIB int nk_button_behavior(nk_flags *state, struct nk_rect r, - const struct nk_input *i, enum nk_button_behavior behavior) + struct nk_input *i, enum nk_button_behavior behavior) { int ret = 0; nk_widget_state_reset(state); @@ -19764,6 +20443,8 @@ nk_button_behavior(nk_flags *state, struct nk_rect r, #else nk_input_is_mouse_pressed(i, NK_BUTTON_LEFT); #endif + if (ret) + i->mouse.clicked = 1; } } if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(i, r)) @@ -19794,7 +20475,7 @@ nk_draw_button(struct nk_command_buffer *out, } NK_LIB int nk_do_button(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, - const struct nk_style_button *style, const struct nk_input *in, + const struct nk_style_button *style, struct nk_input *in, enum nk_button_behavior behavior, struct nk_rect *content) { struct nk_rect bounds; @@ -19844,7 +20525,7 @@ NK_LIB int nk_do_button_text(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *string, int len, nk_flags align, enum nk_button_behavior behavior, - const struct nk_style_button *style, const struct nk_input *in, + const struct nk_style_button *style, struct nk_input *in, const struct nk_user_font *font) { struct nk_rect content; @@ -19890,7 +20571,7 @@ NK_LIB int nk_do_button_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, enum nk_button_behavior behavior, - const struct nk_style_button *style, const struct nk_input *in, + const struct nk_style_button *style, struct nk_input *in, const struct nk_user_font *font) { int ret; @@ -19921,7 +20602,7 @@ NK_LIB int nk_do_button_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, enum nk_button_behavior b, - const struct nk_style_button *style, const struct nk_input *in) + const struct nk_style_button *style, struct nk_input *in) { int ret; struct nk_rect content; @@ -19981,7 +20662,7 @@ nk_do_button_text_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, const char *str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, - const struct nk_user_font *font, const struct nk_input *in) + const struct nk_user_font *font, struct nk_input *in) { int ret; struct nk_rect tri = {0,0,0,0}; @@ -20038,7 +20719,7 @@ nk_do_button_text_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, const char* str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, - const struct nk_user_font *font, const struct nk_input *in) + const struct nk_user_font *font, struct nk_input *in) { int ret; struct nk_rect icon; @@ -20120,7 +20801,7 @@ nk_button_text_styled(struct nk_context *ctx, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; @@ -20162,7 +20843,7 @@ nk_button_color(struct nk_context *ctx, struct nk_color color) { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_style_button button; int ret = 0; @@ -20198,7 +20879,7 @@ nk_button_symbol_styled(struct nk_context *ctx, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; @@ -20230,7 +20911,7 @@ nk_button_image_styled(struct nk_context *ctx, const struct nk_style_button *sty { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; @@ -20264,7 +20945,7 @@ nk_button_symbol_text_styled(struct nk_context *ctx, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; @@ -20311,7 +20992,7 @@ nk_button_image_text_styled(struct nk_context *ctx, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; @@ -20360,7 +21041,7 @@ NK_API int nk_button_image_label_styled(struct nk_context *ctx, * * ===============================================================*/ NK_LIB int -nk_toggle_behavior(const struct nk_input *in, struct nk_rect select, +nk_toggle_behavior(struct nk_input *in, struct nk_rect select, nk_flags *state, int active) { nk_widget_state_reset(state); @@ -20405,6 +21086,7 @@ nk_draw_checkbox(struct nk_command_buffer *out, nk_fill_rect(out, *selector, 0, style->border_color); nk_fill_rect(out, nk_shrink_rect(*selector, style->border), 0, background->data.color); } else nk_draw_image(out, *selector, &background->data.image, nk_white); + if (active) { if (cursor->type == NK_STYLE_ITEM_IMAGE) nk_draw_image(out, *cursors, &cursor->data.image, nk_white); @@ -20444,13 +21126,13 @@ nk_draw_option(struct nk_command_buffer *out, /* draw background and cursor */ if (background->type == NK_STYLE_ITEM_COLOR) { - nk_fill_circle(out, *selector, style->border_color); - nk_fill_circle(out, nk_shrink_rect(*selector, style->border), background->data.color); + nk_stroke_circle(out, *selector, 1, background->data.color); } else nk_draw_image(out, *selector, &background->data.image, nk_white); + if (active) { if (cursor->type == NK_STYLE_ITEM_IMAGE) nk_draw_image(out, *cursors, &cursor->data.image, nk_white); - else nk_fill_circle(out, *cursors, cursor->data.color); + else nk_fill_circle(out, *cursors, background->data.color); } text.padding.x = 0; @@ -20462,7 +21144,7 @@ NK_LIB int nk_do_toggle(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, int *active, const char *str, int len, enum nk_toggle_type type, - const struct nk_style_toggle *style, const struct nk_input *in, + const struct nk_style_toggle *style, struct nk_input *in, const struct nk_user_font *font) { int was_active; @@ -20530,7 +21212,7 @@ nk_check_text(struct nk_context *ctx, const char *text, int len, int active) { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; @@ -20625,7 +21307,7 @@ nk_option_text(struct nk_context *ctx, const char *text, int len, int is_active) { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; @@ -20732,7 +21414,7 @@ nk_draw_selectable(struct nk_command_buffer *out, NK_LIB int nk_do_selectable(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, - const struct nk_style_selectable *style, const struct nk_input *in, + const struct nk_style_selectable *style, struct nk_input *in, const struct nk_user_font *font) { int old_value; @@ -20769,7 +21451,7 @@ NK_LIB int nk_do_selectable_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_image *img, const struct nk_style_selectable *style, - const struct nk_input *in, const struct nk_user_font *font) + struct nk_input *in, const struct nk_user_font *font) { int old_value; struct nk_rect touch; @@ -20816,7 +21498,7 @@ NK_LIB int nk_do_selectable_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, enum nk_symbol_type sym, const struct nk_style_selectable *style, - const struct nk_input *in, const struct nk_user_font *font) + struct nk_input *in, const struct nk_user_font *font) { int old_value; struct nk_rect touch; @@ -20866,7 +21548,7 @@ nk_selectable_text(struct nk_context *ctx, const char *str, int len, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; enum nk_widget_layout_states state; @@ -20895,7 +21577,7 @@ nk_selectable_image_text(struct nk_context *ctx, struct nk_image img, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; enum nk_widget_layout_states state; @@ -20924,7 +21606,7 @@ nk_selectable_symbol_text(struct nk_context *ctx, enum nk_symbol_type sym, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; enum nk_widget_layout_states state; @@ -23536,7 +24218,7 @@ nk_edit_string_zero_terminated(struct nk_context *ctx, nk_flags flags, * * ===============================================================*/ NK_LIB void -nk_drag_behavior(nk_flags *state, const struct nk_input *in, +nk_drag_behavior(nk_flags *state, struct nk_input *in, struct nk_rect drag, struct nk_property_variant *variant, float inc_per_pixel) { @@ -23575,7 +24257,7 @@ nk_drag_behavior(nk_flags *state, const struct nk_input *in, *state |= NK_WIDGET_STATE_LEFT; } NK_LIB void -nk_property_behavior(nk_flags *ws, const struct nk_input *in, +nk_property_behavior(nk_flags *ws, struct nk_input *in, struct nk_rect property, struct nk_rect label, struct nk_rect edit, struct nk_rect empty, int *state, struct nk_property_variant *variant, float inc_per_pixel) @@ -24132,7 +24814,7 @@ nk_chart_push_line(struct nk_context *ctx, struct nk_window *win, struct nk_chart *g, float value, int slot) { struct nk_panel *layout = win->layout; - const struct nk_input *i = &ctx->input; + struct nk_input *i = &ctx->input; struct nk_command_buffer *out = &win->buffer; nk_flags ret = 0; @@ -24354,7 +25036,7 @@ NK_LIB int nk_color_picker_behavior(nk_flags *state, const struct nk_rect *bounds, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, - struct nk_colorf *color, const struct nk_input *in) + struct nk_colorf *color, struct nk_input *in) { float hsva[4]; int value_changed = 0; @@ -24465,7 +25147,7 @@ NK_LIB int nk_do_color_picker(nk_flags *state, struct nk_command_buffer *out, struct nk_colorf *col, enum nk_color_format fmt, struct nk_rect bounds, - struct nk_vec2 padding, const struct nk_input *in, + struct nk_vec2 padding, struct nk_input *in, const struct nk_user_font *font) { int ret = 0; @@ -24514,7 +25196,7 @@ nk_color_pick(struct nk_context * ctx, struct nk_colorf *color, struct nk_window *win; struct nk_panel *layout; const struct nk_style *config; - const struct nk_input *in; + struct nk_input *in; enum nk_widget_layout_states state; struct nk_rect bounds; @@ -24590,7 +25272,7 @@ NK_API int nk_combo_begin_text(struct nk_context *ctx, const char *selected, int len, struct nk_vec2 size) { - const struct nk_input *in; + struct nk_input *in; struct nk_window *win; struct nk_style *style; @@ -24685,7 +25367,7 @@ nk_combo_begin_color(struct nk_context *ctx, struct nk_color color, struct nk_ve { struct nk_window *win; struct nk_style *style; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; @@ -24762,7 +25444,7 @@ nk_combo_begin_symbol(struct nk_context *ctx, enum nk_symbol_type symbol, struct { struct nk_window *win; struct nk_style *style; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; @@ -24945,7 +25627,7 @@ nk_combo_begin_image(struct nk_context *ctx, struct nk_image img, struct nk_vec2 { struct nk_window *win; struct nk_style *style; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; @@ -25321,7 +26003,7 @@ nk_tooltip_begin(struct nk_context *ctx, float width) { int x,y,w,h; struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; int ret; @@ -25476,6 +26158,14 @@ nk_tooltipfv(struct nk_context *ctx, const char *fmt, va_list args) /// - [yy]: Minor version with non-breaking API and library changes /// - [zz]: Bug fix version with no direct changes to API /// +/// - 2020/01/19 (4.01.10) - Added subpixel API from itsuhane. Allowing you to turn on +// NK_ENABLE_SUBPIXEL_API to position window and elements in subpixels +/// - 2019/12/23 (4.01.9) - Changed nk_begin to return a nk_window so you can get the position and other useful info. +/// - 2019/12/05 (4.01.8) - Fixed radio buttons' style. +/// - 2019/12/05 (4.01.7) - Fixed click cascading through multiple buttons; it should only click the upper button. +/// - 2019/12/11 (4.01.6) - Strict c++17 now compiles: only declaring memset, memcpy if they are used. +/// Only asserting index range if ushorts are used for indices. +/// Made paq.sh identical to paq.bat (outputs to nuklear.h). /// - 2019/12/10 (4.01.5) - Fix off-by-one error in NK_INTERSECT /// - 2019/10/09 (4.01.4) - Fix bug for autoscrolling in nk_do_edit /// - 2019/09/20 (4.01.3) - Fixed a bug wherein combobox cannot be closed by clicking the header diff --git a/package.json b/package.json index 27d698731..f73d73911 100644 --- a/package.json +++ b/package.json @@ -1,8 +1,14 @@ { "name": "nuklear", - "version": "4.01.5", + "version": "4.01.10", "repo": "Immediate-Mode-UI/Nuklear", "description": "A small ANSI C gui toolkit", - "keywords": ["gl", "ui", "toolkit"], - "src": ["nuklear.h"] + "keywords": [ + "gl", + "ui", + "toolkit" + ], + "src": [ + "nuklear.h" + ] } diff --git a/src/CHANGELOG b/src/CHANGELOG index 05a65d80c..d4879a616 100644 --- a/src/CHANGELOG +++ b/src/CHANGELOG @@ -8,6 +8,14 @@ /// - [yy]: Minor version with non-breaking API and library changes /// - [zz]: Bug fix version with no direct changes to API /// +/// - 2020/01/19 (4.01.10) - Added subpixel API from itsuhane. Allowing you to turn on +// NK_ENABLE_SUBPIXEL_API to position window and elements in subpixels +/// - 2019/12/23 (4.01.9) - Changed nk_begin to return a nk_window so you can get the position and other useful info. +/// - 2019/12/05 (4.01.8) - Fixed radio buttons' style. +/// - 2019/12/05 (4.01.7) - Fixed click cascading through multiple buttons; it should only click the upper button. +/// - 2019/12/11 (4.01.6) - Strict c++17 now compiles: only declaring memset, memcpy if they are used. +/// Only asserting index range if ushorts are used for indices. +/// Made paq.sh identical to paq.bat (outputs to nuklear.h). /// - 2019/12/10 (4.01.5) - Fix off-by-one error in NK_INTERSECT /// - 2019/10/09 (4.01.4) - Fix bug for autoscrolling in nk_do_edit /// - 2019/09/20 (4.01.3) - Fixed a bug wherein combobox cannot be closed by clicking the header diff --git a/src/Readme.md b/src/Readme.md index 6a6f284ef..052906ceb 100644 --- a/src/Readme.md +++ b/src/Readme.md @@ -1,5 +1,5 @@ File Packer: ------------ - [Click to generate nuklear.h](http://apoorvaj.io/single-header-packer.html?macro=NK&pre=https://raw.githubusercontent.com/vurtun/nuklear/master/src/HEADER&pub=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear.h&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_internal.h&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_math.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_util.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_color.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_utf8.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_buffer.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_string.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_draw.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_vertex.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_font.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_input.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_style.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_context.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_pool.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_page_element.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_table.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_panel.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_window.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_popup.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_contextual.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_menu.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_layout.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_tree.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_group.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_list_view.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_widget.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_text.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_image.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_button.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_toggle.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_selectable.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_slider.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_progress.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_scrollbar.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_text_editor.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_edit.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_property.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_chart.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_color_picker.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_combo.c&priv=https://raw.githubusercontent.com/vurtun/nuklear/master/src/nuklear_tooltip.c&post=https://raw.githubusercontent.com/vurtun/nuklear/master/src/LICENSE&post=https://raw.githubusercontent.com/vurtun/nuklear/master/src/CHANGELOG&post=https://raw.githubusercontent.com/vurtun/nuklear/master/src/CREDITS) -- On Linux/Mac just run ./paq > ../nuklear.h +- On Linux/Mac just run ./paq.sh - On Windows just run paq.bat diff --git a/src/build.py b/src/build.py index aec4e2271..f0524b26b 100644 --- a/src/build.py +++ b/src/build.py @@ -1,7 +1,9 @@ import fnmatch import os.path -import sys +import sys, io + +sys.stdout = io.TextIOWrapper(sys.stdout.buffer, newline='\n' ) def print_help(): print( diff --git a/src/nuklear.h b/src/nuklear.h index 2a9f45d62..b76459254 100644 --- a/src/nuklear.h +++ b/src/nuklear.h @@ -203,6 +203,11 @@ NK_STATIC_ASSERT(sizeof(nk_rune) >= 4); NK_STATIC_ASSERT(sizeof(nk_size) >= sizeof(void*)); NK_STATIC_ASSERT(sizeof(nk_ptr) >= sizeof(void*)); +/* Sub-pixel API can be enabled by defining following macro. + * This will allow drawing in subpixel precision, + * but will increase memory footprint. */ +/* #define NK_ENABLE_SUBPIXEL_API */ + /* ============================================================================ * * API @@ -247,6 +252,16 @@ struct nk_image {nk_handle handle;unsigned short w,h;unsigned short region[4];}; struct nk_cursor {struct nk_image img; struct nk_vec2 size, offset;}; struct nk_scroll {nk_uint x, y;}; +#ifdef NK_ENABLE_SUBPIXEL_API +typedef float nk_scalar_cmd; +typedef float nk_unsigned_scalar_cmd; +typedef struct nk_vec2 nk_vec2_cmd; +#else +typedef short nk_scalar_cmd; +typedef unsigned short nk_unsigned_scalar_cmd; +typedef struct nk_vec2i nk_vec2_cmd; +#endif + enum nk_heading {NK_UP, NK_RIGHT, NK_DOWN, NK_LEFT}; enum nk_button_behavior {NK_BUTTON_DEFAULT, NK_BUTTON_REPEATER}; enum nk_modify {NK_FIXED = nk_false, NK_MODIFIABLE = nk_true}; @@ -1256,10 +1271,10 @@ enum nk_panel_flags { /// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame /// __flags__ | Window flags defined in the nk_panel_flags section with a number of different window behaviors /// -/// Returns `true(1)` if the window can be filled up with widgets from this point -/// until `nk_end` or `false(0)` otherwise for example if minimized +/// Returns a non-zero window pointer if the window can be filled up with widgets from this point +/// until `nk_end` or `nullptr(0)` otherwise for example if minimized */ -NK_API int nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bounds, nk_flags flags); +NK_API struct nk_window* nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bounds, nk_flags flags); /*/// #### nk_begin_titled /// Extended window start with separated title and identifier to allow multiple /// windows with same title but not name @@ -1276,10 +1291,53 @@ NK_API int nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bo /// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame /// __flags__ | Window flags defined in the nk_panel_flags section with a number of different window behaviors /// -/// Returns `true(1)` if the window can be filled up with widgets from this point -/// until `nk_end` or `false(0)` otherwise for example if minimized +/// Returns a non-zero window pointer if the window can be filled up with widgets from this point +/// until `nk_end` or `nullptr(0)` otherwise for example if minimized +*/ +NK_API struct nk_window* nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_rect bounds, nk_flags flags); +/*/// #### nk_add_window +/// Adds a new window; needs to be called every frame for every +/// window (unless hidden) or otherwise the window gets removed +/// it always returns a window pointer, even if the window is hidden or removed +/// this function allows the application to query state and perform the necessary updates +/// to get the same functionality as nk_begin, you should query the following states: +/// - NK_WINDOW_CLOSED +/// - NK_WINDOW_HIDDEN +/// - NK_WINDOW_MINIMIZED +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_add_window(struct nk_context *ctx, nk_hash id, const char *title, struct nk_rect bounds, nk_flags flags); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ------------|----------------------------------------------------------- +/// __ctx__ | Must point to an previously initialized `nk_context` struct +/// __id__ | The id of the window; unique and needs to be persistent over frames to identify the window +/// __title__ | Window title. +/// __bounds__ | Initial position and window size. However if you do not define `NK_WINDOW_SCALABLE` or `NK_WINDOW_MOVABLE` you can set window position and size every frame +/// __flags__ | Window flags defined in the nk_panel_flags section with a number of different window behaviors +/// +/// Returns a non-zero window pointer if the window can be created +/// call nk_window_has_contents(ctx, window) to see if window can be filled up with widgets from this point +*/ +NK_API struct nk_window* nk_add_window(struct nk_context *ctx, nk_hash id, const char *title, struct nk_rect bounds, nk_flags flags); +/*/// #### nk_window_has_contents +/// Checks if the window is ready to be filled up +/// generally used after nk_add_window(_titled) +/// to check if window can be filled up with widgets from this point +/// +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~c +/// int nk_window_has_contents(struct nk_window *window); +/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// +/// Parameter | Description +/// ---------------|----------------------------------------------------------- +/// __nk_window__ | The window to check +/// +/// Returns true(1) if the window's contents are visible +/// false(0) otherwise */ -NK_API int nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_rect bounds, nk_flags flags); +NK_API int nk_window_has_contents(struct nk_window *window); /*/// #### nk_end /// Needs to be called at the end of the window building process to process scaling, scrollbars and general cleanup. /// All widget calls after this functions will result in asserts or no state changes @@ -4185,48 +4243,48 @@ struct nk_command { struct nk_command_scissor { struct nk_command header; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; }; struct nk_command_line { struct nk_command header; - unsigned short line_thickness; - struct nk_vec2i begin; - struct nk_vec2i end; + nk_unsigned_scalar_cmd line_thickness; + nk_vec2_cmd begin; + nk_vec2_cmd end; struct nk_color color; }; struct nk_command_curve { struct nk_command header; - unsigned short line_thickness; - struct nk_vec2i begin; - struct nk_vec2i end; - struct nk_vec2i ctrl[2]; + nk_unsigned_scalar_cmd line_thickness; + nk_vec2_cmd begin; + nk_vec2_cmd end; + nk_vec2_cmd ctrl[2]; struct nk_color color; }; struct nk_command_rect { struct nk_command header; - unsigned short rounding; - unsigned short line_thickness; - short x, y; - unsigned short w, h; + nk_unsigned_scalar_cmd rounding; + nk_unsigned_scalar_cmd line_thickness; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_color color; }; struct nk_command_rect_filled { struct nk_command header; - unsigned short rounding; - short x, y; - unsigned short w, h; + nk_unsigned_scalar_cmd rounding; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_color color; }; struct nk_command_rect_multi_color { struct nk_command header; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_color left; struct nk_color top; struct nk_color bottom; @@ -4235,49 +4293,49 @@ struct nk_command_rect_multi_color { struct nk_command_triangle { struct nk_command header; - unsigned short line_thickness; - struct nk_vec2i a; - struct nk_vec2i b; - struct nk_vec2i c; + nk_unsigned_scalar_cmd line_thickness; + nk_vec2_cmd a; + nk_vec2_cmd b; + nk_vec2_cmd c; struct nk_color color; }; struct nk_command_triangle_filled { struct nk_command header; - struct nk_vec2i a; - struct nk_vec2i b; - struct nk_vec2i c; + nk_vec2_cmd a; + nk_vec2_cmd b; + nk_vec2_cmd c; struct nk_color color; }; struct nk_command_circle { struct nk_command header; - short x, y; - unsigned short line_thickness; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd line_thickness; + nk_unsigned_scalar_cmd w, h; struct nk_color color; }; struct nk_command_circle_filled { struct nk_command header; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_color color; }; struct nk_command_arc { struct nk_command header; - short cx, cy; - unsigned short r; - unsigned short line_thickness; + nk_scalar_cmd cx, cy; + nk_unsigned_scalar_cmd r; + nk_unsigned_scalar_cmd line_thickness; float a[2]; struct nk_color color; }; struct nk_command_arc_filled { struct nk_command header; - short cx, cy; - unsigned short r; + nk_scalar_cmd cx, cy; + nk_unsigned_scalar_cmd r; float a[2]; struct nk_color color; }; @@ -4285,30 +4343,30 @@ struct nk_command_arc_filled { struct nk_command_polygon { struct nk_command header; struct nk_color color; - unsigned short line_thickness; + nk_unsigned_scalar_cmd line_thickness; unsigned short point_count; - struct nk_vec2i points[1]; + nk_vec2_cmd points[1]; }; struct nk_command_polygon_filled { struct nk_command header; struct nk_color color; unsigned short point_count; - struct nk_vec2i points[1]; + nk_vec2_cmd points[1]; }; struct nk_command_polyline { struct nk_command header; struct nk_color color; - unsigned short line_thickness; + nk_unsigned_scalar_cmd line_thickness; unsigned short point_count; - struct nk_vec2i points[1]; + nk_vec2_cmd points[1]; }; struct nk_command_image { struct nk_command header; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; struct nk_image img; struct nk_color col; }; @@ -4328,8 +4386,8 @@ struct nk_command_text { const struct nk_user_font *font; struct nk_color background; struct nk_color foreground; - short x, y; - unsigned short w, h; + nk_scalar_cmd x, y; + nk_unsigned_scalar_cmd w, h; float height; int length; char string[1]; @@ -4372,6 +4430,29 @@ NK_API void nk_draw_text(struct nk_command_buffer*, struct nk_rect, const char * NK_API void nk_push_scissor(struct nk_command_buffer*, struct nk_rect); NK_API void nk_push_custom(struct nk_command_buffer*, struct nk_rect, nk_command_custom_callback, nk_handle usr); +/* subpixel APIs */ +#ifdef NK_ENABLE_SUBPIXEL_API +NK_API void nk_stroke_line_subpixel(struct nk_command_buffer *b, float x0, float y0, float x1, float y1, float line_thickness, struct nk_color); +NK_API void nk_stroke_curve_subpixel(struct nk_command_buffer*, float, float, float, float, float, float, float, float, float line_thickness, struct nk_color); +NK_API void nk_stroke_rect_subpixel(struct nk_command_buffer*, struct nk_rect, float rounding, float line_thickness, struct nk_color); +NK_API void nk_stroke_circle_subpixel(struct nk_command_buffer*, struct nk_rect, float line_thickness, struct nk_color); +NK_API void nk_stroke_arc_subpixel(struct nk_command_buffer*, float cx, float cy, float radius, float a_min, float a_max, float line_thickness, struct nk_color); +NK_API void nk_stroke_triangle_subpixel(struct nk_command_buffer*, float, float, float, float, float, float, float line_thichness, struct nk_color); +NK_API void nk_stroke_polyline_subpixel(struct nk_command_buffer*, float *points, int point_count, float line_thickness, struct nk_color col); +NK_API void nk_stroke_polygon_subpixel(struct nk_command_buffer*, float*, int point_count, float line_thickness, struct nk_color); + +NK_API void nk_fill_rect_subpixel(struct nk_command_buffer*, struct nk_rect, float rounding, struct nk_color); +NK_API void nk_fill_rect_multi_color_subpixel(struct nk_command_buffer*, struct nk_rect, struct nk_color left, struct nk_color top, struct nk_color right, struct nk_color bottom); +NK_API void nk_fill_circle_subpixel(struct nk_command_buffer*, struct nk_rect, struct nk_color); +NK_API void nk_fill_arc_subpixel(struct nk_command_buffer*, float cx, float cy, float radius, float a_min, float a_max, struct nk_color); +NK_API void nk_fill_triangle_subpixel(struct nk_command_buffer*, float x0, float y0, float x1, float y1, float x2, float y2, struct nk_color); +NK_API void nk_fill_polygon_subpixel(struct nk_command_buffer*, float*, int point_count, struct nk_color); + +NK_API void nk_draw_image_subpixel(struct nk_command_buffer*, struct nk_rect, const struct nk_image*, struct nk_color); +NK_API void nk_draw_text_subpixel(struct nk_command_buffer*, struct nk_rect, const char *text, int len, const struct nk_user_font*, struct nk_color, struct nk_color); +NK_API void nk_push_scissor_subpixel(struct nk_command_buffer*, struct nk_rect); +#endif + /* =============================================================== * * INPUT @@ -4391,6 +4472,7 @@ struct nk_mouse { unsigned char grab; unsigned char grabbed; unsigned char ungrab; + unsigned char clicked; }; struct nk_key { diff --git a/src/nuklear_button.c b/src/nuklear_button.c index e40b2526e..de2a7788d 100644 --- a/src/nuklear_button.c +++ b/src/nuklear_button.c @@ -61,7 +61,7 @@ nk_draw_symbol(struct nk_command_buffer *out, enum nk_symbol_type type, } NK_LIB int nk_button_behavior(nk_flags *state, struct nk_rect r, - const struct nk_input *i, enum nk_button_behavior behavior) + struct nk_input *i, enum nk_button_behavior behavior) { int ret = 0; nk_widget_state_reset(state); @@ -78,6 +78,8 @@ nk_button_behavior(nk_flags *state, struct nk_rect r, #else nk_input_is_mouse_pressed(i, NK_BUTTON_LEFT); #endif + if (ret) + i->mouse.clicked = 1; } } if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(i, r)) @@ -108,7 +110,7 @@ nk_draw_button(struct nk_command_buffer *out, } NK_LIB int nk_do_button(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, - const struct nk_style_button *style, const struct nk_input *in, + const struct nk_style_button *style, struct nk_input *in, enum nk_button_behavior behavior, struct nk_rect *content) { struct nk_rect bounds; @@ -158,7 +160,7 @@ NK_LIB int nk_do_button_text(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *string, int len, nk_flags align, enum nk_button_behavior behavior, - const struct nk_style_button *style, const struct nk_input *in, + const struct nk_style_button *style, struct nk_input *in, const struct nk_user_font *font) { struct nk_rect content; @@ -204,7 +206,7 @@ NK_LIB int nk_do_button_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, enum nk_button_behavior behavior, - const struct nk_style_button *style, const struct nk_input *in, + const struct nk_style_button *style, struct nk_input *in, const struct nk_user_font *font) { int ret; @@ -235,7 +237,7 @@ NK_LIB int nk_do_button_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, enum nk_button_behavior b, - const struct nk_style_button *style, const struct nk_input *in) + const struct nk_style_button *style, struct nk_input *in) { int ret; struct nk_rect content; @@ -295,7 +297,7 @@ nk_do_button_text_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, const char *str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, - const struct nk_user_font *font, const struct nk_input *in) + const struct nk_user_font *font, struct nk_input *in) { int ret; struct nk_rect tri = {0,0,0,0}; @@ -352,7 +354,7 @@ nk_do_button_text_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, const char* str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, - const struct nk_user_font *font, const struct nk_input *in) + const struct nk_user_font *font, struct nk_input *in) { int ret; struct nk_rect icon; @@ -434,7 +436,7 @@ nk_button_text_styled(struct nk_context *ctx, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; @@ -476,7 +478,7 @@ nk_button_color(struct nk_context *ctx, struct nk_color color) { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_style_button button; int ret = 0; @@ -512,7 +514,7 @@ nk_button_symbol_styled(struct nk_context *ctx, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; @@ -544,7 +546,7 @@ nk_button_image_styled(struct nk_context *ctx, const struct nk_style_button *sty { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; @@ -578,7 +580,7 @@ nk_button_symbol_text_styled(struct nk_context *ctx, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; @@ -625,7 +627,7 @@ nk_button_image_text_styled(struct nk_context *ctx, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; enum nk_widget_layout_states state; diff --git a/src/nuklear_chart.c b/src/nuklear_chart.c index bb5574f7a..acb6e9661 100644 --- a/src/nuklear_chart.c +++ b/src/nuklear_chart.c @@ -107,7 +107,7 @@ nk_chart_push_line(struct nk_context *ctx, struct nk_window *win, struct nk_chart *g, float value, int slot) { struct nk_panel *layout = win->layout; - const struct nk_input *i = &ctx->input; + struct nk_input *i = &ctx->input; struct nk_command_buffer *out = &win->buffer; nk_flags ret = 0; diff --git a/src/nuklear_color_picker.c b/src/nuklear_color_picker.c index 719748785..2b55355c5 100644 --- a/src/nuklear_color_picker.c +++ b/src/nuklear_color_picker.c @@ -10,7 +10,7 @@ NK_LIB int nk_color_picker_behavior(nk_flags *state, const struct nk_rect *bounds, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, - struct nk_colorf *color, const struct nk_input *in) + struct nk_colorf *color, struct nk_input *in) { float hsva[4]; int value_changed = 0; @@ -121,7 +121,7 @@ NK_LIB int nk_do_color_picker(nk_flags *state, struct nk_command_buffer *out, struct nk_colorf *col, enum nk_color_format fmt, struct nk_rect bounds, - struct nk_vec2 padding, const struct nk_input *in, + struct nk_vec2 padding, struct nk_input *in, const struct nk_user_font *font) { int ret = 0; @@ -170,7 +170,7 @@ nk_color_pick(struct nk_context * ctx, struct nk_colorf *color, struct nk_window *win; struct nk_panel *layout; const struct nk_style *config; - const struct nk_input *in; + struct nk_input *in; enum nk_widget_layout_states state; struct nk_rect bounds; diff --git a/src/nuklear_combo.c b/src/nuklear_combo.c index 26bf7e93e..1592d8ca3 100644 --- a/src/nuklear_combo.c +++ b/src/nuklear_combo.c @@ -44,7 +44,7 @@ NK_API int nk_combo_begin_text(struct nk_context *ctx, const char *selected, int len, struct nk_vec2 size) { - const struct nk_input *in; + struct nk_input *in; struct nk_window *win; struct nk_style *style; @@ -139,7 +139,7 @@ nk_combo_begin_color(struct nk_context *ctx, struct nk_color color, struct nk_ve { struct nk_window *win; struct nk_style *style; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; @@ -216,7 +216,7 @@ nk_combo_begin_symbol(struct nk_context *ctx, enum nk_symbol_type symbol, struct { struct nk_window *win; struct nk_style *style; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; @@ -399,7 +399,7 @@ nk_combo_begin_image(struct nk_context *ctx, struct nk_image img, struct nk_vec2 { struct nk_window *win; struct nk_style *style; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; diff --git a/src/nuklear_contextual.c b/src/nuklear_contextual.c index 5c88c2e2c..50202d76c 100644 --- a/src/nuklear_contextual.c +++ b/src/nuklear_contextual.c @@ -70,7 +70,7 @@ nk_contextual_item_text(struct nk_context *ctx, const char *text, int len, nk_flags alignment) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; @@ -105,7 +105,7 @@ nk_contextual_item_image_text(struct nk_context *ctx, struct nk_image img, const char *text, int len, nk_flags align) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; @@ -141,7 +141,7 @@ nk_contextual_item_symbol_text(struct nk_context *ctx, enum nk_symbol_type symbo const char *text, int len, nk_flags align) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; diff --git a/src/nuklear_draw.c b/src/nuklear_draw.c index ae01ea6df..a5937adfd 100644 --- a/src/nuklear_draw.c +++ b/src/nuklear_draw.c @@ -338,7 +338,7 @@ nk_stroke_polygon(struct nk_command_buffer *b, float *points, int point_count, NK_ASSERT(b); if (!b || col.a == 0 || line_thickness <= 0) return; - size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; cmd = (struct nk_command_polygon*) nk_command_buffer_push(b, NK_COMMAND_POLYGON, size); if (!cmd) return; cmd->color = col; @@ -359,7 +359,7 @@ nk_fill_polygon(struct nk_command_buffer *b, float *points, int point_count, NK_ASSERT(b); if (!b || col.a == 0) return; - size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; cmd = (struct nk_command_polygon_filled*) nk_command_buffer_push(b, NK_COMMAND_POLYGON_FILLED, size); if (!cmd) return; @@ -380,7 +380,7 @@ nk_stroke_polyline(struct nk_command_buffer *b, float *points, int point_count, NK_ASSERT(b); if (!b || col.a == 0 || line_thickness <= 0) return; - size = sizeof(*cmd) + sizeof(short) * 2 * (nk_size)point_count; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; cmd = (struct nk_command_polyline*) nk_command_buffer_push(b, NK_COMMAND_POLYLINE, size); if (!cmd) return; cmd->color = col; @@ -479,3 +479,397 @@ nk_draw_text(struct nk_command_buffer *b, struct nk_rect r, cmd->string[length] = '\0'; } +#ifdef NK_ENABLE_SUBPIXEL_API + +NK_API void +nk_push_scissor_subpixel(struct nk_command_buffer *b, struct nk_rect r) +{ + struct nk_command_scissor *cmd; + NK_ASSERT(b); + if (!b) return; + + b->clip.x = r.x; + b->clip.y = r.y; + b->clip.w = r.w; + b->clip.h = r.h; + cmd = (struct nk_command_scissor*) + nk_command_buffer_push(b, NK_COMMAND_SCISSOR, sizeof(*cmd)); + + if (!cmd) return; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = NK_MAX(0, r.w); + cmd->h = NK_MAX(0, r.h); +} +NK_API void +nk_stroke_line_subpixel(struct nk_command_buffer *b, float x0, float y0, + float x1, float y1, float line_thickness, struct nk_color c) +{ + struct nk_command_line *cmd; + NK_ASSERT(b); + if (!b || line_thickness <= 0) return; + cmd = (struct nk_command_line*) + nk_command_buffer_push(b, NK_COMMAND_LINE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->begin.x = x0; + cmd->begin.y = y0; + cmd->end.x = x1; + cmd->end.y = y1; + cmd->color = c; +} +NK_API void +nk_stroke_curve_subpixel(struct nk_command_buffer *b, float ax, float ay, + float ctrl0x, float ctrl0y, float ctrl1x, float ctrl1y, + float bx, float by, float line_thickness, struct nk_color col) +{ + struct nk_command_curve *cmd; + NK_ASSERT(b); + if (!b || col.a == 0 || line_thickness <= 0) return; + + cmd = (struct nk_command_curve*) + nk_command_buffer_push(b, NK_COMMAND_CURVE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->begin.x = ax; + cmd->begin.y = ay; + cmd->ctrl[0].x = ctrl0x; + cmd->ctrl[0].y = ctrl0y; + cmd->ctrl[1].x = ctrl1x; + cmd->ctrl[1].y = ctrl1y; + cmd->end.x = bx; + cmd->end.y = by; + cmd->color = col; +} +NK_API void +nk_stroke_rect_subpixel(struct nk_command_buffer *b, struct nk_rect rect, + float rounding, float line_thickness, struct nk_color c) +{ + struct nk_command_rect *cmd; + NK_ASSERT(b); + if (!b || c.a == 0 || rect.w == 0 || rect.h == 0 || line_thickness <= 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + clip->x, clip->y, clip->w, clip->h)) return; + } + cmd = (struct nk_command_rect*) + nk_command_buffer_push(b, NK_COMMAND_RECT, sizeof(*cmd)); + if (!cmd) return; + cmd->rounding = rounding; + cmd->line_thickness = line_thickness; + cmd->x = rect.x; + cmd->y = rect.y; + cmd->w = NK_MAX(0, rect.w); + cmd->h = NK_MAX(0, rect.h); + cmd->color = c; +} +NK_API void +nk_fill_rect_subpixel(struct nk_command_buffer *b, struct nk_rect rect, + float rounding, struct nk_color c) +{ + struct nk_command_rect_filled *cmd; + NK_ASSERT(b); + if (!b || c.a == 0 || rect.w == 0 || rect.h == 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + clip->x, clip->y, clip->w, clip->h)) return; + } + + cmd = (struct nk_command_rect_filled*) + nk_command_buffer_push(b, NK_COMMAND_RECT_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->rounding = rounding; + cmd->x = rect.x; + cmd->y = rect.y; + cmd->w = NK_MAX(0, rect.w); + cmd->h = NK_MAX(0, rect.h); + cmd->color = c; +} +NK_API void +nk_fill_rect_multi_color_subpixel(struct nk_command_buffer *b, struct nk_rect rect, + struct nk_color left, struct nk_color top, struct nk_color right, + struct nk_color bottom) +{ + struct nk_command_rect_multi_color *cmd; + NK_ASSERT(b); + if (!b || rect.w == 0 || rect.h == 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(rect.x, rect.y, rect.w, rect.h, + clip->x, clip->y, clip->w, clip->h)) return; + } + + cmd = (struct nk_command_rect_multi_color*) + nk_command_buffer_push(b, NK_COMMAND_RECT_MULTI_COLOR, sizeof(*cmd)); + if (!cmd) return; + cmd->x = rect.x; + cmd->y = rect.y; + cmd->w = NK_MAX(0, rect.w); + cmd->h = NK_MAX(0, rect.h); + cmd->left = left; + cmd->top = top; + cmd->right = right; + cmd->bottom = bottom; +} +NK_API void +nk_stroke_circle_subpixel(struct nk_command_buffer *b, struct nk_rect r, + float line_thickness, struct nk_color c) +{ + struct nk_command_circle *cmd; + if (!b || r.w == 0 || r.h == 0 || line_thickness <= 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(r.x, r.y, r.w, r.h, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_circle*) + nk_command_buffer_push(b, NK_COMMAND_CIRCLE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = NK_MAX(r.w, 0); + cmd->h = NK_MAX(r.h, 0); + cmd->color = c; +} +NK_API void +nk_fill_circle_subpixel(struct nk_command_buffer *b, struct nk_rect r, struct nk_color c) +{ + struct nk_command_circle_filled *cmd; + NK_ASSERT(b); + if (!b || c.a == 0 || r.w == 0 || r.h == 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INTERSECT(r.x, r.y, r.w, r.h, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_circle_filled*) + nk_command_buffer_push(b, NK_COMMAND_CIRCLE_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = NK_MAX(r.w, 0); + cmd->h = NK_MAX(r.h, 0); + cmd->color = c; +} +NK_API void +nk_stroke_arc_subpixel(struct nk_command_buffer *b, float cx, float cy, float radius, + float a_min, float a_max, float line_thickness, struct nk_color c) +{ + struct nk_command_arc *cmd; + if (!b || c.a == 0 || line_thickness <= 0) return; + cmd = (struct nk_command_arc*) + nk_command_buffer_push(b, NK_COMMAND_ARC, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->cx = cx; + cmd->cy = cy; + cmd->r = radius; + cmd->a[0] = a_min; + cmd->a[1] = a_max; + cmd->color = c; +} +NK_API void +nk_fill_arc_subpixel(struct nk_command_buffer *b, float cx, float cy, float radius, + float a_min, float a_max, struct nk_color c) +{ + struct nk_command_arc_filled *cmd; + NK_ASSERT(b); + if (!b || c.a == 0) return; + cmd = (struct nk_command_arc_filled*) + nk_command_buffer_push(b, NK_COMMAND_ARC_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->cx = cx; + cmd->cy = cy; + cmd->r = radius; + cmd->a[0] = a_min; + cmd->a[1] = a_max; + cmd->color = c; +} +NK_API void +nk_stroke_triangle_subpixel(struct nk_command_buffer *b, float x0, float y0, float x1, + float y1, float x2, float y2, float line_thickness, struct nk_color c) +{ + struct nk_command_triangle *cmd; + NK_ASSERT(b); + if (!b || c.a == 0 || line_thickness <= 0) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INBOX(x0, y0, clip->x, clip->y, clip->w, clip->h) && + !NK_INBOX(x1, y1, clip->x, clip->y, clip->w, clip->h) && + !NK_INBOX(x2, y2, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_triangle*) + nk_command_buffer_push(b, NK_COMMAND_TRIANGLE, sizeof(*cmd)); + if (!cmd) return; + cmd->line_thickness = line_thickness; + cmd->a.x = x0; + cmd->a.y = y0; + cmd->b.x = x1; + cmd->b.y = y1; + cmd->c.x = x2; + cmd->c.y = y2; + cmd->color = c; +} +NK_API void +nk_fill_triangle_subpixel(struct nk_command_buffer *b, float x0, float y0, float x1, + float y1, float x2, float y2, struct nk_color c) +{ + struct nk_command_triangle_filled *cmd; + NK_ASSERT(b); + if (!b || c.a == 0) return; + if (!b) return; + if (b->use_clipping) { + const struct nk_rect *clip = &b->clip; + if (!NK_INBOX(x0, y0, clip->x, clip->y, clip->w, clip->h) && + !NK_INBOX(x1, y1, clip->x, clip->y, clip->w, clip->h) && + !NK_INBOX(x2, y2, clip->x, clip->y, clip->w, clip->h)) + return; + } + + cmd = (struct nk_command_triangle_filled*) + nk_command_buffer_push(b, NK_COMMAND_TRIANGLE_FILLED, sizeof(*cmd)); + if (!cmd) return; + cmd->a.x = x0; + cmd->a.y = y0; + cmd->b.x = x1; + cmd->b.y = y1; + cmd->c.x = x2; + cmd->c.y = y2; + cmd->color = c; +} +NK_API void +nk_stroke_polygon_subpixel(struct nk_command_buffer *b, float *points, int point_count, + float line_thickness, struct nk_color col) +{ + int i; + nk_size size = 0; + struct nk_command_polygon *cmd; + + NK_ASSERT(b); + if (!b || col.a == 0 || line_thickness <= 0) return; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; + cmd = (struct nk_command_polygon*) nk_command_buffer_push(b, NK_COMMAND_POLYGON, size); + if (!cmd) return; + cmd->color = col; + cmd->line_thickness = line_thickness; + cmd->point_count = (unsigned short)point_count; + for (i = 0; i < point_count; ++i) { + cmd->points[i].x = points[i*2]; + cmd->points[i].y = points[i*2+1]; + } +} +NK_API void +nk_fill_polygon_subpixel(struct nk_command_buffer *b, float *points, int point_count, + struct nk_color col) +{ + int i; + nk_size size = 0; + struct nk_command_polygon_filled *cmd; + + NK_ASSERT(b); + if (!b || col.a == 0) return; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; + cmd = (struct nk_command_polygon_filled*) + nk_command_buffer_push(b, NK_COMMAND_POLYGON_FILLED, size); + if (!cmd) return; + cmd->color = col; + cmd->point_count = (unsigned short)point_count; + for (i = 0; i < point_count; ++i) { + cmd->points[i].x = points[i*2+0]; + cmd->points[i].y = points[i*2+1]; + } +} +NK_API void +nk_stroke_polyline_subpixel(struct nk_command_buffer *b, float *points, int point_count, + float line_thickness, struct nk_color col) +{ + int i; + nk_size size = 0; + struct nk_command_polyline *cmd; + + NK_ASSERT(b); + if (!b || col.a == 0 || line_thickness <= 0) return; + size = sizeof(*cmd) + sizeof(nk_scalar_cmd) * 2 * (nk_size)point_count; + cmd = (struct nk_command_polyline*) nk_command_buffer_push(b, NK_COMMAND_POLYLINE, size); + if (!cmd) return; + cmd->color = col; + cmd->point_count = (unsigned short)point_count; + cmd->line_thickness = line_thickness; + for (i = 0; i < point_count; ++i) { + cmd->points[i].x = points[i*2]; + cmd->points[i].y = points[i*2+1]; + } +} +NK_API void +nk_draw_image_subpixel(struct nk_command_buffer *b, struct nk_rect r, + const struct nk_image *img, struct nk_color col) +{ + struct nk_command_image *cmd; + NK_ASSERT(b); + if (!b) return; + if (b->use_clipping) { + const struct nk_rect *c = &b->clip; + if (c->w == 0 || c->h == 0 || !NK_INTERSECT(r.x, r.y, r.w, r.h, c->x, c->y, c->w, c->h)) + return; + } + + cmd = (struct nk_command_image*) + nk_command_buffer_push(b, NK_COMMAND_IMAGE, sizeof(*cmd)); + if (!cmd) return; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = NK_MAX(0, r.w); + cmd->h = NK_MAX(0, r.h); + cmd->img = *img; + cmd->col = col; +} +NK_API void +nk_draw_text_subpixel(struct nk_command_buffer *b, struct nk_rect r, + const char *string, int length, const struct nk_user_font *font, + struct nk_color bg, struct nk_color fg) +{ + float text_width = 0; + struct nk_command_text *cmd; + + NK_ASSERT(b); + NK_ASSERT(font); + if (!b || !string || !length || (bg.a == 0 && fg.a == 0)) return; + if (b->use_clipping) { + const struct nk_rect *c = &b->clip; + if (c->w == 0 || c->h == 0 || !NK_INTERSECT(r.x, r.y, r.w, r.h, c->x, c->y, c->w, c->h)) + return; + } + + /* make sure text fits inside bounds */ + text_width = font->width(font->userdata, font->height, string, length); + if (text_width > r.w){ + int glyphs = 0; + float txt_width = (float)text_width; + length = nk_text_clamp(font, string, length, r.w, &glyphs, &txt_width, 0,0); + } + + if (!length) return; + cmd = (struct nk_command_text*) + nk_command_buffer_push(b, NK_COMMAND_TEXT, sizeof(*cmd) + (nk_size)(length + 1)); + if (!cmd) return; + cmd->x = r.x; + cmd->y = r.y; + cmd->w = r.w; + cmd->h = r.h; + cmd->background = bg; + cmd->foreground = fg; + cmd->font = font; + cmd->length = length; + cmd->height = font->height; + NK_MEMCPY(cmd->string, string, (nk_size)length); + cmd->string[length] = '\0'; +} + +#endif \ No newline at end of file diff --git a/src/nuklear_input.c b/src/nuklear_input.c index 563b5decb..b3dded068 100644 --- a/src/nuklear_input.c +++ b/src/nuklear_input.c @@ -23,6 +23,11 @@ nk_input_begin(struct nk_context *ctx) in->mouse.prev.y = in->mouse.pos.y; in->mouse.delta.x = 0; in->mouse.delta.y = 0; + + #if defined(NK_KEYSTATE_BASED_INPUT) || defined(NK_BUTTON_TRIGGER_ON_RELEASE) + in->mouse.clicked = 0; + #endif + for (i = 0; i < NK_KEY_MAX; i++) in->keyboard.keys[i].clicked = 0; } @@ -79,6 +84,14 @@ nk_input_button(struct nk_context *ctx, enum nk_buttons id, int x, int y, int do if (in->mouse.buttons[id].down == down) return; btn = &in->mouse.buttons[id]; + + #ifndef NK_BUTTON_TRIGGER_ON_RELEASE + + if(id == NK_BUTTON_LEFT && !down) + in->mouse.clicked = 0; + + #endif + btn->clicked_pos.x = (float)x; btn->clicked_pos.y = (float)y; btn->down = down; @@ -141,7 +154,7 @@ nk_input_has_mouse_click_in_rect(const struct nk_input *i, enum nk_buttons id, struct nk_rect b) { const struct nk_mouse_button *btn; - if (!i) return nk_false; + if (!i || i->mouse.clicked) return nk_false; btn = &i->mouse.buttons[id]; if (!NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h)) return nk_false; @@ -215,7 +228,7 @@ nk_input_is_mouse_pressed(const struct nk_input *i, enum nk_buttons id) const struct nk_mouse_button *b; if (!i) return nk_false; b = &i->mouse.buttons[id]; - if (b->down && b->clicked) + if (b->down && b->clicked && !i->mouse.clicked) return nk_true; return nk_false; } @@ -223,7 +236,7 @@ NK_API int nk_input_is_mouse_released(const struct nk_input *i, enum nk_buttons id) { if (!i) return nk_false; - return (!i->mouse.buttons[id].down && i->mouse.buttons[id].clicked); + return (!i->mouse.buttons[id].down && !(i->mouse.buttons[id].clicked && !i->mouse.clicked)); } NK_API int nk_input_is_key_pressed(const struct nk_input *i, enum nk_keys key) diff --git a/src/nuklear_internal.h b/src/nuklear_internal.h index 5aac1708c..ab3c9abb7 100644 --- a/src/nuklear_internal.h +++ b/src/nuklear_internal.h @@ -30,9 +30,11 @@ #ifndef NK_MEMSET #define NK_MEMSET nk_memset +#define NK_MEMSET_BUILTIN #endif #ifndef NK_MEMCPY #define NK_MEMCPY nk_memcopy +#define NK_MEMCPY_BUILTIN #endif #ifndef NK_SQRT #define NK_SQRT nk_sqrt @@ -131,8 +133,15 @@ NK_LIB int nk_is_lower(int c); NK_LIB int nk_is_upper(int c); NK_LIB int nk_to_upper(int c); NK_LIB int nk_to_lower(int c); + +#ifdef NK_MEMCPY_BUILTIN NK_LIB void* nk_memcopy(void *dst, const void *src, nk_size n); +#endif + +#ifdef NK_MEMSET_BUILTIN NK_LIB void nk_memset(void *ptr, int c0, nk_size size); +#endif + NK_LIB void nk_zero(void *ptr, nk_size size); NK_LIB char *nk_itoa(char *s, long n); NK_LIB int nk_string_float_limit(char *string, int prec); @@ -240,29 +249,29 @@ NK_LIB void nk_widget_text(struct nk_command_buffer *o, struct nk_rect b, const NK_LIB void nk_widget_text_wrap(struct nk_command_buffer *o, struct nk_rect b, const char *string, int len, const struct nk_text *t, const struct nk_user_font *f); /* button */ -NK_LIB int nk_button_behavior(nk_flags *state, struct nk_rect r, const struct nk_input *i, enum nk_button_behavior behavior); +NK_LIB int nk_button_behavior(nk_flags *state, struct nk_rect r, struct nk_input *i, enum nk_button_behavior behavior); NK_LIB const struct nk_style_item* nk_draw_button(struct nk_command_buffer *out, const struct nk_rect *bounds, nk_flags state, const struct nk_style_button *style); -NK_LIB int nk_do_button(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, const struct nk_style_button *style, const struct nk_input *in, enum nk_button_behavior behavior, struct nk_rect *content); +NK_LIB int nk_do_button(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, const struct nk_style_button *style, struct nk_input *in, enum nk_button_behavior behavior, struct nk_rect *content); NK_LIB void nk_draw_button_text(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, const struct nk_style_button *style, const char *txt, int len, nk_flags text_alignment, const struct nk_user_font *font); -NK_LIB int nk_do_button_text(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *string, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_button_text(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *string, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, struct nk_input *in, const struct nk_user_font *font); NK_LIB void nk_draw_button_symbol(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, const struct nk_style_button *style, enum nk_symbol_type type, const struct nk_user_font *font); -NK_LIB int nk_do_button_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_button_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, enum nk_button_behavior behavior, const struct nk_style_button *style, struct nk_input *in, const struct nk_user_font *font); NK_LIB void nk_draw_button_image(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *content, nk_flags state, const struct nk_style_button *style, const struct nk_image *img); -NK_LIB int nk_do_button_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, enum nk_button_behavior b, const struct nk_style_button *style, const struct nk_input *in); +NK_LIB int nk_do_button_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, enum nk_button_behavior b, const struct nk_style_button *style, struct nk_input *in); NK_LIB void nk_draw_button_text_symbol(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *label, const struct nk_rect *symbol, nk_flags state, const struct nk_style_button *style, const char *str, int len, enum nk_symbol_type type, const struct nk_user_font *font); -NK_LIB int nk_do_button_text_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, const char *str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, const struct nk_input *in); +NK_LIB int nk_do_button_text_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, enum nk_symbol_type symbol, const char *str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, struct nk_input *in); NK_LIB void nk_draw_button_text_image(struct nk_command_buffer *out, const struct nk_rect *bounds, const struct nk_rect *label, const struct nk_rect *image, nk_flags state, const struct nk_style_button *style, const char *str, int len, const struct nk_user_font *font, const struct nk_image *img); -NK_LIB int nk_do_button_text_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, const char* str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, const struct nk_input *in); +NK_LIB int nk_do_button_text_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, struct nk_image img, const char* str, int len, nk_flags align, enum nk_button_behavior behavior, const struct nk_style_button *style, const struct nk_user_font *font, struct nk_input *in); /* toggle */ enum nk_toggle_type { NK_TOGGLE_CHECK, NK_TOGGLE_OPTION }; -NK_LIB int nk_toggle_behavior(const struct nk_input *in, struct nk_rect select, nk_flags *state, int active); +NK_LIB int nk_toggle_behavior(struct nk_input *in, struct nk_rect select, nk_flags *state, int active); NK_LIB void nk_draw_checkbox(struct nk_command_buffer *out, nk_flags state, const struct nk_style_toggle *style, int active, const struct nk_rect *label, const struct nk_rect *selector, const struct nk_rect *cursors, const char *string, int len, const struct nk_user_font *font); NK_LIB void nk_draw_option(struct nk_command_buffer *out, nk_flags state, const struct nk_style_toggle *style, int active, const struct nk_rect *label, const struct nk_rect *selector, const struct nk_rect *cursors, const char *string, int len, const struct nk_user_font *font); -NK_LIB int nk_do_toggle(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, int *active, const char *str, int len, enum nk_toggle_type type, const struct nk_style_toggle *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_toggle(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, int *active, const char *str, int len, enum nk_toggle_type type, const struct nk_style_toggle *style, struct nk_input *in, const struct nk_user_font *font); /* progress */ NK_LIB nk_size nk_progress_behavior(nk_flags *state, struct nk_input *in, struct nk_rect r, struct nk_rect cursor, nk_size max, nk_size value, int modifiable); @@ -282,17 +291,17 @@ NK_LIB float nk_do_scrollbarh(nk_flags *state, struct nk_command_buffer *out, st /* selectable */ NK_LIB void nk_draw_selectable(struct nk_command_buffer *out, nk_flags state, const struct nk_style_selectable *style, int active, const struct nk_rect *bounds, const struct nk_rect *icon, const struct nk_image *img, enum nk_symbol_type sym, const char *string, int len, nk_flags align, const struct nk_user_font *font); -NK_LIB int nk_do_selectable(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_style_selectable *style, const struct nk_input *in, const struct nk_user_font *font); -NK_LIB int nk_do_selectable_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_image *img, const struct nk_style_selectable *style, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_selectable(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_style_selectable *style, struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_selectable_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_image *img, const struct nk_style_selectable *style, struct nk_input *in, const struct nk_user_font *font); /* edit */ NK_LIB void nk_edit_draw_text(struct nk_command_buffer *out, const struct nk_style_edit *style, float pos_x, float pos_y, float x_offset, const char *text, int byte_len, float row_height, const struct nk_user_font *font, struct nk_color background, struct nk_color foreground, int is_selected); NK_LIB nk_flags nk_do_edit(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, nk_flags flags, nk_plugin_filter filter, struct nk_text_edit *edit, const struct nk_style_edit *style, struct nk_input *in, const struct nk_user_font *font); /* color-picker */ -NK_LIB int nk_color_picker_behavior(nk_flags *state, const struct nk_rect *bounds, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, struct nk_colorf *color, const struct nk_input *in); +NK_LIB int nk_color_picker_behavior(nk_flags *state, const struct nk_rect *bounds, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, struct nk_colorf *color, struct nk_input *in); NK_LIB void nk_draw_color_picker(struct nk_command_buffer *o, const struct nk_rect *matrix, const struct nk_rect *hue_bar, const struct nk_rect *alpha_bar, struct nk_colorf col); -NK_LIB int nk_do_color_picker(nk_flags *state, struct nk_command_buffer *out, struct nk_colorf *col, enum nk_color_format fmt, struct nk_rect bounds, struct nk_vec2 padding, const struct nk_input *in, const struct nk_user_font *font); +NK_LIB int nk_do_color_picker(nk_flags *state, struct nk_command_buffer *out, struct nk_colorf *col, enum nk_color_format fmt, struct nk_rect bounds, struct nk_vec2 padding, struct nk_input *in, const struct nk_user_font *font); /* property */ enum nk_property_status { @@ -325,8 +334,8 @@ NK_LIB struct nk_property_variant nk_property_variant_int(int value, int min_val NK_LIB struct nk_property_variant nk_property_variant_float(float value, float min_value, float max_value, float step); NK_LIB struct nk_property_variant nk_property_variant_double(double value, double min_value, double max_value, double step); -NK_LIB void nk_drag_behavior(nk_flags *state, const struct nk_input *in, struct nk_rect drag, struct nk_property_variant *variant, float inc_per_pixel); -NK_LIB void nk_property_behavior(nk_flags *ws, const struct nk_input *in, struct nk_rect property, struct nk_rect label, struct nk_rect edit, struct nk_rect empty, int *state, struct nk_property_variant *variant, float inc_per_pixel); +NK_LIB void nk_drag_behavior(nk_flags *state, struct nk_input *in, struct nk_rect drag, struct nk_property_variant *variant, float inc_per_pixel); +NK_LIB void nk_property_behavior(nk_flags *ws, struct nk_input *in, struct nk_rect property, struct nk_rect label, struct nk_rect edit, struct nk_rect empty, int *state, struct nk_property_variant *variant, float inc_per_pixel); NK_LIB void nk_draw_property(struct nk_command_buffer *out, const struct nk_style_property *style, const struct nk_rect *bounds, const struct nk_rect *label, nk_flags state, const char *name, int len, const struct nk_user_font *font); NK_LIB void nk_do_property(nk_flags *ws, struct nk_command_buffer *out, struct nk_rect property, const char *name, struct nk_property_variant *variant, float inc_per_pixel, char *buffer, int *len, int *state, int *cursor, int *select_begin, int *select_end, const struct nk_style_property *style, enum nk_property_filter filter, struct nk_input *in, const struct nk_user_font *font, struct nk_text_edit *text_edit, enum nk_button_behavior behavior); NK_LIB void nk_property(struct nk_context *ctx, const char *name, struct nk_property_variant *variant, float inc_per_pixel, const enum nk_property_filter filter); diff --git a/src/nuklear_menu.c b/src/nuklear_menu.c index 5b2879e0c..6e7a88e22 100644 --- a/src/nuklear_menu.c +++ b/src/nuklear_menu.c @@ -112,7 +112,7 @@ nk_menu_begin_text(struct nk_context *ctx, const char *title, int len, nk_flags align, struct nk_vec2 size) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; nk_flags state; @@ -143,7 +143,7 @@ nk_menu_begin_image(struct nk_context *ctx, const char *id, struct nk_image img, { struct nk_window *win; struct nk_rect header; - const struct nk_input *in; + struct nk_input *in; int is_clicked = nk_false; nk_flags state; @@ -167,7 +167,7 @@ nk_menu_begin_symbol(struct nk_context *ctx, const char *id, enum nk_symbol_type sym, struct nk_vec2 size) { struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; struct nk_rect header; int is_clicked = nk_false; nk_flags state; @@ -193,7 +193,7 @@ nk_menu_begin_image_text(struct nk_context *ctx, const char *title, int len, { struct nk_window *win; struct nk_rect header; - const struct nk_input *in; + struct nk_input *in; int is_clicked = nk_false; nk_flags state; @@ -225,7 +225,7 @@ nk_menu_begin_symbol_text(struct nk_context *ctx, const char *title, int len, { struct nk_window *win; struct nk_rect header; - const struct nk_input *in; + struct nk_input *in; int is_clicked = nk_false; nk_flags state; diff --git a/src/nuklear_property.c b/src/nuklear_property.c index e7c33df07..2110a6186 100644 --- a/src/nuklear_property.c +++ b/src/nuklear_property.c @@ -7,7 +7,7 @@ * * ===============================================================*/ NK_LIB void -nk_drag_behavior(nk_flags *state, const struct nk_input *in, +nk_drag_behavior(nk_flags *state, struct nk_input *in, struct nk_rect drag, struct nk_property_variant *variant, float inc_per_pixel) { @@ -46,7 +46,7 @@ nk_drag_behavior(nk_flags *state, const struct nk_input *in, *state |= NK_WIDGET_STATE_LEFT; } NK_LIB void -nk_property_behavior(nk_flags *ws, const struct nk_input *in, +nk_property_behavior(nk_flags *ws, struct nk_input *in, struct nk_rect property, struct nk_rect label, struct nk_rect edit, struct nk_rect empty, int *state, struct nk_property_variant *variant, float inc_per_pixel) diff --git a/src/nuklear_selectable.c b/src/nuklear_selectable.c index 0d00acd14..890aab204 100644 --- a/src/nuklear_selectable.c +++ b/src/nuklear_selectable.c @@ -58,7 +58,7 @@ nk_draw_selectable(struct nk_command_buffer *out, NK_LIB int nk_do_selectable(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, - const struct nk_style_selectable *style, const struct nk_input *in, + const struct nk_style_selectable *style, struct nk_input *in, const struct nk_user_font *font) { int old_value; @@ -95,7 +95,7 @@ NK_LIB int nk_do_selectable_image(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, const struct nk_image *img, const struct nk_style_selectable *style, - const struct nk_input *in, const struct nk_user_font *font) + struct nk_input *in, const struct nk_user_font *font) { int old_value; struct nk_rect touch; @@ -142,7 +142,7 @@ NK_LIB int nk_do_selectable_symbol(nk_flags *state, struct nk_command_buffer *out, struct nk_rect bounds, const char *str, int len, nk_flags align, int *value, enum nk_symbol_type sym, const struct nk_style_selectable *style, - const struct nk_input *in, const struct nk_user_font *font) + struct nk_input *in, const struct nk_user_font *font) { int old_value; struct nk_rect touch; @@ -192,7 +192,7 @@ nk_selectable_text(struct nk_context *ctx, const char *str, int len, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; enum nk_widget_layout_states state; @@ -221,7 +221,7 @@ nk_selectable_image_text(struct nk_context *ctx, struct nk_image img, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; enum nk_widget_layout_states state; @@ -250,7 +250,7 @@ nk_selectable_symbol_text(struct nk_context *ctx, enum nk_symbol_type sym, { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; enum nk_widget_layout_states state; diff --git a/src/nuklear_toggle.c b/src/nuklear_toggle.c index 8f4ced27d..bf5490c4b 100644 --- a/src/nuklear_toggle.c +++ b/src/nuklear_toggle.c @@ -7,7 +7,7 @@ * * ===============================================================*/ NK_LIB int -nk_toggle_behavior(const struct nk_input *in, struct nk_rect select, +nk_toggle_behavior(struct nk_input *in, struct nk_rect select, nk_flags *state, int active) { nk_widget_state_reset(state); @@ -52,6 +52,7 @@ nk_draw_checkbox(struct nk_command_buffer *out, nk_fill_rect(out, *selector, 0, style->border_color); nk_fill_rect(out, nk_shrink_rect(*selector, style->border), 0, background->data.color); } else nk_draw_image(out, *selector, &background->data.image, nk_white); + if (active) { if (cursor->type == NK_STYLE_ITEM_IMAGE) nk_draw_image(out, *cursors, &cursor->data.image, nk_white); @@ -91,13 +92,13 @@ nk_draw_option(struct nk_command_buffer *out, /* draw background and cursor */ if (background->type == NK_STYLE_ITEM_COLOR) { - nk_fill_circle(out, *selector, style->border_color); - nk_fill_circle(out, nk_shrink_rect(*selector, style->border), background->data.color); + nk_stroke_circle(out, *selector, 1, background->data.color); } else nk_draw_image(out, *selector, &background->data.image, nk_white); + if (active) { if (cursor->type == NK_STYLE_ITEM_IMAGE) nk_draw_image(out, *cursors, &cursor->data.image, nk_white); - else nk_fill_circle(out, *cursors, cursor->data.color); + else nk_fill_circle(out, *cursors, background->data.color); } text.padding.x = 0; @@ -109,7 +110,7 @@ NK_LIB int nk_do_toggle(nk_flags *state, struct nk_command_buffer *out, struct nk_rect r, int *active, const char *str, int len, enum nk_toggle_type type, - const struct nk_style_toggle *style, const struct nk_input *in, + const struct nk_style_toggle *style, struct nk_input *in, const struct nk_user_font *font) { int was_active; @@ -177,7 +178,7 @@ nk_check_text(struct nk_context *ctx, const char *text, int len, int active) { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; @@ -272,7 +273,7 @@ nk_option_text(struct nk_context *ctx, const char *text, int len, int is_active) { struct nk_window *win; struct nk_panel *layout; - const struct nk_input *in; + struct nk_input *in; const struct nk_style *style; struct nk_rect bounds; diff --git a/src/nuklear_tooltip.c b/src/nuklear_tooltip.c index c4ce1fee2..388fc1b7f 100644 --- a/src/nuklear_tooltip.c +++ b/src/nuklear_tooltip.c @@ -11,7 +11,7 @@ nk_tooltip_begin(struct nk_context *ctx, float width) { int x,y,w,h; struct nk_window *win; - const struct nk_input *in; + struct nk_input *in; struct nk_rect bounds; int ret; diff --git a/src/nuklear_tree.c b/src/nuklear_tree.c index a0cc3de5f..4e0ea04a4 100644 --- a/src/nuklear_tree.c +++ b/src/nuklear_tree.c @@ -14,7 +14,7 @@ nk_tree_state_base(struct nk_context *ctx, enum nk_tree_type type, struct nk_panel *layout; const struct nk_style *style; struct nk_command_buffer *out; - const struct nk_input *in; + struct nk_input *in; const struct nk_style_button *button; enum nk_symbol_type symbol; float row_height; @@ -195,7 +195,7 @@ nk_tree_element_image_push_hashed_base(struct nk_context *ctx, enum nk_tree_type struct nk_panel *layout; const struct nk_style *style; struct nk_command_buffer *out; - const struct nk_input *in; + struct nk_input *in; const struct nk_style_button *button; enum nk_symbol_type symbol; float row_height; @@ -338,4 +338,3 @@ nk_tree_element_pop(struct nk_context *ctx) { nk_tree_state_pop(ctx); } - diff --git a/src/nuklear_util.c b/src/nuklear_util.c index 6379adf18..34c28da17 100644 --- a/src/nuklear_util.c +++ b/src/nuklear_util.c @@ -13,6 +13,8 @@ NK_LIB int nk_is_upper(int c){return (c >= 'A' && c <= 'Z') || (c >= 0xC0 && c < NK_LIB int nk_to_upper(int c) {return (c >= 'a' && c <= 'z') ? (c - ('a' - 'A')) : c;} NK_LIB int nk_to_lower(int c) {return (c >= 'A' && c <= 'Z') ? (c - ('a' + 'A')) : c;} +#ifdef NK_MEMCPY_BUILTIN + NK_LIB void* nk_memcopy(void *dst0, const void *src0, nk_size length) { @@ -69,6 +71,11 @@ nk_memcopy(void *dst0, const void *src0, nk_size length) done: return (dst0); } + +#endif + +#ifdef NK_MEMSET_BUILTIN + NK_LIB void nk_memset(void *ptr, int c0, nk_size size) { @@ -120,6 +127,9 @@ nk_memset(void *ptr, int c0, nk_size size) #undef nk_wsize #undef nk_wmask } + +#endif + NK_LIB void nk_zero(void *ptr, nk_size size) { diff --git a/src/nuklear_vertex.c b/src/nuklear_vertex.c index 8e94f889c..143deeecd 100644 --- a/src/nuklear_vertex.c +++ b/src/nuklear_vertex.c @@ -224,6 +224,8 @@ nk_draw_list_alloc_vertices(struct nk_draw_list *list, nk_size count) if (!vtx) return 0; list->vertex_count += (unsigned int)count; + #ifndef NK_UINT_DRAW_INDEX + /* This assert triggers because your are drawing a lot of stuff and nuklear * defined `nk_draw_index` as `nk_ushort` to safe space be default. * @@ -233,8 +235,11 @@ nk_draw_list_alloc_vertices(struct nk_draw_list *list, nk_size count) * backend (OpenGL, DirectX, ...). For example in OpenGL for `glDrawElements` * instead of specifing `GL_UNSIGNED_SHORT` you have to define `GL_UNSIGNED_INT`. * Sorry for the inconvenience. */ - if(sizeof(nk_draw_index)==2) NK_ASSERT((list->vertex_count < NK_USHORT_MAX && + NK_ASSERT((list->vertex_count < NK_USHORT_MAX && "To many verticies for 16-bit vertex indicies. Please read comment above on how to solve this problem")); + + #endif + return vtx; } NK_INTERN nk_draw_index* diff --git a/src/nuklear_window.c b/src/nuklear_window.c index bd8739d50..5ecc8cf19 100644 --- a/src/nuklear_window.c +++ b/src/nuklear_window.c @@ -50,6 +50,7 @@ nk_find_window(struct nk_context *ctx, nk_hash hash, const char *name) while (iter) { NK_ASSERT(iter != iter->next); if (iter->name == hash) { + if (!name) return iter; int max_len = nk_strlen(iter->name_string); if (!nk_stricmpn(iter->name_string, name, max_len)) return iter; @@ -132,13 +133,13 @@ nk_remove_window(struct nk_context *ctx, struct nk_window *win) win->prev = 0; ctx->count--; } -NK_API int +NK_API struct nk_window* nk_begin(struct nk_context *ctx, const char *title, struct nk_rect bounds, nk_flags flags) { return nk_begin_titled(ctx, title, title, bounds, flags); } -NK_API int +NK_API struct nk_window* nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_rect bounds, nk_flags flags) { @@ -146,7 +147,6 @@ nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, struct nk_style *style; nk_hash name_hash; int name_len; - int ret = 0; NK_ASSERT(ctx); NK_ASSERT(name); @@ -287,10 +287,178 @@ nk_begin_titled(struct nk_context *ctx, const char *name, const char *title, } win->layout = (struct nk_panel*)nk_create_panel(ctx); ctx->current = win; - ret = nk_panel_begin(ctx, title, NK_PANEL_WINDOW); + + if (!nk_panel_begin(ctx, title, NK_PANEL_WINDOW)) + return 0; + + win->layout->offset_x = &win->scrollbar.x; + win->layout->offset_y = &win->scrollbar.y; + return win; +} +NK_API int +nk_window_has_contents(struct nk_window *window) +{ + NK_ASSERT(window); + if (!window) + return 0; + + return !((window->flags & NK_WINDOW_MINIMIZED) || (window->flags & NK_WINDOW_CLOSED) || (window->flags & NK_WINDOW_HIDDEN)); +} +NK_API struct nk_window* +nk_add_window(struct nk_context *ctx, nk_hash id, const char *title, + struct nk_rect bounds, nk_flags flags) +{ + struct nk_window *win; + struct nk_style *style; + + NK_ASSERT(ctx); + 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) + return 0; + + /* find or create window */ + style = &ctx->style; + win = nk_find_window(ctx, id, 0); + if (!win) { + /* create new window */ + win = (struct nk_window*)nk_create_window(ctx); + NK_ASSERT(win); + if (!win) return 0; + + if (flags & NK_WINDOW_BACKGROUND) + nk_insert_window(ctx, win, NK_INSERT_FRONT); + else nk_insert_window(ctx, win, NK_INSERT_BACK); + nk_command_buffer_init(&win->buffer, &ctx->memory, NK_CLIPPING_ON); + + win->flags = flags; + win->bounds = bounds; + win->name = id; //0 means use "hash" only + win->name_string[0] = 0; + win->popup.win = 0; + if (!ctx->active) + ctx->active = win; + } else { + /* update window */ + win->flags &= ~(nk_flags)(NK_WINDOW_PRIVATE-1); + win->flags |= flags; + if (!(win->flags & (NK_WINDOW_MOVABLE | NK_WINDOW_SCALABLE))) + win->bounds = bounds; + /* If this assert triggers you either: + * + * I.) Have more than one window with the same name or + * II.) You forgot to actually draw the window. + * More specific you did not call `nk_clear` (nk_clear will be + * automatically called for you if you are using one of the + * provided demo backends). */ + NK_ASSERT(win->seq != ctx->seq); + win->seq = ctx->seq; + if (!ctx->active && !(win->flags & NK_WINDOW_HIDDEN)) { + ctx->active = win; + ctx->end = win; + } + } + if (win->flags & NK_WINDOW_HIDDEN) { + ctx->current = win; + win->layout = 0; + return win; + } else nk_start(ctx, win); + + /* window overlapping */ + if (!(win->flags & NK_WINDOW_HIDDEN) && !(win->flags & NK_WINDOW_NO_INPUT)) + { + int inpanel, ishovered; + struct nk_window *iter = win; + float h = ctx->style.font->height + 2.0f * style->window.header.padding.y + + (2.0f * style->window.header.label_padding.y); + struct nk_rect win_bounds = (!(win->flags & NK_WINDOW_MINIMIZED))? + win->bounds: nk_rect(win->bounds.x, win->bounds.y, win->bounds.w, h); + + /* activate window if hovered and no other window is overlapping this window */ + inpanel = nk_input_has_mouse_click_down_in_rect(&ctx->input, NK_BUTTON_LEFT, win_bounds, nk_true); + inpanel = inpanel && ctx->input.mouse.buttons[NK_BUTTON_LEFT].clicked; + ishovered = nk_input_is_mouse_hovering_rect(&ctx->input, win_bounds); + if ((win != ctx->active) && ishovered && !ctx->input.mouse.buttons[NK_BUTTON_LEFT].down) { + iter = win->next; + while (iter) { + struct nk_rect iter_bounds = (!(iter->flags & NK_WINDOW_MINIMIZED))? + iter->bounds: nk_rect(iter->bounds.x, iter->bounds.y, iter->bounds.w, h); + if (NK_INTERSECT(win_bounds.x, win_bounds.y, win_bounds.w, win_bounds.h, + iter_bounds.x, iter_bounds.y, iter_bounds.w, iter_bounds.h) && + (!(iter->flags & NK_WINDOW_HIDDEN))) + break; + + if (iter->popup.win && iter->popup.active && !(iter->flags & NK_WINDOW_HIDDEN) && + NK_INTERSECT(win->bounds.x, win_bounds.y, win_bounds.w, win_bounds.h, + iter->popup.win->bounds.x, iter->popup.win->bounds.y, + iter->popup.win->bounds.w, iter->popup.win->bounds.h)) + break; + iter = iter->next; + } + } + + /* activate window if clicked */ + if (iter && inpanel && (win != ctx->end)) { + iter = win->next; + while (iter) { + /* try to find a panel with higher priority in the same position */ + struct nk_rect iter_bounds = (!(iter->flags & NK_WINDOW_MINIMIZED))? + iter->bounds: nk_rect(iter->bounds.x, iter->bounds.y, iter->bounds.w, h); + if (NK_INBOX(ctx->input.mouse.pos.x, ctx->input.mouse.pos.y, + iter_bounds.x, iter_bounds.y, iter_bounds.w, iter_bounds.h) && + !(iter->flags & NK_WINDOW_HIDDEN)) + break; + if (iter->popup.win && iter->popup.active && !(iter->flags & NK_WINDOW_HIDDEN) && + NK_INTERSECT(win_bounds.x, win_bounds.y, win_bounds.w, win_bounds.h, + iter->popup.win->bounds.x, iter->popup.win->bounds.y, + iter->popup.win->bounds.w, iter->popup.win->bounds.h)) + break; + iter = iter->next; + } + } + if (iter && !(win->flags & NK_WINDOW_ROM) && (win->flags & NK_WINDOW_BACKGROUND)) { + win->flags |= (nk_flags)NK_WINDOW_ROM; + iter->flags &= ~(nk_flags)NK_WINDOW_ROM; + ctx->active = iter; + if (!(iter->flags & NK_WINDOW_BACKGROUND)) { + /* current window is active in that position so transfer to top + * at the highest priority in stack */ + nk_remove_window(ctx, iter); + nk_insert_window(ctx, iter, NK_INSERT_BACK); + } + } else { + if (!iter && ctx->end != win) { + if (!(win->flags & NK_WINDOW_BACKGROUND)) { + /* current window is active in that position so transfer to top + * at the highest priority in stack */ + nk_remove_window(ctx, win); + nk_insert_window(ctx, win, NK_INSERT_BACK); + } + win->flags &= ~(nk_flags)NK_WINDOW_ROM; + ctx->active = win; + } + if (ctx->end != win && !(win->flags & NK_WINDOW_BACKGROUND)) + win->flags |= NK_WINDOW_ROM; + } + } + win->layout = (struct nk_panel*)nk_create_panel(ctx); + ctx->current = win; + + if (!nk_panel_begin(ctx, title, NK_PANEL_WINDOW)) { + + if(win->layout->flags & NK_WINDOW_HIDDEN) + win->flags |= NK_WINDOW_CLOSED; + + if(win->layout->flags & NK_WINDOW_MINIMIZED) + win->flags |= NK_WINDOW_MINIMIZED; + + return win; + } + win->layout->offset_x = &win->scrollbar.x; win->layout->offset_y = &win->scrollbar.y; - return ret; + return win; } NK_API void nk_end(struct nk_context *ctx) diff --git a/src/paq.bat b/src/paq.bat index f2668543f..8ad7605be 100644 --- a/src/paq.bat +++ b/src/paq.bat @@ -1 +1,10 @@ -build.py --macro NK --intro HEADER --pub nuklear.h --priv nuklear_internal.h,nuklear_math.c,nuklear_util.c,nuklear_color.c,nuklear_utf8.c,nuklear_buffer.c,nuklear_string.c,nuklear_draw.c,nuklear_vertex.c,nuklear_font.c,nuklear_input.c,nuklear_style.c,nuklear_context.c,nuklear_pool.c,nuklear_page_element.c,nuklear_table.c,nuklear_panel.c,nuklear_window.c,nuklear_popup.c,nuklear_contextual.c,nuklear_menu.c,nuklear_layout.c,nuklear_tree.c,nuklear_group.c,nuklear_list_view.c,nuklear_widget.c,nuklear_text.c,nuklear_image.c,nuklear_button.c,nuklear_toggle.c,nuklear_selectable.c,nuklear_slider.c,nuklear_progress.c,nuklear_scrollbar.c,nuklear_text_editor.c,nuklear_edit.c,nuklear_property.c,nuklear_chart.c,nuklear_color_picker.c,nuklear_combo.c,nuklear_tooltip.c --outro LICENSE,CHANGELOG,CREDITS > ..\nuklear.h \ No newline at end of file +@echo off +del ..\nuklear.h + +python3 build.py --macro NK --intro HEADER --pub nuklear.h --priv nuklear_internal.h,nuklear_math.c,nuklear_util.c,nuklear_color.c,nuklear_utf8.c,nuklear_buffer.c,nuklear_string.c,nuklear_draw.c,nuklear_vertex.c,nuklear_font.c,nuklear_input.c,nuklear_style.c,nuklear_context.c,nuklear_pool.c,nuklear_page_element.c,nuklear_table.c,nuklear_panel.c,nuklear_window.c,nuklear_popup.c,nuklear_contextual.c,nuklear_menu.c,nuklear_layout.c,nuklear_tree.c,nuklear_group.c,nuklear_list_view.c,nuklear_widget.c,nuklear_text.c,nuklear_image.c,nuklear_button.c,nuklear_toggle.c,nuklear_selectable.c,nuklear_slider.c,nuklear_progress.c,nuklear_scrollbar.c,nuklear_text_editor.c,nuklear_edit.c,nuklear_property.c,nuklear_chart.c,nuklear_color_picker.c,nuklear_combo.c,nuklear_tooltip.c --outro LICENSE,CHANGELOG,CREDITS > ..\nuklear.h + +if exist "..\nuklear.h" ( + echo -- nuklear exported +) else ( + echo -- nuklear export failed +) \ No newline at end of file diff --git a/src/paq.sh b/src/paq.sh index 53b8552fc..01712b977 100755 --- a/src/paq.sh +++ b/src/paq.sh @@ -1,3 +1,11 @@ #!/bin/sh -python build.py --macro NK --intro HEADER --pub nuklear.h --priv nuklear_internal.h,nuklear_math.c,nuklear_util.c,nuklear_color.c,nuklear_utf8.c,nuklear_buffer.c,nuklear_string.c,nuklear_draw.c,nuklear_vertex.c,nuklear_font.c,nuklear_input.c,nuklear_style.c,nuklear_context.c,nuklear_pool.c,nuklear_page_element.c,nuklear_table.c,nuklear_panel.c,nuklear_window.c,nuklear_popup.c,nuklear_contextual.c,nuklear_menu.c,nuklear_layout.c,nuklear_tree.c,nuklear_group.c,nuklear_list_view.c,nuklear_widget.c,nuklear_text.c,nuklear_image.c,nuklear_button.c,nuklear_toggle.c,nuklear_selectable.c,nuklear_slider.c,nuklear_progress.c,nuklear_scrollbar.c,nuklear_text_editor.c,nuklear_edit.c,nuklear_property.c,nuklear_chart.c,nuklear_color_picker.c,nuklear_combo.c,nuklear_tooltip.c --outro LICENSE,CHANGELOG,CREDITS +rm ../nuklear.h + +python3 build.py --macro NK --intro HEADER --pub nuklear.h --priv nuklear_internal.h,nuklear_math.c,nuklear_util.c,nuklear_color.c,nuklear_utf8.c,nuklear_buffer.c,nuklear_string.c,nuklear_draw.c,nuklear_vertex.c,nuklear_font.c,nuklear_input.c,nuklear_style.c,nuklear_context.c,nuklear_pool.c,nuklear_page_element.c,nuklear_table.c,nuklear_panel.c,nuklear_window.c,nuklear_popup.c,nuklear_contextual.c,nuklear_menu.c,nuklear_layout.c,nuklear_tree.c,nuklear_group.c,nuklear_list_view.c,nuklear_widget.c,nuklear_text.c,nuklear_image.c,nuklear_button.c,nuklear_toggle.c,nuklear_selectable.c,nuklear_slider.c,nuklear_progress.c,nuklear_scrollbar.c,nuklear_text_editor.c,nuklear_edit.c,nuklear_property.c,nuklear_chart.c,nuklear_color_picker.c,nuklear_combo.c,nuklear_tooltip.c --outro LICENSE,CHANGELOG,CREDITS > ../nuklear.h + +if [ -s ../nuklear.h ] ; then + echo -- nulear exported +else + echo -- nuklear export failed +fi